Teach main thread event queue about closures.

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 77 matching lines @@
 void InputEventFilter::DidOverscroll(int routing_id,
                                      const DidOverscrollParams& params) {
   SendMessage(std::unique_ptr<IPC::Message>(
       new InputHostMsg_DidOverscroll(routing_id, params)));
 }
 
 void InputEventFilter::DidStopFlinging(int routing_id) {
   SendMessage(base::MakeUnique<InputHostMsg_DidStopFlinging>(routing_id));
 }
 
+void InputEventFilter::QueueClosureForMainThreadEventQueue(
+    int routing_id,
+    const base::Closure& closure) {
+  DCHECK(target_task_runner_->BelongsToCurrentThread());
+  RouteQueueMap::iterator iter = route_queues_.find(routing_id);
+  if (iter != route_queues_.end())
+    iter->second->QueueClosure(closure);
+}
+
 void InputEventFilter::DispatchNonBlockingEventToMainThread(
     int routing_id,
     ui::WebScopedInputEvent event,
     const ui::LatencyInfo& latency_info) {
   DCHECK(target_task_runner_->BelongsToCurrentThread());
   RouteQueueMap::iterator iter = route_queues_.find(routing_id);
   if (iter != route_queues_.end()) {
     iter->second->HandleEvent(std::move(event), latency_info,
                               DISPATCH_TYPE_NON_BLOCKING,
                               INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING);
@@ skipping 83 matching lines @@
 
 InputEventFilter::~InputEventFilter() {}
 
 void InputEventFilter::ForwardToHandler(const IPC::Message& message,
                                         base::TimeTicks received_time) {
   DCHECK(input_handler_manager_);
   DCHECK(target_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT1("input", "InputEventFilter::ForwardToHandler",
                "message_type", GetInputMessageTypeName(message));
 
+  int routing_id = message.routing_id();
   if (message.type() != InputMsg_HandleInputEvent::ID) {
     TRACE_EVENT_INSTANT0(
         "input",
         "InputEventFilter::ForwardToHandler::ForwardToMainListener",
         TRACE_EVENT_SCOPE_THREAD);
-    CHECK(main_task_runner_->PostTask(FROM_HERE,
-                                      base::Bind(main_listener_, message)))
-        << "PostTask failed";
+    input_handler_manager_->QueueClosureForMainThreadEventQueue(
+        routing_id, base::Bind(main_listener_, message));
     return;
   }
 
-  int routing_id = message.routing_id();
   InputMsg_HandleInputEvent::Param params;
   if (!InputMsg_HandleInputEvent::Read(&message, &params))
     return;
   ui::WebScopedInputEvent event =
       ui::WebInputEventTraits::Clone(*std::get<0>(params));
   ui::LatencyInfo latency_info = std::get<2>(params);
   InputEventDispatchType dispatch_type = std::get<3>(params);
 
   DCHECK(event);
   DCHECK(dispatch_type == DISPATCH_TYPE_BLOCKING ||
@@ skipping 95 matching lines @@
     return;
   }
 
   CHECK(target_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&InputEventFilter::NeedsMainFrame, this, routing_id)))
       << "PostTask failed";
 }
 
 }  // namespace content