/**
   * Verify that LONG_TAP is triggered after LongPress followed by an UP.
   *
   * @throws Exception
   */
  @SmallTest
  @Feature({"Gestures"})
  public void testGestureLongTap() throws Exception {
    final long downTime = SystemClock.uptimeMillis();
    final long eventTime = SystemClock.uptimeMillis();

    GestureRecordingMotionEventDelegate mockDelegate = new GestureRecordingMotionEventDelegate();
    mGestureHandler =
        new ContentViewGestureHandler(
            getInstrumentation().getTargetContext(),
            mockDelegate,
            new MockZoomManager(getInstrumentation().getTargetContext(), null));
    mLongPressDetector = mGestureHandler.getLongPressDetector();

    MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertNotNull(mockDelegate.getMostRecentGestureEvent());
    assertTrue("Should have a pending LONG_PRESS", mLongPressDetector.hasPendingMessage());

    mLongPressDetector.sendLongPressGestureForTest();

    assertEquals(
        "A LONG_PRESS gesture should have been sent",
        ContentViewGestureHandler.GESTURE_LONG_PRESS,
        mockDelegate.mMostRecentGestureEvent.mType);

    event = motionEvent(MotionEvent.ACTION_UP, downTime, eventTime + 1000);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(
        "A LONG_TAP gesture should have been sent",
        ContentViewGestureHandler.GESTURE_LONG_TAP,
        mockDelegate.mMostRecentGestureEvent.mType);
  }
  /**
   * Verify that a recent show pressed state gesture is canceled when double tap occurs.
   *
   * @throws Exception
   */
  @SmallTest
  @Feature({"Gestures"})
  public void testShowPressCancelOnDoubleTap() throws Exception {
    final long downTime = SystemClock.uptimeMillis();
    final long eventTime = SystemClock.uptimeMillis();

    GestureRecordingMotionEventDelegate mockDelegate = new GestureRecordingMotionEventDelegate();
    mGestureHandler =
        new ContentViewGestureHandler(
            getInstrumentation().getTargetContext(),
            mockDelegate,
            new MockZoomManager(getInstrumentation().getTargetContext(), null));
    mLongPressDetector =
        new LongPressDetector(getInstrumentation().getTargetContext(), mGestureHandler);

    MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);

    assertTrue(mGestureHandler.onTouchEvent(event));
    assertFalse("Should not have a pending LONG_PRESS", mLongPressDetector.hasPendingMessage());

    mGestureHandler.sendShowPressedStateGestureForTesting();

    assertEquals(
        "A show pressed state event should have been sent",
        ContentViewGestureHandler.GESTURE_SHOW_PRESSED_STATE,
        mockDelegate.mMostRecentGestureEvent.mType);
    assertEquals(
        "Only flingCancel and showPressedState should have been sent",
        2,
        mockDelegate.mGestureTypeList.size());

    event =
        MotionEvent.obtain(
            downTime, eventTime + 5, MotionEvent.ACTION_UP, FAKE_COORD_X, FAKE_COORD_Y, 0);
    mGestureHandler.onTouchEvent(event);
    assertEquals("The first tap should not do anything", 2, mockDelegate.mGestureTypeList.size());

    event =
        MotionEvent.obtain(
            eventTime + 10, eventTime + 10, MotionEvent.ACTION_DOWN, FAKE_COORD_X, FAKE_COORD_Y, 0);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(
        "A double tap should have occurred",
        ContentViewGestureHandler.GESTURE_DOUBLE_TAP,
        mockDelegate.mMostRecentGestureEvent.mType);
    assertTrue(
        "A show press cancel event should have been sent",
        mockDelegate.mGestureTypeList.contains(
            ContentViewGestureHandler.GESTURE_SHOW_PRESS_CANCEL));
    assertEquals(
        "Only flingCancel, showPressedState,"
            + "flingCancel, showPressCancel and doubleTap should have been sent",
        5,
        mockDelegate.mGestureTypeList.size());
  }
  /**
   * Verify that certain gesture events are sent with the "last for this vsync" flag set.
   *
   * @throws Exception
   */
  @SmallTest
  @Feature({"Gestures"})
  public void testFinalInputEventsForVSyncInterval() throws Exception {
    Context context = getInstrumentation().getTargetContext();
    final long downTime = SystemClock.uptimeMillis();
    final long eventTime = SystemClock.uptimeMillis();
    final boolean inputEventsDeliveredAtVSync =
        Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN;

    GestureRecordingMotionEventDelegate mockDelegate = new GestureRecordingMotionEventDelegate();
    mGestureHandler =
        new ContentViewGestureHandler(context, mockDelegate, new MockZoomManager(context, null));

    MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);
    assertTrue(mGestureHandler.onTouchEvent(event));
    event =
        MotionEvent.obtain(
            downTime, eventTime + 10, MotionEvent.ACTION_MOVE, FAKE_COORD_X, FAKE_COORD_Y + 30, 0);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(
        "We should have started scrolling",
        ContentViewGestureHandler.GESTURE_SCROLL_BY,
        mockDelegate.mMostRecentGestureEvent.mType);

    if (inputEventsDeliveredAtVSync) {
      assertEquals(
          "Gesture should be last for vsync",
          true,
          mockDelegate.mostRecentGestureEventForLastForVSync());
    } else {
      assertEquals(
          "Gesture should not be last for vsync",
          false,
          mockDelegate.mostRecentGestureEventForLastForVSync());
    }

    mGestureHandler.pinchBegin(downTime, FAKE_COORD_X, FAKE_COORD_Y);
    mGestureHandler.pinchBy(eventTime + 10, FAKE_COORD_X, FAKE_COORD_Y, 2);
    assertEquals(
        "We should have started pinch-zooming",
        ContentViewGestureHandler.GESTURE_PINCH_BY,
        mockDelegate.mMostRecentGestureEvent.mType);

    if (inputEventsDeliveredAtVSync) {
      assertEquals(
          "Gesture should be last for vsync",
          true,
          mockDelegate.mostRecentGestureEventForLastForVSync());
    } else {
      assertEquals(
          "Gesture should not be last for vsync",
          false,
          mockDelegate.mostRecentGestureEventForLastForVSync());
    }
  }
  /**
   * Generate a scroll gesture and verify that the resulting scroll motion event has both absolute
   * and relative position information.
   */
  @SmallTest
  @Feature({"Gestures"})
  public void testScrollUpdateCoordinates() {
    final int deltaX = 16;
    final int deltaY = 84;
    final long downTime = SystemClock.uptimeMillis();

    GestureRecordingMotionEventDelegate delegate = new GestureRecordingMotionEventDelegate();
    ContentViewGestureHandler gestureHandler =
        new ContentViewGestureHandler(
            getInstrumentation().getTargetContext(),
            delegate,
            new MockZoomManager(getInstrumentation().getTargetContext(), null));
    MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);
    assertTrue(gestureHandler.onTouchEvent(event));
    assertNotNull(delegate.getMostRecentGestureEvent());

    // Move twice, because the first move gesture is discarded.
    event =
        MotionEvent.obtain(
            downTime,
            downTime + 5,
            MotionEvent.ACTION_MOVE,
            FAKE_COORD_X - deltaX / 2,
            FAKE_COORD_Y - deltaY / 2,
            0);
    assertTrue(gestureHandler.onTouchEvent(event));

    event =
        MotionEvent.obtain(
            downTime,
            downTime + 10,
            MotionEvent.ACTION_MOVE,
            FAKE_COORD_X - deltaX,
            FAKE_COORD_Y - deltaY,
            0);
    assertTrue(gestureHandler.onTouchEvent(event));

    // Make sure the reported gesture event has all the expected data.
    GestureRecordingMotionEventDelegate.GestureEvent gestureEvent =
        delegate.getMostRecentGestureEvent();
    assertNotNull(gestureEvent);
    assertEquals(ContentViewGestureHandler.GESTURE_SCROLL_BY, gestureEvent.getType());
    assertEquals(downTime + 10, gestureEvent.getTimeMs());
    assertEquals(FAKE_COORD_X - deltaX, gestureEvent.getX());
    assertEquals(FAKE_COORD_Y - deltaY, gestureEvent.getY());

    Bundle extraParams = gestureEvent.getExtraParams();
    assertNotNull(extraParams);
    // No horizontal delta because of snapping.
    assertEquals(0, extraParams.getInt(ContentViewGestureHandler.DISTANCE_X));
    assertEquals(deltaY / 2, extraParams.getInt(ContentViewGestureHandler.DISTANCE_Y));
  }
  /**
   * Verify that the timer of LONG_PRESS will be cancelled when scrolling begins so LONG_PRESS and
   * LONG_TAP won't be triggered.
   *
   * @throws Exception
   */
  @SmallTest
  @Feature({"Gestures"})
  public void testLongPressAndTapCancelWhenScrollBegins() throws Exception {
    final long downTime = SystemClock.uptimeMillis();
    final long eventTime = SystemClock.uptimeMillis();

    GestureRecordingMotionEventDelegate mockDelegate = new GestureRecordingMotionEventDelegate();
    mGestureHandler =
        new ContentViewGestureHandler(
            getInstrumentation().getTargetContext(),
            mockDelegate,
            new MockZoomManager(getInstrumentation().getTargetContext(), null));
    mLongPressDetector = mGestureHandler.getLongPressDetector();

    MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertNotNull(mockDelegate.getMostRecentGestureEvent());
    assertTrue("Should have a pending LONG_PRESS", mLongPressDetector.hasPendingMessage());
    event =
        MotionEvent.obtain(
            downTime,
            eventTime + 5,
            MotionEvent.ACTION_MOVE,
            FAKE_COORD_X * 5,
            FAKE_COORD_Y * 5,
            0);
    assertTrue(mGestureHandler.onTouchEvent(event));
    event =
        MotionEvent.obtain(
            downTime,
            eventTime + 10,
            MotionEvent.ACTION_MOVE,
            FAKE_COORD_X * 10,
            FAKE_COORD_Y * 10,
            0);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertTrue("Should not have a pending LONG_PRESS", !mLongPressDetector.hasPendingMessage());

    // No LONG_TAP because LONG_PRESS timer is cancelled.
    assertFalse(
        "No LONG_PRESS should be sent",
        mockDelegate.mGestureTypeList.contains(ContentViewGestureHandler.GESTURE_LONG_PRESS));
    assertFalse(
        "No LONG_TAP should be sent",
        mockDelegate.mGestureTypeList.contains(ContentViewGestureHandler.GESTURE_LONG_TAP));
  }
  /**
   * Verify that a DOWN followed shortly by an UP will trigger a single tap.
   *
   * @throws Exception
   */
  @SmallTest
  @Feature({"Gestures"})
  public void testGestureSingleClick() throws Exception {
    final long downTime = SystemClock.uptimeMillis();
    final long eventTime = SystemClock.uptimeMillis();

    MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);

    assertFalse(mGestureHandler.onTouchEvent(event));
    assertTrue("Should have a pending gesture", mMockGestureDetector.mLastEvent != null);
    assertTrue("Should have a pending LONG_PRESS", mLongPressDetector.hasPendingMessage());

    event = motionEvent(MotionEvent.ACTION_UP, downTime, eventTime + 10);
    mLongPressDetector.cancelLongPressIfNeeded(event);
    assertTrue("Should not have a pending LONG_PRESS", !mLongPressDetector.hasPendingMessage());
    assertTrue(mGestureHandler.onTouchEvent(event));
    // Synchronous, no need to wait.
    assertTrue("Should have a single tap", mMockListener.mLastSingleTap != null);
  }
  /**
   * Verifies that a single tap doesn't cause a long press event to be sent.
   *
   * @throws Exception
   */
  @SmallTest
  @Feature({"Gestures"})
  public void testNoLongPressIsSentForSingleTapOutOfTouchHandler() throws Exception {
    final long downTime = SystemClock.uptimeMillis();
    final long eventTime = SystemClock.uptimeMillis();

    MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);

    mGestureHandler.hasTouchEventHandlers(true);

    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(1, mGestureHandler.getNumberOfPendingMotionEventsForTesting());
    assertTrue("Should not have a pending gesture", mMockGestureDetector.mLastEvent == null);
    assertFalse("Should not have a pending LONG_PRESS", mLongPressDetector.hasPendingMessage());

    event = motionEvent(MotionEvent.ACTION_UP, downTime, eventTime + 5);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(2, mGestureHandler.getNumberOfPendingMotionEventsForTesting());

    mGestureHandler.confirmTouchEvent(ContentViewGestureHandler.INPUT_EVENT_ACK_STATE_NOT_CONSUMED);

    assertEquals(1, mGestureHandler.getNumberOfPendingMotionEventsForTesting());
    assertEquals(
        "The down touch event should have been sent to the Gesture Detector",
        event.getDownTime(),
        mMockGestureDetector.mLastEvent.getEventTime());
    assertEquals(
        "The next event should be ACTION_UP",
        MotionEvent.ACTION_UP,
        mGestureHandler.peekFirstInPendingMotionEventsForTesting().getActionMasked());

    mGestureHandler.confirmTouchEvent(ContentViewGestureHandler.INPUT_EVENT_ACK_STATE_NOT_CONSUMED);

    assertEquals(0, mGestureHandler.getNumberOfPendingMotionEventsForTesting());
    assertEquals(
        "The up touch event should have been sent to the Gesture Detector",
        event.getEventTime(),
        mMockGestureDetector.mLastEvent.getEventTime());

    assertFalse("Should not have a pending LONG_PRESS", mLongPressDetector.hasPendingMessage());
  }
  /**
   * Verify that a DOWN followed by a MOVE will trigger fling (but not LONG).
   *
   * @throws Exception
   */
  @SmallTest
  @Feature({"Gestures"})
  public void testGestureFlingAndCancelLongClick() throws Exception {
    final long downTime = SystemClock.uptimeMillis();
    final long eventTime = SystemClock.uptimeMillis();

    MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);

    assertFalse(mGestureHandler.onTouchEvent(event));
    assertTrue("Should have a pending gesture", mMockGestureDetector.mLastEvent != null);
    assertTrue("Should have a pending LONG_PRESS", mLongPressDetector.hasPendingMessage());

    event =
        MotionEvent.obtain(
            downTime,
            eventTime + 5,
            MotionEvent.ACTION_MOVE,
            FAKE_COORD_X * 10,
            FAKE_COORD_Y * 10,
            0);
    mLongPressDetector.cancelLongPressIfNeeded(event);
    assertTrue("Should not have a pending LONG_PRESS", !mLongPressDetector.hasPendingMessage());
    assertTrue(mGestureHandler.onTouchEvent(event));

    event =
        MotionEvent.obtain(
            downTime,
            eventTime + 10,
            MotionEvent.ACTION_UP,
            FAKE_COORD_X * 10,
            FAKE_COORD_Y * 10,
            0);
    assertTrue(mGestureHandler.onTouchEvent(event));

    // Synchronous, no need to wait.
    assertTrue("Should have a fling", mMockListener.mLastFling1 != null);
    assertTrue("Should not have a long press", mMockListener.mLastLongPress == null);
  }
  /**
   * Verify that the touch slop region is removed from the first scroll delta to avoid a jump when
   * starting to scroll.
   *
   * @throws Exception
   */
  @SmallTest
  @Feature({"Gestures"})
  public void testTouchSlopRemovedFromScroll() throws Exception {
    Context context = getInstrumentation().getTargetContext();
    final long downTime = SystemClock.uptimeMillis();
    final long eventTime = SystemClock.uptimeMillis();
    final int scaledTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
    final int scrollDelta = 5;

    GestureRecordingMotionEventDelegate mockDelegate = new GestureRecordingMotionEventDelegate();
    mGestureHandler =
        new ContentViewGestureHandler(context, mockDelegate, new MockZoomManager(context, null));

    MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);
    assertTrue(mGestureHandler.onTouchEvent(event));

    event =
        MotionEvent.obtain(
            downTime,
            eventTime + 10,
            MotionEvent.ACTION_MOVE,
            FAKE_COORD_X,
            FAKE_COORD_Y + scaledTouchSlop + scrollDelta,
            0);
    assertTrue(mGestureHandler.onTouchEvent(event));

    assertEquals(
        "We should have started scrolling",
        ContentViewGestureHandler.GESTURE_SCROLL_BY,
        mockDelegate.mMostRecentGestureEvent.mType);

    GestureRecordingMotionEventDelegate.GestureEvent gestureEvent =
        mockDelegate.getMostRecentGestureEvent();
    assertNotNull(gestureEvent);
    Bundle extraParams = gestureEvent.getExtraParams();
    assertEquals(0, extraParams.getInt(ContentViewGestureHandler.DISTANCE_X));
    assertEquals(-scrollDelta, extraParams.getInt(ContentViewGestureHandler.DISTANCE_Y));
  }
 @Override
 public void setUp() {
   mMockListener = new MockListener();
   mMockGestureDetector =
       new MockGestureDetector(getInstrumentation().getTargetContext(), mMockListener);
   mGestureHandler =
       new ContentViewGestureHandler(
           getInstrumentation().getTargetContext(),
           new MockMotionEventDelegate(),
           new MockZoomManager(getInstrumentation().getTargetContext(), null));
   mLongPressDetector =
       new LongPressDetector(getInstrumentation().getTargetContext(), mGestureHandler);
   mGestureHandler.setTestDependencies(mLongPressDetector, mMockGestureDetector, mMockListener);
 }
  /**
   * Verify that the first event sent while the page is scrolling will be converted to a
   * touchcancel. The touchcancel event should stay in the pending queue. Acking the touchcancel
   * event will consume all the touch events of the current session.
   */
  @SmallTest
  @Feature({"Gestures"})
  public void testTouchEventsCanceledWhileScrolling() {
    final int deltaY = 84;
    final long downTime = SystemClock.uptimeMillis();

    MockMotionEventDelegate delegate = new MockMotionEventDelegate();
    ContentViewGestureHandler gestureHandler =
        new ContentViewGestureHandler(
            getInstrumentation().getTargetContext(),
            delegate,
            new MockZoomManager(getInstrumentation().getTargetContext(), null));
    gestureHandler.hasTouchEventHandlers(true);
    MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);
    assertTrue(gestureHandler.onTouchEvent(event));
    gestureHandler.confirmTouchEvent(ContentViewGestureHandler.INPUT_EVENT_ACK_STATE_NOT_CONSUMED);

    event =
        MotionEvent.obtain(
            downTime,
            downTime + 5,
            MotionEvent.ACTION_MOVE,
            FAKE_COORD_X,
            FAKE_COORD_Y - deltaY / 2,
            0);
    assertTrue(gestureHandler.onTouchEvent(event));
    gestureHandler.confirmTouchEvent(ContentViewGestureHandler.INPUT_EVENT_ACK_STATE_NOT_CONSUMED);

    // This event will be converted to touchcancel and put into the pending
    // queue.
    event =
        MotionEvent.obtain(
            downTime,
            downTime + 10,
            MotionEvent.ACTION_MOVE,
            FAKE_COORD_X,
            FAKE_COORD_Y - deltaY,
            0);
    assertTrue(gestureHandler.onTouchEvent(event));
    assertEquals(1, gestureHandler.getNumberOfPendingMotionEventsForTesting());
    assertTrue(
        gestureHandler.isEventCancelledForTesting(
            gestureHandler.peekFirstInPendingMotionEventsForTesting()));

    event = motionEvent(MotionEvent.ACTION_POINTER_DOWN, downTime + 15, downTime + 15);
    assertTrue(gestureHandler.onTouchEvent(event));
    assertEquals(2, gestureHandler.getNumberOfPendingMotionEventsForTesting());

    // Acking the touchcancel will drain all the events.
    gestureHandler.confirmTouchEvent(ContentViewGestureHandler.INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
    assertEquals(0, gestureHandler.getNumberOfPendingMotionEventsForTesting());
  }
  /**
   * Verify that a recent show pressed state gesture is canceled when scrolling begins.
   *
   * @throws Exception
   */
  @SmallTest
  @Feature({"Gestures"})
  public void testShowPressCancelWhenScrollBegins() throws Exception {
    final long downTime = SystemClock.uptimeMillis();
    final long eventTime = SystemClock.uptimeMillis();

    GestureRecordingMotionEventDelegate mockDelegate = new GestureRecordingMotionEventDelegate();
    mGestureHandler =
        new ContentViewGestureHandler(
            getInstrumentation().getTargetContext(),
            mockDelegate,
            new MockZoomManager(getInstrumentation().getTargetContext(), null));
    mLongPressDetector =
        new LongPressDetector(getInstrumentation().getTargetContext(), mGestureHandler);

    MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);

    assertTrue(mGestureHandler.onTouchEvent(event));
    assertFalse("Should not have a pending LONG_PRESS", mLongPressDetector.hasPendingMessage());

    mGestureHandler.sendShowPressedStateGestureForTesting();

    assertEquals(
        "A show pressed state event should have been sent",
        ContentViewGestureHandler.GESTURE_SHOW_PRESSED_STATE,
        mockDelegate.mMostRecentGestureEvent.mType);
    assertEquals(
        "Only flingCancel and showPressedState should have been sent",
        2,
        mockDelegate.mGestureTypeList.size());

    event =
        MotionEvent.obtain(
            downTime,
            eventTime + 10,
            MotionEvent.ACTION_MOVE,
            FAKE_COORD_X * 5,
            FAKE_COORD_Y * 5,
            0);
    assertTrue(mGestureHandler.onTouchEvent(event));

    assertEquals(
        "We should have started scrolling",
        ContentViewGestureHandler.GESTURE_SCROLL_BY,
        mockDelegate.mMostRecentGestureEvent.mType);
    assertTrue(
        "A show press cancel event should have been sent",
        mockDelegate.mGestureTypeList.contains(
            ContentViewGestureHandler.GESTURE_SHOW_PRESS_CANCEL));
    assertEquals(
        "Only flingCancel, showPressedState,"
            + "showPressCancel, scrollBegin and scrollBy should have been sent",
        5,
        mockDelegate.mGestureTypeList.size());

    event =
        MotionEvent.obtain(
            downTime,
            eventTime + 15,
            MotionEvent.ACTION_UP,
            FAKE_COORD_X * 10,
            FAKE_COORD_Y * 10,
            0);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(
        "We should have started flinging",
        ContentViewGestureHandler.GESTURE_FLING_START,
        mockDelegate.mMostRecentGestureEvent.mType);
    assertTrue(
        "A scroll end event should not have been sent",
        !mockDelegate.mGestureTypeList.contains(ContentViewGestureHandler.GESTURE_SCROLL_END));
    assertEquals(
        "The last up should have caused flingCancel and flingStart to be sent",
        7,
        mockDelegate.mGestureTypeList.size());
  }
  /**
   * Verify that for a normal fling (fling after scroll) the following events are sent: -
   * GESTURE_SCROLL_BEGIN - GESTURE_FLING_START
   *
   * @throws Exception
   */
  @SmallTest
  @Feature({"Gestures"})
  public void testFlingEventSequence() throws Exception {
    final long downTime = SystemClock.uptimeMillis();
    final long eventTime = SystemClock.uptimeMillis();

    GestureRecordingMotionEventDelegate mockDelegate = new GestureRecordingMotionEventDelegate();
    mGestureHandler =
        new ContentViewGestureHandler(
            getInstrumentation().getTargetContext(),
            mockDelegate,
            new MockZoomManager(getInstrumentation().getTargetContext(), null));

    MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);

    assertTrue(mGestureHandler.onTouchEvent(event));

    event =
        MotionEvent.obtain(
            downTime,
            eventTime + 10,
            MotionEvent.ACTION_MOVE,
            FAKE_COORD_X * 5,
            FAKE_COORD_Y * 5,
            0);
    assertTrue(mGestureHandler.onTouchEvent(event));

    assertTrue(
        "A flingCancel event should have been sent",
        mockDelegate.mGestureTypeList.contains(ContentViewGestureHandler.GESTURE_FLING_CANCEL));
    assertTrue(
        "A scrollStart event should have been sent",
        mockDelegate.mGestureTypeList.contains(ContentViewGestureHandler.GESTURE_SCROLL_START));
    assertEquals(
        "We should have started scrolling",
        ContentViewGestureHandler.GESTURE_SCROLL_BY,
        mockDelegate.mMostRecentGestureEvent.mType);
    assertEquals(
        "Only flingCancel, scrollBegin and scrollBy should have been sent",
        3,
        mockDelegate.mGestureTypeList.size());

    event =
        MotionEvent.obtain(
            downTime,
            eventTime + 15,
            MotionEvent.ACTION_UP,
            FAKE_COORD_X * 10,
            FAKE_COORD_Y * 10,
            0);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(
        "We should have started flinging",
        ContentViewGestureHandler.GESTURE_FLING_START,
        mockDelegate.mMostRecentGestureEvent.mType);
    assertTrue(
        "A scroll end event should not have been sent",
        !mockDelegate.mGestureTypeList.contains(ContentViewGestureHandler.GESTURE_SCROLL_END));
    assertEquals(
        "The last up should have caused flingCancel and flingStart to be sent",
        5,
        mockDelegate.mGestureTypeList.size());
  }
  /**
   * Verify that when a touch event handler is registered the touch events stop getting queued after
   * we received INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS.
   *
   * @throws Exception
   */
  @SmallTest
  @Feature({"Gestures"})
  public void testFlingOutOfTouchHandler() throws Exception {
    final long downTime = SystemClock.uptimeMillis();
    final long eventTime = SystemClock.uptimeMillis();

    MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);

    mGestureHandler.hasTouchEventHandlers(true);

    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(1, mGestureHandler.getNumberOfPendingMotionEventsForTesting());
    assertTrue("Should not have a pending gesture", mMockGestureDetector.mLastEvent == null);
    assertFalse("Should not have a pending LONG_PRESS", mLongPressDetector.hasPendingMessage());

    mGestureHandler.confirmTouchEvent(
        ContentViewGestureHandler.INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
    assertEquals(0, mGestureHandler.getNumberOfPendingMotionEventsForTesting());
    assertEquals(
        "The down touch event should have been sent to the Gesture Detector",
        event.getEventTime(),
        mMockGestureDetector.mLastEvent.getEventTime());
    assertEquals(
        "The down touch event should have been sent to the Gesture Detector",
        MotionEvent.ACTION_DOWN,
        mMockGestureDetector.mLastEvent.getActionMasked());

    event =
        MotionEvent.obtain(
            downTime,
            eventTime + 5,
            MotionEvent.ACTION_MOVE,
            FAKE_COORD_X * 5,
            FAKE_COORD_Y * 5,
            0);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(0, mGestureHandler.getNumberOfPendingMotionEventsForTesting());
    assertEquals(
        "Motion events should be going to the Gesture Detector directly",
        event.getEventTime(),
        mMockGestureDetector.mLastEvent.getEventTime());
    assertEquals(
        "Motion events should be going to the Gesture Detector directly",
        MotionEvent.ACTION_MOVE,
        mMockGestureDetector.mLastEvent.getActionMasked());

    event =
        MotionEvent.obtain(
            downTime, eventTime + 10, MotionEvent.ACTION_UP, FAKE_COORD_X * 5, FAKE_COORD_Y * 5, 0);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(0, mGestureHandler.getNumberOfPendingMotionEventsForTesting());
    assertEquals(
        "Motion events should be going to the Gesture Detector directly",
        event.getEventTime(),
        mMockGestureDetector.mLastEvent.getEventTime());
    assertEquals(
        "Motion events should be going to the Gesture Detector directly",
        MotionEvent.ACTION_UP,
        mMockGestureDetector.mLastEvent.getActionMasked());

    // Synchronous, no need to wait.
    assertTrue("Should have a fling", mMockListener.mLastFling1 != null);
    assertTrue("Should not have a long press", mMockListener.mLastLongPress == null);
  }
  /**
   * Verify that when a registered touch event handler return NO_CONSUMER_EXISTS for down event all
   * queue is drained until next down.
   *
   * @throws Exception
   */
  @SmallTest
  @Feature({"Gestures"})
  public void testDrainWithFlingAndClickOutofTouchHandler() throws Exception {
    final long downTime = SystemClock.uptimeMillis();
    final long eventTime = SystemClock.uptimeMillis();

    mGestureHandler =
        new ContentViewGestureHandler(
            getInstrumentation().getTargetContext(),
            new MockMotionEventDelegate(),
            new MockZoomManager(getInstrumentation().getTargetContext(), null));
    mLongPressDetector =
        new LongPressDetector(getInstrumentation().getTargetContext(), mGestureHandler);

    MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);

    mGestureHandler.hasTouchEventHandlers(true);

    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(1, mGestureHandler.getNumberOfPendingMotionEventsForTesting());
    assertFalse("Should not have a pending LONG_PRESS", mLongPressDetector.hasPendingMessage());

    event =
        MotionEvent.obtain(
            downTime,
            eventTime + 5,
            MotionEvent.ACTION_MOVE,
            FAKE_COORD_X * 5,
            FAKE_COORD_Y * 5,
            0);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(2, mGestureHandler.getNumberOfPendingMotionEventsForTesting());

    event =
        MotionEvent.obtain(
            downTime,
            eventTime + 10,
            MotionEvent.ACTION_MOVE,
            FAKE_COORD_X * 10,
            FAKE_COORD_Y * 10,
            0);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(2, mGestureHandler.getNumberOfPendingMotionEventsForTesting());

    event =
        MotionEvent.obtain(
            downTime,
            eventTime + 15,
            MotionEvent.ACTION_UP,
            FAKE_COORD_X * 10,
            FAKE_COORD_Y * 10,
            0);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(3, mGestureHandler.getNumberOfPendingMotionEventsForTesting());

    event = motionEvent(MotionEvent.ACTION_DOWN, eventTime + 20, eventTime + 20);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(4, mGestureHandler.getNumberOfPendingMotionEventsForTesting());

    event =
        MotionEvent.obtain(
            downTime, eventTime + 20, MotionEvent.ACTION_UP, FAKE_COORD_X, FAKE_COORD_Y, 0);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(5, mGestureHandler.getNumberOfPendingMotionEventsForTesting());

    mGestureHandler.confirmTouchEvent(
        ContentViewGestureHandler.INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
    assertEquals(
        "The queue should have been drained until first down since no consumer exists",
        2,
        mGestureHandler.getNumberOfPendingMotionEventsForTesting());
    assertEquals(
        MotionEvent.ACTION_DOWN,
        mGestureHandler.peekFirstInPendingMotionEventsForTesting().getActionMasked());

    mGestureHandler.confirmTouchEvent(
        ContentViewGestureHandler.INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
    assertEquals(
        "The queue should have been drained",
        0,
        mGestureHandler.getNumberOfPendingMotionEventsForTesting());
  }
  /**
   * Verify that after a touch event handlers starts handling a gesture, even though some event in
   * the middle of the gesture returns with NOT_CONSUMED, we don't send that to the gesture detector
   * to avoid falling to a faulty state.
   *
   * @throws Exception
   */
  @SmallTest
  @Feature({"Gestures"})
  public void testFlingOnTouchHandlerWithOneEventNotConsumed() throws Exception {
    final long downTime = SystemClock.uptimeMillis();
    final long eventTime = SystemClock.uptimeMillis();

    MotionEvent event = motionEvent(MotionEvent.ACTION_DOWN, downTime, downTime);

    mGestureHandler.hasTouchEventHandlers(true);

    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(1, mGestureHandler.getNumberOfPendingMotionEventsForTesting());
    assertTrue("Should not have a pending gesture", mMockGestureDetector.mLastEvent == null);
    assertFalse("Should not have a pending LONG_PRESS", mLongPressDetector.hasPendingMessage());

    event =
        MotionEvent.obtain(
            downTime,
            eventTime + 5,
            MotionEvent.ACTION_MOVE,
            FAKE_COORD_X * 5,
            FAKE_COORD_Y * 5,
            0);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(2, mGestureHandler.getNumberOfPendingMotionEventsForTesting());

    event =
        MotionEvent.obtain(
            downTime,
            eventTime + 10,
            MotionEvent.ACTION_MOVE,
            FAKE_COORD_X * 10,
            FAKE_COORD_Y * 10,
            0);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(
        "We should have coalesced move events into one",
        2,
        mGestureHandler.getNumberOfPendingMotionEventsForTesting());

    event =
        MotionEvent.obtain(
            downTime,
            eventTime + 15,
            MotionEvent.ACTION_UP,
            FAKE_COORD_X * 10,
            FAKE_COORD_Y * 10,
            0);
    assertTrue(mGestureHandler.onTouchEvent(event));
    assertEquals(3, mGestureHandler.getNumberOfPendingMotionEventsForTesting());

    mGestureHandler.confirmTouchEvent(ContentViewGestureHandler.INPUT_EVENT_ACK_STATE_CONSUMED);
    assertEquals(2, mGestureHandler.getNumberOfPendingMotionEventsForTesting());
    assertEquals(
        MotionEvent.ACTION_MOVE,
        mGestureHandler.peekFirstInPendingMotionEventsForTesting().getActionMasked());

    mGestureHandler.confirmTouchEvent(ContentViewGestureHandler.INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
    assertEquals(1, mGestureHandler.getNumberOfPendingMotionEventsForTesting());
    assertEquals(
        MotionEvent.ACTION_UP,
        mGestureHandler.peekFirstInPendingMotionEventsForTesting().getActionMasked());
    assertTrue(
        "Even though the last event was not consumed by JavaScript,"
            + "it shouldn't have been sent to the Gesture Detector",
        mMockGestureDetector.mLastEvent == null);

    mGestureHandler.confirmTouchEvent(ContentViewGestureHandler.INPUT_EVENT_ACK_STATE_CONSUMED);
    assertEquals(0, mGestureHandler.getNumberOfPendingMotionEventsForTesting());

    // Synchronous, no need to wait.
    assertTrue("Should not have a fling", mMockListener.mLastFling1 == null);
    assertTrue("Should not have a long press", mMockListener.mLastLongPress == null);
  }