cc: Add testing stubs for proxy test

cc/test/layer_tree_test.cc

 // Copyright 2011 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/test/layer_tree_test.h"
 
 #include "base/command_line.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/layer_animation_controller.h"
@@ skipping 28 matching lines @@
     LayerTreeHostImpl* host_impl,
     LayerTreeHostImpl::FrameData* frame_data,
     DrawResult draw_result) {
   return draw_result;
 }
 
 base::TimeDelta TestHooks::LowFrequencyAnimationInterval() const {
   return base::TimeDelta::FromMilliseconds(16);
 }
 
+// Adapts ThreadProxy for test. Injects test hooks for testing.
+class ThreadProxyForTest : public ThreadProxy {
+ public:
+  static scoped_ptr<Proxy> Create(
+      TestHooks* test_hooks,
+      LayerTreeHost* host,
+      scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
+    return make_scoped_ptr(
+        new ThreadProxyForTest(test_hooks,
+                               host,
+                               impl_task_runner)).PassAs<Proxy>();
+  }
+
+  const ThreadProxy::MainThreadOnly& main() const {
+    return ThreadProxy::main();
+  }
+
+  const ThreadProxy::CompositorThreadOnly& impl() const {
+    return ThreadProxy::impl();
+  }
+
+  virtual ~ThreadProxyForTest() {}
+
+ private:
+  TestHooks* test_hooks_;
+
+  ThreadProxyForTest(
+      TestHooks* test_hooks,
+      LayerTreeHost* host,
+      scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner)
+      : ThreadProxy(host, impl_task_runner),
+        test_hooks_(test_hooks) {
+  }
+};
+
 // Adapts LayerTreeHostImpl for test. Runs real code, then invokes test hooks.
 class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
  public:
   static scoped_ptr<LayerTreeHostImplForTesting> Create(
       TestHooks* test_hooks,
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* host_impl_client,
       Proxy* proxy,
       SharedBitmapManager* manager,
       RenderingStatsInstrumentation* stats_instrumentation) {
@@ skipping 221 matching lines @@
 // Adapts LayerTreeHost for test. Injects LayerTreeHostImplForTesting.
 class LayerTreeHostForTesting : public LayerTreeHost {
  public:
   static scoped_ptr<LayerTreeHostForTesting> Create(
       TestHooks* test_hooks,
       LayerTreeHostClientForTesting* client,
       const LayerTreeSettings& settings,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
     scoped_ptr<LayerTreeHostForTesting> layer_tree_host(
         new LayerTreeHostForTesting(test_hooks, client, settings));
-    if (impl_task_runner.get())
-      layer_tree_host->InitializeThreaded(impl_task_runner);
-    else
-      layer_tree_host->InitializeSingleThreaded(client);
+    if (impl_task_runner.get()) {
+      layer_tree_host->InitializeForTesting(
+          ThreadProxyForTest::Create(test_hooks,
+                                     layer_tree_host.get(),
+                                     impl_task_runner));
+    } else {
+      layer_tree_host->InitializeForTesting(
+          SingleThreadProxy::Create(layer_tree_host.get(), client));
+    }
     return layer_tree_host.Pass();
   }
 
   virtual scoped_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
       LayerTreeHostImplClient* host_impl_client) OVERRIDE {
     return LayerTreeHostImplForTesting::Create(
                test_hooks_,
                settings(),
                host_impl_client,
                proxy(),
@@ skipping 351 matching lines @@
     FAIL() << "Test timed out";
     return;
   }
   AfterTest();
 }
 
 void LayerTreeTest::RunTestWithImplSidePainting() {
   RunTest(true, false, true);
 }
 
+const ThreadProxy::MainThreadOnly&
+LayerTreeTest::ThreadProxyMainOnly() const {
+  DCHECK(proxy());
+  DCHECK(proxy()->HasImplThread());
+  return static_cast<ThreadProxyForTest*>(proxy())->main();
+}
+
+const ThreadProxy::CompositorThreadOnly&
+LayerTreeTest::ThreadProxyImplOnly() const {
+  DCHECK(proxy());
+  DCHECK(proxy()->HasImplThread());
+  return static_cast<ThreadProxyForTest*>(proxy())->impl();
+}
+
 scoped_ptr<OutputSurface> LayerTreeTest::CreateOutputSurface(bool fallback) {
   scoped_ptr<FakeOutputSurface> output_surface =
       CreateFakeOutputSurface(fallback);
   if (output_surface) {
     DCHECK_EQ(delegating_renderer_,
               output_surface->capabilities().delegated_rendering);
   }
   output_surface_ = output_surface.get();
   return output_surface.PassAs<OutputSurface>();
 }
@@ skipping 21 matching lines @@
   return -1;
 }
 
 void LayerTreeTest::DestroyLayerTreeHost() {
   if (layer_tree_host_ && layer_tree_host_->root_layer())
     layer_tree_host_->root_layer()->SetLayerTreeHost(NULL);
   layer_tree_host_.reset();
 }
 
 }  // namespace cc