Switch to SemanticAction (#4791)

This patch updates the framework to use the new SemanticAction in
semantics.mojom.

bin/cache/engine.version

@@ -1 +1 @@
-bb9865538b3daf2b452fdff9e767cee5139695e1
+71ce354a447dc3384c4e8b0f031eaa9f313d29e9

packages/flutter/lib/src/gestures/drag.dart

@@ -90,7 +90,7 @@ class DragEndDetails {
   /// Creates details for a [GestureDragEndCallback].
   ///
   /// The [velocity] argument must not be null.
-  DragEndDetails({ this.velocity }) {
+  DragEndDetails({ this.velocity: Velocity.zero }) {
     assert(velocity != null);
   }
 

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

@@ -268,29 +268,19 @@ abstract class RenderToggleable extends RenderConstrainedBox implements Semantic
   @override
   Iterable<SemanticAnnotator> getSemanticAnnotators() sync* {
     yield (SemanticsNode semantics) {
-      semantics.hasCheckedState = true;
+      semantics
-      semantics.isChecked = _value;
+        ..hasCheckedState = true
-      semantics.canBeTapped = isInteractive;
+        ..isChecked = _value;
+      if (isInteractive)
+        semantics.addAction(SemanticAction.tap);
     };
   }
 
   @override
-  void handleSemanticTap() => _handleTap();
+  void performAction(SemanticAction action) {
-
+    if (action == SemanticAction.tap)
-  @override
+      _handleTap();
-  void handleSemanticLongPress() { }
+  }
-
-  @override
-  void handleSemanticScrollLeft() { }
-
-  @override
-  void handleSemanticScrollRight() { }
-
-  @override
-  void handleSemanticScrollUp() { }
-
-  @override
-  void handleSemanticScrollDown() { }
 
   @override
   void debugFillDescription(List<String> description) {

packages/flutter/lib/src/rendering/proxy_box.dart

@@ -2119,63 +2119,65 @@ class RenderSemanticsGestureHandler extends RenderProxyBox implements SemanticAc
   Iterable<SemanticAnnotator> getSemanticAnnotators() sync* {
     if (hasSemantics) {
       yield (SemanticsNode semantics) {
-        semantics.canBeTapped = onTap != null;
+        if (onTap != null)
-        semantics.canBeLongPressed = onLongPress != null;
+          semantics.addAction(SemanticAction.tap);
-        semantics.canBeScrolledHorizontally = onHorizontalDragUpdate != null;
+        if (onLongPress != null)
-        semantics.canBeScrolledVertically = onVerticalDragUpdate != null;
+          semantics.addAction(SemanticAction.longPress);
+        if (onHorizontalDragUpdate != null)
+          semantics.addHorizontalScrollingActions();
+        if (onVerticalDragUpdate != null)
+          semantics.addVerticalScrollingActions();
       };
     }
   }
 
   @override
-  void handleSemanticTap() {
+  void performAction(SemanticAction action) {
-    if (onTap != null)
+    switch (action) {
-      onTap();
+      case SemanticAction.tap:
-  }
+        if (onTap != null)
-
+          onTap();
-  @override
+        break;
-  void handleSemanticLongPress() {
+      case SemanticAction.longPress:
-    if (onLongPress != null)
+        if (onLongPress != null)
-      onLongPress();
+          onLongPress();
-  }
+        break;
-
+      case SemanticAction.scrollLeft:
-  @override
+        if (onHorizontalDragUpdate != null) {
-  void handleSemanticScrollLeft() {
+          final double primaryDelta = size.width * -scrollFactor;
-    if (onHorizontalDragUpdate != null) {
+          onHorizontalDragUpdate(new DragUpdateDetails(
-      final double primaryDelta = size.width * -scrollFactor;
+            delta: new Offset(primaryDelta, 0.0), primaryDelta: primaryDelta
-      onHorizontalDragUpdate(new DragUpdateDetails(
+          ));
-        delta: new Offset(primaryDelta, 0.0), primaryDelta: primaryDelta
+        }
-      ));
+        break;
-    }
+      case SemanticAction.scrollRight:
-  }
+        if (onHorizontalDragUpdate != null) {
-
+          final double primaryDelta = size.width * scrollFactor;
-  @override
+          onHorizontalDragUpdate(new DragUpdateDetails(
-  void handleSemanticScrollRight() {
+            delta: new Offset(primaryDelta, 0.0), primaryDelta: primaryDelta
-    if (onHorizontalDragUpdate != null) {
+          ));
-      final double primaryDelta = size.width * scrollFactor;
+        }
-      onHorizontalDragUpdate(new DragUpdateDetails(
+        break;
-        delta: new Offset(primaryDelta, 0.0), primaryDelta: primaryDelta
+      case SemanticAction.scrollUp:
-      ));
+        if (onVerticalDragUpdate != null) {
-    }
+          final double primaryDelta = size.height * -scrollFactor;
-  }
+          onVerticalDragUpdate(new DragUpdateDetails(
-
+            delta: new Offset(0.0, primaryDelta), primaryDelta: primaryDelta
-  @override
+          ));
-  void handleSemanticScrollUp() {
+        }
-    if (onVerticalDragUpdate != null) {
+        break;
-      final double primaryDelta = size.height * -scrollFactor;
+      case SemanticAction.scrollDown:
-      onVerticalDragUpdate(new DragUpdateDetails(
+        if (onVerticalDragUpdate != null) {
-        delta: new Offset(0.0, primaryDelta), primaryDelta: primaryDelta
+          final double primaryDelta = size.height * scrollFactor;
-      ));
+          onVerticalDragUpdate(new DragUpdateDetails(
-    }
+            delta: new Offset(0.0, primaryDelta), primaryDelta: primaryDelta
-  }
+          ));
-
+        }
-  @override
+        break;
-  void handleSemanticScrollDown() {
+      case SemanticAction.increase:
-    if (onVerticalDragUpdate != null) {
+      case SemanticAction.decrease:
-      final double primaryDelta = size.height * scrollFactor;
+        assert(false);
-      onVerticalDragUpdate(new DragUpdateDetails(
+        break;
-        delta: new Offset(0.0, primaryDelta), primaryDelta: primaryDelta
-      ));
     }
   }
 }

packages/flutter/lib/src/rendering/semantics.dart

@@ -7,11 +7,34 @@ import 'dart:ui' show Rect;
 
 import 'package:flutter/foundation.dart';
 import 'package:flutter/painting.dart';
+import 'package:meta/meta.dart';
 import 'package:sky_services/semantics/semantics.mojom.dart' as mojom;
 import 'package:vector_math/vector_math_64.dart';
 
 import 'node.dart';
 
+enum SemanticAction {
+  tap,
+  longPress,
+  scrollLeft,
+  scrollRight,
+  scrollUp,
+  scrollDown,
+  increase,
+  decrease,
+}
+
+/// Interface for [RenderObject]s to implement when they want to support
+/// being tapped, etc.
+///
+/// These handlers will only be called if the relevant flag is set
+/// (e.g. [handleSemanticTap]() will only be called if
+/// [SemanticsNode.canBeTapped] is true, [handleSemanticScrollDown]() will only
+/// be called if [SemanticsNode.canBeScrolledVertically] is true, etc).
+abstract class SemanticActionHandler { // ignore: one_member_abstracts
+  void performAction(SemanticAction action);
+}
+
 /// The type of function returned by [RenderObject.getSemanticAnnotators()].
 ///
 /// These callbacks are called with the [SemanticsNode] object that
@@ -22,40 +45,9 @@ import 'node.dart';
 /// contract that semantic annotators must follow.
 typedef void SemanticAnnotator(SemanticsNode semantics);
 
-/// Interface for [RenderObject]s to implement when they want to support
-/// being tapped, etc.
-///
-/// These handlers will only be called if the relevant flag is set
-/// (e.g. [handleSemanticTap]() will only be called if
-/// [SemanticsNode.canBeTapped] is true, [handleSemanticScrollDown]() will only
-/// be called if [SemanticsNode.canBeScrolledVertically] is true, etc).
-abstract class SemanticActionHandler {
-  /// Called when the user taps on the render object.
-  void handleSemanticTap() { }
-
-  /// Called when the user presses on the render object for a long period of time.
-  void handleSemanticLongPress() { }
-
-  /// Called when the user scrolls to the left.
-  void handleSemanticScrollLeft() { }
-
-  /// Called when the user scrolls to the right.
-  void handleSemanticScrollRight() { }
-
-  /// Called when the user scrolls up.
-  void handleSemanticScrollUp() { }
-
-  /// Called when the user scrolls down.
-  void handleSemanticScrollDown() { }
-}
-
 enum _SemanticFlags {
   mergeAllDescendantsIntoThisNode,
   inheritedMergeAllDescendantsIntoThisNode, // whether an ancestor had mergeAllDescendantsIntoThisNode set
-  canBeTapped,
-  canBeLongPressed,
-  canBeScrolledHorizontally,
-  canBeScrolledVertically,
   hasCheckedState,
   isChecked,
 }
@@ -137,6 +129,27 @@ class SemanticsNode extends AbstractNode {
   // FLAGS AND LABELS
   // These are supposed to be set by SemanticAnnotator obtained from getSemanticAnnotators
 
+  final Set<SemanticAction> _actions = new Set<SemanticAction>();
+
+  void addAction(SemanticAction action) {
+    if (_actions.add(action))
+      _markDirty();
+  }
+
+  void addHorizontalScrollingActions() {
+    addAction(SemanticAction.scrollLeft);
+    addAction(SemanticAction.scrollRight);
+  }
+
+  void addVerticalScrollingActions() {
+    addAction(SemanticAction.scrollUp);
+    addAction(SemanticAction.scrollDown);
+  }
+
+  bool _hasAction(SemanticAction action) {
+    return _actionHandler != null && _actions.contains(action);
+  }
+
   BitField<_SemanticFlags> _flags = new BitField<_SemanticFlags>.filled(_SemanticFlags.values.length, false);
 
   void _setFlag(_SemanticFlags flag, bool value, { bool needsHandler: false }) {
@@ -148,10 +161,6 @@ class SemanticsNode extends AbstractNode {
     }
   }
 
-  bool _canHandle(_SemanticFlags flag) {
-    return _actionHandler != null && _flags[flag];
-  }
-
   /// Whether all this node and all of its descendants should be treated as one logical entity.
   bool get mergeAllDescendantsIntoThisNode => _flags[_SemanticFlags.mergeAllDescendantsIntoThisNode];
   set mergeAllDescendantsIntoThisNode(bool value) => _setFlag(_SemanticFlags.mergeAllDescendantsIntoThisNode, value);
@@ -161,22 +170,6 @@ class SemanticsNode extends AbstractNode {
 
   bool get _shouldMergeAllDescendantsIntoThisNode => mergeAllDescendantsIntoThisNode || _inheritedMergeAllDescendantsIntoThisNode;
 
-  /// Whether this node responds to tap gestures.
-  bool get canBeTapped => _flags[_SemanticFlags.canBeTapped];
-  set canBeTapped(bool value) => _setFlag(_SemanticFlags.canBeTapped, value, needsHandler: true);
-
-  /// Whether this node responds to long-press gestures.
-  bool get canBeLongPressed => _flags[_SemanticFlags.canBeLongPressed];
-  set canBeLongPressed(bool value) => _setFlag(_SemanticFlags.canBeLongPressed, value, needsHandler: true);
-
-  /// Whether this node responds to horizontal scrolling.
-  bool get canBeScrolledHorizontally => _flags[_SemanticFlags.canBeScrolledHorizontally];
-  set canBeScrolledHorizontally(bool value) => _setFlag(_SemanticFlags.canBeScrolledHorizontally, value, needsHandler: true);
-
-  /// Whether this node responds to vertical scrolling.
-  bool get canBeScrolledVertically => _flags[_SemanticFlags.canBeScrolledVertically];
-  set canBeScrolledVertically(bool value) => _setFlag(_SemanticFlags.canBeScrolledVertically, value, needsHandler: true);
-
   /// Whether this node has Boolean state that can be controlled by the user.
   bool get hasCheckedState => _flags[_SemanticFlags.hasCheckedState];
   set hasCheckedState(bool value) => _setFlag(_SemanticFlags.hasCheckedState, value);
@@ -199,6 +192,7 @@ class SemanticsNode extends AbstractNode {
   /// Restore this node to its default state.
   void reset() {
     bool hadInheritedMergeAllDescendantsIntoThisNode = _inheritedMergeAllDescendantsIntoThisNode;
+    _actions.clear();
     _flags.reset();
     if (hadInheritedMergeAllDescendantsIntoThisNode)
       _inheritedMergeAllDescendantsIntoThisNode = true;
@@ -370,21 +364,16 @@ class SemanticsNode extends AbstractNode {
       result.geometry.width = math.max(rect.width, 0.0);
       result.geometry.height = math.max(rect.height, 0.0);
       result.flags = new mojom.SemanticFlags();
-      result.flags.canBeTapped = canBeTapped;
-      result.flags.canBeLongPressed = canBeLongPressed;
-      result.flags.canBeScrolledHorizontally = canBeScrolledHorizontally;
-      result.flags.canBeScrolledVertically = canBeScrolledVertically;
       result.flags.hasCheckedState = hasCheckedState;
       result.flags.isChecked = isChecked;
       result.strings = new mojom.SemanticStrings();
       result.strings.label = label;
       List<mojom.SemanticsNode> children = <mojom.SemanticsNode>[];
+      Set<SemanticAction> mergedActions = new Set<SemanticAction>();
+      mergedActions.addAll(_actions);
       if (_shouldMergeAllDescendantsIntoThisNode) {
         _visitDescendants((SemanticsNode node) {
-          result.flags.canBeTapped = result.flags.canBeTapped || node.canBeTapped;
+          mergedActions.addAll(node._actions);
-          result.flags.canBeLongPressed = result.flags.canBeLongPressed || node.canBeLongPressed;
-          result.flags.canBeScrolledHorizontally = result.flags.canBeScrolledHorizontally || node.canBeScrolledHorizontally;
-          result.flags.canBeScrolledVertically = result.flags.canBeScrolledVertically || node.canBeScrolledVertically;
           result.flags.hasCheckedState = result.flags.hasCheckedState || node.hasCheckedState;
           result.flags.isChecked = result.flags.isChecked || node.isChecked;
           if (node.label != '')
@@ -400,6 +389,9 @@ class SemanticsNode extends AbstractNode {
         }
       }
       result.children = children;
+      result.actions = <int>[];
+      for (SemanticAction action in mergedActions)
+        result.actions.add(action.index);
       _dirty = false;
     }
     return result;
@@ -499,37 +491,47 @@ class SemanticsNode extends AbstractNode {
     _dirtyNodes.clear();
   }
 
-  static SemanticActionHandler _getSemanticActionHandlerForId(int id, { _SemanticFlags neededFlag }) {
+  static SemanticActionHandler _getSemanticActionHandlerForId(int id, { @required SemanticAction action }) {
-    assert(neededFlag != null);
+    assert(action != null);
     SemanticsNode result = _nodes[id];
-    if (result != null && result._shouldMergeAllDescendantsIntoThisNode && !result._canHandle(neededFlag)) {
+    if (result != null && result._shouldMergeAllDescendantsIntoThisNode && !result._hasAction(action)) {
       result._visitDescendants((SemanticsNode node) {
-        if (node._actionHandler != null && node._flags[neededFlag]) {
+        if (node._actionHandler != null && node._hasAction(action)) {
           result = node;
           return false; // found node, abort walk
         }
         return true; // continue walk
       });
     }
-    if (result == null || !result._canHandle(neededFlag))
+    if (result == null || !result._hasAction(action))
       return null;
     return result._actionHandler;
   }
 
   @override
   String toString() {
-    return '$runtimeType($_id'
+    StringBuffer buffer = new StringBuffer();
-             '${_dirty ? " (${ _dirtyNodes.contains(this) ? 'dirty' : 'STALE' })" : ""}'
+    buffer.write('$runtimeType($_id');
-             '${_shouldMergeAllDescendantsIntoThisNode ? " (leaf merge)" : ""}'
+    if (_dirty)
-             '; $rect'
+      buffer.write(" (${ _dirtyNodes.contains(this) ? 'dirty' : 'STALE' })");
-             '${wasAffectedByClip ? " (clipped)" : ""}'
+    if (_shouldMergeAllDescendantsIntoThisNode)
-             '${canBeTapped ? "; canBeTapped" : ""}'
+      buffer.write(' (leaf merge)');
-             '${canBeLongPressed ? "; canBeLongPressed" : ""}'
+    buffer.write('; $rect');
-             '${canBeScrolledHorizontally ? "; canBeScrolledHorizontally" : ""}'
+    if (wasAffectedByClip)
-             '${canBeScrolledVertically ? "; canBeScrolledVertically" : ""}'
+      buffer.write(' (clipped)');
-             '${hasCheckedState ? (isChecked ? "; checked" : "; unchecked") : ""}'
+    for (SemanticAction action in _actions) {
-             '${label != "" ? "; \"$label\"" : ""}'
+      buffer.write('; $action');
-           ')';
+    }
+    if (hasCheckedState) {
+      if (isChecked)
+        buffer.write('; checked');
+      else
+        buffer.write('; unchecked');
+    }
+    if (label.isNotEmpty)
+      buffer.write('; "$label"');
+    buffer.write(')');
+    return buffer.toString();
   }
 
   /// Returns a string representation of this node and its descendants.
@@ -556,32 +558,9 @@ class SemanticsServer extends mojom.SemanticsServer {
   }
 
   @override
-  void tap(int nodeID) {
+  void performAction(int id, mojom.SemanticAction encodedAction) {
-    SemanticsNode._getSemanticActionHandlerForId(nodeID, neededFlag: _SemanticFlags.canBeTapped)?.handleSemanticTap();
+    SemanticAction action = SemanticAction.values[encodedAction.mojoEnumValue];
-  }
+    SemanticActionHandler node = SemanticsNode._getSemanticActionHandlerForId(id, action: action);
-
+    node?.performAction(action);
-  @override
-  void longPress(int nodeID) {
-    SemanticsNode._getSemanticActionHandlerForId(nodeID, neededFlag: _SemanticFlags.canBeLongPressed)?.handleSemanticLongPress();
-  }
-
-  @override
-  void scrollLeft(int nodeID) {
-    SemanticsNode._getSemanticActionHandlerForId(nodeID, neededFlag: _SemanticFlags.canBeScrolledHorizontally)?.handleSemanticScrollLeft();
-  }
-
-  @override
-  void scrollRight(int nodeID) {
-    SemanticsNode._getSemanticActionHandlerForId(nodeID, neededFlag: _SemanticFlags.canBeScrolledHorizontally)?.handleSemanticScrollRight();
-  }
-
-  @override
-  void scrollUp(int nodeID) {
-    SemanticsNode._getSemanticActionHandlerForId(nodeID, neededFlag: _SemanticFlags.canBeScrolledVertically)?.handleSemanticScrollUp();
-  }
-
-  @override
-  void scrollDown(int nodeID) {
-    SemanticsNode._getSemanticActionHandlerForId(nodeID, neededFlag: _SemanticFlags.canBeScrolledVertically)?.handleSemanticScrollDown();
   }
 }

packages/flutter/lib/src/widgets/semantics_debugger.dart

@@ -58,14 +58,14 @@ class _SemanticsDebuggerState extends State<SemanticsDebugger> {
 
   void _handleTap() {
     assert(_lastPointerDownLocation != null);
-    _SemanticsDebuggerListener.instance.handleTap(_lastPointerDownLocation);
+    _SemanticsDebuggerListener.instance._performAction(_lastPointerDownLocation, SemanticAction.tap);
     setState(() {
       _lastPointerDownLocation = null;
     });
   }
   void _handleLongPress() {
     assert(_lastPointerDownLocation != null);
-    _SemanticsDebuggerListener.instance.handleLongPress(_lastPointerDownLocation);
+    _SemanticsDebuggerListener.instance._performAction(_lastPointerDownLocation, SemanticAction.longPress);
     setState(() {
       _lastPointerDownLocation = null;
     });
@@ -107,10 +107,7 @@ class _SemanticsDebuggerEntry {
   _SemanticsDebuggerEntry(this.id);
 
   final int id;
-  bool canBeTapped = false;
+  final Set<SemanticAction> actions = new Set<SemanticAction>();
-  bool canBeLongPressed = false;
-  bool canBeScrolledHorizontally = false;
-  bool canBeScrolledVertically = false;
   bool hasCheckedState = false;
   bool isChecked = false;
   String label;
@@ -120,13 +117,14 @@ class _SemanticsDebuggerEntry {
 
   @override
   String toString() {
-    return '_SemanticsDebuggerEntry($id; $rect; "$label"'
+    StringBuffer buffer = new StringBuffer();
-           '${canBeTapped ? "; canBeTapped" : ""}'
+    buffer.write('_SemanticsDebuggerEntry($id; $rect; "$label"');
-           '${canBeLongPressed ? "; canBeLongPressed" : ""}'
+    for (SemanticAction action in actions)
-           '${canBeScrolledHorizontally ? "; canBeScrolledHorizontally" : ""}'
+      buffer.write('; $action');
-           '${canBeScrolledVertically ? "; canBeScrolledVertically" : ""}'
+    buffer
-           '${hasCheckedState ? isChecked ? "; checked" : "; unchecked" : ""}'
+      ..write('${hasCheckedState ? isChecked ? "; checked" : "; unchecked" : ""}')
-           ')';
+      ..write(')');
+    return buffer.toString();
   }
 
   String toStringDeep([ String prefix = '']) {
@@ -142,13 +140,14 @@ class _SemanticsDebuggerEntry {
 
   void updateWith(mojom.SemanticsNode node) {
     if (node.flags != null) {
-      canBeTapped = node.flags.canBeTapped;
-      canBeLongPressed = node.flags.canBeLongPressed;
-      canBeScrolledHorizontally = node.flags.canBeScrolledHorizontally;
-      canBeScrolledVertically = node.flags.canBeScrolledVertically;
       hasCheckedState = node.flags.hasCheckedState;
       isChecked = node.flags.isChecked;
     }
+    if (node.actions != null) {
+      actions.clear();
+      for (int encodedAction in node.actions)
+        actions.add(SemanticAction.values[encodedAction]);
+    }
     if (node.strings != null) {
       assert(node.strings.label != null);
       label = node.strings.label;
@@ -190,6 +189,13 @@ class _SemanticsDebuggerEntry {
     height: 0.8
   );
 
+  bool get _isScrollable {
+    return actions.contains(SemanticAction.scrollLeft)
+        || actions.contains(SemanticAction.scrollRight)
+        || actions.contains(SemanticAction.scrollUp)
+        || actions.contains(SemanticAction.scrollDown);
+  }
+
   TextPainter textPainter;
   void _updateMessage() {
     List<String> annotations = <String>[];
@@ -198,16 +204,16 @@ class _SemanticsDebuggerEntry {
       annotations.add(isChecked ? 'checked' : 'unchecked');
       wantsTap = true;
     }
-    if (canBeTapped) {
+    if (actions.contains(SemanticAction.tap)) {
       if (!wantsTap)
         annotations.add('button');
     } else {
       if (wantsTap)
         annotations.add('disabled');
     }
-    if (canBeLongPressed)
+    if (actions.contains(SemanticAction.longPress))
       annotations.add('long-pressable');
-    if (canBeScrolledHorizontally || canBeScrolledVertically)
+    if (_isScrollable)
       annotations.add('scrollable');
     String message;
     if (annotations.isEmpty) {
@@ -349,12 +355,11 @@ class _SemanticsDebuggerListener extends ChangeNotifier implements mojom.Semanti
     return rootNode?.hitTest(position, filter);
   }
 
-  void handleTap(Point position) {
+  void _performAction(Point position, SemanticAction action) {
-    _server.tap(_hitTest(position, (_SemanticsDebuggerEntry entry) => entry.canBeTapped)?.id ?? 0);
+    _SemanticsDebuggerEntry entry = _hitTest(position, (_SemanticsDebuggerEntry entry) => entry.actions.contains(action));
-  }
+    _server.performAction(entry?.id ?? 0, mojom.SemanticAction.values[action.index]);
-  void handleLongPress(Point position) {
-    _server.longPress(_hitTest(position, (_SemanticsDebuggerEntry entry) => entry.canBeLongPressed)?.id ?? 0);
   }
+
   void handlePanEnd(Point position, Velocity velocity) {
     double vx = velocity.pixelsPerSecond.dx;
     double vy = velocity.pixelsPerSecond.dy;
@@ -362,14 +367,14 @@ class _SemanticsDebuggerListener extends ChangeNotifier implements mojom.Semanti
       return;
     if (vx.abs() > vy.abs()) {
       if (vx.sign < 0)
-        _server.scrollLeft(_hitTest(position, (_SemanticsDebuggerEntry entry) => entry.canBeScrolledHorizontally)?.id ?? 0);
+        _performAction(position, SemanticAction.scrollLeft);
       else
-        _server.scrollRight(_hitTest(position, (_SemanticsDebuggerEntry entry) => entry.canBeScrolledHorizontally)?.id ?? 0);
+        _performAction(position, SemanticAction.scrollRight);
     } else {
       if (vy.sign < 0)
-        _server.scrollUp(_hitTest(position, (_SemanticsDebuggerEntry entry) => entry.canBeScrolledVertically)?.id ?? 0);
+        _performAction(position, SemanticAction.scrollUp);
       else
-        _server.scrollDown(_hitTest(position, (_SemanticsDebuggerEntry entry) => entry.canBeScrolledVertically)?.id ?? 0);
+        _performAction(position, SemanticAction.scrollDown);
     }
   }
 }

packages/flutter/test/material/tooltip_test.dart

@@ -421,10 +421,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].flags.isChecked, isFalse);
     expect(client.updates[0].strings.label, equals('TIP'));
@@ -443,10 +440,7 @@ void main() {
     await tester.pump(const Duration(seconds: 2)); // faded in, show timer started (and at 0.0)
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].flags.isChecked, isFalse);
     expect(client.updates[0].strings.label, equals('TIP'));

packages/flutter/test/widget/buttons_test.dart

@@ -5,6 +5,7 @@
 import 'package:flutter/material.dart';
 import 'package:flutter/widgets.dart';
 import 'package:flutter_test/flutter_test.dart';
+import 'package:sky_services/semantics/semantics.mojom.dart' as mojom;
 
 import 'test_semantics.dart';
 
@@ -23,10 +24,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].flags.isChecked, isFalse);
     expect(client.updates[0].strings.label, equals(''));
@@ -37,10 +35,7 @@ void main() {
     expect(client.updates[0].geometry.height, equals(600.0));
     expect(client.updates[0].children.length, equals(1));
     expect(client.updates[0].children[0].id, equals(1));
-    expect(client.updates[0].children[0].flags.canBeTapped, isTrue);
+    expect(client.updates[0].children[0].actions, equals(<int>[mojom.SemanticAction.tap.mojoEnumValue]));
-    expect(client.updates[0].children[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].children[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].children[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].children[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].children[0].flags.isChecked, isFalse);
     expect(client.updates[0].children[0].strings.label, equals('Hello'));

packages/flutter/test/widget/semantics_1_test.dart

@@ -24,10 +24,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].flags.isChecked, isFalse);
     expect(client.updates[0].strings.label, equals('test1'));
@@ -61,10 +58,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].flags.isChecked, isFalse);
     expect(client.updates[0].strings.label, equals('child1'));
@@ -98,10 +92,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].flags.isChecked, isFalse);
     expect(client.updates[0].strings.label, equals(''));
@@ -112,10 +103,7 @@ void main() {
     expect(client.updates[0].geometry.height, equals(600.0));
     expect(client.updates[0].children.length, equals(2));
     expect(client.updates[0].children[0].id, equals(1));
-    expect(client.updates[0].children[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].children[0].actions, isEmpty);
-    expect(client.updates[0].children[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].children[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].children[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].children[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].children[0].flags.isChecked, isFalse);
     expect(client.updates[0].children[0].strings.label, equals('child1'));
@@ -126,10 +114,7 @@ void main() {
     expect(client.updates[0].children[0].geometry.height, equals(10.0));
     expect(client.updates[0].children[0].children.length, equals(0));
     expect(client.updates[0].children[1].id, equals(2));
-    expect(client.updates[0].children[1].flags.canBeTapped, isFalse);
+    expect(client.updates[0].children[1].actions, isEmpty);
-    expect(client.updates[0].children[1].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].children[1].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].children[1].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].children[1].flags.hasCheckedState, isFalse);
     expect(client.updates[0].children[1].flags.isChecked, isFalse);
     expect(client.updates[0].children[1].strings.label, equals('child2'));
@@ -163,10 +148,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].flags.isChecked, isFalse);
     expect(client.updates[0].strings.label, equals('child1'));
@@ -200,10 +182,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].flags.isChecked, isFalse);
     expect(client.updates[0].strings.label, equals(''));
@@ -214,10 +193,7 @@ void main() {
     expect(client.updates[0].geometry.height, equals(600.0));
     expect(client.updates[0].children.length, equals(2));
     expect(client.updates[0].children[0].id, equals(3));
-    expect(client.updates[0].children[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].children[0].actions, isEmpty);
-    expect(client.updates[0].children[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].children[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].children[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].children[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].children[0].flags.isChecked, isFalse);
     expect(client.updates[0].children[0].strings.label, equals('child1'));
@@ -228,10 +204,7 @@ void main() {
     expect(client.updates[0].children[0].geometry.height, equals(10.0));
     expect(client.updates[0].children[0].children.length, equals(0));
     expect(client.updates[0].children[1].id, equals(2));
-    expect(client.updates[0].children[1].flags.canBeTapped, isFalse);
+    expect(client.updates[0].children[1].actions, isEmpty);
-    expect(client.updates[0].children[1].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].children[1].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].children[1].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].children[1].flags.hasCheckedState, isFalse);
     expect(client.updates[0].children[1].flags.isChecked, isFalse);
     expect(client.updates[0].children[1].strings.label, equals('child2'));

packages/flutter/test/widget/semantics_2_test.dart

@@ -38,10 +38,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].flags.isChecked, isFalse);
     expect(client.updates[0].strings.label, equals(''));
@@ -52,10 +49,7 @@ void main() {
     expect(client.updates[0].geometry.height, equals(600.0));
     expect(client.updates[0].children.length, equals(2));
     expect(client.updates[0].children[0].id, equals(1));
-    expect(client.updates[0].children[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].children[0].actions, isEmpty);
-    expect(client.updates[0].children[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].children[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].children[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].children[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].children[0].flags.isChecked, isFalse);
     expect(client.updates[0].children[0].strings.label, equals('child1'));
@@ -66,10 +60,7 @@ void main() {
     expect(client.updates[0].children[0].geometry.height, equals(10.0));
     expect(client.updates[0].children[0].children.length, equals(0));
     expect(client.updates[0].children[1].id, equals(2));
-    expect(client.updates[0].children[1].flags.canBeTapped, isFalse);
+    expect(client.updates[0].children[1].actions, isEmpty);
-    expect(client.updates[0].children[1].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].children[1].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].children[1].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].children[1].flags.hasCheckedState, isFalse);
     expect(client.updates[0].children[1].flags.isChecked, isFalse);
     expect(client.updates[0].children[1].strings.label, equals('child2'));
@@ -103,10 +94,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].flags.isChecked, isFalse);
     expect(client.updates[0].strings.label, equals('child1'));
@@ -140,10 +128,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].flags.isChecked, isFalse);
     expect(client.updates[0].strings.label, equals(''));
@@ -154,10 +139,7 @@ void main() {
     expect(client.updates[0].geometry.height, equals(600.0));
     expect(client.updates[0].children.length, equals(2));
     expect(client.updates[0].children[0].id, equals(3));
-    expect(client.updates[0].children[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].children[0].actions, isEmpty);
-    expect(client.updates[0].children[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].children[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].children[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].children[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].children[0].flags.isChecked, isFalse);
     expect(client.updates[0].children[0].strings.label, equals('child1'));
@@ -168,10 +150,7 @@ void main() {
     expect(client.updates[0].children[0].geometry.height, equals(10.0));
     expect(client.updates[0].children[0].children.length, equals(0));
     expect(client.updates[0].children[1].id, equals(2));
-    expect(client.updates[0].children[1].flags.canBeTapped, isFalse);
+    expect(client.updates[0].children[1].actions, isEmpty);
-    expect(client.updates[0].children[1].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].children[1].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].children[1].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].children[1].flags.hasCheckedState, isFalse);
     expect(client.updates[0].children[1].flags.isChecked, isFalse);
     expect(client.updates[0].children[1].strings.label, equals('child2'));

packages/flutter/test/widget/semantics_3_test.dart

@@ -27,10 +27,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isTrue);
     expect(client.updates[0].flags.isChecked, isTrue);
     expect(client.updates[0].strings.label, equals('test'));
@@ -55,10 +52,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isTrue);
     expect(client.updates[0].flags.isChecked, isTrue);
     expect(client.updates[0].strings.label, equals(''));
@@ -83,10 +77,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].flags.isChecked, isFalse);
     expect(client.updates[0].strings.label, equals('test'));
@@ -114,10 +105,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isTrue);
     expect(client.updates[0].flags.isChecked, isTrue);
     expect(client.updates[0].strings.label, equals('test'));

packages/flutter/test/widget/semantics_7_test.dart

@@ -46,10 +46,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isFalse);
     expect(client.updates[0].flags.isChecked, isFalse);
     expect(client.updates[0].strings.label, equals(''));
@@ -60,10 +57,7 @@ void main() {
     expect(client.updates[0].geometry.height, equals(600.0));
     expect(client.updates[0].children.length, equals(2));
     expect(client.updates[0].children[0].id, equals(1));
-    expect(client.updates[0].children[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].children[0].actions, isEmpty);
-    expect(client.updates[0].children[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].children[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].children[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].children[0].flags.hasCheckedState, isTrue);
     expect(client.updates[0].children[0].flags.isChecked, isTrue);
     expect(client.updates[0].children[0].strings.label, equals(label));
@@ -75,10 +69,7 @@ void main() {
     expect(client.updates[0].children[0].children.length, equals(0));
     // IDs 2 and 3 are used up by the nodes that get merged in
     expect(client.updates[0].children[1].id, equals(4));
-    expect(client.updates[0].children[1].flags.canBeTapped, isFalse);
+    expect(client.updates[0].children[1].actions, isEmpty);
-    expect(client.updates[0].children[1].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].children[1].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].children[1].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].children[1].flags.hasCheckedState, isTrue);
     expect(client.updates[0].children[1].flags.isChecked, isTrue);
     expect(client.updates[0].children[1].strings.label, equals(label));
@@ -135,10 +126,7 @@ void main() {
     }
 
     expect(a.id, equals(1));
-    expect(a.flags.canBeTapped, isFalse);
+    expect(a.actions, isEmpty);
-    expect(a.flags.canBeLongPressed, isFalse);
-    expect(a.flags.canBeScrolledHorizontally, isFalse);
-    expect(a.flags.canBeScrolledVertically, isFalse);
     expect(a.flags.hasCheckedState, isTrue);
     expect(a.flags.isChecked, isTrue);
     expect(a.strings.label, equals(label));
@@ -150,10 +138,7 @@ void main() {
     expect(a.children.length, equals(0));
 
     expect(b.id, equals(4));
-    expect(b.flags.canBeTapped, isFalse);
+    expect(b.actions, isEmpty);
-    expect(b.flags.canBeLongPressed, isFalse);
-    expect(b.flags.canBeScrolledHorizontally, isFalse);
-    expect(b.flags.canBeScrolledVertically, isFalse);
     expect(b.flags.hasCheckedState, isTrue);
     expect(b.flags.isChecked, isTrue);
     expect(b.strings.label, equals(label));

packages/flutter/test/widget/semantics_8_test.dart

@@ -34,10 +34,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isTrue);
     expect(client.updates[0].flags.isChecked, isTrue);
     expect(client.updates[0].strings.label, equals('label'));
@@ -73,10 +70,7 @@ void main() {
     );
     expect(client.updates.length, equals(2));
     expect(client.updates[0].id, equals(0));
-    expect(client.updates[0].flags.canBeTapped, isFalse);
+    expect(client.updates[0].actions, isEmpty);
-    expect(client.updates[0].flags.canBeLongPressed, isFalse);
-    expect(client.updates[0].flags.canBeScrolledHorizontally, isFalse);
-    expect(client.updates[0].flags.canBeScrolledVertically, isFalse);
     expect(client.updates[0].flags.hasCheckedState, isTrue);
     expect(client.updates[0].flags.isChecked, isTrue);
     expect(client.updates[0].strings.label, equals('label'));