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 34 matching lines @@
 
 // Simulate a 16ms frame signal.
 const base::TimeDelta kFrameInterval = base::TimeDelta::FromMilliseconds(16);
 
 const int kTestRoutingID = 13;
 const char* kCoalescedCountHistogram =
     "Event.MainThreadEventQueue.CoalescedCount";
 
 }  // namespace
 
+class HandledTask {
+ public:
+  virtual ~HandledTask() {}
+
+  virtual blink::WebCoalescedInputEvent* taskAsEvent() = 0;
+  virtual unsigned taskAsClosure() const = 0;
+};
+
+class HandledEvent : public HandledTask {
+ public:
+  explicit HandledEvent(const blink::WebCoalescedInputEvent* event)
+      : event_(event->event(), event->getCoalescedEventsPointers()) {}
+  ~HandledEvent() override {}
+
+  blink::WebCoalescedInputEvent* taskAsEvent() override { return &event_; }
+  unsigned taskAsClosure() const override {
+    NOTREACHED();
+    return 0;
+  }
+
+ private:
+  blink::WebCoalescedInputEvent event_;
+};
+
+class HandledClosure : public HandledTask {
+ public:
+  explicit HandledClosure(unsigned closure_id) : closure_id_(closure_id) {}
+  ~HandledClosure() override {}
+
+  blink::WebCoalescedInputEvent* taskAsEvent() override {
+    NOTREACHED();
+    return nullptr;
+  }
+  unsigned taskAsClosure() const override { return closure_id_; }
+
+ private:
+  unsigned closure_id_;
+};
+
 class MainThreadEventQueueTest : public testing::TestWithParam<unsigned>,
                                  public MainThreadEventQueueClient {
  public:
   MainThreadEventQueueTest()
       : main_task_runner_(new base::TestSimpleTaskRunner()),
         raf_aligned_input_setting_(GetParam()),
-        needs_main_frame_(false) {
+        needs_main_frame_(false),
+        closure_count_(0) {
     std::vector<base::StringPiece> features;
     std::vector<base::StringPiece> disabled_features;
     if (raf_aligned_input_setting_ & kRafAlignedEnabledTouch) {
       features.push_back(features::kRafAlignedTouchInputEvents.name);
     } else {
       disabled_features.push_back(features::kRafAlignedTouchInputEvents.name);
     }
     if (raf_aligned_input_setting_ & kRafAlignedEnabledMouse) {
       features.push_back(features::kRafAlignedMouseInputEvents.name);
     } else {
       disabled_features.push_back(features::kRafAlignedMouseInputEvents.name);
     }
 
     feature_list_.InitFromCommandLine(base::JoinString(features, ","),
                                       base::JoinString(disabled_features, ","));
   }
 
   void SetUp() override {
     queue_ = new MainThreadEventQueue(kTestRoutingID, this, main_task_runner_,
                                       &renderer_scheduler_);
   }
 
   void HandleEventOnMainThread(int routing_id,
                                const blink::WebCoalescedInputEvent* event,
                                const ui::LatencyInfo& latency,
                                InputEventDispatchType type) override {
     EXPECT_EQ(kTestRoutingID, routing_id);
-    handled_events_.push_back(blink::WebCoalescedInputEvent(
-        event->event(), event->getCoalescedEventsPointers()));
+
+    std::unique_ptr<HandledTask> handled_event(new HandledEvent(event));
+    handled_tasks_.push_back(std::move(handled_event));
 
     queue_->EventHandled(event->event().type(),
                          blink::WebInputEventResult::HandledApplication,
                          INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   }
 
   void SendInputEventAck(int routing_id,
                          blink::WebInputEvent::Type type,
                          InputEventAckState ack_result,
                          uint32_t touch_event_id) override {
     additional_acked_events_.push_back(touch_event_id);
   }
 
   bool HandleEvent(WebInputEvent& event, InputEventAckState ack_result) {
     return queue_->HandleEvent(ui::WebInputEventTraits::Clone(event),
                                ui::LatencyInfo(), DISPATCH_TYPE_BLOCKING,
                                ack_result);
   }
 
+  void RunClosure(unsigned closure_id) {
+    std::unique_ptr<HandledTask> closure(new HandledClosure(closure_id));
+    handled_tasks_.push_back(std::move(closure));
+  }
+
+  void QueueClosure() {
+    unsigned closure_id = ++closure_count_;
+    queue_->QueueClosure(base::Bind(&MainThreadEventQueueTest::RunClosure,
+                                    base::Unretained(this), closure_id));
+  }
+
   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 13 matching lines @@
       frame_time_ += kFrameInterval;
       queue_->DispatchRafAlignedInput(frame_time_);
     }
   }
 
  protected:
   base::test::ScopedFeatureList feature_list_;
   scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_;
   blink::scheduler::MockRendererScheduler renderer_scheduler_;
   scoped_refptr<MainThreadEventQueue> queue_;
-  std::vector<blink::WebCoalescedInputEvent> handled_events_;
+  std::vector<std::unique_ptr<HandledTask>> handled_tasks_;
 
   std::vector<uint32_t> additional_acked_events_;
   int raf_aligned_input_setting_;
   bool needs_main_frame_;
   base::TimeTicks frame_time_;
+  unsigned closure_count_;
 };
 
 TEST_P(MainThreadEventQueueTest, NonBlockingWheel) {
   base::HistogramTester histogram_tester;
 
   WebMouseWheelEvent kEvents[4] = {
       SyntheticWebMouseWheelEventBuilder::Build(10, 10, 0, 53, 0, 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),
   };
 
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
 
   for (WebMouseWheelEvent& event : kEvents)
     HandleEvent(event, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
 
   EXPECT_EQ(2u, event_queue().size());
   EXPECT_EQ((raf_aligned_input_setting_ & kRafAlignedEnabledMouse) == 0,
             main_task_runner_->HasPendingTask());
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
-  EXPECT_EQ(2u, handled_events_.size());
-  for (const auto& coalesced_event : handled_events_) {
-    EXPECT_EQ(2u, coalesced_event.coalescedEventSize());
+  EXPECT_EQ(2u, handled_tasks_.size());
+  for (const auto& task : handled_tasks_) {
+    EXPECT_EQ(2u, task->taskAsEvent()->coalescedEventSize());
   }
 
   {
-    EXPECT_EQ(kEvents[0].size(), handled_events_.at(0).event().size());
-    EXPECT_EQ(kEvents[0].type(), handled_events_.at(0).event().type());
+    EXPECT_EQ(kEvents[0].size(),
+              handled_tasks_.at(0)->taskAsEvent()->event().size());
+    EXPECT_EQ(kEvents[0].type(),
+              handled_tasks_.at(0)->taskAsEvent()->event().type());
     const WebMouseWheelEvent* last_wheel_event =
         static_cast<const WebMouseWheelEvent*>(
-            handled_events_.at(0).eventPointer());
+            handled_tasks_.at(0)->taskAsEvent()->eventPointer());
     EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive,
               last_wheel_event->dispatchType);
     WebMouseWheelEvent coalesced_event = kEvents[0];
     ui::Coalesce(kEvents[1], &coalesced_event);
     coalesced_event.dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
     EXPECT_EQ(coalesced_event, *last_wheel_event);
   }
 
   {
     WebMouseWheelEvent coalesced_event = kEvents[0];
     std::vector<const WebInputEvent*> coalesced_events =
-        handled_events_[0].getCoalescedEventsPointers();
+        handled_tasks_[0]->taskAsEvent()->getCoalescedEventsPointers();
     const WebMouseWheelEvent* coalesced_wheel_event0 =
         static_cast<const WebMouseWheelEvent*>(coalesced_events[0]);
     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*>(coalesced_events[1]);
     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).eventPointer());
+            handled_tasks_.at(1)->taskAsEvent()->eventPointer());
     WebMouseWheelEvent coalesced_event = kEvents[2];
     ui::Coalesce(kEvents[3], &coalesced_event);
     coalesced_event.dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
     EXPECT_EQ(coalesced_event, *last_wheel_event);
   }
 
   {
     WebMouseWheelEvent coalesced_event = kEvents[2];
     std::vector<const WebInputEvent*> coalesced_events =
-        handled_events_[1].getCoalescedEventsPointers();
+        handled_tasks_[1]->taskAsEvent()->getCoalescedEventsPointers();
     const WebMouseWheelEvent* coalesced_wheel_event0 =
         static_cast<const WebMouseWheelEvent*>(coalesced_events[0]);
     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*>(coalesced_events[1]);
     coalesced_event.dispatchType =
@@ skipping 18 matching lines @@
   kEvents[3].MovePoint(0, 35, 35);
 
   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());
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
-  EXPECT_EQ(3u, handled_events_.size());
+  EXPECT_EQ(3u, handled_tasks_.size());
 
-  EXPECT_EQ(kEvents[0].size(), handled_events_.at(0).event().size());
-  EXPECT_EQ(kEvents[0].type(), handled_events_.at(0).event().type());
-  const WebTouchEvent* last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(0).eventPointer());
+  EXPECT_EQ(kEvents[0].size(),
+            handled_tasks_.at(0)->taskAsEvent()->event().size());
+  EXPECT_EQ(kEvents[0].type(),
+            handled_tasks_.at(0)->taskAsEvent()->event().type());
+  const WebTouchEvent* last_touch_event = static_cast<const WebTouchEvent*>(
+      handled_tasks_.at(0)->taskAsEvent()->eventPointer());
   kEvents[0].dispatchType =
       WebInputEvent::DispatchType::ListenersNonBlockingPassive;
   EXPECT_EQ(kEvents[0], *last_touch_event);
 
   {
-    EXPECT_EQ(1u, handled_events_[0].coalescedEventSize());
+    EXPECT_EQ(1u, handled_tasks_[0]->taskAsEvent()->coalescedEventSize());
     const WebTouchEvent* coalesced_touch_event =
         static_cast<const WebTouchEvent*>(
-            handled_events_[0].getCoalescedEventsPointers()[0]);
+            handled_tasks_[0]->taskAsEvent()->getCoalescedEventsPointers()[0]);
     EXPECT_EQ(kEvents[0], *coalesced_touch_event);
   }
 
-  EXPECT_EQ(kEvents[1].size(), handled_events_.at(1).event().size());
-  EXPECT_EQ(kEvents[1].type(), handled_events_.at(1).event().type());
-  last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(1).eventPointer());
+  EXPECT_EQ(kEvents[1].size(),
+            handled_tasks_.at(1)->taskAsEvent()->event().size());
+  EXPECT_EQ(kEvents[1].type(),
+            handled_tasks_.at(1)->taskAsEvent()->event().type());
+  last_touch_event = static_cast<const WebTouchEvent*>(
+      handled_tasks_.at(1)->taskAsEvent()->eventPointer());
   kEvents[1].dispatchType =
       WebInputEvent::DispatchType::ListenersNonBlockingPassive;
   EXPECT_EQ(kEvents[1], *last_touch_event);
 
   {
-    EXPECT_EQ(1u, handled_events_[1].coalescedEventSize());
+    EXPECT_EQ(1u, handled_tasks_[1]->taskAsEvent()->coalescedEventSize());
     const WebTouchEvent* coalesced_touch_event =
         static_cast<const WebTouchEvent*>(
-            handled_events_[1].getCoalescedEventsPointers()[0]);
+            handled_tasks_[1]->taskAsEvent()->getCoalescedEventsPointers()[0]);
     EXPECT_EQ(kEvents[1], *coalesced_touch_event);
   }
 
-  EXPECT_EQ(kEvents[2].size(), handled_events_.at(1).event().size());
-  EXPECT_EQ(kEvents[2].type(), handled_events_.at(2).event().type());
-  last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(2).eventPointer());
+  EXPECT_EQ(kEvents[2].size(),
+            handled_tasks_.at(1)->taskAsEvent()->event().size());
+  EXPECT_EQ(kEvents[2].type(),
+            handled_tasks_.at(2)->taskAsEvent()->event().type());
+  last_touch_event = static_cast<const WebTouchEvent*>(
+      handled_tasks_.at(2)->taskAsEvent()->eventPointer());
   WebTouchEvent coalesced_event = kEvents[2];
   ui::Coalesce(kEvents[3], &coalesced_event);
   coalesced_event.dispatchType =
       WebInputEvent::DispatchType::ListenersNonBlockingPassive;
   EXPECT_EQ(coalesced_event, *last_touch_event);
 
   {
-    EXPECT_EQ(2u, handled_events_[2].coalescedEventSize());
+    EXPECT_EQ(2u, handled_tasks_[2]->taskAsEvent()->coalescedEventSize());
     WebTouchEvent coalesced_event = kEvents[2];
     std::vector<const WebInputEvent*> coalesced_events =
-        handled_events_[2].getCoalescedEventsPointers();
+        handled_tasks_[2]->taskAsEvent()->getCoalescedEventsPointers();
     const WebTouchEvent* coalesced_touch_event0 =
         static_cast<const WebTouchEvent*>(coalesced_events[0]);
     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*>(coalesced_events[1]);
     coalesced_event.dispatchType =
@@ skipping 27 matching lines @@
 
   EXPECT_EQ(2u, event_queue().size());
   EXPECT_TRUE(main_task_runner_->HasPendingTask());
   RunPendingTasksWithSimulatedRaf();
 
   EXPECT_EQ(0u, event_queue().size());
   EXPECT_EQ(2u, additional_acked_events_.size());
   EXPECT_EQ(kEvents[1].uniqueTouchEventId, additional_acked_events_.at(0));
   EXPECT_EQ(kEvents[2].uniqueTouchEventId, additional_acked_events_.at(1));
 
-  const WebTouchEvent* last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(1).eventPointer());
+  const WebTouchEvent* last_touch_event = static_cast<const WebTouchEvent*>(
+      handled_tasks_.at(1)->taskAsEvent()->eventPointer());
   EXPECT_EQ(kEvents[3].uniqueTouchEventId,
             last_touch_event->uniqueTouchEventId);
 
   HandleEvent(kEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   HandleEvent(kEvents[2], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   HandleEvent(kEvents[3], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   EXPECT_EQ(1u, event_queue().size());
   RunPendingTasksWithSimulatedRaf();
   histogram_tester.ExpectUniqueSample(kCoalescedCountHistogram, 2, 2);
 }
@@ skipping 17 matching lines @@
   HandleEvent(kWheelEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   HandleEvent(kTouchEvents[1], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
 
   EXPECT_EQ(2u, event_queue().size());
   EXPECT_EQ(raf_aligned_input_setting_ !=
                 (kRafAlignedEnabledMouse | kRafAlignedEnabledTouch),
             main_task_runner_->HasPendingTask());
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
-  EXPECT_EQ(2u, handled_events_.size());
+  EXPECT_EQ(2u, handled_tasks_.size());
   {
-    EXPECT_EQ(kWheelEvents[0].size(), handled_events_.at(0).event().size());
-    EXPECT_EQ(kWheelEvents[0].type(), handled_events_.at(0).event().type());
+    EXPECT_EQ(kWheelEvents[0].size(),
+              handled_tasks_.at(0)->taskAsEvent()->event().size());
+    EXPECT_EQ(kWheelEvents[0].type(),
+              handled_tasks_.at(0)->taskAsEvent()->event().type());
     const WebMouseWheelEvent* last_wheel_event =
         static_cast<const WebMouseWheelEvent*>(
-            handled_events_.at(0).eventPointer());
+            handled_tasks_.at(0)->taskAsEvent()->eventPointer());
     EXPECT_EQ(WebInputEvent::DispatchType::ListenersNonBlockingPassive,
               last_wheel_event->dispatchType);
     WebMouseWheelEvent coalesced_event = kWheelEvents[0];
     ui::Coalesce(kWheelEvents[1], &coalesced_event);
     coalesced_event.dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
     EXPECT_EQ(coalesced_event, *last_wheel_event);
   }
   {
-    EXPECT_EQ(kTouchEvents[0].size(), handled_events_.at(1).event().size());
-    EXPECT_EQ(kTouchEvents[0].type(), handled_events_.at(1).event().type());
-    const WebTouchEvent* last_touch_event =
-        static_cast<const WebTouchEvent*>(handled_events_.at(1).eventPointer());
+    EXPECT_EQ(kTouchEvents[0].size(),
+              handled_tasks_.at(1)->taskAsEvent()->event().size());
+    EXPECT_EQ(kTouchEvents[0].type(),
+              handled_tasks_.at(1)->taskAsEvent()->event().type());
+    const WebTouchEvent* last_touch_event = static_cast<const WebTouchEvent*>(
+        handled_tasks_.at(1)->taskAsEvent()->eventPointer());
     WebTouchEvent coalesced_event = kTouchEvents[0];
     ui::Coalesce(kTouchEvents[1], &coalesced_event);
     coalesced_event.dispatchType =
         WebInputEvent::DispatchType::ListenersNonBlockingPassive;
     EXPECT_EQ(coalesced_event, *last_touch_event);
   }
 }
 
 TEST_P(MainThreadEventQueueTest, RafAlignedMouseInput) {
   // Don't run the test when we aren't supporting rAF aligned input.
   if ((raf_aligned_input_setting_ & kRafAlignedEnabledMouse) == 0)
     return;
 
   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_tasks_.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_tasks_.at(3)->taskAsEvent()->event().modifiers());
+  EXPECT_EQ(wheelEvents[0].modifiers(),
+            handled_tasks_.at(4)->taskAsEvent()->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_tasks_.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 106 matching lines @@
   SyntheticWebTouchEvent kEvents;
   kEvents.PressPoint(10, 10);
   kEvents.touchStartOrFirstTouchMove = true;
   set_enable_fling_passive_listener_flag(true);
 
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
   HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING);
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
-  EXPECT_EQ(1u, handled_events_.size());
-  EXPECT_EQ(kEvents.size(), handled_events_.at(0).event().size());
-  EXPECT_EQ(kEvents.type(), handled_events_.at(0).event().type());
+  EXPECT_EQ(1u, handled_tasks_.size());
+  EXPECT_EQ(kEvents.size(),
+            handled_tasks_.at(0)->taskAsEvent()->event().size());
+  EXPECT_EQ(kEvents.type(),
+            handled_tasks_.at(0)->taskAsEvent()->event().type());
   EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling());
-  const WebTouchEvent* last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(0).eventPointer());
+  const WebTouchEvent* last_touch_event = static_cast<const WebTouchEvent*>(
+      handled_tasks_.at(0)->taskAsEvent()->eventPointer());
   kEvents.dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling;
   EXPECT_EQ(kEvents, *last_touch_event);
 
   kEvents.MovePoint(0, 30, 30);
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING);
   EXPECT_EQ((raf_aligned_input_setting_ & kRafAlignedEnabledTouch) == 0,
             main_task_runner_->HasPendingTask());
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
-  EXPECT_EQ(2u, handled_events_.size());
-  EXPECT_EQ(kEvents.size(), handled_events_.at(1).event().size());
-  EXPECT_EQ(kEvents.type(), handled_events_.at(1).event().type());
+  EXPECT_EQ(2u, handled_tasks_.size());
+  EXPECT_EQ(kEvents.size(),
+            handled_tasks_.at(1)->taskAsEvent()->event().size());
+  EXPECT_EQ(kEvents.type(),
+            handled_tasks_.at(1)->taskAsEvent()->event().type());
   EXPECT_TRUE(last_touch_start_forced_nonblocking_due_to_fling());
-  last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(1).eventPointer());
+  last_touch_event = static_cast<const WebTouchEvent*>(
+      handled_tasks_.at(1)->taskAsEvent()->eventPointer());
   kEvents.dispatchType = WebInputEvent::ListenersForcedNonBlockingDueToFling;
   EXPECT_EQ(kEvents, *last_touch_event);
 
   kEvents.MovePoint(0, 50, 50);
   kEvents.touchStartOrFirstTouchMove = false;
   HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING);
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
-  EXPECT_EQ(3u, handled_events_.size());
-  EXPECT_EQ(kEvents.size(), handled_events_.at(2).event().size());
-  EXPECT_EQ(kEvents.type(), handled_events_.at(2).event().type());
+  EXPECT_EQ(3u, handled_tasks_.size());
+  EXPECT_EQ(kEvents.size(),
+            handled_tasks_.at(2)->taskAsEvent()->event().size());
+  EXPECT_EQ(kEvents.type(),
+            handled_tasks_.at(2)->taskAsEvent()->event().type());
   EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking);
-  last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(2).eventPointer());
+  last_touch_event = static_cast<const WebTouchEvent*>(
+      handled_tasks_.at(2)->taskAsEvent()->eventPointer());
   EXPECT_EQ(kEvents, *last_touch_event);
 
   kEvents.ReleasePoint(0);
   HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING);
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
-  EXPECT_EQ(4u, handled_events_.size());
-  EXPECT_EQ(kEvents.size(), handled_events_.at(3).event().size());
-  EXPECT_EQ(kEvents.type(), handled_events_.at(3).event().type());
+  EXPECT_EQ(4u, handled_tasks_.size());
+  EXPECT_EQ(kEvents.size(),
+            handled_tasks_.at(3)->taskAsEvent()->event().size());
+  EXPECT_EQ(kEvents.type(),
+            handled_tasks_.at(3)->taskAsEvent()->event().type());
   EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking);
-  last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(3).eventPointer());
+  last_touch_event = static_cast<const WebTouchEvent*>(
+      handled_tasks_.at(3)->taskAsEvent()->eventPointer());
   EXPECT_EQ(kEvents, *last_touch_event);
 }
 
 TEST_P(MainThreadEventQueueTest, BlockingTouchesOutsideFling) {
   SyntheticWebTouchEvent kEvents;
   kEvents.PressPoint(10, 10);
   kEvents.touchStartOrFirstTouchMove = true;
   set_enable_fling_passive_listener_flag(false);
 
   HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
-  EXPECT_EQ(1u, handled_events_.size());
-  EXPECT_EQ(kEvents.size(), handled_events_.at(0).event().size());
-  EXPECT_EQ(kEvents.type(), handled_events_.at(0).event().type());
+  EXPECT_EQ(1u, handled_tasks_.size());
+  EXPECT_EQ(kEvents.size(),
+            handled_tasks_.at(0)->taskAsEvent()->event().size());
+  EXPECT_EQ(kEvents.type(),
+            handled_tasks_.at(0)->taskAsEvent()->event().type());
   EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking);
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
-  const WebTouchEvent* last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(0).eventPointer());
+  const WebTouchEvent* last_touch_event = static_cast<const WebTouchEvent*>(
+      handled_tasks_.at(0)->taskAsEvent()->eventPointer());
   EXPECT_EQ(kEvents, *last_touch_event);
 
   set_enable_fling_passive_listener_flag(false);
   HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
-  EXPECT_EQ(2u, handled_events_.size());
-  EXPECT_EQ(kEvents.size(), handled_events_.at(1).event().size());
-  EXPECT_EQ(kEvents.type(), handled_events_.at(1).event().type());
+  EXPECT_EQ(2u, handled_tasks_.size());
+  EXPECT_EQ(kEvents.size(),
+            handled_tasks_.at(1)->taskAsEvent()->event().size());
+  EXPECT_EQ(kEvents.type(),
+            handled_tasks_.at(1)->taskAsEvent()->event().type());
   EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking);
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
-  last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(1).eventPointer());
+  last_touch_event = static_cast<const WebTouchEvent*>(
+      handled_tasks_.at(1)->taskAsEvent()->eventPointer());
   EXPECT_EQ(kEvents, *last_touch_event);
 
   set_enable_fling_passive_listener_flag(true);
   HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
-  EXPECT_EQ(3u, handled_events_.size());
-  EXPECT_EQ(kEvents.size(), handled_events_.at(2).event().size());
-  EXPECT_EQ(kEvents.type(), handled_events_.at(2).event().type());
+  EXPECT_EQ(3u, handled_tasks_.size());
+  EXPECT_EQ(kEvents.size(),
+            handled_tasks_.at(2)->taskAsEvent()->event().size());
+  EXPECT_EQ(kEvents.type(),
+            handled_tasks_.at(2)->taskAsEvent()->event().type());
   EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking);
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
-  last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(2).eventPointer());
+  last_touch_event = static_cast<const WebTouchEvent*>(
+      handled_tasks_.at(2)->taskAsEvent()->eventPointer());
   EXPECT_EQ(kEvents, *last_touch_event);
 
   kEvents.MovePoint(0, 30, 30);
   HandleEvent(kEvents, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   RunPendingTasksWithSimulatedRaf();
   EXPECT_FALSE(main_task_runner_->HasPendingTask());
   EXPECT_EQ(0u, event_queue().size());
-  EXPECT_EQ(4u, handled_events_.size());
-  EXPECT_EQ(kEvents.size(), handled_events_.at(3).event().size());
-  EXPECT_EQ(kEvents.type(), handled_events_.at(3).event().type());
+  EXPECT_EQ(4u, handled_tasks_.size());
+  EXPECT_EQ(kEvents.size(),
+            handled_tasks_.at(3)->taskAsEvent()->event().size());
+  EXPECT_EQ(kEvents.type(),
+            handled_tasks_.at(3)->taskAsEvent()->event().type());
   EXPECT_EQ(kEvents.dispatchType, WebInputEvent::Blocking);
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
-  last_touch_event =
-      static_cast<const WebTouchEvent*>(handled_events_.at(3).eventPointer());
+  last_touch_event = static_cast<const WebTouchEvent*>(
+      handled_tasks_.at(3)->taskAsEvent()->eventPointer());
   EXPECT_EQ(kEvents, *last_touch_event);
 }
 
 // The boolean parameterized test varies whether rAF aligned input
 // is enabled or not.
 INSTANTIATE_TEST_CASE_P(
     MainThreadEventQueueTests,
     MainThreadEventQueueTest,
     testing::Range(0u,
                    (kRafAlignedEnabledTouch | kRafAlignedEnabledMouse) + 1));
@@ skipping 55 matching lines @@
   base::FieldTrialList::CreateFieldTrial(
       "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());
 }
 
+TEST_P(MainThreadEventQueueTest, QueuingTwoClosures) {
+  EXPECT_FALSE(main_task_runner_->HasPendingTask());
+  EXPECT_EQ(0u, event_queue().size());
+
+  QueueClosure();
+  QueueClosure();
+  EXPECT_EQ(2u, event_queue().size());
+  EXPECT_TRUE(main_task_runner_->HasPendingTask());
+  EXPECT_FALSE(needs_main_frame_);
+  main_task_runner_->RunUntilIdle();
+  EXPECT_EQ(1u, handled_tasks_.at(0)->taskAsClosure());
+  EXPECT_EQ(2u, handled_tasks_.at(1)->taskAsClosure());
+}
+
+TEST_P(MainThreadEventQueueTest, QueuingClosureWithRafEvent) {
+  SyntheticWebTouchEvent kEvents[2];
+  kEvents[0].PressPoint(10, 10);
+  kEvents[1].PressPoint(10, 10);
+  kEvents[1].MovePoint(0, 20, 20);
+
+  // Simulate queueuing closure, event, closure, raf aligned event.
+  EXPECT_FALSE(main_task_runner_->HasPendingTask());
+  EXPECT_EQ(0u, event_queue().size());
+  QueueClosure();
+  EXPECT_EQ(1u, event_queue().size());
+  EXPECT_TRUE(main_task_runner_->HasPendingTask());
+  EXPECT_FALSE(needs_main_frame_);
+
+  EXPECT_FALSE(HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED));
+  QueueClosure();
+  EXPECT_EQ(3u, event_queue().size());
+  EXPECT_TRUE(main_task_runner_->HasPendingTask());
+  EXPECT_FALSE(needs_main_frame_);
+  EXPECT_FALSE(HandleEvent(kEvents[1], INPUT_EVENT_ACK_STATE_NOT_CONSUMED));
+  EXPECT_EQ(4u, event_queue().size());
+
+  if ((raf_aligned_input_setting_ & kRafAlignedEnabledTouch) != 0) {
+    EXPECT_TRUE(needs_main_frame_);
+    main_task_runner_->RunUntilIdle();
+
+    // The queue should still have the rAF event.
+    EXPECT_TRUE(needs_main_frame_);
+    EXPECT_EQ(1u, event_queue().size());
+    RunPendingTasksWithSimulatedRaf();
+  } else {
+    EXPECT_FALSE(needs_main_frame_);
+    main_task_runner_->RunUntilIdle();
+  }
+
+  EXPECT_EQ(0u, event_queue().size());
+  EXPECT_FALSE(main_task_runner_->HasPendingTask());
+  EXPECT_FALSE(needs_main_frame_);
+
+  EXPECT_EQ(1u, handled_tasks_.at(0)->taskAsClosure());
+  EXPECT_EQ(kEvents[0].type(),
+            handled_tasks_.at(1)->taskAsEvent()->event().type());
+  EXPECT_EQ(2u, handled_tasks_.at(2)->taskAsClosure());
+  EXPECT_EQ(kEvents[1].type(),
+            handled_tasks_.at(3)->taskAsEvent()->event().type());
+}
+
+TEST_P(MainThreadEventQueueTest, QueuingClosuresBetweenEvents) {
+  SyntheticWebTouchEvent kEvents[2];
+  kEvents[0].PressPoint(10, 10);
+  kEvents[1].PressPoint(10, 10);
+  kEvents[1].ReleasePoint(0);
+
+  EXPECT_FALSE(main_task_runner_->HasPendingTask());
+  EXPECT_EQ(0u, event_queue().size());
+
+  EXPECT_FALSE(HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_NOT_CONSUMED));
+  QueueClosure();
+  QueueClosure();
+  EXPECT_FALSE(HandleEvent(kEvents[1], INPUT_EVENT_ACK_STATE_NOT_CONSUMED));
+  EXPECT_EQ(4u, event_queue().size());
+  EXPECT_FALSE(needs_main_frame_);
+  main_task_runner_->RunUntilIdle();
+  EXPECT_EQ(0u, event_queue().size());
+  EXPECT_FALSE(main_task_runner_->HasPendingTask());
+  EXPECT_FALSE(needs_main_frame_);
+
+  EXPECT_EQ(kEvents[0].type(),
+            handled_tasks_.at(0)->taskAsEvent()->event().type());
+  EXPECT_EQ(1u, handled_tasks_.at(1)->taskAsClosure());
+  EXPECT_EQ(2u, handled_tasks_.at(2)->taskAsClosure());
+  EXPECT_EQ(kEvents[1].type(),
+            handled_tasks_.at(3)->taskAsEvent()->event().type());
+}
+
 }  // namespace content