Don't use PostTask queueing between compositor and main thread.

content/renderer/input/input_event_filter_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 <stddef.h>
 
 #include <new>
 #include <tuple>
 #include <utility>
 #include <vector>
@@ skipping 192 matching lines @@
     const WebInputEvent* event = event_recorder_.record_at(i);
     ASSERT_TRUE(event);
 
     EXPECT_EQ(kEvents[i].size, event->size);
     EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0);
   }
 
   event_recorder_.set_send_to_widget(true);
 
   AddEventsToFilter(filter_.get(), kEvents, arraysize(kEvents));
-  EXPECT_EQ(arraysize(kEvents), ipc_sink_.message_count());
+  EXPECT_EQ(2 * arraysize(kEvents), ipc_sink_.message_count());
   EXPECT_EQ(2 * arraysize(kEvents), event_recorder_.record_count());
-  EXPECT_EQ(arraysize(kEvents), message_recorder_.message_count());
+  EXPECT_EQ(1u, message_recorder_.message_count());
 
-  for (size_t i = 0; i < arraysize(kEvents); ++i) {
-    const IPC::Message& message = message_recorder_.message_at(i);
+  {

[tdresser, 2016/07/20 20:52:27]

Should we get rid of the {}?

[dtapuska, 2016/07/27 05:29:00]

I was trying to scope the local variables that I was testing. This was
consistent in the test case that this is done.

+    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 = std::get<0>(params);
 
-    EXPECT_EQ(kEvents[i].size, event->size);
-    EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0);
+    EXPECT_EQ(kEvents[2].size, event->size);
+    EXPECT_TRUE(memcmp(&kEvents[2], event, event->size) == 0);
   }
 
   // Now reset everything, and test that DidHandleInputEvent is called.
 
   ipc_sink_.ClearMessages();
   event_recorder_.Clear();
   message_recorder_.Clear();
 
   event_recorder_.set_handle_events(true);
 
@@ skipping 69 matching lines @@
   // We should have sent all messages back to the main thread and preserved
   // their relative order.
   ASSERT_EQ(message_recorder_.message_count(), messages.size());
   for (size_t i = 0; i < messages.size(); ++i) {
     EXPECT_EQ(message_recorder_.message_at(i).type(), messages[i].type()) << i;
   }
 }
 
 TEST_F(InputEventFilterTest, NonBlockingWheel) {
   WebMouseWheelEvent kEvents[4] = {
-      SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false),
+      SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 1, false),
       SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false),
       SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false),
       SyntheticWebMouseWheelEventBuilder::Build(30, 30, 0, 53, 1, false),
   };
 
   filter_->RegisterRoutingID(kTestRoutingID);
   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());
   ASSERT_EQ(4u, ipc_sink_.message_count());
 
-  // First event is sent right away.
-  EXPECT_EQ(1u, message_recorder_.message_count());
-
-  // Second event was queued; ack the first.
-  filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::MouseWheel,
-                                   INPUT_EVENT_ACK_STATE_CONSUMED);
-  base::RunLoop().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_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::MouseWheel,
-                                   INPUT_EVENT_ACK_STATE_CONSUMED);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(3u, message_recorder_.message_count());
-
-  // The last events will be coalesced.
-  filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::MouseWheel,
-                                   INPUT_EVENT_ACK_STATE_CONSUMED);
-  base::RunLoop().RunUntilIdle();
+  // All events are handled, one is coalesced.
   EXPECT_EQ(3u, message_recorder_.message_count());
 
   // First two messages should be identical.
   for (size_t i = 0; i < 2; ++i) {
     const IPC::Message& message = message_recorder_.message_at(i);
 
     ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type());
     InputMsg_HandleInputEvent::Param params;
     EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, &params));
     const WebInputEvent* event = std::get<0>(params);
     InputEventDispatchType dispatch_type = std::get<2>(params);
 
     EXPECT_EQ(kEvents[i].size, event->size);
     kEvents[i].dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
     EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0);
-    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN,
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING,
               dispatch_type);
   }
 
   // Third message is coalesced.
   {
     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 WebMouseWheelEvent* event =
         static_cast<const WebMouseWheelEvent*>(std::get<0>(params));
     InputEventDispatchType dispatch_type = std::get<2>(params);
 
     kEvents[2].dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
     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_NOTIFY_MAIN,
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING,
               dispatch_type);
   }
 }
 
 TEST_F(InputEventFilterTest, 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);
 
   filter_->RegisterRoutingID(kTestRoutingID);
   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());
   ASSERT_EQ(4u, ipc_sink_.message_count());
 
-  // First event is sent right away.
-  EXPECT_EQ(1u, message_recorder_.message_count());
-
-  // Second event was queued; ack the first.
-  filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchStart,
-                                   INPUT_EVENT_ACK_STATE_CONSUMED);
-  base::RunLoop().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_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchMove,
-                                   INPUT_EVENT_ACK_STATE_CONSUMED);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(3u, message_recorder_.message_count());
-
-  // The last events will be coalesced.
-  filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchMove,
-                                   INPUT_EVENT_ACK_STATE_CONSUMED);
-  base::RunLoop().RunUntilIdle();
+  // All events are handled and one set was coalesced.
   EXPECT_EQ(3u, message_recorder_.message_count());
 
   // First two messages should be identical.
   for (size_t i = 0; i < 2; ++i) {
     const IPC::Message& message = message_recorder_.message_at(i);
 
     ASSERT_EQ(InputMsg_HandleInputEvent::ID, message.type());
     InputMsg_HandleInputEvent::Param params;
     EXPECT_TRUE(InputMsg_HandleInputEvent::Read(&message, &params));
     const WebInputEvent* event = std::get<0>(params);
     InputEventDispatchType dispatch_type = std::get<2>(params);
 
     EXPECT_EQ(kEvents[i].size, event->size);
     kEvents[i].dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
     EXPECT_TRUE(memcmp(&kEvents[i], event, event->size) == 0);
-    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN,
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING,
               dispatch_type);
   }
 
   // Third message is coalesced.
   {
     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 WebTouchEvent* event =
         static_cast<const WebTouchEvent*>(std::get<0>(params));
     InputEventDispatchType dispatch_type = std::get<2>(params);
 
     EXPECT_EQ(kEvents[3].size, event->size);
     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_NOTIFY_MAIN,
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING,
               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_->RegisterRoutingID(kTestRoutingID);
   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());
+  EXPECT_EQ(3u, message_recorder_.message_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 = std::get<0>(params);
     InputEventDispatchType dispatch_type = std::get<2>(params);
 
     EXPECT_EQ(kEvents[0].size, event->size);
     kEvents[0].dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
     EXPECT_TRUE(memcmp(&kEvents[0], event, event->size) == 0);
-    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN,
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING,
               dispatch_type);
   }
 
   {
-    // Second event was queued; ack the first.
-    filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchStart,
-                                     INPUT_EVENT_ACK_STATE_CONSUMED);
-    base::RunLoop().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 = std::get<0>(params);
     InputEventDispatchType dispatch_type = std::get<2>(params);
 
     EXPECT_EQ(kEvents[1].size, event->size);
     kEvents[1].dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
     EXPECT_TRUE(memcmp(&kEvents[1], event, event->size) == 0);
-    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN,
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_NON_BLOCKING,
               dispatch_type);
   }
 
   {
-    // Third event should be put in the queue.
-    filter_->NotifyInputEventHandled(kTestRoutingID, WebInputEvent::TouchEnd,
-                                     INPUT_EVENT_ACK_STATE_CONSUMED);
-    base::RunLoop().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 = std::get<0>(params);
     InputEventDispatchType dispatch_type = std::get<2>(params);
 
     EXPECT_EQ(kBlockingEvents[0].size, event->size);
     EXPECT_TRUE(memcmp(&kBlockingEvents[0], event, event->size) == 0);
-    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_BLOCKING_NOTIFY_MAIN,
-              dispatch_type);
+    EXPECT_EQ(InputEventDispatchType::DISPATCH_TYPE_BLOCKING, dispatch_type);
   }
 }
 
 }  // namespace content