Force events to be non blocking if main thread is unresponsive.

content/renderer/input/main_thread_event_queue_unittest.cc

 // Copyright 2016 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 <stddef.h>
 
 #include <new>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/test/test_simple_task_runner.h"
 #include "build/build_config.h"
 #include "content/common/input/synthetic_web_input_event_builders.h"
 #include "content/renderer/input/main_thread_event_queue.h"
 #include "content/renderer/render_thread_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/scheduler/test/mock_renderer_scheduler.h"
 
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 
 namespace blink {
-bool operator==(const WebMouseWheelEvent& lhs, const WebMouseWheelEvent& rhs) {
-  return memcmp(&lhs, &rhs, lhs.size) == 0;
+
+::testing::AssertionResult AreEqual(const WebMouseWheelEvent& lhs,
+                                    const WebMouseWheelEvent& rhs) {
+  if (lhs.size != rhs.size)
+    return ::testing::AssertionSuccess() << "Sizes aren't equal";
+  if (lhs.type != rhs.type)
+    return ::testing::AssertionSuccess() << "Types aren't equal";
+  if (memcmp(&lhs, &rhs, lhs.size) == 0)
+    return ::testing::AssertionSuccess();
+  else
+    return ::testing::AssertionFailure();
 }
 
-bool operator==(const WebTouchEvent& lhs, const WebTouchEvent& rhs) {
-  return memcmp(&lhs, &rhs, lhs.size) == 0;
+::testing::AssertionResult AreEqual(const WebTouchEvent& lhs,
+                                    const WebTouchEvent& rhs) {
+  if (lhs.size != rhs.size)
+    return ::testing::AssertionSuccess() << "Sizes aren't equal";
+  if (lhs.type != rhs.type)
+    return ::testing::AssertionSuccess() << "Types aren't equal";
+  if (memcmp(&lhs, &rhs, lhs.size) == 0)
+    return ::testing::AssertionSuccess();
+  else
+    return ::testing::AssertionFailure();
 }
+
 }  // namespace blink
 
 namespace content {
 namespace {
 
 const int kTestRoutingID = 13;
 }
 
 class MainThreadEventQueueTest : public testing::Test,
                                  public MainThreadEventQueueClient {
@@ skipping 35 matching lines @@
   }
 
   bool last_touch_start_forced_nonblocking_due_to_fling() {
     return queue_->last_touch_start_forced_nonblocking_due_to_fling_;
   }
 
   void set_enable_fling_passive_listener_flag(bool enable_flag) {
     queue_->enable_fling_passive_listener_flag_ = enable_flag;
   }
 
+  void set_enable_non_blocking_due_to_main_thread_responsiveness_flag(bool enable_flag) {
+    queue_->enable_non_blocking_due_to_main_thread_responsiveness_flag_ =
+        enable_flag;
+  }
+
+  const WebTouchEvent* last_touch_event() const {
+    for (auto i = handled_events_.rbegin(); i != handled_events_.rend(); ++i) {
+      if (WebInputEvent::isTouchEventType(i->get()->type))
+        return static_cast<const WebTouchEvent*>(i->get());
+    }
+    CHECK(false);
+    return nullptr;
+  }
+
+  const WebMouseWheelEvent* first_wheel_event() const {
+    for (auto i = handled_events_.begin(); i != handled_events_.end(); ++i) {
+      if (i->get()->type == WebInputEvent::MouseWheel)
+        return static_cast<const WebMouseWheelEvent*>(i->get());
+    }
+    CHECK(false);
+    return nullptr;
+  }
+
+  const WebMouseWheelEvent* last_wheel_event() const {
+    for (auto i = handled_events_.rbegin(); i != handled_events_.rend(); ++i) {
+      if (i->get()->type == WebInputEvent::MouseWheel)
+        return static_cast<const WebMouseWheelEvent*>(i->get());
+    }
+    CHECK(false);
+    return nullptr;
+  }
+
  protected:
   scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_;
   blink::scheduler::MockRendererScheduler renderer_scheduler_;
   scoped_refptr<MainThreadEventQueue> queue_;
   std::vector<ui::ScopedWebInputEvent> handled_events_;
   std::vector<uint32_t> additional_acked_events_;
 };
 
 TEST_F(MainThreadEventQueueTest, NonBlockingWheel) {
   WebMouseWheelEvent kEvents[4] = {
@@ skipping 10 matching lines @@
     HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
 
   EXPECT_EQ(2u, event_queue().size());
   EXPECT_TRUE(main_task_runner_->HasPendingTask());
   main_task_runner_->RunUntilIdle();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(2u, handled_events_.size());
 
   {
-    EXPECT_EQ(kEvents[0].size, handled_events_.at(0)->size);
-    EXPECT_EQ(kEvents[0].type, handled_events_.at(0)->type);
-    const WebMouseWheelEvent* last_wheel_event =
-        static_cast<const WebMouseWheelEvent*>(handled_events_.at(0).get());
     EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive,
-              last_wheel_event->dispatchType);
+              last_wheel_event()->dispatchType);
     WebMouseWheelEvent coalesced_event = kEvents[0];
     internal::Coalesce(kEvents[1], &coalesced_event);
     coalesced_event.dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
-    EXPECT_EQ(coalesced_event, *last_wheel_event);
+    EXPECT_TRUE(AreEqual(coalesced_event, *first_wheel_event()));
   }
 
   {
-    const WebMouseWheelEvent* last_wheel_event =
-        static_cast<const WebMouseWheelEvent*>(handled_events_.at(1).get());
     WebMouseWheelEvent coalesced_event = kEvents[2];
     internal::Coalesce(kEvents[3], &coalesced_event);
     coalesced_event.dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
-    EXPECT_EQ(coalesced_event, *last_wheel_event);
+    EXPECT_TRUE(AreEqual(coalesced_event, *last_wheel_event()));
   }
 }
 
 TEST_F(MainThreadEventQueueTest, NonBlockingTouch) {
   SyntheticWebTouchEvent kEvents[4];
   kEvents[0].PressPoint(10, 10);
   kEvents[1].PressPoint(10, 10);
   kEvents[1].modifiers = 1;
   kEvents[1].MovePoint(0, 20, 20);
   kEvents[2].PressPoint(10, 10);
   kEvents[2].MovePoint(0, 30, 30);
   kEvents[3].PressPoint(10, 10);
   kEvents[3].MovePoint(0, 35, 35);
 
   for (SyntheticWebTouchEvent& event : kEvents)
     HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
 
   EXPECT_EQ(3u, event_queue().size());
   EXPECT_TRUE(main_task_runner_->HasPendingTask());
   main_task_runner_->RunUntilIdle();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(3u, handled_events_.size());
 
-  EXPECT_EQ(kEvents[0].size, handled_events_.at(0)->size);
-  EXPECT_EQ(kEvents[0].type, handled_events_.at(0)->type);
-  const WebTouchEvent* last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(0).get());
   kEvents[0].dispatchType =
       WebInputEvent::DispatchType::ListenersNonBlockingPassive;
-  EXPECT_EQ(kEvents[0], *last_touch_event);
+  EXPECT_TRUE(AreEqual(kEvents[0], *last_touch_event()));
 
-  EXPECT_EQ(kEvents[1].size, handled_events_.at(1)->size);
-  EXPECT_EQ(kEvents[1].type, handled_events_.at(1)->type);
-  last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(1).get());
   kEvents[1].dispatchType =
       WebInputEvent::DispatchType::ListenersNonBlockingPassive;
-  EXPECT_EQ(kEvents[1], *last_touch_event);
+  EXPECT_TRUE(AreEqual(kEvents[0], *last_touch_event()));
 
-  EXPECT_EQ(kEvents[2].size, handled_events_.at(1)->size);
-  EXPECT_EQ(kEvents[2].type, handled_events_.at(2)->type);
-  last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(2).get());
   WebTouchEvent coalesced_event = kEvents[2];
   internal::Coalesce(kEvents[3], &coalesced_event);
   coalesced_event.dispatchType =
       WebInputEvent::DispatchType::ListenersNonBlockingPassive;
-  EXPECT_EQ(coalesced_event, *last_touch_event);
+  EXPECT_TRUE(AreEqual(kEvents[0], *last_touch_event()));
 }
 
 TEST_F(MainThreadEventQueueTest, BlockingTouch) {
   SyntheticWebTouchEvent kEvents[4];
   kEvents[0].PressPoint(10, 10);
   kEvents[1].PressPoint(10, 10);
   kEvents[1].MovePoint(0, 20, 20);
   kEvents[2].PressPoint(10, 10);
   kEvents[2].MovePoint(0, 30, 30);
   kEvents[3].PressPoint(10, 10);
@@ skipping 35 matching lines @@
   HandleEvent(kWheelEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   HandleEvent(kTouchEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
 
   EXPECT_EQ(2u, event_queue().size());
   EXPECT_TRUE(main_task_runner_->HasPendingTask());
   main_task_runner_->RunUntilIdle();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(2u, handled_events_.size());
   {
-    EXPECT_EQ(kWheelEvents[0].size, handled_events_.at(0)->size);
-    EXPECT_EQ(kWheelEvents[0].type, handled_events_.at(0)->type);
-    const WebMouseWheelEvent* last_wheel_event =
-        static_cast<const WebMouseWheelEvent*>(handled_events_.at(0).get());
     EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive,
-              last_wheel_event->dispatchType);
+              last_wheel_event()->dispatchType);
     WebMouseWheelEvent coalesced_event = kWheelEvents[0];
     internal::Coalesce(kWheelEvents[1], &coalesced_event);
     coalesced_event.dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
-    EXPECT_EQ(coalesced_event, *last_wheel_event);
+    EXPECT_TRUE(AreEqual(coalesced_event, *last_wheel_event()));
   }
   {
-    EXPECT_EQ(kTouchEvents[0].size, handled_events_.at(1)->size);
-    EXPECT_EQ(kTouchEvents[0].type, handled_events_.at(1)->type);
-    const WebTouchEvent* last_touch_event =
-        static_cast<const WebTouchEvent*>(handled_events_.at(1).get());
     WebTouchEvent coalesced_event = kTouchEvents[0];
     internal::Coalesce(kTouchEvents[1], &coalesced_event);
     coalesced_event.dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
-    EXPECT_EQ(coalesced_event, *last_touch_event);
+    EXPECT_TRUE(AreEqual(coalesced_event, *last_touch_event()));
   }
 }
 
 TEST_F(MainThreadEventQueueTest, BlockingTouchesDuringFling) {
   SyntheticWebTouchEvent kEvents[1];
   kEvents[0].PressPoint(10, 10);
   kEvents[0].touchStartOrFirstTouchMove = true;
   set_is_flinging(true);
   set_enable_fling_passive_listener_flag(true);
 
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
   HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   main_task_runner_->RunUntilIdle();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(1u, handled_events_.size());
-  EXPECT_EQ(kEvents[0].size, handled_events_.at(0)->size);
-  EXPECT_EQ(kEvents[0].type, handled_events_.at(0)->type);
   EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling());
-  const WebTouchEvent* last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(0).get());
   kEvents[0].dispatchedDuringFling = true;
   kEvents[0].dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling;
-  EXPECT_EQ(kEvents[0], *last_touch_event);
+  EXPECT_TRUE(AreEqual(kEvents[0], *last_touch_event()));
 
   kEvents[0].MovePoint(0, 30, 30);
   HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   main_task_runner_->RunUntilIdle();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(2u, handled_events_.size());
-  EXPECT_EQ(kEvents[0].size, handled_events_.at(1)->size);
-  EXPECT_EQ(kEvents[0].type, handled_events_.at(1)->type);
   EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling());
-  last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(1).get());
   kEvents[0].dispatchedDuringFling = true;
   kEvents[0].dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling;
-  EXPECT_EQ(kEvents[0], *last_touch_event);
+  EXPECT_TRUE(AreEqual(kEvents[0], *last_touch_event()));
 
   kEvents[0].MovePoint(0, 50, 50);
   kEvents[0].touchStartOrFirstTouchMove = false;
   HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   main_task_runner_->RunUntilIdle();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(3u, handled_events_.size());
-  EXPECT_EQ(kEvents[0].size, handled_events_.at(2)->size);
-  EXPECT_EQ(kEvents[0].type, handled_events_.at(2)->type);
   EXPECT_TRUE(kEvents[0].dispatchedDuringFling);
   EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking);
-  last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(2).get());
-  EXPECT_EQ(kEvents[0], *last_touch_event);
+  EXPECT_TRUE(AreEqual(kEvents[0], *last_touch_event()));
 
   kEvents[0].ReleasePoint(0);
   HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   main_task_runner_->RunUntilIdle();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(4u, handled_events_.size());
-  EXPECT_EQ(kEvents[0].size, handled_events_.at(3)->size);
-  EXPECT_EQ(kEvents[0].type, handled_events_.at(3)->type);
   EXPECT_TRUE(kEvents[0].dispatchedDuringFling);
   EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking);
-  last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(3).get());
-  EXPECT_EQ(kEvents[0], *last_touch_event);
+  EXPECT_TRUE(AreEqual(kEvents[0], *last_touch_event()));
 }
 
 TEST_F(MainThreadEventQueueTest, BlockingTouchesOutsideFling) {
-  SyntheticWebTouchEvent kEvents[1];
-  kEvents[0].PressPoint(10, 10);
-  kEvents[0].touchStartOrFirstTouchMove = true;
+  SyntheticWebTouchEvent kEvent;
+  kEvent.PressPoint(10, 10);
+  kEvent.touchStartOrFirstTouchMove = true;
   set_is_flinging(false);
   set_enable_fling_passive_listener_flag(false);
 
-  HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  HandleEvent(kEvent, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   main_task_runner_->RunUntilIdle();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(1u, handled_events_.size());
-  EXPECT_EQ(kEvents[0].size, handled_events_.at(0)->size);
-  EXPECT_EQ(kEvents[0].type, handled_events_.at(0)->type);
-  EXPECT_FALSE(kEvents[0].dispatchedDuringFling);
-  EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking);
+  EXPECT_FALSE(kEvent.dispatchedDuringFling);
+  EXPECT_EQ(kEvent.dispatchType, WebInputEvent::Blocking);
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
-  const WebTouchEvent* last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(0).get());
-  EXPECT_EQ(kEvents[0], *last_touch_event);
+  EXPECT_TRUE(AreEqual(kEvent, *last_touch_event()));
 
   set_is_flinging(true);
   set_enable_fling_passive_listener_flag(false);
-  HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  HandleEvent(kEvent, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   main_task_runner_->RunUntilIdle();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(2u, handled_events_.size());
-  EXPECT_EQ(kEvents[0].size, handled_events_.at(1)->size);
-  EXPECT_EQ(kEvents[0].type, handled_events_.at(1)->type);
-  EXPECT_FALSE(kEvents[0].dispatchedDuringFling);
-  EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking);
+  EXPECT_FALSE(kEvent.dispatchedDuringFling);
+  EXPECT_EQ(kEvent.dispatchType, WebInputEvent::Blocking);
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
-  last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(1).get());
-  kEvents[0].dispatchedDuringFling = true;
-  EXPECT_EQ(kEvents[0], *last_touch_event);
+  kEvent.dispatchedDuringFling = true;
+  EXPECT_TRUE(AreEqual(kEvent, *last_touch_event()));
 
   set_is_flinging(false);
   set_enable_fling_passive_listener_flag(true);
-  HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  HandleEvent(kEvent, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   main_task_runner_->RunUntilIdle();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(3u, handled_events_.size());
-  EXPECT_EQ(kEvents[0].size, handled_events_.at(2)->size);
-  EXPECT_EQ(kEvents[0].type, handled_events_.at(2)->type);
-  EXPECT_TRUE(kEvents[0].dispatchedDuringFling);
-  EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking);
+  EXPECT_TRUE(kEvent.dispatchedDuringFling);
+  EXPECT_EQ(kEvent.dispatchType, WebInputEvent::Blocking);
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
-  last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(2).get());
-  kEvents[0].dispatchedDuringFling = false;
-  EXPECT_EQ(kEvents[0], *last_touch_event);
+  kEvent.dispatchedDuringFling = false;
+  EXPECT_TRUE(AreEqual(kEvent, *last_touch_event()));
 
-  kEvents[0].MovePoint(0, 30, 30);
-  HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  kEvent.MovePoint(0, 30, 30);
+  HandleEvent(kEvent, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   main_task_runner_->RunUntilIdle();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(4u, handled_events_.size());
-  EXPECT_EQ(kEvents[0].size, handled_events_.at(3)->size);
-  EXPECT_EQ(kEvents[0].type, handled_events_.at(3)->type);
-  EXPECT_FALSE(kEvents[0].dispatchedDuringFling);
-  EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking);
+  EXPECT_FALSE(kEvent.dispatchedDuringFling);
+  EXPECT_EQ(kEvent.dispatchType, WebInputEvent::Blocking);
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
-  last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(3).get());
-  EXPECT_EQ(kEvents[0], *last_touch_event);
+  EXPECT_TRUE(AreEqual(kEvent, *last_touch_event()));
 }
 
-}  // namespace content
+TEST_F(MainThreadEventQueueTest, ForcedNonBlockingDueToUnresponsiveMainThread) {
+  SyntheticWebTouchEvent kEvent;
+  kEvent.PressPoint(10, 10);
+  kEvent.touchStartOrFirstTouchMove = true;
+  set_enable_non_blocking_due_to_main_thread_responsiveness_flag(true);
+
+  EXPECT_CALL(renderer_scheduler_,
+              ShouldForceEventsNonBlockingForUnresponsiveMainThread())
+      .Times(4)
+      .WillRepeatedly(testing::Return(true));
+
+  HandleEvent(kEvent, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  main_task_runner_->RunUntilIdle();
+  EXPECT_FALSE(main_task_runner_->HasPendingTask());
+  EXPECT_EQ(0u, event_queue().size());
+  EXPECT_EQ(1u, handled_events_.size());
+  kEvent.dispatchType =
+      WebInputEvent::ListenersForcedNonBlockingDueToMainThreadResponsiveness;
+  EXPECT_TRUE(AreEqual(kEvent, *last_touch_event()));
+
+  kEvent.MovePoint(0, 30, 30);
+  HandleEvent(kEvent, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  main_task_runner_->RunUntilIdle();
+  EXPECT_FALSE(main_task_runner_->HasPendingTask());
+  EXPECT_EQ(0u, event_queue().size());
+  EXPECT_EQ(2u, handled_events_.size());
+  kEvent.dispatchType =
+      WebInputEvent::ListenersForcedNonBlockingDueToMainThreadResponsiveness;
+  EXPECT_TRUE(AreEqual(kEvent, *last_touch_event()));
+
+  kEvent.MovePoint(0, 50, 50);
+  kEvent.touchStartOrFirstTouchMove = false;
+  HandleEvent(kEvent, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  main_task_runner_->RunUntilIdle();
+  EXPECT_FALSE(main_task_runner_->HasPendingTask());
+  EXPECT_EQ(0u, event_queue().size());
+  EXPECT_EQ(3u, handled_events_.size());
+  kEvent.dispatchType =
+      WebInputEvent::ListenersForcedNonBlockingDueToMainThreadResponsiveness;
+  EXPECT_TRUE(AreEqual(kEvent, *last_touch_event()));
+
+  kEvent.ReleasePoint(0);
+  HandleEvent(kEvent, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  main_task_runner_->RunUntilIdle();
+  EXPECT_FALSE(main_task_runner_->HasPendingTask());
+  EXPECT_EQ(0u, event_queue().size());
+  EXPECT_EQ(4u, handled_events_.size());
+  kEvent.dispatchType =
+      WebInputEvent::ListenersForcedNonBlockingDueToMainThreadResponsiveness;
+  EXPECT_TRUE(AreEqual(kEvent, *last_touch_event()));
+}
+
+}  // namespace content