Teach main thread event queue about closures.

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>
 
@@ skipping 90 matching lines @@
   }
 
   bool HandleEvent(WebInputEvent& event, InputEventAckState ack_result) {
     return queue_->HandleEvent(ui::WebInputEventTraits::Clone(event),
                                ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING,
                                ack_result);
   }
 
   void NeedsMainFrame(int routing_id) override { needs_main_frame_ = true; }
 
-  WebInputEventQueue<EventWithDispatchType>& event_queue() {
+  WebInputEventQueue<QueuedItem>& event_queue() {
     return queue_->shared_state_.events_;
   }
 
   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;
   }
@@ skipping 311 matching lines @@
 
   WebMouseEvent mouseDown =
       SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseDown, 10, 10, 0);
 
   WebMouseEvent mouseMove =
       SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseMove, 10, 10, 0);
 
   WebMouseEvent mouseUp =
       SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseUp, 10, 10, 0);
 
-  WebMouseWheelEvent wheelEvents[2] = {
+  WebMouseWheelEvent wheelEvents[3] = {
       SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, false),
       SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 0, false),
+      SyntheticWebMouseWheelEventBuilder::Build(20, 20, 0, 53, 1, false),
   };
 
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
 
   // Simulate enqueing a discrete event, followed by continuous events and

[mustaq, 2017/03/24 15:31:18]

"Discrete" vs "continuous": do we define these terms in some raf-related header
file at least? Otherwise they won't mean anything to a stranger to the raf
world.

[dtapuska, 2017/03/24 20:16:34]

Continuous are rAF aligned events. Discrete aren't.

   // then a discrete event. The last discrete event should flush the
   // continuous events so the aren't aligned to rAF and are processed
   // immediately.
   HandleEvent(mouseDown, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   HandleEvent(mouseMove, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   HandleEvent(wheelEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   HandleEvent(wheelEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   HandleEvent(mouseUp, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
 
   EXPECT_EQ(4u, event_queue().size());
   EXPECT_TRUE(main_task_runner_->HasPendingTask());
   EXPECT_TRUE(needs_main_frame_);
   main_task_runner_->RunUntilIdle();
   EXPECT_EQ(0u, event_queue().size());
   RunPendingTasksWithSimulatedRaf();
 
-  // Simulate the rAF running before the PostTask occurs. The first rAF
-  // shouldn't do anything.
+  // Simulate the rAF running before the PostTask occurs. The rAF
+  // will consume everything.
   HandleEvent(mouseDown, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   HandleEvent(wheelEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   EXPECT_EQ(2u, event_queue().size());
   EXPECT_TRUE(needs_main_frame_);
   RunSimulatedRafOnce();
   EXPECT_FALSE(needs_main_frame_);
-  EXPECT_EQ(2u, event_queue().size());
+  EXPECT_EQ(0u, event_queue().size());
+  main_task_runner_->RunUntilIdle();
+
+  // Simulate event consumption but no rAF signal. The mouse wheel events
+  // should still be in the queue.
+  handled_events_.clear();
+  HandleEvent(mouseDown, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
+  HandleEvent(wheelEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
+  HandleEvent(wheelEvents[2], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);

[mustaq, 2017/03/24 15:31:18]

Wondering why wheelEvent[2] not [1]? Event |modifier|s don't affect dispatches,
am I right?

[dtapuska, 2017/03/24 20:16:35]

Because 0 and 1 will get coalesced together. The modifiers forces them not to be
coalesced.

+  EXPECT_EQ(3u, event_queue().size());
+  EXPECT_TRUE(needs_main_frame_);
   main_task_runner_->RunUntilIdle();
   EXPECT_TRUE(needs_main_frame_);
-  EXPECT_EQ(1u, event_queue().size());
-  RunPendingTasksWithSimulatedRaf();
-  EXPECT_EQ(0u, event_queue().size());
+  EXPECT_EQ(2u, event_queue().size());
+  RunSimulatedRafOnce();
+  EXPECT_EQ(wheelEvents[0].modifiers(),
+            handled_events_.at(1).event().modifiers());
+  EXPECT_EQ(wheelEvents[2].modifiers(),
+            handled_events_.at(2).event().modifiers());

[mustaq, 2017/03/24 15:31:18]

Please add a longer raf/non-raf queued sequence, to show that a queue=[non-raf,
raf, non-raf, raf] after RunUntilIdle() retains only the last (raf) event and
dispatches the middle one.

[dtapuska, 2017/03/24 20:16:37]

Done.

 }
 
 TEST_P(MainThreadEventQueueTest, RafAlignedTouchInput) {
   // Don't run the test when we aren't supporting rAF aligned input.
   if ((raf_aligned_input_setting_ & kRafAlignedEnabledTouch) == 0)
     return;
 
   SyntheticWebTouchEvent kEvents[3];
   kEvents[0].PressPoint(10, 10);
   kEvents[1].PressPoint(10, 10);
@@ skipping 11 matching lines @@
   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());
   EXPECT_TRUE(needs_main_frame_);
   main_task_runner_->RunUntilIdle();
   EXPECT_EQ(0u, event_queue().size());
   RunPendingTasksWithSimulatedRaf();
 
-  // Simulate the rAF running before the PostTask occurs. The first rAF
-  // shouldn't do anything.
+  // Simulate the rAF running before the PostTask occurs. The rAF
+  // will consume everything.
   HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   HandleEvent(kEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   EXPECT_EQ(2u, event_queue().size());
   EXPECT_TRUE(needs_main_frame_);
   RunSimulatedRafOnce();
   EXPECT_FALSE(needs_main_frame_);
+  EXPECT_EQ(0u, event_queue().size());
+  main_task_runner_->RunUntilIdle();
+
+  // Simulate event consumption but no rAF signal. The mouse wheel events

[mustaq, 2017/03/24 15:31:18]

s/mouse wheel events/touchmove event/.

[dtapuska, 2017/03/24 20:16:36]

Done.

+  // should still be in the queue.
+  handled_events_.clear();
+  HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
+  HandleEvent(kEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   EXPECT_EQ(2u, event_queue().size());
-  RunPendingTasksWithSimulatedRaf();
-  EXPECT_EQ(0u, event_queue().size());
+  EXPECT_TRUE(needs_main_frame_);
+  main_task_runner_->RunUntilIdle();
+  EXPECT_TRUE(needs_main_frame_);
+  EXPECT_EQ(1u, event_queue().size());
+  RunSimulatedRafOnce();
 
   // Simulate the touch move being discrete
   kEvents[0].touchStartOrFirstTouchMove = true;
   kEvents[1].touchStartOrFirstTouchMove = true;
 
   for (SyntheticWebTouchEvent& event : kEvents)
     HandleEvent(event, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   EXPECT_EQ(3u, event_queue().size());
   EXPECT_TRUE(main_task_runner_->HasPendingTask());
@@ skipping 295 matching lines @@
       "MainThreadResponsivenessScrollIntervention", "Control");
   queue_ = new MainThreadEventQueue(kTestRoutingID,
                                     &dummy_main_thread_event_queue_client_,
                                     main_task_runner_, &renderer_scheduler_);
   EXPECT_FALSE(enable_non_blocking_due_to_main_thread_responsiveness_flag());
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(0),
             main_thread_responsiveness_threshold());
 }
 
 }  // namespace content