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 61 matching lines @@
   input_handler_manager_ = input_handler_manager;
 }
 
 void InputEventFilter::RegisterRoutingID(int routing_id) {
   base::AutoLock locked(routes_lock_);
   routes_.insert(routing_id);
   route_queues_[routing_id] = new MainThreadEventQueue(
       routing_id, this, main_task_runner_, renderer_scheduler_);
 }
 
+void InputEventFilter::RegisterAssociatedRenderFrameRoutingID(
+    int render_frame_routing_id,
+    int render_view_routing_id) {
+  base::AutoLock locked(routes_lock_);
+  DCHECK(routes_.find(render_view_routing_id) != routes_.end());
+  associated_routes_[render_frame_routing_id] = render_view_routing_id;
+}
+
 void InputEventFilter::UnregisterRoutingID(int routing_id) {
   base::AutoLock locked(routes_lock_);
   routes_.erase(routing_id);
   route_queues_.erase(routing_id);
+  associated_routes_.erase(routing_id);
 }
 
 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);
+    return;
+  }
+
+  // For some reason we didn't find an event queue for the route.
+  // Don't drop the task on the floor allow it to execute.
+  NOTREACHED();
+  main_task_runner_->PostTask(FROM_HERE, 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 61 matching lines @@
 
   // If TimeTicks is not consistent across processes we cannot use the event's
   // platform timestamp in this process. Instead the time that the event is
   // received on the IO thread is used as the event's timestamp.
   base::TimeTicks received_time;
   if (!base::TimeTicks::IsConsistentAcrossProcesses())
     received_time = base::TimeTicks::Now();
 
   TRACE_EVENT0("input", "InputEventFilter::OnMessageReceived::InputMessage");
 
+  int routing_id = message.routing_id();
   {
     base::AutoLock locked(routes_lock_);
-    if (routes_.find(message.routing_id()) == routes_.end())
-      return false;
+    if (routes_.find(routing_id) == routes_.end()) {
+      // |routes_| is based on the RenderView routing_id but the routing_id
+      // may be from a RenderFrame. Messages from RenderFrames should be handled
+      // synchronously with the associated RenderView as well.
+      // Use the associated table to see if we have a mapping from
+      // RenderFrame->RenderView if so use the queue for that routing id.
+      // TODO(dtapuska): Input messages should NOT be sent to RenderFrames and
+      // RenderViews; they should only goto one and this code will be
+      // unnecessary as this would break for mojo which doesn't guarantee
+      // ordering on different channels but Chrome IPC does.
+      auto associated_routing_id = associated_routes_.find(routing_id);
+      if (associated_routing_id == associated_routes_.end() ||
+          routes_.find(associated_routing_id->second) == routes_.end()) {
+        return false;
+      }
+      routing_id = associated_routing_id->second;
+    }
   }
 
   bool postedTask = target_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&InputEventFilter::ForwardToHandler, this, message,
-                            received_time));
+      FROM_HERE, base::Bind(&InputEventFilter::ForwardToHandler, this,
+                            routing_id, message, received_time));
   LOG_IF(WARNING, !postedTask) << "PostTask failed";
   return true;
 }
 
 InputEventFilter::~InputEventFilter() {}
 
-void InputEventFilter::ForwardToHandler(const IPC::Message& message,
+void InputEventFilter::ForwardToHandler(int associated_routing_id,
+                                        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));
 
   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(
+        associated_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);
 
+  // HandleInputEvent is always sent to the RenderView routing ID
+  // so it should be the same as the message routing ID.
+  DCHECK(associated_routing_id == message.routing_id());
   DCHECK(event);
   DCHECK(dispatch_type == DISPATCH_TYPE_BLOCKING ||
          dispatch_type == DISPATCH_TYPE_NON_BLOCKING);
 
   if (!received_time.is_null())
     event->setTimeStampSeconds(ui::EventTimeStampToSeconds(received_time));
 
   input_handler_manager_->HandleInputEvent(
-      routing_id, std::move(event), latency_info,
+      associated_routing_id, std::move(event), latency_info,
       base::Bind(&InputEventFilter::DidForwardToHandlerAndOverscroll, this,
-                 routing_id, dispatch_type));
+                 associated_routing_id, dispatch_type));
 };
 
 void InputEventFilter::DidForwardToHandlerAndOverscroll(
     int routing_id,
     InputEventDispatchType dispatch_type,
     InputEventAckState ack_state,
     ui::WebScopedInputEvent event,
     const ui::LatencyInfo& latency_info,
     std::unique_ptr<DidOverscrollParams> overscroll_params) {
   bool send_ack = dispatch_type == DISPATCH_TYPE_BLOCKING;
@@ skipping 76 matching lines @@
     return;
   }
 
   CHECK(target_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&InputEventFilter::NeedsMainFrame, this, routing_id)))
       << "PostTask failed";
 }
 
 }  // namespace content