Articulate the cancel behavior in the WebTouchEvent.

content/browser/renderer_host/input/touch_event_queue_unittest.cc

 // Copyright 2013 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.
 
 #include "content/browser/renderer_host/input/touch_event_queue.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/location.h"
@@ skipping 338 matching lines @@
   MoveTouchPoint(0, 5, 5);
   EXPECT_EQ(2U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 
   // Receive an ACK for the first touch-event.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
-  EXPECT_TRUE(acked_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, acked_event().dispatchType);
 
   // Receive an ACK for the second touch-event.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
-  EXPECT_TRUE(acked_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, acked_event().dispatchType);
 }
 
 // Tests that touch-events with multiple points are queued properly.
 TEST_F(TouchEventQueueTest, BasicMultiTouch) {
   const size_t kPointerCount = 10;
   for (float i = 0; i < kPointerCount; ++i)
     PressTouchPoint(i, i);
 
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
@@ skipping 687 matching lines @@
   // TouchEvent forwarding is disabled until the ack is received for the
   // timed-out event and the future cancel event.
   EXPECT_FALSE(IsTimeoutRunning());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Ack'ing the original event should trigger a cancel event.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(IsTimeoutRunning());
   EXPECT_EQ(WebInputEvent::TouchCancel, sent_event().type);
-  EXPECT_FALSE(sent_event().cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Touch events should not be forwarded until we receive the cancel acks.
   MoveTouchPoint(0, 1, 1);
   ASSERT_EQ(0U, GetAndResetSentEventCount());
   ASSERT_EQ(1U, GetAndResetAckedEventCount());
 
   ReleaseTouchPoint(0);
   ASSERT_EQ(0U, GetAndResetSentEventCount());
   ASSERT_EQ(1U, GetAndResetAckedEventCount());
 
   // The synthetic TouchCancel ack should not reach the client, but should
   // resume touch forwarding.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 
   // Subsequent events should be handled normally.
   PressTouchPoint(0, 1);
   EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
-  EXPECT_TRUE(sent_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 }
 
 // Tests that the timeout is never started if the renderer consumes
 // a TouchEvent from the current touch sequence.
 TEST_F(TouchEventQueueTest, NoTouchTimeoutIfRendererIsConsumingGesture) {
   SetUpForTimeoutTesting();
 
   // Queue a TouchStart.
@@ skipping 495 matching lines @@
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   for (int i = 0; i < 3; ++i) {
    SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
                        INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
    MoveTouchPoint(0, 10, 5+i);
    SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
    EXPECT_FALSE(HasPendingAsyncTouchMove());
-   EXPECT_TRUE(sent_event().cancelable);
+   EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
    EXPECT_EQ(0U, queued_event_count());
    EXPECT_EQ(1U, GetAndResetSentEventCount());
 
    // Consuming a scroll event will throttle subsequent touchmoves.
    SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
                        INPUT_EVENT_ACK_STATE_CONSUMED);
    MoveTouchPoint(0, 10, 7+i);
    EXPECT_TRUE(HasPendingAsyncTouchMove());
    EXPECT_EQ(0U, queued_event_count());
    EXPECT_EQ(0U, GetAndResetSentEventCount());
@@ skipping 39 matching lines @@
 
   // Queuing the final touchend should flush the pending async touchmove. In
   // this case, we will first dispatch an async touchmove and then a touchend.
   // For the async touchmove, we will not send ack again.
   ReleaseTouchPoint(0);
   followup_scroll.type = WebInputEvent::GestureScrollEnd;
   SetFollowupEvent(followup_scroll);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(2U, all_sent_events().size());
   EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type);
-  EXPECT_FALSE(all_sent_events()[0].cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
   EXPECT_EQ(WebInputEvent::TouchEnd, all_sent_events()[1].type);
-  EXPECT_FALSE(all_sent_events()[1].cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[1].dispatchType);
   EXPECT_EQ(2U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(1U, queued_event_count());
 
   // Ack the touchend.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
@@ skipping 39 matching lines @@
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, uncancelable_touch_moves_pending_ack_count());
 
   // The pending touchmove should be flushed with the the new touchmove if
   // sufficient time has passed and ack to the client.
   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
   MoveTouchPoint(0, 0, 15);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_FALSE(sent_event().cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Non-touchmove events should always flush any pending touchmove events. In
   // this case, we will first dispatch an async touchmove and then a
   // touchstart. For the async touchmove, we will not send ack again.
   MoveTouchPoint(0, 0, 25);
   EXPECT_TRUE(HasPendingAsyncTouchMove());
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   PressTouchPoint(30, 30);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(2U, all_sent_events().size());
   EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type);
-  EXPECT_FALSE(all_sent_events()[0].cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
   EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[1].type);
-  EXPECT_TRUE(all_sent_events()[1].cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, all_sent_events()[1].dispatchType);
   EXPECT_EQ(2U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(1U, queued_event_count());
 
   // Ack the touchstart.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Send a secondary touchmove.
   MoveTouchPoint(1, 0, 25);
   EXPECT_TRUE(HasPendingAsyncTouchMove());
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // An unconsumed scroll should resume synchronous touch handling.
   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   // The pending touchmove should be coalesced with the next (now synchronous)
   // touchmove.
   MoveTouchPoint(0, 0, 26);
-  EXPECT_TRUE(sent_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
   EXPECT_EQ(WebTouchPoint::StateMoved, sent_event().touches[0].state);
   EXPECT_EQ(WebTouchPoint::StateMoved, sent_event().touches[1].state);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 
   // Subsequent touches will queue until the preceding, synchronous touches are
   // ack'ed.
   ReleaseTouchPoint(1);
   EXPECT_EQ(2U, queued_event_count());
   ReleaseTouchPoint(0);
   EXPECT_EQ(3U, queued_event_count());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(sent_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type);
   EXPECT_EQ(2U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(sent_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
@@ skipping 35 matching lines @@
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Queuing the final touchend should flush the pending, async touchmove. In
   // this case, we will first dispatch an async touchmove and then a touchend.
   // For the async touchmove, we will not send ack again.
   ReleaseTouchPoint(0);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(2U, all_sent_events().size());
   EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type);
-  EXPECT_FALSE(all_sent_events()[0].cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
   EXPECT_EQ(0, all_sent_events()[0].touches[0].position.x);
   EXPECT_EQ(0, all_sent_events()[0].touches[0].position.y);
   EXPECT_EQ(WebInputEvent::TouchEnd, all_sent_events()[1].type);
-  EXPECT_FALSE(all_sent_events()[1].cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[1].dispatchType);
   EXPECT_EQ(2U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 }
 
 // Ensure that async touch dispatch and touch ack timeout interactions work
 // appropriately.
 TEST_F(TouchEventQueueTest, AsyncTouchWithAckTimeout) {
   SetUpForTimeoutTesting();
 
   // The touchstart should start the timeout.
@@ skipping 21 matching lines @@
   // An async touch should fire after the throttling interval has expired, but
   // it should not start the touch ack timeout.
   MoveTouchPoint(0, 5, 5);
   EXPECT_TRUE(HasPendingAsyncTouchMove());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
   MoveTouchPoint(0, 5, 5);
   EXPECT_FALSE(IsTimeoutRunning());
   EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_FALSE(sent_event().cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // An unconsumed scroll event will resume synchronous touchmoves, which are
   // subject to the ack timeout.
   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   MoveTouchPoint(0, 20, 5);
   EXPECT_TRUE(IsTimeoutRunning());
-  EXPECT_TRUE(sent_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // The timeout should fire, disabling touch forwarding until both acks are
   // received and acking the timed out event.
   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
   EXPECT_FALSE(IsTimeoutRunning());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 
   // Ack'ing the original event should trigger a cancel event.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_FALSE(sent_event().cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Subsequent touchmove's should not be forwarded, even as the scroll gesture
   // goes from unconsumed to consumed.
   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   MoveTouchPoint(0, 20, 5);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
@@ skipping 32 matching lines @@
   // the queued touchcancel should be flushed.
   WebTouchEvent followup_cancel;
   followup_cancel.type = WebInputEvent::TouchCancel;
   followup_cancel.touchesLength = 1;
   followup_cancel.touches[0].state = WebTouchPoint::StateCancelled;
   SetFollowupEvent(followup_cancel);
   MoveTouchPoint(0, 5, 5);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(2U, all_sent_events().size());
   EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type);
-  EXPECT_FALSE(all_sent_events()[0].cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
   EXPECT_EQ(WebInputEvent::TouchCancel, all_sent_events()[1].type);
-  EXPECT_FALSE(all_sent_events()[1].cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[1].dispatchType);
   EXPECT_EQ(2U, GetAndResetSentEventCount());
   // Sending the ack is because the async touchmove is not ready for
   // dispatching send the ack immediately.
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
 
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(WebInputEvent::TouchCancel, acked_event().type);
@@ skipping 65 matching lines @@
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // We set the next touch event time to be after the throttled interval.
   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
   // Dispatch the touch move event when sufficient time has passed.
   MoveTouchPoint(0, 0, 40);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_FALSE(sent_event().cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   // When we dispatch an async touchmove, we do not put it back to the queue
   // any more and we will ack to client right away.
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count());
 
   // Do not dispatch the event until throttledTouchmoves intervals expires and
   // receive an ack from render.
   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
@@ skipping 39 matching lines @@
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Dispatch the touch move event when sufficient time has passed.
   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
   MoveTouchPoint(0, 0, 40);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_FALSE(sent_event().cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   // When we dispatch an async touchmove, we do not put it back to the queue
   // any more and we will ack to client right away.
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count());
 
   // We receive an ack back from render but the time interval is not expired,
   // so we do not dispatch the touch move event.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, uncancelable_touch_moves_pending_ack_count());
   MoveTouchPoint(0, 0, 50);
   EXPECT_TRUE(HasPendingAsyncTouchMove());
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Dispatch the touch move when sufficient time has passed.
   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
   MoveTouchPoint(0, 0, 50);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
-  EXPECT_FALSE(sent_event().cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count());
 }
 
 TEST_F(TouchEventQueueTest, AsyncTouchFlushedByNonTouchMove) {
   // Process a TouchStart
   PressTouchPoint(0, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
@@ skipping 14 matching lines @@
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Dispatch the touch move when sufficient time has passed.
   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
   MoveTouchPoint(0, 0, 40);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_FALSE(sent_event().cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   // When we dispatch an async touchmove, we do not put it back to the queue
   // any more and we will ack to client right away.
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count());
 
   for (int i = 0; i < 3; ++i) {
     // We throttle the touchmoves, put it in the pending_async_touch_move_,
     // do not dispatch it.
     MoveTouchPoint(0, 10 + 10 * i, 10 + 10 * i);
     EXPECT_TRUE(HasPendingAsyncTouchMove());
     EXPECT_EQ(0U, queued_event_count());
     EXPECT_EQ(0U, GetAndResetSentEventCount());
     EXPECT_EQ(1U, GetAndResetAckedEventCount());
     EXPECT_EQ(static_cast<size_t>(i + 1),
               uncancelable_touch_moves_pending_ack_count());
 
     // Send touchstart will flush pending_async_touch_move_, and increase the
     // count. In this case, we will first dispatch an async touchmove and
     // then a touchstart. For the async touchmove, we will not send ack again.
     PressTouchPoint(30, 30);
     EXPECT_FALSE(HasPendingAsyncTouchMove());
     EXPECT_EQ(2U, all_sent_events().size());
     EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type);
-    EXPECT_FALSE(all_sent_events()[0].cancelable);
+    EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
     EXPECT_EQ(10 + 10 * i, all_sent_events()[0].touches[0].position.x);
     EXPECT_EQ(10 + 10 * i, all_sent_events()[0].touches[0].position.y);
     EXPECT_EQ(static_cast<size_t>(i + 2),
               uncancelable_touch_moves_pending_ack_count());
     EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[1].type);
-    EXPECT_TRUE(all_sent_events()[1].cancelable);
+    EXPECT_EQ(WebInputEvent::Blocking, all_sent_events()[1].dispatchType);
     EXPECT_EQ(2U, GetAndResetSentEventCount());
     EXPECT_EQ(0U, GetAndResetAckedEventCount());
 
     SendTouchEventAckWithID(INPUT_EVENT_ACK_STATE_NOT_CONSUMED,
                             GetUniqueTouchEventID());
     EXPECT_EQ(0U, queued_event_count());
     EXPECT_FALSE(HasPendingAsyncTouchMove());
     EXPECT_EQ(0U, GetAndResetSentEventCount());
     EXPECT_EQ(1U, GetAndResetAckedEventCount());
   }
@@ skipping 25 matching lines @@
 
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   // When we receive this ack from render, and the count is 0, so we can
   // dispatch the pending_async_touchmove_.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count());
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
-  EXPECT_FALSE(sent_event().cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 }
 
 // Ensure that even when we receive the ack from render, we still need to wait
 // for the interval expires to send the next async touchmove once the scroll
 // starts.
 TEST_F(TouchEventQueueTest, DoNotIncreaseIfClientConsumeAsyncTouchMove) {
   // Process a TouchStart
   PressTouchPoint(0, 1);
@@ skipping 15 matching lines @@
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Dispatch the touch move event when sufficient time has passed.
   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
   MoveTouchPoint(0, 0, 40);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_FALSE(sent_event().cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   // When we dispatch an async touchmove, we do not put it back to the queue
   // any more and we will ack to client right away.
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count());
 
   // We receive an ack back from render but the time interval is not expired,
   // so we do not dispatch the touch move event.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, uncancelable_touch_moves_pending_ack_count());
   MoveTouchPoint(0, 0, 50);
   EXPECT_TRUE(HasPendingAsyncTouchMove());
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Dispatch the touch move when sufficient time has passed. Becasue the event
   // is consumed by client already, we would not increase the count and ack to
   // client again.
   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
   SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
   MoveTouchPoint(0, 0, 50);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
-  EXPECT_FALSE(sent_event().cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, uncancelable_touch_moves_pending_ack_count());
 }
 
 TEST_F(TouchEventQueueTest, TouchAbsorptionWithConsumedFirstMove) {
   // Queue a TouchStart.
   PressTouchPoint(0, 1);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   MoveTouchPoint(0, 20, 5);
   SendGestureEvent(blink::WebInputEvent::GestureScrollBegin);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(2U, GetAndResetSentEventCount());
 
   // Even if the first touchmove event was consumed, subsequent unconsumed
   // touchmove events should trigger scrolling.
   MoveTouchPoint(0, 60, 5);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
-  EXPECT_TRUE(sent_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   MoveTouchPoint(0, 20, 5);
   WebGestureEvent followup_scroll;
   followup_scroll.type = WebInputEvent::GestureScrollUpdate;
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
                       INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
-  EXPECT_TRUE(sent_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Touch move event is throttled.
   MoveTouchPoint(0, 60, 5);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 }
 
 TEST_F(TouchEventQueueTest, TouchStartCancelableDuringScroll) {
   // Queue a touchstart and touchmove that go unconsumed, transitioning to an
   // active scroll sequence.
   PressTouchPoint(0, 1);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(sent_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
 
   MoveTouchPoint(0, 20, 5);
-  EXPECT_TRUE(sent_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   SendGestureEvent(blink::WebInputEvent::GestureScrollBegin);
   SendGestureEvent(blink::WebInputEvent::GestureScrollUpdate);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_TRUE(sent_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
 
   // Even though scrolling has begun, touchstart events should be cancelable,
   // allowing, for example, customized pinch processing.
   PressTouchPoint(10, 11);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(sent_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
 
   // As the touch start was consumed, touchmoves should no longer be throttled.
   MoveTouchPoint(1, 11, 11);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(sent_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
 
   // With throttling disabled, touchend and touchmove events should also be
   // cancelable.
   MoveTouchPoint(1, 12, 12);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(sent_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
   ReleaseTouchPoint(1);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_TRUE(sent_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
 
   // If subsequent touchmoves aren't consumed, the generated scroll events
   // will restore async touch dispatch.
   MoveTouchPoint(0, 25, 5);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   SendGestureEvent(blink::WebInputEvent::GestureScrollUpdate);
-  EXPECT_TRUE(sent_event().cancelable);
+  EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
   MoveTouchPoint(0, 30, 5);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-  EXPECT_FALSE(sent_event().cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
 
   // The touchend will be uncancelable during an active scroll sequence.
   ReleaseTouchPoint(0);
-  EXPECT_FALSE(sent_event().cancelable);
+  EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
 }
 
 TEST_F(TouchEventQueueTest, UnseenTouchPointerIdsNotForwarded) {
   SyntheticWebTouchEvent event;
   event.PressPoint(0, 0);
   SendTouchEvent(event);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
@@ skipping 173 matching lines @@
   // TouchMove should be allowed and test for touches state.
   const WebTouchEvent& event2 = sent_event();
   EXPECT_EQ(WebInputEvent::TouchMove, event2.type);
   EXPECT_EQ(WebTouchPoint::StateStationary, event2.touches[0].state);
   EXPECT_EQ(WebTouchPoint::StateMoved, event2.touches[1].state);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
 }  // namespace content