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() {
+  MainThreadEventQueueTaskList& 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
   // 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(mouseUp, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
+  HandleEvent(wheelEvents[2], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
+  HandleEvent(wheelEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
+  EXPECT_EQ(5u, 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[2].modifiers(),
+            handled_events_.at(3).event().modifiers());
+  EXPECT_EQ(wheelEvents[0].modifiers(),
+            handled_events_.at(4).event().modifiers());
 }
 
 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 touch events
+  // 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