Add a unit test expection for calling the render scheduler on coalesced events.

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>
 
 #include "base/macros.h"
 #include "base/test/test_simple_task_runner.h"
 #include "build/build_config.h"
 #include "content/common/input/synthetic_web_input_event_builders.h"
 #include "content/renderer/input/main_thread_event_queue.h"
+#include "content/renderer/render_thread_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/platform/scheduler/test/mock_renderer_scheduler.h"
 
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 
 namespace blink {
 bool operator==(const WebMouseWheelEvent& lhs, const WebMouseWheelEvent& rhs) {
   return memcmp(&lhs, &rhs, lhs.size) == 0;
 }
 
 bool operator==(const WebTouchEvent& lhs, const WebTouchEvent& rhs) {
   return memcmp(&lhs, &rhs, lhs.size) == 0;
 }
 }  // namespace blink
 
 namespace content {
 namespace {
 
 const int kTestRoutingID = 13;
 }
 
 class MainThreadEventQueueTest : public testing::Test,
                                  public MainThreadEventQueueClient {
  public:
   MainThreadEventQueueTest()
       : main_task_runner_(new base::TestSimpleTaskRunner()),
-        queue_(
-            new MainThreadEventQueue(kTestRoutingID, this, main_task_runner_)) {
-  }
+        queue_(new MainThreadEventQueue(kTestRoutingID,
+                                        this,
+                                        main_task_runner_,
+                                        &renderer_scheduler_)) {}
 
   void HandleEventOnMainThread(int routing_id,
                                const blink::WebInputEvent* event,
                                const ui::LatencyInfo& latency,
                                InputEventDispatchType type) override {
     EXPECT_EQ(kTestRoutingID, routing_id);
     handled_events_.push_back(ui::WebInputEventTraits::Clone(*event));
     queue_->EventHandled(event->type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   }
 
@@ skipping 20 matching lines @@
   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;
   }
 
  protected:
   scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_;
+  blink::scheduler::MockRendererScheduler renderer_scheduler_;
   scoped_refptr<MainThreadEventQueue> queue_;
   std::vector<ui::ScopedWebInputEvent> handled_events_;
   std::vector<uint32_t> additional_acked_events_;
 };
 
 TEST_F(MainThreadEventQueueTest, NonBlockingWheel) {
   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),
@@ skipping 88 matching lines @@
 
 TEST_F(MainThreadEventQueueTest, BlockingTouch) {
   SyntheticWebTouchEvent kEvents[4];
   kEvents[0].PressPoint(10, 10);
   kEvents[1].PressPoint(10, 10);
   kEvents[1].MovePoint(0, 20, 20);
   kEvents[2].PressPoint(10, 10);
   kEvents[2].MovePoint(0, 30, 30);
   kEvents[3].PressPoint(10, 10);
   kEvents[3].MovePoint(0, 35, 35);
+
+  EXPECT_CALL(renderer_scheduler_, DidHandleInputEventOnMainThread(testing::_))
+      .Times(2);
   // Ensure that coalescing takes place.
   HandleEvent(kEvents[0], INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
   HandleEvent(kEvents[1], INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   HandleEvent(kEvents[2], INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   HandleEvent(kEvents[3], INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   EXPECT_EQ(2u, event_queue().size());
   EXPECT_TRUE(main_task_runner_->HasPendingTask());
   main_task_runner_->RunUntilIdle();
   EXPECT_EQ(0u, event_queue().size());
@@ skipping 185 matching lines @@
   EXPECT_EQ(kEvents[0].type, handled_events_.at(3)->type);
   EXPECT_FALSE(kEvents[0].dispatchedDuringFling);
   EXPECT_EQ(kEvents[0].dispatchType, WebInputEvent::Blocking);
   EXPECT_FALSE(last_touch_start_forced_nonblocking_due_to_fling());
   last_touch_event =
       static_cast<const WebTouchEvent*>(handled_events_.at(3).get());
   EXPECT_EQ(kEvents[0], *last_touch_event);
 }
 
 }  // namespace content