Allow MainThreadEventQueue to call the RenderWidget directly.

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 "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/common/input/event_with_latency_info.h"
 #include "content/common/input_messages.h"
+#include "content/renderer/render_widget.h"
 
 namespace content {
 
 namespace {
 
 const size_t kTenSeconds = 10 * 1000 * 1000;
 
 class QueuedClosure : public MainThreadEventQueueTask {
  public:
   QueuedClosure(const base::Closure& closure) : closure_(closure) {}
 
   ~QueuedClosure() override {}
 
   FilterResult FilterNewEvent(
       const MainThreadEventQueueTask& other_task) override {
     return other_task.IsWebInputEvent() ? FilterResult::KeepIterating
                                         : FilterResult::StopIterating;
   }
 
   bool IsWebInputEvent() const override { return false; }
 
-  void Dispatch(int routing_id, MainThreadEventQueueClient*) override {
-    closure_.Run();
-  }
-
-  void EventHandled(int routing_id,
-                    blink::scheduler::RendererScheduler* renderer_scheduler,
-                    MainThreadEventQueueClient* client,
-                    blink::WebInputEvent::Type type,
-                    blink::WebInputEventResult result,
-                    InputEventAckState ack_result) override {}
+  void Dispatch(MainThreadEventQueue*) override { closure_.Run(); }
 
  private:
   base::Closure closure_;
 };
 
 class QueuedWebInputEvent : public ScopedWebInputEventWithLatencyInfo,
                             public MainThreadEventQueueTask {
  public:
   QueuedWebInputEvent(ui::WebScopedInputEvent event,
                       const ui::LatencyInfo& latency,
@@ skipping 39 matching lines @@
 
     // The newest event (|other_item|) always wins when updating fields.
     dispatch_type_ = other_event.dispatch_type_;
     originally_cancelable_ = other_event.originally_cancelable_;
 
     return FilterResult::CoalescedEvent;
   }
 
   bool IsWebInputEvent() const override { return true; }
 
-  void Dispatch(int routing_id, MainThreadEventQueueClient* client) override {
+  void Dispatch(MainThreadEventQueue* queue) override {
     // Report the coalesced count only for continuous events; otherwise
     // the zero value would be dominated by non-continuous events.
     base::TimeTicks now = base::TimeTicks::Now();
     if (IsContinuousEvent()) {
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Event.MainThreadEventQueue.Continuous.QueueingTime",
           (now - creationTimestamp()).InMicroseconds(), 1, kTenSeconds, 50);
 
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Event.MainThreadEventQueue.Continuous.FreshnessTime",
           (now - lastCoalescedTimestamp()).InMicroseconds(), 1, kTenSeconds,
           50);
 
       UMA_HISTOGRAM_COUNTS_1000("Event.MainThreadEventQueue.CoalescedCount",
                                 coalescedCount());
     } else {
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Event.MainThreadEventQueue.NonContinuous.QueueingTime",
           (now - creationTimestamp()).InMicroseconds(), 1, kTenSeconds, 50);
     }
 
-    InputEventDispatchType dispatch_type = dispatchType();
-    if (!blockingCoalescedEventIds().empty()) {
-      switch (dispatch_type) {
-        case DISPATCH_TYPE_BLOCKING:
-          dispatch_type = DISPATCH_TYPE_BLOCKING_NOTIFY_MAIN;
-          break;
-        case DISPATCH_TYPE_NON_BLOCKING:
-          dispatch_type = DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN;
-          break;
-        default:
-          NOTREACHED();
-      }
-    }
-    client->HandleEventOnMainThread(routing_id, &coalesced_event(),
-                                    latencyInfo(), dispatch_type);
-  }
-
-  void EventHandled(int routing_id,
-                    blink::scheduler::RendererScheduler* renderer_scheduler,
-                    MainThreadEventQueueClient* client,
-                    blink::WebInputEvent::Type type,
-                    blink::WebInputEventResult result,
-                    InputEventAckState ack_result) override {
+    InputEventAckState ack_result = queue->HandleEventOnMainThread(
+        coalesced_event(), latencyInfo(), dispatchType());
     for (const auto id : blockingCoalescedEventIds()) {
-      client->SendInputEventAck(routing_id, type, ack_result, id);
-      if (renderer_scheduler) {
-        renderer_scheduler->DidHandleInputEventOnMainThread(event(), result);
-      }
+      queue->SendInputEventAck(event().GetType(), ack_result, id);
+      queue->NotifySchedulerOfEventHandled(event(), ack_result);
     }
   }
 
   bool originallyCancelable() const { return originally_cancelable_; }
 
  private:
   FilterResult HandleTouchScrollStartQueued() {
     // A TouchScrollStart will queued after this touch move which will make all
     // previous touch moves that are queued uncancelable.
     switch (event().GetType()) {
@@ skipping 76 matching lines @@
 }
 
 }  // namespace
 
 MainThreadEventQueue::SharedState::SharedState()
     : sent_main_frame_request_(false), sent_post_task_(false) {}
 
 MainThreadEventQueue::SharedState::~SharedState() {}
 
 MainThreadEventQueue::MainThreadEventQueue(
-    int routing_id,
-    MainThreadEventQueueClient* client,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
     blink::scheduler::RendererScheduler* renderer_scheduler)
-    : routing_id_(routing_id),
-      client_(client),
-      last_touch_start_forced_nonblocking_due_to_fling_(false),
+    : last_touch_start_forced_nonblocking_due_to_fling_(false),
       enable_fling_passive_listener_flag_(base::FeatureList::IsEnabled(
           features::kPassiveEventListenersDueToFling)),
       enable_non_blocking_due_to_main_thread_responsiveness_flag_(
           base::FeatureList::IsEnabled(
               features::kMainThreadBusyScrollIntervention)),
       handle_raf_aligned_touch_input_(
           base::FeatureList::IsEnabled(features::kRafAlignedTouchInputEvents)),
       handle_raf_aligned_mouse_input_(
           base::FeatureList::IsEnabled(features::kRafAlignedMouseInputEvents)),
       main_task_runner_(main_task_runner),
@@ skipping 119 matching lines @@
     needs_post_task = !shared_state_.sent_post_task_;
     shared_state_.sent_post_task_ = true;
   }
 
   if (needs_post_task)
     PostTaskToMainThread();
 }
 
 void MainThreadEventQueue::DispatchInFlightEvent() {
   if (in_flight_event_) {
-    in_flight_event_->Dispatch(routing_id_, client_);
+    in_flight_event_->Dispatch(this);
     in_flight_event_.reset();
   }
 }
 
 void MainThreadEventQueue::PossiblyScheduleMainFrame() {
   if (IsRafAlignedInputDisabled())
     return;
   bool needs_main_frame = false;
   {
     base::AutoLock lock(shared_state_lock_);
     if (!shared_state_.sent_main_frame_request_ &&
         !shared_state_.events_.empty() &&
         IsRafAlignedEvent(shared_state_.events_.front())) {
       needs_main_frame = true;
       shared_state_.sent_main_frame_request_ = true;
     }
   }
   if (needs_main_frame)
-    client_->NeedsMainFrame(routing_id_);
+    NeedsMainFrame();
 }
 
 void MainThreadEventQueue::DispatchEvents() {
   size_t events_to_process;
 
   // Record the queue size so that we only process
   // that maximum number of events.
   {
     base::AutoLock lock(shared_state_lock_);
     shared_state_.sent_post_task_ = false;
@@ skipping 13 matching lines @@
         return;
       in_flight_event_ = shared_state_.events_.Pop();
     }
 
     // Dispatching the event is outside of critical section.
     DispatchInFlightEvent();
   }
   PossiblyScheduleMainFrame();
 }
 
-void MainThreadEventQueue::EventHandled(blink::WebInputEvent::Type type,
-                                        blink::WebInputEventResult result,
-                                        InputEventAckState ack_result) {
-  if (in_flight_event_) {
-    in_flight_event_->EventHandled(routing_id_, renderer_scheduler_, client_,
-                                   type, result, ack_result);
-  }
-}
-
 void MainThreadEventQueue::DispatchRafAlignedInput(base::TimeTicks frame_time) {
   if (IsRafAlignedInputDisabled())
     return;
 
   size_t queue_size_at_start;
 
   // Record the queue size so that we only process
   // that maximum number of events.
   {
     base::AutoLock lock(shared_state_lock_);
@@ skipping 53 matching lines @@
       } else {
         needs_main_frame = !shared_state_.sent_main_frame_request_;
         shared_state_.sent_main_frame_request_ = true;
       }
     }
   }
 
   if (needs_post_task)
     PostTaskToMainThread();
   if (needs_main_frame)
-    client_->NeedsMainFrame(routing_id_);
+    NeedsMainFrame();
 }
 
 bool MainThreadEventQueue::IsRafAlignedInputDisabled() const {
   return !handle_raf_aligned_mouse_input_ && !handle_raf_aligned_touch_input_;
 }
 
 bool MainThreadEventQueue::IsRafAlignedEvent(
     const std::unique_ptr<MainThreadEventQueueTask>& item) const {
   if (!item->IsWebInputEvent())
     return false;
   const QueuedWebInputEvent* event =
       static_cast<const QueuedWebInputEvent*>(item.get());
   switch (event->event().GetType()) {
     case blink::WebInputEvent::kMouseMove:
     case blink::WebInputEvent::kMouseWheel:
       return handle_raf_aligned_mouse_input_;
     case blink::WebInputEvent::kTouchMove:
       return handle_raf_aligned_touch_input_;
     default:
       return false;
   }
 }
 
+void MainThreadEventQueue::NotifySchedulerOfEventHandled(
+    const blink::WebInputEvent& event,
+    InputEventAckState ack_result) {
+  if (renderer_scheduler_) {
+    renderer_scheduler_->DidHandleInputEventOnMainThread(
+        event, ack_result == INPUT_EVENT_ACK_STATE_CONSUMED
+                   ? blink::WebInputEventResult::kHandledApplication
+                   : blink::WebInputEventResult::kNotHandled);
+  }
+}
+
+MainThreadEventQueueWithRenderWidget::MainThreadEventQueueWithRenderWidget(
+    const base::WeakPtr<RenderWidget>& widget,
+    blink::scheduler::RendererScheduler* renderer_scheduler)
+    : MainThreadEventQueue(renderer_scheduler->CompositorTaskRunner(),
+                           renderer_scheduler),
+      widget_(widget) {}
+
+MainThreadEventQueueWithRenderWidget::~MainThreadEventQueueWithRenderWidget() {}
+
+InputEventAckState
+MainThreadEventQueueWithRenderWidget::HandleEventOnMainThread(
+    const blink::WebCoalescedInputEvent& event,
+    const ui::LatencyInfo& latency,
+    InputEventDispatchType dispatch_type) {
+  if (widget_)
+    return widget_->HandleInputEvent(event, latency, dispatch_type);
+  return INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
+}
+
+void MainThreadEventQueueWithRenderWidget::SendInputEventAck(
+    blink::WebInputEvent::Type type,
+    InputEventAckState ack_result,
+    uint32_t touch_event_id) {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  if (!widget_)
+    return;
+  InputEventAck ack(InputEventAckSource::MAIN_THREAD, type, ack_result,
+                    touch_event_id);
+  widget_->Send(new InputHostMsg_HandleInputEvent_ACK(MSG_ROUTING_NONE, ack));
+}
+
+void MainThreadEventQueueWithRenderWidget::NeedsMainFrame() {
+  if (main_task_runner_->BelongsToCurrentThread()) {
+    if (widget_)
+      widget_->SetNeedsMainFrame();
+    return;
+  }
+
+  main_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&MainThreadEventQueueWithRenderWidget::NeedsMainFrame, this));
+}
+
 }  // namespace content