Move compositor thread input handling logic into content

cc/trees/layer_tree_host_unittest_scroll.cc

 // Copyright 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 "cc/trees/layer_tree_host.h"
 
+#include "base/memory/weak_ptr.h"
 #include "cc/base/thread_impl.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebLayerScrollClient.h"
@@ skipping 646 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostScrollTestScrollZeroMaxScrollOffset);
 
 class ThreadCheckingInputHandlerClient : public InputHandlerClient {
  public:
   ThreadCheckingInputHandlerClient(base::SingleThreadTaskRunner* runner,
                                    bool* received_stop_flinging)
       : task_runner_(runner) ,
         received_stop_flinging_(received_stop_flinging) {}
 
-  virtual void BindToHandler(InputHandler* handler) OVERRIDE {
-    if (!task_runner_->BelongsToCurrentThread())
-      ADD_FAILURE() << "BindToClient called on wrong thread";
-  }
-
   virtual void Animate(base::TimeTicks time) OVERRIDE {
     if (!task_runner_->BelongsToCurrentThread())
       ADD_FAILURE() << "Animate called on wrong thread";
   }
 
   virtual void MainThreadHasStoppedFlinging() OVERRIDE {
     if (!task_runner_->BelongsToCurrentThread())
       ADD_FAILURE() << "MainThreadHasStoppedFlinging called on wrong thread";
     *received_stop_flinging_ = true;
   }
 
  private:
   base::SingleThreadTaskRunner* task_runner_;
   bool* received_stop_flinging_;
 };
 
-class ThreadCheckingFakeLayerTreeHostClient : public FakeLayerTreeHostClient {
- public:
-  ThreadCheckingFakeLayerTreeHostClient(
-      base::SingleThreadTaskRunner* task_runner,
-      bool* received_stop_flinging)
-      : FakeLayerTreeHostClient(DIRECT_3D) ,
-        task_runner_(task_runner),
-        received_stop_flinging_(received_stop_flinging) {}
-
-  virtual scoped_ptr<InputHandlerClient> CreateInputHandlerClient() OVERRIDE {
-    return scoped_ptr<InputHandlerClient>(new ThreadCheckingInputHandlerClient(
-          task_runner_, received_stop_flinging_)).Pass();
-  }
-
- private:
-  base::SingleThreadTaskRunner* task_runner_;
-  bool* received_stop_flinging_;
-};
+void BindInputHandlerOnCompositorThread(
+    const base::WeakPtr<cc::InputHandler>& input_handler,
+    ThreadCheckingInputHandlerClient* client) {
+  input_handler->BindToClient(client);
+}
 
 TEST(LayerTreeHostFlingTest, DidStopFlingingThread) {
   base::Thread impl_thread("cc");
   impl_thread.Start();
   scoped_ptr<cc::Thread> impl_ccthread =
       cc::ThreadImpl::CreateForDifferentThread(
           impl_thread.message_loop_proxy());
 
   bool received_stop_flinging = false;
-  ThreadCheckingFakeLayerTreeHostClient client(
-      impl_thread.message_loop_proxy().get(),
-      &received_stop_flinging);
   LayerTreeSettings settings;
 
+  ThreadCheckingInputHandlerClient input_handler_client(
+      impl_thread.message_loop_proxy().get(), &received_stop_flinging);
+  cc::FakeLayerTreeHostClient client(cc::FakeLayerTreeHostClient::DIRECT_3D);

[danakj, 2013/05/01 19:20:43]

no cc:: needed

+
   scoped_ptr<LayerTreeHost> layer_tree_host =
       LayerTreeHost::Create(&client, settings, impl_ccthread.Pass());
 
+  impl_thread.message_loop_proxy()->PostTask(FROM_HERE,
+      base::Bind(&BindInputHandlerOnCompositorThread,
+                 layer_tree_host->GetInputHandler(),
+                 &input_handler_client));
+
   layer_tree_host->DidStopFlinging();
   layer_tree_host.reset();
   impl_thread.Stop();
   EXPECT_TRUE(received_stop_flinging);
 }
 
 }  // namespace
 }  // namespace cc