Refactor chip class and move independent chips into separate classes (#101507)

packages/flutter/lib/material.dart

@@ -45,6 +45,10 @@ export 'src/material/checkbox.dart';
 export 'src/material/checkbox_list_tile.dart';
 export 'src/material/checkbox_theme.dart';
 export 'src/material/chip.dart';
+export 'src/material/chip_action.dart';
+export 'src/material/chip_choice.dart';
+export 'src/material/chip_filter.dart';
+export 'src/material/chip_input.dart';
 export 'src/material/chip_theme.dart';
 export 'src/material/circle_avatar.dart';
 export 'src/material/color_scheme.dart';

packages/flutter/lib/src/material/chip_action.dart

+// Copyright 2014 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter/widgets.dart';
+
+import 'chip.dart';
+import 'debug.dart';
+import 'theme_data.dart';
+
+/// A material design action chip.
+///
+/// Action chips are a set of options which trigger an action related to primary
+/// content. Action chips should appear dynamically and contextually in a UI.
+///
+/// Action chips can be tapped to trigger an action or show progress and
+/// confirmation. They cannot be disabled; if the action is not applicable, the
+/// chip should not be included in the interface. (This contrasts with buttons,
+/// where unavailable choices are usually represented as disabled controls.)
+///
+/// Action chips are displayed after primary content, such as below a card or
+/// persistently at the bottom of a screen.
+///
+/// The material button widgets, [ElevatedButton], [TextButton], and
+/// [OutlinedButton], are an alternative to action chips, which should appear
+/// statically and consistently in a UI.
+///
+/// Requires one of its ancestors to be a [Material] widget.
+///
+/// {@tool snippet}
+///
+/// ```dart
+/// ActionChip(
+///   avatar: CircleAvatar(
+///     backgroundColor: Colors.grey.shade800,
+///     child: const Text('AB'),
+///   ),
+///   label: const Text('Aaron Burr'),
+///   onPressed: () {
+///     print('If you stand for nothing, Burr, what’ll you fall for?');
+///   }
+/// )
+/// ```
+/// {@end-tool}
+///
+/// See also:
+///
+///  * [Chip], a chip that displays information and can be deleted.
+///  * [InputChip], a chip that represents a complex piece of information, such
+///    as an entity (person, place, or thing) or conversational text, in a
+///    compact form.
+///  * [ChoiceChip], allows a single selection from a set of options. Choice
+///    chips contain related descriptive text or categories.
+///  * [CircleAvatar], which shows images or initials of people.
+///  * [Wrap], A widget that displays its children in multiple horizontal or
+///    vertical runs.
+///  * <https://material.io/design/components/chips.html>
+class ActionChip extends StatelessWidget implements ChipAttributes, TappableChipAttributes {
+  /// Create a chip that acts like a button.
+  ///
+  /// The [label], [onPressed], [autofocus], and [clipBehavior] arguments must
+  /// not be null. The [pressElevation] and [elevation] must be null or
+  /// non-negative. Typically, [pressElevation] is greater than [elevation].
+  const ActionChip({
+    Key? key,
+    this.avatar,
+    required this.label,
+    this.labelStyle,
+    this.labelPadding,
+    required this.onPressed,
+    this.pressElevation,
+    this.tooltip,
+    this.side,
+    this.shape,
+    this.clipBehavior = Clip.none,
+    this.focusNode,
+    this.autofocus = false,
+    this.backgroundColor,
+    this.padding,
+    this.visualDensity,
+    this.materialTapTargetSize,
+    this.elevation,
+    this.shadowColor,
+  }) : assert(label != null),
+       assert(clipBehavior != null),
+       assert(autofocus != null),
+       assert(
+         onPressed != null,
+         'Rather than disabling an ActionChip by setting onPressed to null, '
+         'remove it from the interface entirely.',
+       ),
+       assert(pressElevation == null || pressElevation >= 0.0),
+       assert(elevation == null || elevation >= 0.0),
+       super(key: key);
+
+  @override
+  final Widget? avatar;
+  @override
+  final Widget label;
+  @override
+  final TextStyle? labelStyle;
+  @override
+  final EdgeInsetsGeometry? labelPadding;
+  @override
+  final VoidCallback onPressed;
+  @override
+  final double? pressElevation;
+  @override
+  final String? tooltip;
+  @override
+  final BorderSide? side;
+  @override
+  final OutlinedBorder? shape;
+  @override
+  final Clip clipBehavior;
+  @override
+  final FocusNode? focusNode;
+  @override
+  final bool autofocus;
+  @override
+  final Color? backgroundColor;
+  @override
+  final EdgeInsetsGeometry? padding;
+  @override
+  final VisualDensity? visualDensity;
+  @override
+  final MaterialTapTargetSize? materialTapTargetSize;
+  @override
+  final double? elevation;
+  @override
+  final Color? shadowColor;
+
+  @override
+  Widget build(BuildContext context) {
+    assert(debugCheckHasMaterial(context));
+    return RawChip(
+      avatar: avatar,
+      label: label,
+      onPressed: onPressed,
+      pressElevation: pressElevation,
+      tooltip: tooltip,
+      labelStyle: labelStyle,
+      backgroundColor: backgroundColor,
+      side: side,
+      shape: shape,
+      clipBehavior: clipBehavior,
+      focusNode: focusNode,
+      autofocus: autofocus,
+      padding: padding,
+      visualDensity: visualDensity,
+      labelPadding: labelPadding,
+      materialTapTargetSize: materialTapTargetSize,
+      elevation: elevation,
+      shadowColor: shadowColor,
+    );
+  }
+}

packages/flutter/lib/src/material/chip_choice.dart

+// Copyright 2014 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter/widgets.dart';
+
+import 'chip.dart';
+import 'chip_theme.dart';
+import 'debug.dart';
+import 'theme_data.dart';
+
+/// A material design choice chip.
+///
+/// [ChoiceChip]s represent a single choice from a set. Choice chips contain
+/// related descriptive text or categories.
+///
+/// Requires one of its ancestors to be a [Material] widget. The [selected] and
+/// [label] arguments must not be null.
+///
+/// {@tool snippet}
+///
+/// ```dart
+/// class MyThreeOptions extends StatefulWidget {
+///   const MyThreeOptions({Key? key}) : super(key: key);
+///
+///   @override
+///   State<MyThreeOptions> createState() => _MyThreeOptionsState();
+/// }
+///
+/// class _MyThreeOptionsState extends State<MyThreeOptions> {
+///   int? _value = 1;
+///
+///   @override
+///   Widget build(BuildContext context) {
+///     return Wrap(
+///       children: List<Widget>.generate(
+///         3,
+///         (int index) {
+///           return ChoiceChip(
+///             label: Text('Item $index'),
+///             selected: _value == index,
+///             onSelected: (bool selected) {
+///               setState(() {
+///                 _value = selected ? index : null;
+///               });
+///             },
+///           );
+///         },
+///       ).toList(),
+///     );
+///   }
+/// }
+/// ```
+/// {@end-tool}
+///
+/// See also:
+///
+///  * [Chip], a chip that displays information and can be deleted.
+///  * [InputChip], a chip that represents a complex piece of information, such
+///    as an entity (person, place, or thing) or conversational text, in a
+///    compact form.
+///  * [FilterChip], uses tags or descriptive words as a way to filter content.
+///  * [ActionChip], represents an action related to primary content.
+///  * [CircleAvatar], which shows images or initials of people.
+///  * [Wrap], A widget that displays its children in multiple horizontal or
+///    vertical runs.
+///  * <https://material.io/design/components/chips.html>
+class ChoiceChip extends StatelessWidget
+    implements
+        ChipAttributes,
+        SelectableChipAttributes,
+        DisabledChipAttributes {
+  /// Create a chip that acts like a radio button.
+  ///
+  /// The [label], [selected], [autofocus], and [clipBehavior] arguments must
+  /// not be null. The [pressElevation] and [elevation] must be null or
+  /// non-negative. Typically, [pressElevation] is greater than [elevation].
+  const ChoiceChip({
+    Key? key,
+    this.avatar,
+    required this.label,
+    this.labelStyle,
+    this.labelPadding,
+    this.onSelected,
+    this.pressElevation,
+    required this.selected,
+    this.selectedColor,
+    this.disabledColor,
+    this.tooltip,
+    this.side,
+    this.shape,
+    this.clipBehavior = Clip.none,
+    this.focusNode,
+    this.autofocus = false,
+    this.backgroundColor,
+    this.padding,
+    this.visualDensity,
+    this.materialTapTargetSize,
+    this.elevation,
+    this.shadowColor,
+    this.selectedShadowColor,
+    this.avatarBorder = const CircleBorder(),
+  }) : assert(selected != null),
+       assert(label != null),
+       assert(clipBehavior != null),
+       assert(autofocus != null),
+       assert(pressElevation == null || pressElevation >= 0.0),
+       assert(elevation == null || elevation >= 0.0),
+       super(key: key);
+
+  @override
+  final Widget? avatar;
+  @override
+  final Widget label;
+  @override
+  final TextStyle? labelStyle;
+  @override
+  final EdgeInsetsGeometry? labelPadding;
+  @override
+  final ValueChanged<bool>? onSelected;
+  @override
+  final double? pressElevation;
+  @override
+  final bool selected;
+  @override
+  final Color? disabledColor;
+  @override
+  final Color? selectedColor;
+  @override
+  final String? tooltip;
+  @override
+  final BorderSide? side;
+  @override
+  final OutlinedBorder? shape;
+  @override
+  final Clip clipBehavior;
+  @override
+  final FocusNode? focusNode;
+  @override
+  final bool autofocus;
+  @override
+  final Color? backgroundColor;
+  @override
+  final EdgeInsetsGeometry? padding;
+  @override
+  final VisualDensity? visualDensity;
+  @override
+  final MaterialTapTargetSize? materialTapTargetSize;
+  @override
+  final double? elevation;
+  @override
+  final Color? shadowColor;
+  @override
+  final Color? selectedShadowColor;
+  @override
+  final ShapeBorder avatarBorder;
+
+  @override
+  bool get isEnabled => onSelected != null;
+
+  @override
+  Widget build(BuildContext context) {
+    assert(debugCheckHasMaterial(context));
+    final ChipThemeData chipTheme = ChipTheme.of(context);
+    return RawChip(
+      avatar: avatar,
+      label: label,
+      labelStyle: labelStyle ?? (selected ? chipTheme.secondaryLabelStyle : null),
+      labelPadding: labelPadding,
+      onSelected: onSelected,
+      pressElevation: pressElevation,
+      selected: selected,
+      showCheckmark: false,
+      tooltip: tooltip,
+      side: side,
+      shape: shape,
+      clipBehavior: clipBehavior,
+      focusNode: focusNode,
+      autofocus: autofocus,
+      disabledColor: disabledColor,
+      selectedColor: selectedColor ?? chipTheme.secondarySelectedColor,
+      backgroundColor: backgroundColor,
+      padding: padding,
+      visualDensity: visualDensity,
+      isEnabled: isEnabled,
+      materialTapTargetSize: materialTapTargetSize,
+      elevation: elevation,
+      shadowColor: shadowColor,
+      selectedShadowColor: selectedShadowColor,
+      avatarBorder: avatarBorder,
+    );
+  }
+}

packages/flutter/lib/src/material/chip_filter.dart

+// Copyright 2014 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter/widgets.dart';
+
+import 'chip.dart';
+import 'debug.dart';
+import 'theme_data.dart';
+
+/// A material design filter chip.
+///
+/// Filter chips use tags or descriptive words as a way to filter content.
+///
+/// Filter chips are a good alternative to [Checkbox] or [Switch] widgets.
+/// Unlike these alternatives, filter chips allow for clearly delineated and
+/// exposed options in a compact area.
+///
+/// Requires one of its ancestors to be a [Material] widget.
+///
+/// {@tool snippet}
+///
+/// ```dart
+/// class ActorFilterEntry {
+///   const ActorFilterEntry(this.name, this.initials);
+///   final String name;
+///   final String initials;
+/// }
+///
+/// class CastFilter extends StatefulWidget {
+///   const CastFilter({Key? key}) : super(key: key);
+///
+///   @override
+///   State createState() => CastFilterState();
+/// }
+///
+/// class CastFilterState extends State<CastFilter> {
+///   final List<ActorFilterEntry> _cast = <ActorFilterEntry>[
+///     const ActorFilterEntry('Aaron Burr', 'AB'),
+///     const ActorFilterEntry('Alexander Hamilton', 'AH'),
+///     const ActorFilterEntry('Eliza Hamilton', 'EH'),
+///     const ActorFilterEntry('James Madison', 'JM'),
+///   ];
+///   final List<String> _filters = <String>[];
+///
+///   Iterable<Widget> get actorWidgets {
+///     return _cast.map((ActorFilterEntry actor) {
+///       return Padding(
+///         padding: const EdgeInsets.all(4.0),
+///         child: FilterChip(
+///           avatar: CircleAvatar(child: Text(actor.initials)),
+///           label: Text(actor.name),
+///           selected: _filters.contains(actor.name),
+///           onSelected: (bool value) {
+///             setState(() {
+///               if (value) {
+///                 _filters.add(actor.name);
+///               } else {
+///                 _filters.removeWhere((String name) {
+///                   return name == actor.name;
+///                 });
+///               }
+///             });
+///           },
+///         ),
+///       );
+///     });
+///   }
+///
+///   @override
+///   Widget build(BuildContext context) {
+///     return Column(
+///       mainAxisAlignment: MainAxisAlignment.center,
+///       children: <Widget>[
+///         Wrap(
+///           children: actorWidgets.toList(),
+///         ),
+///         Text('Look for: ${_filters.join(', ')}'),
+///       ],
+///     );
+///   }
+/// }
+/// ```
+/// {@end-tool}
+///
+/// See also:
+///
+///  * [Chip], a chip that displays information and can be deleted.
+///  * [InputChip], a chip that represents a complex piece of information, such
+///    as an entity (person, place, or thing) or conversational text, in a
+///    compact form.
+///  * [ChoiceChip], allows a single selection from a set of options. Choice
+///    chips contain related descriptive text or categories.
+///  * [ActionChip], represents an action related to primary content.
+///  * [CircleAvatar], which shows images or initials of people.
+///  * [Wrap], A widget that displays its children in multiple horizontal or
+///    vertical runs.
+///  * <https://material.io/design/components/chips.html>
+class FilterChip extends StatelessWidget
+    implements
+        ChipAttributes,
+        SelectableChipAttributes,
+        CheckmarkableChipAttributes,
+        DisabledChipAttributes {
+  /// Create a chip that acts like a checkbox.
+  ///
+  /// The [selected], [label], [autofocus], and [clipBehavior] arguments must
+  /// not be null. The [pressElevation] and [elevation] must be null or
+  /// non-negative. Typically, [pressElevation] is greater than [elevation].
+  const FilterChip({
+    Key? key,
+    this.avatar,
+    required this.label,
+    this.labelStyle,
+    this.labelPadding,
+    this.selected = false,
+    required this.onSelected,
+    this.pressElevation,
+    this.disabledColor,
+    this.selectedColor,
+    this.tooltip,
+    this.side,
+    this.shape,
+    this.clipBehavior = Clip.none,
+    this.focusNode,
+    this.autofocus = false,
+    this.backgroundColor,
+    this.padding,
+    this.visualDensity,
+    this.materialTapTargetSize,
+    this.elevation,
+    this.shadowColor,
+    this.selectedShadowColor,
+    this.showCheckmark,
+    this.checkmarkColor,
+    this.avatarBorder = const CircleBorder(),
+  }) : assert(selected != null),
+       assert(label != null),
+       assert(clipBehavior != null),
+       assert(autofocus != null),
+       assert(pressElevation == null || pressElevation >= 0.0),
+       assert(elevation == null || elevation >= 0.0),
+       super(key: key);
+
+  @override
+  final Widget? avatar;
+  @override
+  final Widget label;
+  @override
+  final TextStyle? labelStyle;
+  @override
+  final EdgeInsetsGeometry? labelPadding;
+  @override
+  final bool selected;
+  @override
+  final ValueChanged<bool>? onSelected;
+  @override
+  final double? pressElevation;
+  @override
+  final Color? disabledColor;
+  @override
+  final Color? selectedColor;
+  @override
+  final String? tooltip;
+  @override
+  final BorderSide? side;
+  @override
+  final OutlinedBorder? shape;
+  @override
+  final Clip clipBehavior;
+  @override
+  final FocusNode? focusNode;
+  @override
+  final bool autofocus;
+  @override
+  final Color? backgroundColor;
+  @override
+  final EdgeInsetsGeometry? padding;
+  @override
+  final VisualDensity? visualDensity;
+  @override
+  final MaterialTapTargetSize? materialTapTargetSize;
+  @override
+  final double? elevation;
+  @override
+  final Color? shadowColor;
+  @override
+  final Color? selectedShadowColor;
+  @override
+  final bool? showCheckmark;
+  @override
+  final Color? checkmarkColor;
+  @override
+  final ShapeBorder avatarBorder;
+
+  @override
+  bool get isEnabled => onSelected != null;
+
+  @override
+  Widget build(BuildContext context) {
+    assert(debugCheckHasMaterial(context));
+    return RawChip(
+      avatar: avatar,
+      label: label,
+      labelStyle: labelStyle,
+      labelPadding: labelPadding,
+      onSelected: onSelected,
+      pressElevation: pressElevation,
+      selected: selected,
+      tooltip: tooltip,
+      side: side,
+      shape: shape,
+      clipBehavior: clipBehavior,
+      focusNode: focusNode,
+      autofocus: autofocus,
+      backgroundColor: backgroundColor,
+      disabledColor: disabledColor,
+      selectedColor: selectedColor,
+      padding: padding,
+      visualDensity: visualDensity,
+      isEnabled: isEnabled,
+      materialTapTargetSize: materialTapTargetSize,
+      elevation: elevation,
+      shadowColor: shadowColor,
+      selectedShadowColor: selectedShadowColor,
+      showCheckmark: showCheckmark,
+      checkmarkColor: checkmarkColor,
+      avatarBorder: avatarBorder,
+    );
+  }
+}

packages/flutter/lib/src/material/chip_input.dart

+// Copyright 2014 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter/widgets.dart';
+
+import 'chip.dart';
+import 'debug.dart';
+import 'theme_data.dart';
+
+/// A material design input chip.
+///
+/// Input chips represent a complex piece of information, such as an entity
+/// (person, place, or thing) or conversational text, in a compact form.
+///
+/// Input chips can be made selectable by setting [onSelected], deletable by
+/// setting [onDeleted], and pressable like a button with [onPressed]. They have
+/// a [label], and they can have a leading icon (see [avatar]) and a trailing
+/// icon ([deleteIcon]). Colors and padding can be customized.
+///
+/// Requires one of its ancestors to be a [Material] widget.
+///
+/// Input chips work together with other UI elements. They can appear:
+///
+///  * In a [Wrap] widget.
+///  * In a horizontally scrollable list, like a [ListView] whose
+///    scrollDirection is [Axis.horizontal].
+///
+/// {@tool snippet}
+///
+/// ```dart
+/// InputChip(
+///   avatar: CircleAvatar(
+///     backgroundColor: Colors.grey.shade800,
+///     child: const Text('AB'),
+///   ),
+///   label: const Text('Aaron Burr'),
+///   onPressed: () {
+///     print('I am the one thing in life.');
+///   }
+/// )
+/// ```
+/// {@end-tool}
+///
+/// See also:
+///
+///  * [Chip], a chip that displays information and can be deleted.
+///  * [ChoiceChip], allows a single selection from a set of options. Choice
+///    chips contain related descriptive text or categories.
+///  * [FilterChip], uses tags or descriptive words as a way to filter content.
+///  * [ActionChip], represents an action related to primary content.
+///  * [CircleAvatar], which shows images or initials of people.
+///  * [Wrap], A widget that displays its children in multiple horizontal or
+///    vertical runs.
+///  * <https://material.io/design/components/chips.html>
+class InputChip extends StatelessWidget
+    implements
+        ChipAttributes,
+        DeletableChipAttributes,
+        SelectableChipAttributes,
+        CheckmarkableChipAttributes,
+        DisabledChipAttributes,
+        TappableChipAttributes {
+  /// Creates an [InputChip].
+  ///
+  /// The [onPressed] and [onSelected] callbacks must not both be specified at
+  /// the same time.
+  ///
+  /// The [label], [isEnabled], [selected], [autofocus], and [clipBehavior]
+  /// arguments must not be null. The [pressElevation] and [elevation] must be
+  /// null or non-negative. Typically, [pressElevation] is greater than
+  /// [elevation].
+  const InputChip({
+    Key? key,
+    this.avatar,
+    required this.label,
+    this.labelStyle,
+    this.labelPadding,
+    this.selected = false,
+    this.isEnabled = true,
+    this.onSelected,
+    this.deleteIcon,
+    this.onDeleted,
+    this.deleteIconColor,
+    this.deleteButtonTooltipMessage,
+    this.onPressed,
+    this.pressElevation,
+    this.disabledColor,
+    this.selectedColor,
+    this.tooltip,
+    this.side,
+    this.shape,
+    this.clipBehavior = Clip.none,
+    this.focusNode,
+    this.autofocus = false,
+    this.backgroundColor,
+    this.padding,
+    this.visualDensity,
+    this.materialTapTargetSize,
+    this.elevation,
+    this.shadowColor,
+    this.selectedShadowColor,
+    this.showCheckmark,
+    this.checkmarkColor,
+    this.avatarBorder = const CircleBorder(),
+    @Deprecated(
+      'Migrate to deleteButtonTooltipMessage. '
+      'This feature was deprecated after v2.10.0-0.3.pre.'
+    )
+    this.useDeleteButtonTooltip = true,
+  }) : assert(selected != null),
+       assert(isEnabled != null),
+       assert(label != null),
+       assert(clipBehavior != null),
+       assert(autofocus != null),
+       assert(pressElevation == null || pressElevation >= 0.0),
+       assert(elevation == null || elevation >= 0.0),
+       super(key: key);
+
+  @override
+  final Widget? avatar;
+  @override
+  final Widget label;
+  @override
+  final TextStyle? labelStyle;
+  @override
+  final EdgeInsetsGeometry? labelPadding;
+  @override
+  final bool selected;
+  @override
+  final bool isEnabled;
+  @override
+  final ValueChanged<bool>? onSelected;
+  @override
+  final Widget? deleteIcon;
+  @override
+  final VoidCallback? onDeleted;
+  @override
+  final Color? deleteIconColor;
+  @override
+  final String? deleteButtonTooltipMessage;
+  @override
+  final VoidCallback? onPressed;
+  @override
+  final double? pressElevation;
+  @override
+  final Color? disabledColor;
+  @override
+  final Color? selectedColor;
+  @override
+  final String? tooltip;
+  @override
+  final BorderSide? side;
+  @override
+  final OutlinedBorder? shape;
+  @override
+  final Clip clipBehavior;
+  @override
+  final FocusNode? focusNode;
+  @override
+  final bool autofocus;
+  @override
+  final Color? backgroundColor;
+  @override
+  final EdgeInsetsGeometry? padding;
+  @override
+  final VisualDensity? visualDensity;
+  @override
+  final MaterialTapTargetSize? materialTapTargetSize;
+  @override
+  final double? elevation;
+  @override
+  final Color? shadowColor;
+  @override
+  final Color? selectedShadowColor;
+  @override
+  final bool? showCheckmark;
+  @override
+  final Color? checkmarkColor;
+  @override
+  final ShapeBorder avatarBorder;
+  @override
+  @Deprecated(
+    'Migrate to deleteButtonTooltipMessage. '
+    'This feature was deprecated after v2.10.0-0.3.pre.'
+  )
+  final bool useDeleteButtonTooltip;
+
+  @override
+  Widget build(BuildContext context) {
+    assert(debugCheckHasMaterial(context));
+    return RawChip(
+      avatar: avatar,
+      label: label,
+      labelStyle: labelStyle,
+      labelPadding: labelPadding,
+      deleteIcon: deleteIcon,
+      onDeleted: onDeleted,
+      deleteIconColor: deleteIconColor,
+      useDeleteButtonTooltip: useDeleteButtonTooltip,
+      deleteButtonTooltipMessage: deleteButtonTooltipMessage,
+      onSelected: onSelected,
+      onPressed: onPressed,
+      pressElevation: pressElevation,
+      selected: selected,
+      disabledColor: disabledColor,
+      selectedColor: selectedColor,
+      tooltip: tooltip,
+      side: side,
+      shape: shape,
+      clipBehavior: clipBehavior,
+      focusNode: focusNode,
+      autofocus: autofocus,
+      backgroundColor: backgroundColor,
+      padding: padding,
+      visualDensity: visualDensity,
+      materialTapTargetSize: materialTapTargetSize,
+      elevation: elevation,
+      shadowColor: shadowColor,
+      selectedShadowColor: selectedShadowColor,
+      showCheckmark: showCheckmark,
+      checkmarkColor: checkmarkColor,
+      isEnabled: isEnabled && (onSelected != null || onDeleted != null || onPressed != null),
+      avatarBorder: avatarBorder,
+    );
+  }
+}

packages/flutter/test/material/chip_action_test.dart

+// Copyright 2014 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+/// Adds the basic requirements for a Chip.
+Widget wrapForChip({
+  required Widget child,
+  TextDirection textDirection = TextDirection.ltr,
+  double textScaleFactor = 1.0,
+  Brightness brightness = Brightness.light,
+}) {
+  return MaterialApp(
+    theme: ThemeData(brightness: brightness),
+    home: Directionality(
+      textDirection: textDirection,
+      child: MediaQuery(
+        data: MediaQueryData.fromWindow(WidgetsBinding.instance.window).copyWith(textScaleFactor: textScaleFactor),
+        child: Material(child: child),
+      ),
+    ),
+  );
+}
+
+void checkChipMaterialClipBehavior(WidgetTester tester, Clip clipBehavior) {
+  final Iterable<Material> materials = tester.widgetList<Material>(find.byType(Material));
+  // There should be two Material widgets, first Material is from the "_wrapForChip" and
+  // last Material is from the "RawChip".
+  expect(materials.length, 2);
+  // The last Material from `RawChip` should have the clip behavior.
+  expect(materials.last.clipBehavior, clipBehavior);
+}
+
+void main() {
+  testWidgets('ActionChip can be tapped', (WidgetTester tester) async {
+    await tester.pumpWidget(
+      MaterialApp(
+        home: Material(
+          child: ActionChip(
+            onPressed: () { },
+            label: const Text('action chip'),
+          ),
+        ),
+      ),
+    );
+
+    await tester.tap(find.byType(ActionChip));
+    expect(tester.takeException(), null);
+  });
+
+  testWidgets('ActionChip clipBehavior properly passes through to the Material', (WidgetTester tester) async {
+    const Text label = Text('label');
+    await tester.pumpWidget(wrapForChip(child: ActionChip(label: label, onPressed: () { })));
+    checkChipMaterialClipBehavior(tester, Clip.none);
+
+    await tester.pumpWidget(wrapForChip(child: ActionChip(label: label, clipBehavior: Clip.antiAlias, onPressed: () { })));
+    checkChipMaterialClipBehavior(tester, Clip.antiAlias);
+  });
+}

packages/flutter/test/material/chip_choice_test.dart

+// Copyright 2014 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import '../rendering/mock_canvas.dart';
+
+RenderBox getMaterialBox(WidgetTester tester) {
+  return tester.firstRenderObject<RenderBox>(
+    find.descendant(
+      of: find.byType(RawChip),
+      matching: find.byType(CustomPaint),
+    ),
+  );
+}
+
+Material getMaterial(WidgetTester tester) {
+  return tester.widget<Material>(
+    find.descendant(
+      of: find.byType(RawChip),
+      matching: find.byType(Material),
+    ),
+  );
+}
+
+DefaultTextStyle getLabelStyle(WidgetTester tester, String labelText) {
+  return tester.widget(
+    find.ancestor(
+      of: find.text(labelText),
+      matching: find.byType(DefaultTextStyle),
+    ).first,
+  );
+}
+
+/// Adds the basic requirements for a Chip.
+Widget wrapForChip({
+  required Widget child,
+  TextDirection textDirection = TextDirection.ltr,
+  double textScaleFactor = 1.0,
+  Brightness brightness = Brightness.light,
+}) {
+  return MaterialApp(
+    theme: ThemeData(brightness: brightness),
+    home: Directionality(
+      textDirection: textDirection,
+      child: MediaQuery(
+        data: MediaQueryData.fromWindow(WidgetsBinding.instance.window).copyWith(textScaleFactor: textScaleFactor),
+        child: Material(child: child),
+      ),
+    ),
+  );
+}
+
+void checkChipMaterialClipBehavior(WidgetTester tester, Clip clipBehavior) {
+  final Iterable<Material> materials = tester.widgetList<Material>(find.byType(Material));
+  // There should be two Material widgets, first Material is from the "_wrapForChip" and
+  // last Material is from the "RawChip".
+  expect(materials.length, 2);
+  // The last Material from `RawChip` should have the clip behavior.
+  expect(materials.last.clipBehavior, clipBehavior);
+}
+
+void main() {
+  testWidgets('ChoiceChip defaults', (WidgetTester tester) async {
+    Widget buildFrame(Brightness brightness) {
+      return MaterialApp(
+        theme: ThemeData(brightness: brightness),
+        home: const Scaffold(
+          body: Center(
+            child: ChoiceChip(
+              label: Text('Chip A'),
+              selected: true,
+            ),
+          ),
+        ),
+      );
+    }
+
+    await tester.pumpWidget(buildFrame(Brightness.light));
+    expect(getMaterialBox(tester), paints..path(color: const Color(0x3d000000)));
+    expect(tester.getSize(find.byType(ChoiceChip)), const Size(108.0, 48.0));
+    expect(getMaterial(tester).color, null);
+    expect(getMaterial(tester).elevation, 0);
+    expect(getMaterial(tester).shape, const StadiumBorder());
+    expect(getLabelStyle(tester, 'Chip A').style.color?.value, 0xde000000);
+
+    await tester.pumpWidget(buildFrame(Brightness.dark));
+    await tester.pumpAndSettle(); // Theme transition animation
+    expect(getMaterialBox(tester), paints..path(color: const Color(0x3dffffff)));
+    expect(tester.getSize(find.byType(ChoiceChip)), const Size(108.0, 48.0));
+    expect(getMaterial(tester).color, null);
+    expect(getMaterial(tester).elevation, 0);
+    expect(getMaterial(tester).shape, const StadiumBorder());
+    expect(getLabelStyle(tester, 'Chip A').style.color?.value, 0xdeffffff);
+  });
+
+  testWidgets('ChoiceChip can be tapped', (WidgetTester tester) async {
+    await tester.pumpWidget(
+      const MaterialApp(
+        home: Material(
+          child: ChoiceChip(
+            selected: false,
+            label: Text('choice chip'),
+          ),
+        ),
+      ),
+    );
+
+    await tester.tap(find.byType(ChoiceChip));
+    expect(tester.takeException(), null);
+  });
+
+  testWidgets('ChoiceChip clipBehavior properly passes through to the Material', (WidgetTester tester) async {
+    const Text label = Text('label');
+    await tester.pumpWidget(wrapForChip(child: const ChoiceChip(label: label, selected: false)));
+    checkChipMaterialClipBehavior(tester, Clip.none);
+
+    await tester.pumpWidget(wrapForChip(child: const ChoiceChip(label: label, selected: false, clipBehavior: Clip.antiAlias)));
+    checkChipMaterialClipBehavior(tester, Clip.antiAlias);
+  });
+}

packages/flutter/test/material/chip_filter_test.dart

+// Copyright 2014 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import '../rendering/mock_canvas.dart';
+
+/// Adds the basic requirements for a Chip.
+Widget wrapForChip({
+  required Widget child,
+  TextDirection textDirection = TextDirection.ltr,
+  double textScaleFactor = 1.0,
+  Brightness brightness = Brightness.light,
+}) {
+  return MaterialApp(
+    theme: ThemeData(brightness: brightness),
+    home: Directionality(
+      textDirection: textDirection,
+      child: MediaQuery(
+        data: MediaQueryData.fromWindow(WidgetsBinding.instance.window).copyWith(textScaleFactor: textScaleFactor),
+        child: Material(child: child),
+      ),
+    ),
+  );
+}
+
+Future<void> pumpCheckmarkChip(
+  WidgetTester tester, {
+  required Widget chip,
+  Color? themeColor,
+  Brightness brightness = Brightness.light,
+}) async {
+  await tester.pumpWidget(
+    wrapForChip(
+      brightness: brightness,
+      child: Builder(
+        builder: (BuildContext context) {
+          final ChipThemeData chipTheme = ChipTheme.of(context);
+          return ChipTheme(
+            data: themeColor == null ? chipTheme : chipTheme.copyWith(
+              checkmarkColor: themeColor,
+            ),
+            child: chip,
+          );
+        },
+      ),
+    ),
+  );
+}
+
+Widget selectedFilterChip({ Color? checkmarkColor }) {
+  return FilterChip(
+    label: const Text('InputChip'),
+    selected: true,
+    showCheckmark: true,
+    checkmarkColor: checkmarkColor,
+    onSelected: (bool _) { },
+  );
+}
+
+void expectCheckmarkColor(Finder finder, Color color) {
+  expect(
+    finder,
+    paints
+      // The first path that is painted is the selection overlay. We do not care
+      // how it is painted but it has to be added it to this pattern so that the
+      // check mark can be checked next.
+      ..path()
+      // The second path that is painted is the check mark.
+      ..path(color: color),
+  );
+}
+
+void checkChipMaterialClipBehavior(WidgetTester tester, Clip clipBehavior) {
+  final Iterable<Material> materials = tester.widgetList<Material>(find.byType(Material));
+  // There should be two Material widgets, first Material is from the "_wrapForChip" and
+  // last Material is from the "RawChip".
+  expect(materials.length, 2);
+  // The last Material from `RawChip` should have the clip behavior.
+  expect(materials.last.clipBehavior, clipBehavior);
+}
+
+void main() {
+  testWidgets('FilterChip can be tapped', (WidgetTester tester) async {
+    await tester.pumpWidget(
+      MaterialApp(
+        home: Material(
+          child: FilterChip(
+            onSelected: (bool valueChanged) { },
+            label: const Text('filter chip'),
+          ),
+        ),
+      ),
+    );
+
+    await tester.tap(find.byType(FilterChip));
+    expect(tester.takeException(), null);
+  });
+
+  testWidgets('Filter chip check mark color is determined by platform brightness when light', (WidgetTester tester) async {
+    await pumpCheckmarkChip(
+      tester,
+      chip: selectedFilterChip(),
+    );
+
+    expectCheckmarkColor(
+      find.byType(FilterChip),
+      Colors.black.withAlpha(0xde),
+    );
+  });
+
+  testWidgets('Filter chip check mark color is determined by platform brightness when dark', (WidgetTester tester) async {
+    await pumpCheckmarkChip(
+      tester,
+      chip: selectedFilterChip(),
+      brightness: Brightness.dark,
+    );
+
+    expectCheckmarkColor(
+      find.byType(FilterChip),
+      Colors.white.withAlpha(0xde),
+    );
+  });
+
+  testWidgets('Filter chip check mark color can be set by the chip theme', (WidgetTester tester) async {
+    await pumpCheckmarkChip(
+      tester,
+      chip: selectedFilterChip(),
+      themeColor: const Color(0xff00ff00),
+    );
+
+    expectCheckmarkColor(
+      find.byType(FilterChip),
+      const Color(0xff00ff00),
+    );
+  });
+
+  testWidgets('Filter chip check mark color can be set by the chip constructor', (WidgetTester tester) async {
+    await pumpCheckmarkChip(
+      tester,
+      chip: selectedFilterChip(checkmarkColor: const Color(0xff00ff00)),
+    );
+
+    expectCheckmarkColor(
+      find.byType(FilterChip),
+      const Color(0xff00ff00),
+    );
+  });
+
+  testWidgets('Filter chip check mark color is set by chip constructor even when a theme color is specified', (WidgetTester tester) async {
+    await pumpCheckmarkChip(
+      tester,
+      chip: selectedFilterChip(checkmarkColor: const Color(0xffff0000)),
+      themeColor: const Color(0xff00ff00),
+    );
+
+    expectCheckmarkColor(
+      find.byType(FilterChip),
+      const Color(0xffff0000),
+    );
+  });
+
+  testWidgets('FilterChip clipBehavior properly passes through to the Material', (WidgetTester tester) async {
+    const Text label = Text('label');
+    await tester.pumpWidget(wrapForChip(child: FilterChip(label: label, onSelected: (bool b) { })));
+    checkChipMaterialClipBehavior(tester, Clip.none);
+
+    await tester.pumpWidget(wrapForChip(child: FilterChip(label: label, onSelected: (bool b) { }, clipBehavior: Clip.antiAlias)));
+    checkChipMaterialClipBehavior(tester, Clip.antiAlias);
+  });
+}

packages/flutter/test/material/chip_input_test.dart

+// Copyright 2014 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import '../rendering/mock_canvas.dart';
+
+/// Adds the basic requirements for a Chip.
+Widget wrapForChip({
+  required Widget child,
+  TextDirection textDirection = TextDirection.ltr,
+  double textScaleFactor = 1.0,
+  Brightness brightness = Brightness.light,
+}) {
+  return MaterialApp(
+    theme: ThemeData(brightness: brightness),
+    home: Directionality(
+      textDirection: textDirection,
+      child: MediaQuery(
+        data: MediaQueryData.fromWindow(WidgetsBinding.instance.window).copyWith(textScaleFactor: textScaleFactor),
+        child: Material(child: child),
+      ),
+    ),
+  );
+}
+
+Widget selectedInputChip({ Color? checkmarkColor }) {
+  return InputChip(
+    label: const Text('InputChip'),
+    selected: true,
+    showCheckmark: true,
+    checkmarkColor: checkmarkColor,
+  );
+}
+
+
+Future<void> pumpCheckmarkChip(
+  WidgetTester tester, {
+  required Widget chip,
+  Color? themeColor,
+  Brightness brightness = Brightness.light,
+}) async {
+  await tester.pumpWidget(
+    wrapForChip(
+      brightness: brightness,
+      child: Builder(
+        builder: (BuildContext context) {
+          final ChipThemeData chipTheme = ChipTheme.of(context);
+          return ChipTheme(
+            data: themeColor == null ? chipTheme : chipTheme.copyWith(
+              checkmarkColor: themeColor,
+            ),
+            child: chip,
+          );
+        },
+      ),
+    ),
+  );
+}
+
+void expectCheckmarkColor(Finder finder, Color color) {
+  expect(
+    finder,
+    paints
+      // The first path that is painted is the selection overlay. We do not care
+      // how it is painted but it has to be added it to this pattern so that the
+      // check mark can be checked next.
+      ..path()
+      // The second path that is painted is the check mark.
+      ..path(color: color),
+  );
+}
+
+void checkChipMaterialClipBehavior(WidgetTester tester, Clip clipBehavior) {
+  final Iterable<Material> materials = tester.widgetList<Material>(find.byType(Material));
+  // There should be two Material widgets, first Material is from the "_wrapForChip" and
+  // last Material is from the "RawChip".
+  expect(materials.length, 2);
+  // The last Material from `RawChip` should have the clip behavior.
+  expect(materials.last.clipBehavior, clipBehavior);
+}
+
+void main() {
+  testWidgets('InputChip can be tapped', (WidgetTester tester) async {
+    await tester.pumpWidget(
+      const MaterialApp(
+        home: Material(
+          child: InputChip(
+            label: Text('input chip'),
+          ),
+        ),
+      ),
+    );
+
+    await tester.tap(find.byType(InputChip));
+    expect(tester.takeException(), null);
+  });
+
+  testWidgets('loses focus when disabled', (WidgetTester tester) async {
+    final FocusNode focusNode = FocusNode(debugLabel: 'InputChip');
+    await tester.pumpWidget(
+      wrapForChip(
+        child: InputChip(
+          focusNode: focusNode,
+          autofocus: true,
+          shape: const RoundedRectangleBorder(),
+          avatar: const CircleAvatar(child: Text('A')),
+          label: const Text('Chip A'),
+          onPressed: () { },
+        ),
+      ),
+    );
+    await tester.pump();
+    expect(focusNode.hasPrimaryFocus, isTrue);
+
+    await tester.pumpWidget(
+      wrapForChip(
+        child: InputChip(
+          focusNode: focusNode,
+          autofocus: true,
+          shape: const RoundedRectangleBorder(),
+          avatar: const CircleAvatar(child: Text('A')),
+          label: const Text('Chip A'),
+        ),
+      ),
+    );
+    await tester.pump();
+    expect(focusNode.hasPrimaryFocus, isFalse);
+  });
+
+  testWidgets('cannot be traversed to when disabled', (WidgetTester tester) async {
+    final FocusNode focusNode1 = FocusNode(debugLabel: 'InputChip 1');
+    final FocusNode focusNode2 = FocusNode(debugLabel: 'InputChip 2');
+    await tester.pumpWidget(
+      wrapForChip(
+        child: Column(
+          children: <Widget>[
+            InputChip(
+              focusNode: focusNode1,
+              autofocus: true,
+              label: const Text('Chip A'),
+              onPressed: () { },
+            ),
+            InputChip(
+              focusNode: focusNode2,
+              autofocus: true,
+              label: const Text('Chip B'),
+            ),
+          ],
+        ),
+      ),
+    );
+    await tester.pump();
+    expect(focusNode1.hasPrimaryFocus, isTrue);
+    expect(focusNode2.hasPrimaryFocus, isFalse);
+
+    expect(focusNode1.nextFocus(), isTrue);
+
+    await tester.pump();
+    expect(focusNode1.hasPrimaryFocus, isTrue);
+    expect(focusNode2.hasPrimaryFocus, isFalse);
+  });
+
+  testWidgets('Input chip check mark color is determined by platform brightness when light', (WidgetTester tester) async {
+    await pumpCheckmarkChip(
+      tester,
+      chip: selectedInputChip(),
+    );
+
+    expectCheckmarkColor(
+      find.byType(InputChip),
+      Colors.black.withAlpha(0xde),
+    );
+  });
+
+  testWidgets('Input chip check mark color is determined by platform brightness when dark', (WidgetTester tester) async {
+    await pumpCheckmarkChip(
+      tester,
+      chip: selectedInputChip(),
+      brightness: Brightness.dark,
+    );
+
+    expectCheckmarkColor(
+      find.byType(InputChip),
+      Colors.white.withAlpha(0xde),
+    );
+  });
+
+  testWidgets('Input chip check mark color can be set by the chip theme', (WidgetTester tester) async {
+    await pumpCheckmarkChip(
+      tester,
+      chip: selectedInputChip(),
+      themeColor: const Color(0xff00ff00),
+    );
+
+    expectCheckmarkColor(
+      find.byType(InputChip),
+      const Color(0xff00ff00),
+    );
+  });
+
+  testWidgets('Input chip check mark color can be set by the chip constructor', (WidgetTester tester) async {
+    await pumpCheckmarkChip(
+      tester,
+      chip: selectedInputChip(checkmarkColor: const Color(0xff00ff00)),
+    );
+
+    expectCheckmarkColor(
+      find.byType(InputChip),
+      const Color(0xff00ff00),
+    );
+  });
+
+  testWidgets('Input chip check mark color is set by chip constructor even when a theme color is specified', (WidgetTester tester) async {
+    await pumpCheckmarkChip(
+      tester,
+      chip: selectedInputChip(checkmarkColor: const Color(0xffff0000)),
+      themeColor: const Color(0xff00ff00),
+    );
+
+    expectCheckmarkColor(
+      find.byType(InputChip),
+      const Color(0xffff0000),
+    );
+  });
+
+  testWidgets('InputChip clipBehavior properly passes through to the Material', (WidgetTester tester) async {
+    const Text label = Text('label');
+    await tester.pumpWidget(wrapForChip(child: const InputChip(label: label)));
+    checkChipMaterialClipBehavior(tester, Clip.none);
+
+    await tester.pumpWidget(wrapForChip(child: const InputChip(label: label, clipBehavior: Clip.antiAlias)));
+    checkChipMaterialClipBehavior(tester, Clip.antiAlias);
+  });
+}