Respect the order of input messages from browser to renderer

content/renderer/input/input_handler_manager.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_handler_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 86 matching lines @@
   // The same handler may be registered for a route multiple times.
   if (input_handlers_.count(routing_id) != 0)
     return;
 
   TRACE_EVENT1("input",
       "InputHandlerManager::AddInputHandlerOnCompositorThread",
       "result", "AddingRoute");
   std::unique_ptr<InputHandlerWrapper> wrapper(
       new InputHandlerWrapper(this, routing_id, main_task_runner, input_handler,
                               render_view_impl, enable_smooth_scrolling));
-  client_->DidAddInputHandler(routing_id);
+  client_->RegisterRoutingID(routing_id);
   if (synchronous_handler_proxy_client_) {
     synchronous_handler_proxy_client_->DidAddSynchronousHandlerProxy(
         routing_id, wrapper->input_handler_proxy());
   }
   input_handlers_.add(routing_id, std::move(wrapper));
 }
 
 void InputHandlerManager::RemoveInputHandler(int routing_id) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(input_handlers_.contains(routing_id));
 
   TRACE_EVENT0("input", "InputHandlerManager::RemoveInputHandler");
 
-  client_->DidRemoveInputHandler(routing_id);
+  client_->UnregisterRoutingID(routing_id);
   if (synchronous_handler_proxy_client_) {
     synchronous_handler_proxy_client_->DidRemoveSynchronousHandlerProxy(
         routing_id);
   }
   input_handlers_.erase(routing_id);
 }
 
+void InputHandlerManager::RegisterRoutingID(int routing_id) {
+  if (task_runner_->BelongsToCurrentThread()) {
+    RegisterRoutingIDOnCompositorThread(routing_id);
+  } else {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&InputHandlerManager::RegisterRoutingIDOnCompositorThread,
+                   base::Unretained(this), routing_id));
+  }
+}
+
+void InputHandlerManager::RegisterRoutingIDOnCompositorThread(int routing_id) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  client_->RegisterRoutingID(routing_id);
+}
+
+void InputHandlerManager::UnregisterRoutingID(int routing_id) {
+  if (task_runner_->BelongsToCurrentThread()) {
+    UnregisterRoutingIDOnCompositorThread(routing_id);
+  } else {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&InputHandlerManager::UnregisterRoutingIDOnCompositorThread,
+                   base::Unretained(this), routing_id));
+  }
+}
+
+void InputHandlerManager::UnregisterRoutingIDOnCompositorThread(
+    int routing_id) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  client_->UnregisterRoutingID(routing_id);
+}
+
 void InputHandlerManager::ObserveWheelEventAndResultOnMainThread(
     int routing_id,
     const blink::WebMouseWheelEvent& wheel_event,
     const cc::InputHandlerScrollResult& scroll_result) {
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &InputHandlerManager::ObserveWheelEventAndResultOnCompositorThread,
           base::Unretained(this), routing_id, wheel_event, scroll_result));
 }
@@ skipping 109 matching lines @@
 
 void InputHandlerManager::DidStopFlinging(int routing_id) {
   client_->DidStopFlinging(routing_id);
 }
 
 void InputHandlerManager::DidAnimateForInput() {
   renderer_scheduler_->DidAnimateForInputOnCompositorThread();
 }
 
 }  // namespace content