[Android] Share gesture types between Java and C++

content/public/android/java/src/org/chromium/content/browser/ContentViewGestureHandler.java

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.content.browser;
 
 import android.annotation.TargetApi;
 import android.content.Context;
 import android.os.Build;
 import android.os.Bundle;
@@ skipping 12 matching lines @@
 import org.chromium.content.common.TraceEvent;
 
 /**
  * This class handles all MotionEvent handling done in ContentViewCore including the gesture
  * recognition. It sends all related native calls through the interface MotionEventDelegate.
  */
 class ContentViewGestureHandler {
 
     private static final String TAG = "ContentViewGestureHandler";
     /**
-     * Used for GESTURE_FLING_START x velocity
+     * Used for FLING_START x velocity
      */
     static final String VELOCITY_X = "Velocity X";
     /**
-     * Used for GESTURE_FLING_START y velocity
+     * Used for FLING_START y velocity
      */
     static final String VELOCITY_Y = "Velocity Y";
     /**
-     * Used for GESTURE_SCROLL_BY x distance (scroll offset of update)
+     * Used for SCROLL_BY x distance (scroll offset of update)
      */
     static final String DISTANCE_X = "Distance X";
     /**
-     * Used for GESTURE_SCROLL_BY y distance (scroll offset of update)
+     * Used for SCROLL_BY y distance (scroll offset of update)
      */
     static final String DISTANCE_Y = "Distance Y";
     /**
-     * Used for GESTURE_SCROLL_START delta X hint (movement triggering scroll)
+     * Used for SCROLL_START delta X hint (movement triggering scroll)
      */
     static final String DELTA_HINT_X = "Delta Hint X";
     /**
-     * Used for GESTURE_SCROLL_START delta Y hint (movement triggering scroll)
+     * Used for SCROLL_START delta Y hint (movement triggering scroll)
      */
     static final String DELTA_HINT_Y = "Delta Hint Y";
     /**
-     * Used in GESTURE_SINGLE_TAP_CONFIRMED to check whether ShowPress has been called before.
+     * Used in SINGLE_TAP_CONFIRMED to check whether ShowPress has been called before.
      */
     static final String SHOW_PRESS = "ShowPress";
     /**
-     * Used for GESTURE_PINCH_BY delta
+     * Used for PINCH_BY delta
      */
     static final String DELTA = "Delta";
 
     private final Bundle mExtraParamBundleSingleTap;
     private final Bundle mExtraParamBundleFling;
     private final Bundle mExtraParamBundleScroll;
     private final Bundle mExtraParamBundleScrollStart;
     private final Bundle mExtraParamBundleDoubleTapDragZoom;
     private final Bundle mExtraParamBundlePinchBy;
     private GestureDetector mGestureDetector;
     private OnGestureListener mListener;
     private OnDoubleTapListener mDoubleTapListener;
     private ScaleGestureDetector mMultiTouchDetector;
     private ScaleGestureListener mMultiTouchListener;
     private MotionEvent mCurrentDownEvent;
     private final MotionEventDelegate mMotionEventDelegate;
 
     // Remember whether onShowPress() is called. If it is not, in onSingleTapConfirmed()
     // we will first show the press state, then trigger the click.
     private boolean mShowPressIsCalled;
 
-    // Whether a sent GESTURE_TAP_DOWN event has yet to be accompanied by a corresponding
-    // GESTURE_SINGLE_TAP_UP, GESTURE_SINGLE_TAP_CONFIRMED, GESTURE_TAP_CANCEL or
-    // GESTURE_DOUBLE_TAP.
+    // Whether a sent TAP_DOWN event has yet to be accompanied by a corresponding
+    // SINGLE_TAP_UP, SINGLE_TAP_CONFIRMED, TAP_CANCEL or DOUBLE_TAP.
     private boolean mNeedsTapEndingEvent;
 
     // This flag is used for ignoring the remaining touch events, i.e., All the events until the
     // next ACTION_DOWN. This is automatically set to false on the next ACTION_DOWN.
     private boolean mIgnoreRemainingTouchEvents;
 
     // TODO(klobag): this is to avoid a bug in GestureDetector. With multi-touch,
     // mAlwaysInTapRegion is not reset. So when the last finger is up, onSingleTapUp()
     // will be mistakenly fired.
     private boolean mIgnoreSingleTap;
@@ skipping 35 matching lines @@
     // Used to track the accumulated scroll error over time. This is used to remove the
     // rounding error we introduced by passing integers to webkit.
     private float mAccumulatedScrollErrorX = 0;
     private float mAccumulatedScrollErrorY = 0;
 
     // The page's viewport and scale sometimes allow us to disable double tap gesture detection,
     // according to the logic in ContentViewCore.onRenderCoordinatesUpdated().
     private boolean mShouldDisableDoubleTap;
 
     // Keeps track of the last long press event, if we end up opening a context menu, we would need
-    // to potentially use the event to send GESTURE_TAP_CANCEL to remove ::active styling
+    // to potentially use the event to send TAP_CANCEL to remove ::active styling
     private MotionEvent mLastLongPressEvent;
 
     // Whether the click delay should always be disabled by sending clicks for double tap gestures.
     private final boolean mDisableClickDelay;
 
-    // DO NOT change these constants without also changing the corresponding values
-    // found in content_view_core_impl.cc
-    // TODO(jdduke): Initialize these from their corresponding WebInputEvent::Type, crbug/339530.
-    static final int GESTURE_SHOW_PRESS = 0;
-    static final int GESTURE_DOUBLE_TAP = 1;
-    static final int GESTURE_SINGLE_TAP_UP = 2;
-    static final int GESTURE_SINGLE_TAP_CONFIRMED = 3;
-    static final int GESTURE_SINGLE_TAP_UNCONFIRMED = 4;
-    static final int GESTURE_LONG_PRESS = 5;
-    static final int GESTURE_SCROLL_START = 6;
-    static final int GESTURE_SCROLL_BY = 7;
-    static final int GESTURE_SCROLL_END = 8;
-    static final int GESTURE_FLING_START = 9;
-    static final int GESTURE_FLING_CANCEL = 10;
-    static final int GESTURE_FLING_END = 11;
-    static final int GESTURE_PINCH_BEGIN = 12;
-    static final int GESTURE_PINCH_BY = 13;
-    static final int GESTURE_PINCH_END = 14;
-    static final int GESTURE_TAP_CANCEL = 15;
-    static final int GESTURE_LONG_TAP = 16;
-    static final int GESTURE_TAP_DOWN = 17;
-
     private final float mPxToDp;
 
     static final int DOUBLE_TAP_MODE_NONE = 0;
     static final int DOUBLE_TAP_MODE_DRAG_DETECTION_IN_PROGRESS = 1;
     static final int DOUBLE_TAP_MODE_DRAG_ZOOM = 2;
     static final int DOUBLE_TAP_MODE_DISABLED = 3;
 
     /**
      * This is an interface to handle MotionEvent related communication with the native side also
      * access some ContentView specific parameters.
      */
     public interface MotionEventDelegate {
         /**
          * Signal the start of gesture detection for the provided {@link MotionEvent}.
          * @param event The {@link MotionEvent} being fed to the gesture detectors.
          */
         public void onTouchEventHandlingBegin(MotionEvent event);
 
         /**
          * Signal that all gestures for the current {@link MotionEvent} have been dispatched.
          */
         public void onTouchEventHandlingEnd();
 
         /**
          * Forward a generated event to the client.  This will normally be wrapped by
          * calls to {@link #onTouchEventHandlingBegin(MotionEvent)} and
          * {@link #onTouchEventHandlingEnd()}, unless the gesture is generated from
-         * a touch timeout, e.g., GESTURE_LONG_PRESS.
+         * a touch timeout, e.g., LONG_PRESS.
          * @param type The type of the gesture event.
          * @param timeMs The time the gesture event occurred at.
          * @param x The x location for the gesture event.
          * @param y The y location for the gesture event.
          * @param extraParams A bundle that holds specific extra parameters for certain gestures.
          *                    This is read-only and should not be modified in this function.
          * Refer to gesture type definition for more information.
          * @return Whether the gesture was forwarded successfully.
          */
         boolean onGestureEventCreated(int type, long timeMs, int x, int y, Bundle extraParams);
@@ skipping 29 matching lines @@
                         mShowPressIsCalled = false;
                         mIgnoreSingleTap = false;
                         mTouchScrolling = false;
                         mSeenFirstScrollEvent = false;
                         mLastRawX = e.getRawX();
                         mLastRawY = e.getRawY();
                         mAccumulatedScrollErrorX = 0;
                         mAccumulatedScrollErrorY = 0;
                         mLastLongPressEvent = null;
                         mNeedsTapEndingEvent = false;
-                        if (sendMotionEventAsGesture(GESTURE_TAP_DOWN, e, null)) {
+                        if (sendMotionEventAsGesture(GestureEventType.TAP_DOWN, e, null)) {
                             mNeedsTapEndingEvent = true;
                         }
                         // Return true to indicate that we want to handle touch
                         return true;
                     }
 
                     @Override
                     public boolean onScroll(MotionEvent e1, MotionEvent e2,
                             float rawDistanceX, float rawDistanceY) {
                         assert e1.getEventTime() <= e2.getEventTime();
@@ skipping 23 matching lines @@
 
                         mLastRawX = e2.getRawX();
                         mLastRawY = e2.getRawY();
                         if (!mTouchScrolling) {
                             sendTapCancelIfNecessary(e1);
                             // Note that scroll start hints are in distance traveled, where
                             // scroll deltas are in the opposite direction.
                             mExtraParamBundleScrollStart.putInt(DELTA_HINT_X, (int) -rawDistanceX);
                             mExtraParamBundleScrollStart.putInt(DELTA_HINT_Y, (int) -rawDistanceY);
                             assert mExtraParamBundleScrollStart.size() == 2;
-                            if (sendGesture(GESTURE_SCROLL_START, e2.getEventTime(),
+                            if (sendGesture(GestureEventType.SCROLL_START, e2.getEventTime(),
                                         (int) e1.getX(), (int) e1.getY(),
                                         mExtraParamBundleScrollStart)) {
                                 mTouchScrolling = true;
                             }
                         }
 
                         // distanceX and distanceY is the scrolling offset since last onScroll.
                         // Because we are passing integers to webkit, this could introduce
                         // rounding errors. The rounding errors will accumulate overtime.
                         // To solve this, we should be adding back the rounding errors each time
                         // when we calculate the new offset.
                         int x = (int) e2.getX();
                         int y = (int) e2.getY();
                         int dx = (int) (distanceX + mAccumulatedScrollErrorX);
                         int dy = (int) (distanceY + mAccumulatedScrollErrorY);
                         mAccumulatedScrollErrorX = distanceX + mAccumulatedScrollErrorX - dx;
                         mAccumulatedScrollErrorY = distanceY + mAccumulatedScrollErrorY - dy;
 
                         mExtraParamBundleScroll.putInt(DISTANCE_X, dx);
                         mExtraParamBundleScroll.putInt(DISTANCE_Y, dy);
                         assert mExtraParamBundleScroll.size() == 2;
 
                         if ((dx | dy) != 0) {
-                            sendGesture(GESTURE_SCROLL_BY,
+                            sendGesture(GestureEventType.SCROLL_BY,
                                     e2.getEventTime(), x, y, mExtraParamBundleScroll);
                         }
 
                         return true;
                     }
 
                     @Override
                     public boolean onFling(MotionEvent e1, MotionEvent e2,
                             float velocityX, float velocityY) {
                         assert e1.getEventTime() <= e2.getEventTime();
                         if (mSnapScrollController.isSnappingScrolls()) {
                             if (mSnapScrollController.isSnapHorizontal()) {
                                 velocityY = 0;
                             } else {
                                 velocityX = 0;
                             }
                         }
 
                         fling(e2.getEventTime(), (int) e1.getX(0), (int) e1.getY(0),
                                         (int) velocityX, (int) velocityY);
                         return true;
                     }
 
                     @Override
                     public void onShowPress(MotionEvent e) {
                         mShowPressIsCalled = true;
-                        sendMotionEventAsGesture(GESTURE_SHOW_PRESS, e, null);
+                        sendMotionEventAsGesture(GestureEventType.SHOW_PRESS, e, null);
                     }
 
                     @Override
                     public boolean onSingleTapUp(MotionEvent e) {
                         if (isDistanceBetweenDownAndUpTooLong(e.getRawX(), e.getRawY())) {
                             sendTapCancelIfNecessary(e);
                             mIgnoreSingleTap = true;
                             return true;
                         }
                         // This is a hack to address the issue where user hovers
                         // over a link for longer than DOUBLE_TAP_TIMEOUT, then
                         // onSingleTapConfirmed() is not triggered. But we still
                         // want to trigger the tap event at UP. So we override
                         // onSingleTapUp() in this case. This assumes singleTapUp
                         // gets always called before singleTapConfirmed.
                         if (!mIgnoreSingleTap) {
                             if (e.getEventTime() - e.getDownTime() > DOUBLE_TAP_TIMEOUT) {
-                                if (sendTapEndingEventAsGesture(GESTURE_SINGLE_TAP_UP, e, null)) {
+                                if (sendTapEndingEventAsGesture(
+                                            GestureEventType.SINGLE_TAP_UP, e, null)) {
                                     mIgnoreSingleTap = true;
                                 }
                                 return true;
                             } else if (isDoubleTapDisabled() || mDisableClickDelay) {
                                 // If double tap has been disabled, there is no need to wait
                                 // for the double tap timeout.
                                 return onSingleTapConfirmed(e);
                             } else {
                                 // Notify Blink about this tapUp event anyway,
                                 // when none of the above conditions applied.
-                                sendMotionEventAsGesture(GESTURE_SINGLE_TAP_UNCONFIRMED, e, null);
+                                sendMotionEventAsGesture(
+                                        GestureEventType.SINGLE_TAP_UNCONFIRMED, e, null);
                             }
                         }
 
                         return triggerLongTapIfNeeded(e);
                     }
 
                     @Override
                     public boolean onSingleTapConfirmed(MotionEvent e) {
                         // Long taps in the edges of the screen have their events delayed by
                         // ContentViewHolder for tab swipe operations. As a consequence of the delay
                         // this method might be called after receiving the up event.
                         // These corner cases should be ignored.
                         if (mIgnoreSingleTap) return true;
 
                         mExtraParamBundleSingleTap.putBoolean(SHOW_PRESS, mShowPressIsCalled);
                         assert mExtraParamBundleSingleTap.size() == 1;
-                        if (sendTapEndingEventAsGesture(GESTURE_SINGLE_TAP_CONFIRMED, e,
+                        if (sendTapEndingEventAsGesture(GestureEventType.SINGLE_TAP_CONFIRMED, e,
                                 mExtraParamBundleSingleTap)) {
                             mIgnoreSingleTap = true;
                         }
                         return true;
                     }
 
                     @Override
                     public boolean onDoubleTapEvent(MotionEvent e) {
                         switch (e.getActionMasked()) {
                             case MotionEvent.ACTION_DOWN:
@@ skipping 18 matching lines @@
 
                                     // Begin double tap drag zoom mode if the move distance is
                                     // further than the threshold.
                                     if (isDistanceGreaterThanTouchSlop(distanceX, distanceY)) {
                                         sendTapCancelIfNecessary(e);
                                         mExtraParamBundleScrollStart.putInt(DELTA_HINT_X,
                                                 (int) -distanceX);
                                         mExtraParamBundleScrollStart.putInt(DELTA_HINT_Y,
                                                 (int) -distanceY);
                                         assert mExtraParamBundleScrollStart.size() == 2;
-                                        sendGesture(GESTURE_SCROLL_START, e.getEventTime(),
+                                        sendGesture(GestureEventType.SCROLL_START, e.getEventTime(),
                                                 (int) e.getX(), (int) e.getY(),
                                                 mExtraParamBundleScrollStart);
                                         pinchBegin(e.getEventTime(),
                                                 Math.round(mDoubleTapDragZoomAnchorX),
                                                 Math.round(mDoubleTapDragZoomAnchorY));
                                         mDoubleTapMode = DOUBLE_TAP_MODE_DRAG_ZOOM;
                                     }
                                 } else if (mDoubleTapMode == DOUBLE_TAP_MODE_DRAG_ZOOM) {
                                     assert mExtraParamBundleDoubleTapDragZoom.isEmpty();
-                                    sendGesture(GESTURE_SCROLL_BY, e.getEventTime(),
+                                    sendGesture(GestureEventType.SCROLL_BY, e.getEventTime(),
                                             (int) e.getX(), (int) e.getY(),
                                             mExtraParamBundleDoubleTapDragZoom);
 
                                     float dy = mDoubleTapY - e.getY();
                                     pinchBy(e.getEventTime(),
                                             Math.round(mDoubleTapDragZoomAnchorX),
                                             Math.round(mDoubleTapDragZoomAnchorY),
                                             (float) Math.pow(dy > 0 ?
                                                     1.0f - DOUBLE_TAP_DRAG_ZOOM_SPEED :
                                                     1.0f + DOUBLE_TAP_DRAG_ZOOM_SPEED,
                                                     Math.abs(dy * mPxToDp)));
                                 }
                                 break;
                             case MotionEvent.ACTION_UP:
                                 if (mDoubleTapMode != DOUBLE_TAP_MODE_DRAG_ZOOM) {
                                     // Normal double tap gesture.
-                                    sendTapEndingEventAsGesture(GESTURE_DOUBLE_TAP, e, null);
+                                    sendTapEndingEventAsGesture(
+                                            GestureEventType.DOUBLE_TAP, e, null);
                                 }
                                 endDoubleTapDragIfNecessary(e);
                                 break;
                             case MotionEvent.ACTION_CANCEL:
                                 sendTapCancelIfNecessary(e);
                                 endDoubleTapDragIfNecessary(e);
                                 break;
                             default:
                                 break;
                         }
                         mDoubleTapY = e.getY();
                         return true;
                     }
 
                     @Override
                     public boolean onLongPress(MotionEvent e) {
                         assert !isDoubleTapActive();
                         if (isScaleGestureDetectionInProgress()) return false;
                         setIgnoreSingleTap(true);
                         mLastLongPressEvent = e;
-                        sendMotionEventAsGesture(GESTURE_LONG_PRESS, e, null);
+                        sendMotionEventAsGesture(GestureEventType.LONG_PRESS, e, null);
                         // Returning true puts the GestureDetector in "longpress" mode, disabling
                         // further scrolling.  This is undesirable, as it is quite common for a
                         // longpress gesture to fire on content that won't trigger a context menu.
                         return false;
                     }
 
                     /**
                      * This method inspects the distance between where the user started touching
                      * the surface, and where she released. If the points are too far apart, we
                      * should assume that the web page has consumed the scroll-events in-between,
@@ skipping 110 matching lines @@
      * @param velocityX Initial velocity of the fling (X) measured in pixels per second.
      * @param velocityY Initial velocity of the fling (Y) measured in pixels per second.
      */
     void fling(long timeMs, int x, int y, int velocityX, int velocityY) {
         if (velocityX == 0 && velocityY == 0) {
             endTouchScrollIfNecessary(timeMs, true);
             return;
         }
 
         if (!mTouchScrolling) {
-            // The native side needs a GESTURE_SCROLL_BEGIN before GESTURE_FLING_START
+            // The native side needs a SCROLL_BEGIN before FLING_START
             // to send the fling to the correct target. Send if it has not sent.
             // The distance traveled in one second is a reasonable scroll start hint.
             mExtraParamBundleScrollStart.putInt(DELTA_HINT_X, velocityX);
             mExtraParamBundleScrollStart.putInt(DELTA_HINT_Y, velocityY);
             assert mExtraParamBundleScrollStart.size() == 2;
-            sendGesture(GESTURE_SCROLL_START, timeMs, x, y, mExtraParamBundleScrollStart);
+            sendGesture(GestureEventType.SCROLL_START, timeMs, x, y, mExtraParamBundleScrollStart);
         }
         endTouchScrollIfNecessary(timeMs, false);
 
         mExtraParamBundleFling.putInt(VELOCITY_X, velocityX);
         mExtraParamBundleFling.putInt(VELOCITY_Y, velocityY);
         assert mExtraParamBundleFling.size() == 2;
-        sendGesture(GESTURE_FLING_START, timeMs, x, y, mExtraParamBundleFling);
+        sendGesture(GestureEventType.FLING_START, timeMs, x, y, mExtraParamBundleFling);
     }
 
-    /**
-     * End DOUBLE_TAP_MODE_DRAG_ZOOM by sending GESTURE_SCROLL_END and GESTURE_PINCH_END events.
+    /**π
+     * End DOUBLE_TAP_MODE_DRAG_ZOOM by sending SCROLL_END and PINCH_END events.
      * @param event A hint event that its x, y, and eventTime will be used for the ending events
      *              to send. This argument is an optional and can be null.
      */
     private void endDoubleTapDragIfNecessary(MotionEvent event) {
         assert event != null;
         if (!isDoubleTapActive()) return;
         if (mDoubleTapMode == DOUBLE_TAP_MODE_DRAG_ZOOM) {
             pinchEnd(event.getEventTime());
-            sendGesture(GESTURE_SCROLL_END, event.getEventTime(),
+            sendGesture(GestureEventType.SCROLL_END, event.getEventTime(),
                     (int) event.getX(), (int) event.getY(), null);
         }
         mDoubleTapMode = DOUBLE_TAP_MODE_NONE;
         updateDoubleTapListener();
     }
 
     /**
-     * Reset touch scroll flag and optionally send a GESTURE_SCROLL_END event if necessary.
+     * Reset touch scroll flag and optionally send a SCROLL_END event if necessary.
      * @param timeMs The time in ms for the event initiating this gesture.
-     * @param sendScrollEndEvent Whether to send GESTURE_SCROLL_END event.
+     * @param sendScrollEndEvent Whether to send SCROLL_END event.
      */
     private void endTouchScrollIfNecessary(long timeMs, boolean sendScrollEndEvent) {
         if (!mTouchScrolling) return;
         mTouchScrolling = false;
         if (sendScrollEndEvent) {
-            sendGesture(GESTURE_SCROLL_END, timeMs, 0, 0, null);
+            sendGesture(GestureEventType.SCROLL_END, timeMs, 0, 0, null);
         }
     }
 
     /**
      * @return Whether native is tracking a scroll.
      */
     boolean isNativeScrolling() {
         // TODO(wangxianzhu): Also return true when fling is active once the UI knows exactly when
         // the fling ends.
         return mTouchScrolling;
     }
 
     /**
-     * @return Whether native is tracking a pinch (i.e. between sending GESTURE_PINCH_BEGIN and
-     *         GESTURE_PINCH_END).
+     * @return Whether native is tracking a pinch (i.e. between sending PINCH_BEGIN and PINCH_END).
      */
     boolean isNativePinching() {
         return mPinchInProgress;
     }
 
     /**
      * Starts a pinch gesture.
      * @param timeMs The time in ms for the event initiating this gesture.
      * @param x The x coordinate for the event initiating this gesture.
      * @param y The x coordinate for the event initiating this gesture.
      */
     private void pinchBegin(long timeMs, int x, int y) {
-        sendGesture(GESTURE_PINCH_BEGIN, timeMs, x, y, null);
+        sendGesture(GestureEventType.PINCH_BEGIN, timeMs, x, y, null);
     }
 
     /**
      * Pinch by a given percentage.
      * @param timeMs The time in ms for the event initiating this gesture.
      * @param anchorX The x coordinate for the anchor point to be used in pinch.
      * @param anchorY The y coordinate for the anchor point to be used in pinch.
      * @param delta The percentage to pinch by.
      */
     private void pinchBy(long timeMs, int anchorX, int anchorY, float delta) {
         mExtraParamBundlePinchBy.putFloat(DELTA, delta);
         assert mExtraParamBundlePinchBy.size() == 1;
-        sendGesture(GESTURE_PINCH_BY, timeMs, anchorX, anchorY, mExtraParamBundlePinchBy);
+        sendGesture(GestureEventType.PINCH_BY, timeMs, anchorX, anchorY, mExtraParamBundlePinchBy);
         mPinchInProgress = true;
     }
 
     /**
      * End a pinch gesture.
      * @param timeMs The time in ms for the event initiating this gesture.
      */
     private void pinchEnd(long timeMs) {
-        sendGesture(GESTURE_PINCH_END, timeMs, 0, 0, null);
+        sendGesture(GestureEventType.PINCH_END, timeMs, 0, 0, null);
         mPinchInProgress = false;
     }
 
     /**
      * Ignore singleTap gestures.
      */
     void setIgnoreSingleTap(boolean value) {
         mIgnoreSingleTap = value;
     }
 
@@ skipping 164 matching lines @@
             (int) event.getX(), (int) event.getY(), extraParams);
     }
 
     private boolean sendGesture(
             int type, long timeMs, int x, int y, Bundle extraParams) {
         assert timeMs != 0;
         // The only valid gestures that can occur after the touch sequence has
         // ended are SHOW_PRESS and SINGLE_TAP_CONFIRMED, potentially triggered
         // after the double-tap delay window times out.
         if (mCurrentDownEvent == null
-                && type != GESTURE_SINGLE_TAP_CONFIRMED
-                && type != GESTURE_SHOW_PRESS) {
+                && type != GestureEventType.SINGLE_TAP_CONFIRMED
+                && type != GestureEventType.SHOW_PRESS) {
             return false;
         }
         return mMotionEventDelegate.onGestureEventCreated(type, timeMs, x, y, extraParams);
     }
 
     private boolean sendTapEndingEventAsGesture(int type, MotionEvent e, Bundle extraParams) {
         if (!sendMotionEventAsGesture(type, e, extraParams)) return false;
         mNeedsTapEndingEvent = false;
         return true;
     }
 
     private void sendTapCancelIfNecessary(MotionEvent e) {
         if (!mNeedsTapEndingEvent) return;
-        if (!sendTapEndingEventAsGesture(GESTURE_TAP_CANCEL, e, null)) return;
+        if (!sendTapEndingEventAsGesture(GestureEventType.TAP_CANCEL, e, null)) return;
         mLastLongPressEvent = null;
     }
 
     /**
      * @return Whether the ContentViewGestureHandler can handle a MotionEvent right now. True only
      * if it's the start of a new stream (ACTION_DOWN), or a continuation of the current stream.
      */
     private boolean canHandle(MotionEvent ev) {
         return ev.getAction() == MotionEvent.ACTION_DOWN ||
                 (mCurrentDownEvent != null && mCurrentDownEvent.getDownTime() == ev.getDownTime());
     }
 
     /**
      * @return Whether the event can trigger a LONG_TAP gesture. True when it can and the event
      * will be consumed.
      */
     private boolean triggerLongTapIfNeeded(MotionEvent ev) {
         if (mLastLongPressEvent != null
                 && ev.getAction() == MotionEvent.ACTION_UP
                 && !isScaleGestureDetectionInProgress()) {
             sendTapCancelIfNecessary(ev);
-            sendMotionEventAsGesture(GESTURE_LONG_TAP, ev, null);
+            sendMotionEventAsGesture(GestureEventType.LONG_TAP, ev, null);
             return true;
         }
         return false;
     }
 
     /**
      * This is for testing only.
      * Sends a show pressed state gesture through mListener. This should always be called after
      * a down event;
      */
@@ skipping 74 matching lines @@
             mGestureDetector.setOnDoubleTapListener(null);
         } else {
             mGestureDetector.setOnDoubleTapListener(mDoubleTapListener);
         }
     }
 
     private boolean isDistanceGreaterThanTouchSlop(float distanceX, float distanceY) {
         return distanceX * distanceX + distanceY * distanceY > mScaledTouchSlopSquare;
     }
 }