Fix WebView compositor input handling

content/renderer/gpu/input_handler_manager.cc

Index: content/renderer/gpu/input_handler_manager.cc
diff --git a/content/renderer/gpu/input_handler_manager.cc b/content/renderer/gpu/input_handler_manager.cc
index aeff90e16fd70af99c798ae3cda591122ce5c59a..e43af42b7385237cc6f8150af40187bb55412843 100644
--- a/content/renderer/gpu/input_handler_manager.cc
+++ b/content/renderer/gpu/input_handler_manager.cc
@@ -8,46 +8,53 @@
 #include "base/debug/trace_event.h"
 #include "cc/input/input_handler.h"
 #include "content/renderer/gpu/input_event_filter.h"
+#include "content/renderer/gpu/input_handler_manager_client.h"
 #include "content/renderer/gpu/input_handler_wrapper.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebActiveWheelFlingParameters.h"
 
 using WebKit::WebInputEvent;
 
 namespace content {
 
 InputHandlerManager::InputHandlerManager(
-    IPC::Listener* main_listener,
     const scoped_refptr<base::MessageLoopProxy>& message_loop_proxy)
     : message_loop_proxy_(message_loop_proxy) {
-  filter_ =
-      new InputEventFilter(main_listener,
-                           message_loop_proxy,
-                           base::Bind(&InputHandlerManager::HandleInputEvent,
-                                      base::Unretained(this)));
 }
 
 InputHandlerManager::~InputHandlerManager() {

[joth, 2013/05/31 18:05:08]

should this unbind Handler() instance from the client? (As the client has to
outline the manager)
i.e. call BindToClient(NULL);

[jdduke (slow), 2013/05/31 20:48:24]

You're absolutely right, I had that in and must have reverted in all the
shuffle.  Good catch!

 }
 
-IPC::ChannelProxy::MessageFilter*
-InputHandlerManager::GetMessageFilter() const {
-  return filter_;
+void InputHandlerManager::BindToClient(InputHandlerManagerClient* client) {
+  DCHECK(!client_ || !client);
+  if (client_)
+    client->DidBind(InputHandlerManagerClient::Handler());
+
+  client_ = client;
+
+  if (client_) {
+    client->DidBind(base::Bind(&InputHandlerManager::HandleInputEvent,
+                    base::Unretained(this)));

[joth, 2013/05/31 18:05:08]

nit: intent to next open-paren

[jdduke (slow), 2013/05/31 20:48:24]

Done.

+  }
 }
 
 void InputHandlerManager::AddInputHandler(
     int routing_id,
     const base::WeakPtr<cc::InputHandler>& input_handler,
     const base::WeakPtr<RenderViewImpl>& render_view_impl) {
-  DCHECK(!message_loop_proxy_->BelongsToCurrentThread());
-
-  message_loop_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&InputHandlerManager::AddInputHandlerOnCompositorThread,
-                 base::Unretained(this),
-                 routing_id,
-                 base::MessageLoopProxy::current(),
-                 input_handler,
-                 render_view_impl));
+  if (message_loop_proxy_->BelongsToCurrentThread()) {
+    AddInputHandlerOnCompositorThread(routing_id,
+                                      base::MessageLoopProxy::current(),
+                                      input_handler,
+                                      render_view_impl);
+  } else {
+    message_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&InputHandlerManager::AddInputHandlerOnCompositorThread,
+                   base::Unretained(this),

[joth, 2013/05/31 18:05:08]

Any idea why the Unretained() is safe here? (I see this pre-dates your change
anyway)

I guess the answer  is 'in practice the InputHandlerManager lasts as long as the
process, so its moot'

[jdduke (slow), 2013/05/31 20:48:24]

Right.

+                   routing_id,
+                   base::MessageLoopProxy::current(),
+                   input_handler,
+                   render_view_impl));
+  }
 }
 
 void InputHandlerManager::AddInputHandlerOnCompositorThread(
@@ -55,6 +62,7 @@ void InputHandlerManager::AddInputHandlerOnCompositorThread(
     const scoped_refptr<base::MessageLoopProxy>& main_loop,
     const base::WeakPtr<cc::InputHandler>& input_handler,
     const base::WeakPtr<RenderViewImpl>& render_view_impl) {
+  DCHECK(client_);
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
 
   // The handler could be gone by this point if the compositor has shut down.
@@ -66,24 +74,26 @@ void InputHandlerManager::AddInputHandlerOnCompositorThread(
     return;
 
   TRACE_EVENT0("InputHandlerManager::AddInputHandler", "AddingRoute");
-  filter_->AddRoute(routing_id);
+  client_->DidAddInputHandler(routing_id);
   input_handlers_[routing_id] =
       make_scoped_refptr(new InputHandlerWrapper(this,
           routing_id, main_loop, input_handler, render_view_impl));
 }
 
 void InputHandlerManager::RemoveInputHandler(int routing_id) {
+  DCHECK(client_);
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
 
   TRACE_EVENT0("InputHandlerManager::RemoveInputHandler", "RemovingRoute");
 
-  filter_->RemoveRoute(routing_id);
+  client_->DidRemoveInputHandler(routing_id);
   input_handlers_.erase(routing_id);
 }
 
 void InputHandlerManager::HandleInputEvent(
     int routing_id,
     const WebInputEvent* input_event) {
+  DCHECK(client_);
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
 
   InputHandlerMap::iterator it = input_handlers_.find(routing_id);
@@ -91,7 +101,7 @@ void InputHandlerManager::HandleInputEvent(
     TRACE_EVENT0("InputHandlerManager::HandleInputEvent",
                  "NoInputHandlerFound");
     // Oops, we no longer have an interested input handler..
-    filter_->DidNotHandleInputEvent(true);
+    client_->DidNotHandleInputEvent(true);
     return;
   }