Allow MainThreadEventQueue to call the RenderWidget directly.

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 28 matching lines @@
 
 namespace content {
 namespace {
 
 const unsigned kRafAlignedEnabledTouch = 1;
 const unsigned kRafAlignedEnabledMouse = 1 << 1;
 
 // 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()) {}
+  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_;
@@ skipping 33 matching lines @@
       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);
-
-    std::unique_ptr<HandledTask> handled_event(new HandledEvent(event));
-    handled_tasks_.push_back(std::move(handled_event));
-
-    queue_->EventHandled(event->Event().GetType(),
-                         blink::WebInputEventResult::kHandledApplication,
-                         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);
+    queue_ =
+        new MainThreadEventQueue(this, main_task_runner_, &renderer_scheduler_);
   }
 
   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; }
-
   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;
   }
 
   void RunPendingTasksWithSimulatedRaf() {
     while (needs_main_frame_ || main_task_runner_->HasPendingTask()) {
       main_task_runner_->RunUntilIdle();
       needs_main_frame_ = false;
       frame_time_ += kFrameInterval;
       queue_->DispatchRafAlignedInput(frame_time_);
     }
   }
 
   void RunSimulatedRafOnce() {
     if (needs_main_frame_) {
       needs_main_frame_ = false;
       frame_time_ += kFrameInterval;
       queue_->DispatchRafAlignedInput(frame_time_);
     }
   }
 
+  InputEventAckState HandleInputEvent(
+      const blink::WebCoalescedInputEvent& event,
+      const ui::LatencyInfo& latency,
+      InputEventDispatchType dispatch_type) override {
+    std::unique_ptr<HandledTask> handled_event(new HandledEvent(event));
+    handled_tasks_.push_back(std::move(handled_event));
+    return INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
+  }
+
+  void SendInputEventAck(blink::WebInputEvent::Type type,
+                         InputEventAckState ack_result,
+                         uint32_t touch_event_id) override {
+    additional_acked_events_.push_back(touch_event_id);
+  }
+
+  void SetNeedsMainFrame() override { needs_main_frame_ = true; }
+
  protected:
   base::test::ScopedFeatureList feature_list_;
   scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_;
   blink::scheduler::MockRendererScheduler renderer_scheduler_;
   scoped_refptr<MainThreadEventQueue> queue_;
   std::vector<std::unique_ptr<HandledTask>> handled_tasks_;
 
   std::vector<uint32_t> additional_acked_events_;
   int raf_aligned_input_setting_;
   bool needs_main_frame_;
@@ skipping 670 matching lines @@
 }
 
 // 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));
 
-class DummyMainThreadEventQueueClient : public MainThreadEventQueueClient {
-  void HandleEventOnMainThread(int routing_id,
-                               const blink::WebCoalescedInputEvent* event,
-                               const ui::LatencyInfo& latency,
-                               InputEventDispatchType dispatch_type) override {}
-
-  void SendInputEventAck(int routing_id,
-                         blink::WebInputEvent::Type type,
-                         InputEventAckState ack_result,
-                         uint32_t touch_event_id) override {}
-
-  void NeedsMainFrame(int routing_id) override {}
-};
-
 class MainThreadEventQueueInitializationTest
-    : public testing::Test {
+    : public testing::Test,
+      public MainThreadEventQueueClient {
  public:
   MainThreadEventQueueInitializationTest()
       : field_trial_list_(new base::FieldTrialList(nullptr)) {}
 
   base::TimeDelta main_thread_responsiveness_threshold() {
     return queue_->main_thread_responsiveness_threshold_;
   }
 
   bool enable_non_blocking_due_to_main_thread_responsiveness_flag() {
     return queue_->enable_non_blocking_due_to_main_thread_responsiveness_flag_;
   }
 
+  InputEventAckState HandleInputEvent(
+      const blink::WebCoalescedInputEvent& event,
+      const ui::LatencyInfo& latency,
+      InputEventDispatchType dispatch_type) override {
+    return INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
+  }
+
+  void SendInputEventAck(blink::WebInputEvent::Type type,
+                         InputEventAckState ack_result,
+                         uint32_t touch_event_id) override {}
+
+  void SetNeedsMainFrame() override {}
+
  protected:
   scoped_refptr<MainThreadEventQueue> queue_;
   base::test::ScopedFeatureList feature_list_;
   blink::scheduler::MockRendererScheduler renderer_scheduler_;
   scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_;
   std::unique_ptr<base::FieldTrialList> field_trial_list_;
-  DummyMainThreadEventQueueClient dummy_main_thread_event_queue_client_;
 };
 
 TEST_F(MainThreadEventQueueInitializationTest,
        MainThreadResponsivenessThresholdEnabled) {
   feature_list_.InitFromCommandLine(
       features::kMainThreadBusyScrollIntervention.name, "");
 
   base::FieldTrialList::CreateFieldTrial(
       "MainThreadResponsivenessScrollIntervention", "Enabled123");
-  queue_ = new MainThreadEventQueue(kTestRoutingID,
-                                    &dummy_main_thread_event_queue_client_,
-                                    main_task_runner_, &renderer_scheduler_);
+  queue_ =
+      new MainThreadEventQueue(this, main_task_runner_, &renderer_scheduler_);
   EXPECT_TRUE(enable_non_blocking_due_to_main_thread_responsiveness_flag());
   EXPECT_EQ(base::TimeDelta::FromMilliseconds(123),
             main_thread_responsiveness_threshold());
 }
 
 TEST_F(MainThreadEventQueueInitializationTest,
        MainThreadResponsivenessThresholdDisabled) {
   base::FieldTrialList::CreateFieldTrial(
       "MainThreadResponsivenessScrollIntervention", "Control");
-  queue_ = new MainThreadEventQueue(kTestRoutingID,
-                                    &dummy_main_thread_event_queue_client_,
-                                    main_task_runner_, &renderer_scheduler_);
+  queue_ =
+      new MainThreadEventQueue(this, 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();
@@ skipping 145 matching lines @@
             static_cast<const WebTouchEvent&>(
                 handled_tasks_.at(0)->taskAsEvent()->Event())
                 .dispatch_type);
   EXPECT_EQ(WebInputEvent::kBlocking,
             static_cast<const WebTouchEvent&>(
                 handled_tasks_.at(1)->taskAsEvent()->Event())
                 .dispatch_type);
 }
 
 }  // namespace content