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_;
 };
 
+// Time interval at which touchmove events during scroll will be skipped
+// during rAF signal.
+const base::TimeDelta kAsyncTouchMoveInterval =
+    base::TimeDelta::FromMilliseconds(200);
+
+}  // namespace
+
 class QueuedWebInputEvent : public ScopedWebInputEventWithLatencyInfo,
                             public MainThreadEventQueueTask {
  public:
   QueuedWebInputEvent(ui::WebScopedInputEvent event,
                       const ui::LatencyInfo& latency,
                       InputEventDispatchType dispatch_type,
                       bool originally_cancelable)
       : ScopedWebInputEventWithLatencyInfo(std::move(event), latency),
         dispatch_type_(dispatch_type),
         non_blocking_coalesced_count_(0),
@@ skipping 33 matching lines @@
     last_coalesced_timestamp_ = base::TimeTicks::Now();
 
     // The newest event (|other_item|) always wins when updating fields.
     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 {
-    for (const auto id : blockingCoalescedEventIds()) {
-      client->SendInputEventAck(routing_id, type, ack_result, id);
-      if (renderer_scheduler) {
-        renderer_scheduler->DidHandleInputEventOnMainThread(event(), result);
-      }
-    }
+    InputEventAckState ack_result = queue->HandleEventOnMainThread(
+        coalesced_event(), latencyInfo(), dispatchType());
+    for (const auto id : blockingCoalescedEventIds())
+      queue->SendInputEventAck(event(), ack_result, id);
   }
 
   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()) {
       case blink::WebInputEvent::kTouchMove: {
@@ skipping 50 matching lines @@
   base::TimeTicks creation_timestamp_;
   base::TimeTicks last_coalesced_timestamp_;
 
   // Whether the received event was originally cancelable or not. The compositor
   // input handler can change the event based on presence of event handlers so
   // this is the state at which the renderer received the event from the
   // browser.
   bool originally_cancelable_;
 };
 
-// Time interval at which touchmove events will be skipped during rAF signal.
-const base::TimeDelta kAsyncTouchMoveInterval =
-    base::TimeDelta::FromMilliseconds(200);
-
-bool IsAsyncTouchMove(
-    const std::unique_ptr<MainThreadEventQueueTask>& queued_item) {
-  if (!queued_item->IsWebInputEvent())
-    return false;
-  const QueuedWebInputEvent* event =
-      static_cast<const QueuedWebInputEvent*>(queued_item.get());
-  if (event->event().GetType() != blink::WebInputEvent::kTouchMove)
-    return false;
-  const blink::WebTouchEvent& touch_event =
-      static_cast<const blink::WebTouchEvent&>(event->event());
-  return touch_event.moved_beyond_slop_region && !event->originallyCancelable();
-}
-
-}  // 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),
+    : client_(client),
       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)),
@@ skipping 120 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_);
+    SetNeedsMainFrame();
 }
 
 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);
-  }
+static bool IsAsyncTouchMove(
+    const std::unique_ptr<MainThreadEventQueueTask>& queued_item) {
+  if (!queued_item->IsWebInputEvent())
+    return false;
+  const QueuedWebInputEvent* event =
+      static_cast<const QueuedWebInputEvent*>(queued_item.get());
+  if (event->event().GetType() != blink::WebInputEvent::kTouchMove)
+    return false;
+  const blink::WebTouchEvent& touch_event =
+      static_cast<const blink::WebTouchEvent&>(event->event());
+  return touch_event.moved_beyond_slop_region && !event->originallyCancelable();
 }
 
 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.
@@ skipping 55 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_);
+    SetNeedsMainFrame();
 }
 
 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;
   }
 }
 
+InputEventAckState MainThreadEventQueue::HandleEventOnMainThread(
+    const blink::WebCoalescedInputEvent& event,
+    const ui::LatencyInfo& latency,
+    InputEventDispatchType dispatch_type) {
+  if (client_)
+    return client_->HandleInputEvent(event, latency, dispatch_type);
+  return INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
+}
+
+void MainThreadEventQueue::SendInputEventAck(const blink::WebInputEvent& event,
+                                             InputEventAckState ack_result,
+                                             uint32_t touch_event_id) {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  if (!client_)
+    return;
+  client_->SendInputEventAck(event.GetType(), ack_result, touch_event_id);
+  if (renderer_scheduler_) {
+    renderer_scheduler_->DidHandleInputEventOnMainThread(
+        event, ack_result == INPUT_EVENT_ACK_STATE_CONSUMED
+                   ? blink::WebInputEventResult::kHandledApplication
+                   : blink::WebInputEventResult::kNotHandled);
+  }
+}
+
+void MainThreadEventQueue::SetNeedsMainFrame() {
+  if (main_task_runner_->BelongsToCurrentThread()) {
+    if (client_)
+      client_->SetNeedsMainFrame();
+    return;
+  }
+
+  main_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&MainThreadEventQueue::SetNeedsMainFrame, this));
+}
+
+void MainThreadEventQueue::ClearClient() {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  client_ = nullptr;
+}
+
 }  // namespace content