Allow MainThreadEventQueue to call the RenderWidget directly.

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 81c324cbb5e5c8d3df38789857ef46af93098a0b..b4fc32ee7dfc6640ad6e51087c16811fe173cb4d 100644
--- a/content/renderer/input/main_thread_event_queue_unittest.cc
+++ b/content/renderer/input/main_thread_event_queue_unittest.cc
@@ -46,7 +46,6 @@ 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";
 
@@ -62,8 +61,8 @@ class HandledTask {
 
 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_; }
@@ -91,8 +90,34 @@ class HandledClosure : public HandledTask {
   unsigned closure_id_;
 };
 
-class MainThreadEventQueueTest : public testing::TestWithParam<unsigned>,
-                                 public MainThreadEventQueueClient {
+class MainThreadEventQueueTest;
+
+class MainThreadEventQueueForTest : public MainThreadEventQueue {
+ public:
+  MainThreadEventQueueForTest(
+      const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
+      blink::scheduler::RendererScheduler* scheduler,
+      MainThreadEventQueueTest* test)
+      : MainThreadEventQueue(main_task_runner, scheduler), test_(test) {}
+
+  InputEventAckState HandleEventOnMainThread(
+      const blink::WebCoalescedInputEvent& event,
+      const ui::LatencyInfo& latency,
+      InputEventDispatchType dispatch_type) override;
+
+  void SendInputEventAck(blink::WebInputEvent::Type type,
+                         InputEventAckState ack_result,
+                         uint32_t touch_event_id) override;
+
+  void NeedsMainFrame() override;
+
+ private:
+  ~MainThreadEventQueueForTest() override {}
+
+  MainThreadEventQueueTest* test_;
+};
+
+class MainThreadEventQueueTest : public testing::TestWithParam<unsigned> {
  public:
   MainThreadEventQueueTest()
       : main_task_runner_(new base::TestSimpleTaskRunner()),
@@ -117,29 +142,8 @@ class MainThreadEventQueueTest : public testing::TestWithParam<unsigned>,
   }
 
   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 MainThreadEventQueueForTest(main_task_runner_,
+                                             &renderer_scheduler_, this);
   }
 
   bool HandleEvent(WebInputEvent& event, InputEventAckState ack_result) {
@@ -159,8 +163,6 @@ class MainThreadEventQueueTest : public testing::TestWithParam<unsigned>,
                                     base::Unretained(this), closure_id));
   }
 
-  void NeedsMainFrame(int routing_id) override { needs_main_frame_ = true; }
-
   MainThreadEventQueueTaskList& event_queue() {
     return queue_->shared_state_.events_;
   }
@@ -191,10 +193,11 @@ class MainThreadEventQueueTest : public testing::TestWithParam<unsigned>,
   }
 
  protected:
+  friend class MainThreadEventQueueForTest;
   base::test::ScopedFeatureList feature_list_;
   scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_;
   blink::scheduler::MockRendererScheduler renderer_scheduler_;
-  scoped_refptr<MainThreadEventQueue> queue_;
+  scoped_refptr<MainThreadEventQueueForTest> queue_;
   std::vector<std::unique_ptr<HandledTask>> handled_tasks_;
 
   std::vector<uint32_t> additional_acked_events_;
@@ -204,6 +207,26 @@ class MainThreadEventQueueTest : public testing::TestWithParam<unsigned>,
   unsigned closure_count_;
 };
 
+InputEventAckState MainThreadEventQueueForTest::HandleEventOnMainThread(
+    const blink::WebCoalescedInputEvent& event,
+    const ui::LatencyInfo& latency,
+    InputEventDispatchType dispatch_type) {
+  std::unique_ptr<HandledTask> handled_event(new HandledEvent(event));
+  test_->handled_tasks_.push_back(std::move(handled_event));
+  return INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
+}
+
+void MainThreadEventQueueForTest::SendInputEventAck(
+    blink::WebInputEvent::Type type,
+    InputEventAckState ack_result,
+    uint32_t touch_event_id) {
+  test_->additional_acked_events_.push_back(touch_event_id);
+}
+
+void MainThreadEventQueueForTest::NeedsMainFrame() {
+  test_->needs_main_frame_ = true;
+}
+
 TEST_P(MainThreadEventQueueTest, NonBlockingWheel) {
   base::HistogramTester histogram_tester;
 
@@ -880,20 +903,6 @@ INSTANTIATE_TEST_CASE_P(
     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:
@@ -914,7 +923,28 @@ class MainThreadEventQueueInitializationTest
   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_;
+};
+
+class MockMainThreadEventQueue : public MainThreadEventQueue {
+ public:
+  MockMainThreadEventQueue(
+      const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
+      blink::scheduler::RendererScheduler* scheduler)
+      : MainThreadEventQueue(main_task_runner, scheduler) {}
+
+  MOCK_METHOD3(HandleEventOnMainThread,
+               InputEventAckState(const blink::WebCoalescedInputEvent& event,
+                                  const ui::LatencyInfo& latency,
+                                  InputEventDispatchType dispatch_type));
+
+  MOCK_METHOD3(SendInputEventAck,
+               void(blink::WebInputEvent::Type type,
+                    InputEventAckState ack_result,
+                    uint32_t touch_event_id));
+  MOCK_METHOD0(NeedsMainFrame, void());
+
+ private:
+  ~MockMainThreadEventQueue() override {}
 };
 
 TEST_F(MainThreadEventQueueInitializationTest,
@@ -924,9 +954,8 @@ TEST_F(MainThreadEventQueueInitializationTest,
 
   base::FieldTrialList::CreateFieldTrial(
       "MainThreadResponsivenessScrollIntervention", "Enabled123");
-  queue_ = new MainThreadEventQueue(kTestRoutingID,
-                                    &dummy_main_thread_event_queue_client_,
-                                    main_task_runner_, &renderer_scheduler_);
+  queue_ =
+      new MockMainThreadEventQueue(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());
@@ -936,9 +965,8 @@ 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 MockMainThreadEventQueue(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());