Implement active wheel fling transfer via WebCompositorInputHandlerClient

content/renderer/gpu/compositor_thread.cc

 // Copyright (c) 2012 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/gpu/compositor_thread.h"
 
 #include "base/bind.h"
 #include "content/renderer/gpu/input_event_filter.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositor.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositorClient.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebActiveWheelFlingParameters.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositorInputHandlerClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositorInputHandler.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 
 using WebKit::WebCompositorInputHandler;
 using WebKit::WebInputEvent;
 
 //------------------------------------------------------------------------------
 
 class CompositorThread::InputHandlerWrapper
-    : public WebKit::WebCompositorClient {
+    : public WebKit::WebCompositorInputHandlerClient,
+      public base::RefCountedThreadSafe<InputHandlerWrapper> {
  public:
   InputHandlerWrapper(CompositorThread* compositor_thread,
                       int routing_id,
-                      WebKit::WebCompositorInputHandler* input_handler)
+                      WebKit::WebCompositorInputHandler* input_handler,
+                      scoped_refptr<base::MessageLoopProxy> main_loop,
+                      base::WeakPtr<RenderViewImpl> render_view_impl)
       : compositor_thread_(compositor_thread),
         routing_id_(routing_id),
-        input_handler_(input_handler) {
+        input_handler_(input_handler),
+        main_loop_(main_loop),
+        render_view_impl_(render_view_impl) {
     input_handler_->setClient(this);
   }
 
+  virtual void transferActiveWheelFlingAnimation(
+      const WebKit::WebActiveWheelFlingParameters& params) {
+    main_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(&CompositorThread::InputHandlerWrapper::
+                       TransferActiveWheelFlingAnimation,
+                   this, params));
+  }
+
   virtual ~InputHandlerWrapper() {
     input_handler_->setClient(NULL);
   }
 
   int routing_id() const { return routing_id_; }
   WebKit::WebCompositorInputHandler* input_handler() const {
     return input_handler_;
   }
 
-  // WebCompositorClient methods:
+  // WebCompositorInputHandlerClient methods:
 
   virtual void willShutdown() {
     compositor_thread_->RemoveInputHandler(routing_id_);
   }
 
   virtual void didHandleInputEvent() {
     compositor_thread_->filter_->DidHandleInputEvent();
   }
 
   virtual void didNotHandleInputEvent(bool send_to_widget) {
     compositor_thread_->filter_->DidNotHandleInputEvent(send_to_widget);
   }
 
  private:
+  void TransferActiveWheelFlingAnimation(

[darin (slow to review), 2012/03/27 03:47:54]

Another approach would be to define this as a public method on RenderViewImpl. 
It is safe to create and copy WeakPtrs on background threads.  It is just not
safe to dereference WeakPtrs off of their bound thread.

In transferActiveWheelFlingAnimation() above, you could just do:

  main_loop_->PostTask(
      FROM_HERE,
      base::Bind(&RenderViewImpl::TransferActiveWheelFlingAnimation,
           render_view_impl_, params));

One note:  Passing RenderViewImpl to this class has pros and cons.  Pro: simple,
Con: complicates dependency injection.  compositor_thread.cc never had a unit
test, so perhaps it doesn't matter.

+      WebKit::WebActiveWheelFlingParameters params) {
+    DCHECK(main_loop_->BelongsToCurrentThread());
+    if (render_view_impl_.get() && render_view_impl_->webview())
+        render_view_impl_->webview()->transferActiveWheelFlingAnimation(params);

[darin (slow to review), 2012/03/27 03:47:54]

nit: indentation

+  }
+
   CompositorThread* compositor_thread_;
   int routing_id_;
   WebKit::WebCompositorInputHandler* input_handler_;
+  scoped_refptr<base::MessageLoopProxy> main_loop_;
+
+  // Can only be accessed on the main thread.
+  base::WeakPtr<RenderViewImpl> render_view_impl_;
 
   DISALLOW_COPY_AND_ASSIGN(InputHandlerWrapper);
 };
 
 //------------------------------------------------------------------------------
 
 CompositorThread::CompositorThread(IPC::Channel::Listener* main_listener)
     : thread_("Compositor") {
   filter_ =
       new InputEventFilter(main_listener,
                            thread_.message_loop()->message_loop_proxy(),
                            base::Bind(&CompositorThread::HandleInputEvent,
                                       base::Unretained(this)));
 }
 
 CompositorThread::~CompositorThread() {
 }
 
 IPC::ChannelProxy::MessageFilter* CompositorThread::GetMessageFilter() const {
   return filter_;
 }
 
-void CompositorThread::AddInputHandler(int routing_id, int input_handler_id) {
-  if (thread_.message_loop() != MessageLoop::current()) {
-    thread_.message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&CompositorThread::AddInputHandler, base::Unretained(this),
-                   routing_id, input_handler_id));
-    return;
-  }
+void CompositorThread::AddInputHandler(
+    int routing_id, int input_handler_id,
+    base::WeakPtr<RenderViewImpl> render_view_impl) {

[darin (slow to review), 2012/03/27 03:47:54]

nit: pass WeakPtr by const ref

+  DCHECK_NE(thread_.message_loop(), MessageLoop::current());
+
+  thread_.message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&CompositorThread::AddInputHandlerOnCompositorThread,
+                 base::Unretained(this),
+                 routing_id,
+                 input_handler_id,
+                 base::MessageLoopProxy::current(),
+                 render_view_impl));
+}
+
+void CompositorThread::AddInputHandlerOnCompositorThread(
+    int routing_id, int input_handler_id,
+    scoped_refptr<base::MessageLoopProxy> main_loop,
+    base::WeakPtr<RenderViewImpl> render_view_impl) {

[darin (slow to review), 2012/03/27 03:47:54]

nit: pass WeakPtr by const ref

+
+  DCHECK_EQ(thread_.message_loop(), MessageLoop::current());
 
   WebCompositorInputHandler* input_handler =
       WebCompositorInputHandler::fromIdentifier(input_handler_id);
   if (!input_handler)
     return;
 
   if (input_handlers_.count(routing_id) != 0) {
     // It's valid to call AddInputHandler() for the same routing id with the
     // same input_handler many times, but it's not valid to change the
     // input_handler for a route.
     DCHECK_EQ(input_handlers_[routing_id]->input_handler(), input_handler);
     return;
   }
 
   filter_->AddRoute(routing_id);
   input_handlers_[routing_id] =
-      make_linked_ptr(new InputHandlerWrapper(this, routing_id, input_handler));
+      make_scoped_refptr(new InputHandlerWrapper(this,
+          routing_id, input_handler, main_loop, render_view_impl));
 }
 
 void CompositorThread::RemoveInputHandler(int routing_id) {
-  DCHECK(thread_.message_loop() == MessageLoop::current());
+  DCHECK_EQ(MessageLoop::current(), thread_.message_loop());
 
   filter_->RemoveRoute(routing_id);
   input_handlers_.erase(routing_id);
 }
 
 void CompositorThread::HandleInputEvent(
     int routing_id,
     const WebInputEvent* input_event) {
   DCHECK_EQ(MessageLoop::current(), thread_.message_loop());
 
   InputHandlerMap::iterator it = input_handlers_.find(routing_id);
   if (it == input_handlers_.end()) {
     // Oops, we no longer have an interested input handler..
     filter_->DidNotHandleInputEvent(true);
     return;
   }
 
   it->second->input_handler()->handleInputEvent(*input_event);
 }