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

content/renderer/input/main_thread_event_queue.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 "content/renderer/input/main_thread_event_queue.h"
 
 #include "content/common/input/event_with_latency_info.h"
 #include "content/common/input_messages.h"
-#include "content/renderer/render_thread_impl.h"
 
 namespace content {
 
 EventWithDispatchType::EventWithDispatchType(
     ui::ScopedWebInputEvent event,
     const ui::LatencyInfo& latency,
     InputEventDispatchType dispatch_type)
     : ScopedWebInputEventWithLatencyInfo(std::move(event), latency),
       dispatch_type_(dispatch_type) {}
 
@@ skipping 12 matching lines @@
     // We should only have blocking touch events that need coalescing.
     eventsToAck_.push_back(
         ui::WebInputEventTraits::GetUniqueTouchEventId(other.event()));
   }
   ScopedWebInputEventWithLatencyInfo::CoalesceWith(other);
 }
 
 MainThreadEventQueue::MainThreadEventQueue(
     int routing_id,
     MainThreadEventQueueClient* client,
-    const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner)
+    const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
+    blink::scheduler::RendererScheduler* renderer_scheduler)
     : routing_id_(routing_id),
       client_(client),
       is_flinging_(false),
       last_touch_start_forced_nonblocking_due_to_fling_(false),
       enable_fling_passive_listener_flag_(base::FeatureList::IsEnabled(
           features::kPassiveEventListenersDueToFling)),
-      main_task_runner_(main_task_runner) {}
+      main_task_runner_(main_task_runner),
+      renderer_scheduler_(renderer_scheduler) {}
 
 MainThreadEventQueue::~MainThreadEventQueue() {}
 
 bool MainThreadEventQueue::HandleEvent(
     ui::ScopedWebInputEvent event,
     const ui::LatencyInfo& latency,
     InputEventDispatchType original_dispatch_type,
     InputEventAckState ack_result) {
   DCHECK(original_dispatch_type == DISPATCH_TYPE_BLOCKING ||
          original_dispatch_type == DISPATCH_TYPE_NON_BLOCKING);
@@ skipping 67 matching lines @@
                                      in_flight_event_->latencyInfo(),
                                      dispatch_type);
   }
 
   in_flight_event_.reset();
 }
 
 void MainThreadEventQueue::EventHandled(blink::WebInputEvent::Type type,
                                         InputEventAckState ack_result) {
   if (in_flight_event_) {
-    RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
     // Send acks for blocking touch events.
     for (const auto id : in_flight_event_->eventsToAck()) {
       client_->SendInputEventAck(routing_id_, type, ack_result, id);
-      if (render_thread_impl) {
-        render_thread_impl->GetRendererScheduler()
-            ->DidHandleInputEventOnMainThread(in_flight_event_->event());
+      if (renderer_scheduler_) {
+        renderer_scheduler_->DidHandleInputEventOnMainThread(
+            in_flight_event_->event());
       }
     }
   }
 }
 
 void MainThreadEventQueue::SendEventNotificationToMainThread() {
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MainThreadEventQueue::PopEventOnMainThread,
                             this));
 }
 
 void MainThreadEventQueue::QueueEvent(
     std::unique_ptr<EventWithDispatchType> event) {
   bool send_notification = false;
   {
     base::AutoLock lock(event_queue_lock_);
     size_t size_before = events_.size();
     events_.Queue(std::move(event));
     send_notification = events_.size() != size_before;
   }
   if (send_notification)
     SendEventNotificationToMainThread();
 }
 
 }  // namespace content