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

content/renderer/input/input_event_filter.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/renderer/input/input_event_filter.h"
 
 #include <tuple>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 54 matching lines @@
   RouteQueueMap::iterator iter = route_queues_.find(routing_id);
   if (iter == route_queues_.end() || !iter->second)
     return;
 
   iter->second->set_is_flinging(is_flinging);
 }
 
 void InputEventFilter::RegisterRoutingID(int routing_id) {
   base::AutoLock locked(routes_lock_);
   routes_.insert(routing_id);
-  route_queues_[routing_id].reset(new MainThreadEventQueue(routing_id, this));
+  route_queues_[routing_id] =
+      new MainThreadEventQueue(routing_id, this, main_task_runner_);
 }
 
 void InputEventFilter::UnregisterRoutingID(int routing_id) {
   base::AutoLock locked(routes_lock_);
   routes_.erase(routing_id);
   route_queues_.erase(routing_id);
 }
 
 void InputEventFilter::DidOverscroll(int routing_id,
                                      const DidOverscrollParams& params) {
@@ skipping 11 matching lines @@
 }
 
 void InputEventFilter::DidStopFlinging(int routing_id) {
   SetIsFlingingInMainThreadEventQueue(routing_id, false);
   SendMessage(base::WrapUnique(new InputHostMsg_DidStopFlinging(routing_id)));
 }
 
 void InputEventFilter::NotifyInputEventHandled(int routing_id,
                                                blink::WebInputEvent::Type type,
                                                InputEventAckState ack_result) {
-  DCHECK(target_task_runner_->BelongsToCurrentThread());
-  RouteQueueMap::iterator iter = route_queues_.find(routing_id);
-  if (iter == route_queues_.end() || !iter->second)
-    return;
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  scoped_refptr<MainThreadEventQueue> queue;
+  {
+    base::AutoLock locked(routes_lock_);
+    RouteQueueMap::iterator iter = route_queues_.find(routing_id);
+    if (iter == route_queues_.end() || !iter->second)
+      return;
+    queue = iter->second;
+  }
 
-  iter->second->EventHandled(type, ack_result);
+  queue->EventHandled(type, ack_result);

[tdresser, 2016/07/20 20:52:27]

Does the queue really need to be refptr?

[dtapuska, 2016/07/27 05:29:00]

yes for thread safety.

 }
 
 void InputEventFilter::OnFilterAdded(IPC::Sender* sender) {
   io_task_runner_ = base::ThreadTaskRunnerHandle::Get();
   sender_ = sender;
 }
 
 void InputEventFilter::OnFilterRemoved() {
   sender_ = NULL;
 }
@@ skipping 100 matching lines @@
 void InputEventFilter::SendMessageOnIOThread(
     std::unique_ptr<IPC::Message> message) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (!sender_)
     return;  // Filter was removed.
 
   sender_->Send(message.release());
 }
 
-void InputEventFilter::SendEventToMainThread(
+void InputEventFilter::HandleEventOnMainThread(
     int routing_id,
     const blink::WebInputEvent* event,
     const ui::LatencyInfo& latency_info,
     InputEventDispatchType dispatch_type) {
-  TRACE_EVENT_INSTANT0(
-      "input", "InputEventFilter::ForwardToHandler::SendEventToMainThread",
-      TRACE_EVENT_SCOPE_THREAD);
+  TRACE_EVENT_INSTANT0("input", "InputEventFilter::HandlEventOnMainThread",
+                       TRACE_EVENT_SCOPE_THREAD);

[tdresser, 2016/07/20 20:52:27]

This rename could potentially break some telemetry stuff. (Go ahead and land it,
but be aware it's a possibility, or do some searching to see if any telemetry
measurements use this data)

[dtapuska, 2016/07/27 05:29:00]

I grepped catapult and didn't see any use of the string.

   IPC::Message new_msg =
       InputMsg_HandleInputEvent(routing_id, event, latency_info, dispatch_type);
-  main_task_runner_->PostTask(FROM_HERE, base::Bind(main_listener_, new_msg));
+  main_listener_.Run(new_msg);
 }
 
 void InputEventFilter::SendInputEventAck(int routing_id,
                                          blink::WebInputEvent::Type type,
                                          InputEventAckState ack_result,
                                          uint32_t touch_event_id) {
   InputEventAck ack(type, ack_result, touch_event_id);
   SendMessage(std::unique_ptr<IPC::Message>(
       new InputHostMsg_HandleInputEvent_ACK(routing_id, ack)));
 }
 
 }  // namespace content