Don't use PostTask queueing between compositor and main thread.

content/browser/renderer_host/input/input_router_impl.cc

 // Copyright 2013 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/browser/renderer_host/input/input_router_impl.h"
 
 #include <math.h>
 
 #include <utility>
 
@@ skipping 61 matching lines @@
                                  InputAckHandler* ack_handler,
                                  int routing_id,
                                  const Config& config)
     : sender_(sender),
       client_(client),
       ack_handler_(ack_handler),
       routing_id_(routing_id),
       frame_tree_node_id_(-1),
       select_message_pending_(false),
       move_caret_pending_(false),
-      mouse_move_pending_(false),
       current_ack_source_(ACK_SOURCE_NONE),
       flush_requested_(false),
       active_renderer_fling_count_(0),
       touch_scroll_started_sent_(false),
       wheel_event_queue_(this, kDefaultWheelScrollTransactionMs),
       touch_event_queue_(this, config.touch_config),
       gesture_event_queue_(this, this, config.gesture_config),
       device_scale_factor_(1.f) {
   DCHECK(sender);
   DCHECK(client);
@@ skipping 88 matching lines @@
 void InputRouterImpl::SendTouchEvent(
     const TouchEventWithLatencyInfo& touch_event) {
   input_stream_validator_.Validate(touch_event.event);
   touch_event_queue_.QueueEvent(touch_event);
 }
 
 // Forwards MouseEvent without passing it through
 // TouchpadTapSuppressionController.
 void InputRouterImpl::SendMouseEventImmediately(
     const MouseEventWithLatencyInfo& mouse_event) {
-  // Avoid spamming the renderer with mouse move events.  It is important
-  // to note that WM_MOUSEMOVE events are anyways synthetic, but since our
-  // thread is able to rapidly consume WM_MOUSEMOVE events, we may get way
-  // more WM_MOUSEMOVE events than we wish to send to the renderer.
-  if (mouse_event.event.type == WebInputEvent::MouseMove) {
-    if (mouse_move_pending_) {
-      if (!next_mouse_move_)
-        next_mouse_move_.reset(new MouseEventWithLatencyInfo(mouse_event));
-      else
-        next_mouse_move_->CoalesceWith(mouse_event);
-      return;
-    }
-    mouse_move_pending_ = true;
-    current_mouse_move_ = mouse_event;
-  }
+  if (mouse_event.event.type == blink::WebInputEvent::MouseMove)
+    mouse_move_queue_.push_back(mouse_event);
 
   FilterAndSendWebInputEvent(mouse_event.event, mouse_event.latency);
 }
 
 void InputRouterImpl::SendTouchEventImmediately(
     const TouchEventWithLatencyInfo& touch_event) {
   if (WebTouchEventTraits::IsTouchSequenceStart(touch_event.event)) {
     touch_action_filter_.ResetTouchAction();
     // Note that if the previous touch-action was TOUCH_ACTION_NONE, enabling
     // the timeout here will not take effect until the *following* touch
@@ skipping 20 matching lines @@
   touch_event_queue_.SetIsMobileOptimizedSite(is_mobile_optimized);
 }
 
 void InputRouterImpl::RequestNotificationWhenFlushed() {
   flush_requested_ = true;
   SignalFlushedIfNecessary();
 }
 
 bool InputRouterImpl::HasPendingEvents() const {
   return !touch_event_queue_.empty() || !gesture_event_queue_.empty() ||
-         !key_queue_.empty() || mouse_move_pending_ ||
+         !key_queue_.empty() || !mouse_move_queue_.empty() ||
          wheel_event_queue_.has_pending() || select_message_pending_ ||
          move_caret_pending_ || active_renderer_fling_count_ > 0;
 }
 
 void InputRouterImpl::SetDeviceScaleFactor(float device_scale_factor) {
   device_scale_factor_ = device_scale_factor;
 }
 
 bool InputRouterImpl::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
@@ skipping 106 matching lines @@
                "InputRouterImpl::FilterAndSendWebInputEvent",
                "type",
                WebInputEventTraits::GetName(input_event.type));
   TRACE_EVENT_WITH_FLOW2("input,benchmark,devtools.timeline",
                          "LatencyInfo.Flow",
                          TRACE_ID_DONT_MANGLE(latency_info.trace_id()),
                          TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
                          "step", "SendInputEventUI",
                          "frameTreeNodeId", frame_tree_node_id_);
 
-  // Any input event cancels a pending mouse move event.
-  next_mouse_move_.reset();
-
   OfferToHandlers(input_event, latency_info);
 }
 
 void InputRouterImpl::OfferToHandlers(const WebInputEvent& input_event,
                                       const ui::LatencyInfo& latency_info) {
   output_stream_validator_.Validate(input_event);
 
   if (OfferToClient(input_event, latency_info))
     return;
 
@@ skipping 15 matching lines @@
 bool InputRouterImpl::OfferToClient(const WebInputEvent& input_event,
                                     const ui::LatencyInfo& latency_info) {
   bool consumed = false;
 
   InputEventAckState filter_ack =
       client_->FilterInputEvent(input_event, latency_info);
   switch (filter_ack) {
     case INPUT_EVENT_ACK_STATE_CONSUMED:
     case INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS:
       // Send the ACK and early exit.
-      next_mouse_move_.reset();
       ProcessInputEventAck(
           input_event.type, filter_ack, latency_info,
           WebInputEventTraits::GetUniqueTouchEventId(input_event), CLIENT);
       // WARNING: |this| may be deleted at this point.
       consumed = true;
       break;
     case INPUT_EVENT_ACK_STATE_UNKNOWN:
       // Simply drop the event.
       consumed = true;
       break;
@@ skipping 168 matching lines @@
     // TODO(jdduke): crbug.com/274029 - Make ack-triggered shutdown async.
   }
 }
 
 void InputRouterImpl::ProcessMouseAck(blink::WebInputEvent::Type type,
                                       InputEventAckState ack_result,
                                       const ui::LatencyInfo& latency) {
   if (type != WebInputEvent::MouseMove)
     return;
 
-  current_mouse_move_.latency.AddNewLatencyFrom(latency);
-  ack_handler_->OnMouseEventAck(current_mouse_move_, ack_result);
-
-  DCHECK(mouse_move_pending_);
-  mouse_move_pending_ = false;
-
-  if (next_mouse_move_) {
-    DCHECK(next_mouse_move_->event.type == WebInputEvent::MouseMove);
-    std::unique_ptr<MouseEventWithLatencyInfo> next_mouse_move =
-        std::move(next_mouse_move_);
-    SendMouseEvent(*next_mouse_move);
+  if (mouse_move_queue_.empty()) {
+    ack_handler_->OnUnexpectedEventAck(InputAckHandler::UNEXPECTED_ACK);
+  } else {
+    MouseEventWithLatencyInfo front_item = mouse_move_queue_.front();
+    front_item.latency.AddNewLatencyFrom(latency);
+    mouse_move_queue_.pop_front();
+    ack_handler_->OnMouseEventAck(front_item, ack_result);
   }
 }
 
 void InputRouterImpl::ProcessWheelAck(InputEventAckState ack_result,
                                       const ui::LatencyInfo& latency) {
   wheel_event_queue_.ProcessMouseWheelAck(ack_result, latency);
 }
 
 void InputRouterImpl::ProcessGestureAck(WebInputEvent::Type type,
                                         InputEventAckState ack_result,
@@ skipping 33 matching lines @@
 
   flush_requested_ = false;
   client_->DidFlush();
 }
 
 void InputRouterImpl::SetFrameTreeNodeId(int frameTreeNodeId) {
   frame_tree_node_id_ = frameTreeNodeId;
 }
 
 }  // namespace content