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_;
 };
 
 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 {
+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()),
         raf_aligned_input_setting_(GetParam()),
         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);
-
-    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) {
     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;
@@ skipping 10 matching lines @@
 
   void RunSimulatedRafOnce() {
     if (needs_main_frame_) {
       needs_main_frame_ = false;
       frame_time_ += kFrameInterval;
       queue_->DispatchRafAlignedInput(frame_time_);
     }
   }
 
  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_;
   int raf_aligned_input_setting_;
   bool needs_main_frame_;
   base::TimeTicks frame_time_;
   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;
 
   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),
   };
 
@@ skipping 656 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:
   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_;
   }
 
  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_;
+};
+
+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,
        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 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());
 }
 
 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());
 }
 
 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