Change the non-blocking event queue to the main thread event queue.

content/renderer/input/input_event_filter_unittest.cc

Index: content/renderer/input/input_event_filter_unittest.cc
diff --git a/content/renderer/input/input_event_filter_unittest.cc b/content/renderer/input/input_event_filter_unittest.cc
index 8027752a6ecafa2f72b053421e65f73711069dc3..b28594113e1c0a424eeba7136495e0cc9acc62d3 100644
--- a/content/renderer/input/input_event_filter_unittest.cc
+++ b/content/renderer/input/input_event_filter_unittest.cc
@@ -59,9 +59,7 @@ class InputEventRecorder {
                                       const WebInputEvent* event,
                                       ui::LatencyInfo* latency_info) {
     DCHECK_EQ(kTestRoutingID, routing_id);
-
     records_.push_back(Record(event));
-
     if (handle_events_) {
       return INPUT_EVENT_ACK_STATE_CONSUMED;
     } else if (send_to_widget_) {
@@ -113,9 +111,8 @@ class IPCMessageRecorder : public IPC::Listener {
 
 void AddMessagesToFilter(IPC::MessageFilter* message_filter,
                          const std::vector<IPC::Message>& events) {
-  for (size_t i = 0; i < events.size(); ++i) {
+  for (size_t i = 0; i < events.size(); ++i)
     message_filter->OnMessageReceived(events[i]);
-  }
 
   base::MessageLoop::current()->RunUntilIdle();
 }
@@ -325,22 +322,19 @@ TEST_F(InputEventFilterTest, NonBlockingWheel) {
   EXPECT_EQ(1u, message_recorder_.message_count());
 
   // Second event was queued; ack the first.
-  filter_->NonBlockingInputEventHandled(kTestRoutingID,
-                                        WebInputEvent::MouseWheel);
+  filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::MouseWheel);
   base::MessageLoop::current()->RunUntilIdle();
   ASSERT_EQ(4u, ipc_sink_.message_count());
   EXPECT_EQ(2u, message_recorder_.message_count());
 
   // Third event won't be coalesced into the second because modifiers are
   // different.
-  filter_->NonBlockingInputEventHandled(kTestRoutingID,
-                                        WebInputEvent::MouseWheel);
+  filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::MouseWheel);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(3u, message_recorder_.message_count());
 
   // The last events will be coalesced.
-  filter_->NonBlockingInputEventHandled(kTestRoutingID,
-                                        WebInputEvent::MouseWheel);
+  filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::MouseWheel);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(3u, message_recorder_.message_count());
 
@@ -356,7 +350,7 @@ TEST_F(InputEventFilterTest, NonBlockingWheel) {
 
     EXPECT_EQ(kEvents[i].size, event->size);
     EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0);
-    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING,
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN,
               dispatch_type);
   }
 
@@ -374,7 +368,7 @@ TEST_F(InputEventFilterTest, NonBlockingWheel) {
     EXPECT_EQ(kEvents[2].size, event->size);
     EXPECT_EQ(kEvents[2].deltaX + kEvents[3].deltaX, event->deltaX);
     EXPECT_EQ(kEvents[2].deltaY + kEvents[3].deltaY, event->deltaY);
-    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING,
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN,
               dispatch_type);
   }
 }
@@ -402,22 +396,19 @@ TEST_F(InputEventFilterTest, NonBlockingTouch) {
   EXPECT_EQ(1u, message_recorder_.message_count());
 
   // Second event was queued; ack the first.
-  filter_->NonBlockingInputEventHandled(kTestRoutingID,
-                                        WebInputEvent::TouchStart);
+  filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchStart);
   base::MessageLoop::current()->RunUntilIdle();
   ASSERT_EQ(4u, ipc_sink_.message_count());
   EXPECT_EQ(2u, message_recorder_.message_count());
 
   // Third event won't be coalesced into the second because modifiers are
   // different.
-  filter_->NonBlockingInputEventHandled(kTestRoutingID,
-                                        WebInputEvent::TouchMove);
+  filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchMove);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(3u, message_recorder_.message_count());
 
   // The last events will be coalesced.
-  filter_->NonBlockingInputEventHandled(kTestRoutingID,
-                                        WebInputEvent::TouchMove);
+  filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchMove);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(3u, message_recorder_.message_count());
 
@@ -433,7 +424,7 @@ TEST_F(InputEventFilterTest, NonBlockingTouch) {
 
     EXPECT_EQ(kEvents[i].size, event->size);
     EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0);
-    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING,
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN,
               dispatch_type);
   }
 
@@ -452,7 +443,83 @@ TEST_F(InputEventFilterTest, NonBlockingTouch) {
     EXPECT_EQ(1u, kEvents[3].touchesLength);
     EXPECT_EQ(kEvents[3].touches[0].position.x, event->touches[0].position.x);
     EXPECT_EQ(kEvents[3].touches[0].position.y, event->touches[0].position.y);
-    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING,
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN,
+              dispatch_type);
+  }
+}
+
+TEST_F(InputEventFilterTest, IntermingledNonBlockingTouch) {
+  SyntheticWebTouchEvent kEvents[2];
+  kEvents[0].PressPoint(10, 10);
+  kEvents[1].PressPoint(10, 10);
+  kEvents[1].ReleasePoint(0);
+  SyntheticWebTouchEvent kBlockingEvents[1];
+  kBlockingEvents[0].PressPoint(10, 10);
+
+  filter_->DidAddInputHandler(kTestRoutingID, nullptr);
+  event_recorder_.set_send_to_widget(true);
+  event_recorder_.set_passive(true);
+  AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
+  EXPECT_EQ(arraysize(kEvents), event_recorder_.record_count());
+
+  event_recorder_.set_passive(false);
+  AddEventsToFilter(filter_.get(), kBlockingEvents, arraysize(kBlockingEvents));
+  EXPECT_EQ(arraysize(kEvents) + arraysize(kBlockingEvents),
+            event_recorder_.record_count());
+  ASSERT_EQ(3u, event_recorder_.record_count());
+
+  {
+    // First event is sent right away.
+    EXPECT_EQ(1u, message_recorder_.message_count());
+
+    const IPC::Message& message = message_recorder_.message_at(0);
+    ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type());
+    InputMsg_HandleInputEvent::Param params;
+    EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, &params));
+    const WebInputEvent* event = base::get<0>(params);
+    InputEventDispatchType dispatch_type = base::get<2>(params);
+
+    EXPECT_EQ(kEvents[0].size, event->size);
+    EXPECT_TRUE(memcmp(&kEvents[0], event, event->size) == 0);
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN,
+              dispatch_type);
+  }
+
+  {
+    // Second event was queued; ack the first.
+    filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchStart);
+    base::MessageLoop::current()->RunUntilIdle();
+    EXPECT_EQ(2u, message_recorder_.message_count());
+
+    const IPC::Message& message = message_recorder_.message_at(1);
+    ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type());
+    InputMsg_HandleInputEvent::Param params;
+    EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, &params));
+    const WebInputEvent* event = base::get<0>(params);
+    InputEventDispatchType dispatch_type = base::get<2>(params);
+
+    EXPECT_EQ(kEvents[1].size, event->size);
+    EXPECT_TRUE(memcmp(&kEvents[1], event, event->size) == 0);
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN,
+              dispatch_type);
+  }
+
+  {
+    // Third event should be put in the queue.
+    filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchEnd);
+    base::MessageLoop::current()->RunUntilIdle();
+    EXPECT_EQ(3u, message_recorder_.message_count());
+
+    const IPC::Message& message = message_recorder_.message_at(2);
+    ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type());
+    InputMsg_HandleInputEvent::Param params;
+    EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, &params));
+    const WebInputEvent* event = base::get<0>(params);
+    InputEventDispatchType dispatch_type = base::get<2>(params);
+
+    EXPECT_EQ(kBlockingEvents[0].size, event->size);
+    EXPECT_TRUE(memcmp(&kBlockingEvents[0], event, event->size) == 0);
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NORMAL_NOTIFY_MAIN,
               dispatch_type);
   }
 }