Keep track of coalesced events in main thread event queue

content/renderer/input/main_thread_event_queue_unittest.cc

Index: content/renderer/input/main_thread_event_queue_unittest.cc
diff --git a/content/renderer/input/main_thread_event_queue_unittest.cc b/content/renderer/input/main_thread_event_queue_unittest.cc
index 3eec236e186e590b50e82ce7c572a41cc901a452..1109e8ae6ee6cba81ed7f1fb7a1b4fea1beaff9f 100644
--- a/content/renderer/input/main_thread_event_queue_unittest.cc
+++ b/content/renderer/input/main_thread_event_queue_unittest.cc
@@ -70,12 +70,20 @@ class MainThreadEventQueueTest : public testing::TestWithParam<unsigned>,
   }
 
   void HandleEventOnMainThread(int routing_id,
-                               const blink::WebInputEvent* event,
+                               const blink::WebCoalescedInputEvent* event,
                                const ui::LatencyInfo& latency,
                                InputEventDispatchType type) override {
     EXPECT_EQ(kTestRoutingID, routing_id);
-    handled_events_.push_back(ui::WebInputEventTraits::Clone(*event));
-    queue_->EventHandled(event->type(), INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+    handled_events_.push_back(ui::WebInputEventTraits::Clone(event->event()));
+    std::vector<blink::WebScopedInputEvent> coalescedEvents;

[dtapuska, 2017/01/13 18:56:23]

Is it not possible to just update the handled_events_ queue to be
WebCoalescedInputEvents? Instead of a parallel list?

[Navid Zolghadr, 2017/01/13 19:02:10]

Yeah. I didn't like what I did either. Only when I updated the handled_event_ to
keep the coalesced ones as well then I had to update a lot more code lines in
this file. But if that is okay I'll update the handled_event_ itself to store
WebCoalescedInputEvent. 

[dtapuska, 2017/01/13 19:10:23]

I'd prefer to have cleaner code than minimizing the amount of code changed.

[Navid Zolghadr, 2017/01/16 18:01:55]

Done.

+    for (size_t i = 0; i < event->coalescedEventSize(); i++) {
+      coalescedEvents.push_back(
+          ui::WebInputEventTraits::Clone(event->coalescedEvent(i)));
+    }
+    handled_coalesced_events_.push_back(std::move(coalescedEvents));
+
+    queue_->EventHandled(event->event().type(),
+                         INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   }
 
   void SendInputEventAck(int routing_id,
@@ -126,6 +134,9 @@ class MainThreadEventQueueTest : public testing::TestWithParam<unsigned>,
   blink::scheduler::MockRendererScheduler renderer_scheduler_;
   scoped_refptr<MainThreadEventQueue> queue_;
   std::vector<blink::WebScopedInputEvent> handled_events_;
+  std::vector<std::vector<blink::WebScopedInputEvent>>
+      handled_coalesced_events_;
+
   std::vector<uint32_t> additional_acked_events_;
   int raf_aligned_input_setting_;
   bool needs_main_frame_;
@@ -154,6 +165,9 @@ TEST_P(MainThreadEventQueueTest, NonBlockingWheel) {
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(2u, handled_events_.size());
+  for (const auto& coalescedEvents : handled_coalesced_events_) {
+    EXPECT_EQ(2u, coalescedEvents.size());
+  }
 
   {
     EXPECT_EQ(kEvents[0].size(), handled_events_.at(0)->size());
@@ -170,6 +184,24 @@ TEST_P(MainThreadEventQueueTest, NonBlockingWheel) {
   }
 
   {
+    WebMouseWheelEvent coalesced_event = kEvents[0];
+    const WebMouseWheelEvent* coalesced_wheel_event0 =
+        static_cast<const WebMouseWheelEvent*>(
+            handled_coalesced_events_[0][0].get());
+    coalesced_event.dispatchType =
+        WebInputEvent::DispatchType::ListenersNonBlockingPassive;
+    EXPECT_EQ(coalesced_event, *coalesced_wheel_event0);
+
+    coalesced_event = kEvents[1];
+    const WebMouseWheelEvent* coalesced_wheel_event1 =
+        static_cast<const WebMouseWheelEvent*>(
+            handled_coalesced_events_[0][1].get());
+    coalesced_event.dispatchType =
+        WebInputEvent::DispatchType::ListenersNonBlockingPassive;
+    EXPECT_EQ(coalesced_event, *coalesced_wheel_event1);
+  }
+
+  {
     const WebMouseWheelEvent* last_wheel_event =
         static_cast<const WebMouseWheelEvent*>(handled_events_.at(1).get());
     WebMouseWheelEvent coalesced_event = kEvents[2];
@@ -178,6 +210,25 @@ TEST_P(MainThreadEventQueueTest, NonBlockingWheel) {
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
     EXPECT_EQ(coalesced_event, *last_wheel_event);
   }
+
+  {
+    WebMouseWheelEvent coalesced_event = kEvents[2];
+    const WebMouseWheelEvent* coalesced_wheel_event0 =
+        static_cast<const WebMouseWheelEvent*>(
+            handled_coalesced_events_[1][0].get());
+    coalesced_event.dispatchType =
+        WebInputEvent::DispatchType::ListenersNonBlockingPassive;
+    EXPECT_EQ(coalesced_event, *coalesced_wheel_event0);
+
+    coalesced_event = kEvents[3];
+    const WebMouseWheelEvent* coalesced_wheel_event1 =
+        static_cast<const WebMouseWheelEvent*>(
+            handled_coalesced_events_[1][1].get());
+    coalesced_event.dispatchType =
+        WebInputEvent::DispatchType::ListenersNonBlockingPassive;
+    EXPECT_EQ(coalesced_event, *coalesced_wheel_event1);
+  }
+
   histogram_tester.ExpectUniqueSample(kCoalescedCountHistogram, 1, 2);
 }
 
@@ -203,6 +254,7 @@ TEST_P(MainThreadEventQueueTest, NonBlockingTouch) {
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(3u, handled_events_.size());
+  EXPECT_EQ(3u, handled_coalesced_events_.size());
 
   EXPECT_EQ(kEvents[0].size(), handled_events_.at(0)->size());
   EXPECT_EQ(kEvents[0].type(), handled_events_.at(0)->type());
@@ -211,6 +263,15 @@ TEST_P(MainThreadEventQueueTest, NonBlockingTouch) {
   kEvents[0].dispatchType =
       WebInputEvent::DispatchType::ListenersNonBlockingPassive;
   EXPECT_EQ(kEvents[0], *last_touch_event);
+  EXPECT_EQ(1u, handled_coalesced_events_[0].size());
+
+  {
+    EXPECT_EQ(1u, handled_coalesced_events_[0].size());
+    const WebTouchEvent* coalesced_touch_event =
+        static_cast<const WebTouchEvent*>(
+            handled_coalesced_events_[0][0].get());
+    EXPECT_EQ(kEvents[0], *coalesced_touch_event);
+  }
 
   EXPECT_EQ(kEvents[1].size(), handled_events_.at(1)->size());
   EXPECT_EQ(kEvents[1].type(), handled_events_.at(1)->type());
@@ -220,6 +281,14 @@ TEST_P(MainThreadEventQueueTest, NonBlockingTouch) {
       WebInputEvent::DispatchType::ListenersNonBlockingPassive;
   EXPECT_EQ(kEvents[1], *last_touch_event);
 
+  {
+    EXPECT_EQ(1u, handled_coalesced_events_[1].size());
+    const WebTouchEvent* coalesced_touch_event =
+        static_cast<const WebTouchEvent*>(
+            handled_coalesced_events_[1][0].get());
+    EXPECT_EQ(kEvents[1], *coalesced_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 =
@@ -229,6 +298,26 @@ TEST_P(MainThreadEventQueueTest, NonBlockingTouch) {
   coalesced_event.dispatchType =
       WebInputEvent::DispatchType::ListenersNonBlockingPassive;
   EXPECT_EQ(coalesced_event, *last_touch_event);
+
+  {
+    EXPECT_EQ(2u, handled_coalesced_events_[2].size());
+    WebTouchEvent coalesced_event = kEvents[2];
+    const WebTouchEvent* coalesced_touch_event0 =
+        static_cast<const WebTouchEvent*>(
+            handled_coalesced_events_[2][0].get());
+    coalesced_event.dispatchType =
+        WebInputEvent::DispatchType::ListenersNonBlockingPassive;
+    EXPECT_EQ(coalesced_event, *coalesced_touch_event0);
+
+    coalesced_event = kEvents[3];
+    const WebTouchEvent* coalesced_touch_event1 =
+        static_cast<const WebTouchEvent*>(
+            handled_coalesced_events_[2][1].get());
+    coalesced_event.dispatchType =
+        WebInputEvent::DispatchType::ListenersNonBlockingPassive;
+    EXPECT_EQ(coalesced_event, *coalesced_touch_event1);
+  }
+
   histogram_tester.ExpectBucketCount(kCoalescedCountHistogram, 0, 1);
   histogram_tester.ExpectBucketCount(kCoalescedCountHistogram, 1, 1);
 }