Introduce separate client and init path for single-threaded cc

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"
 #include "cc/animation/timing_function.h"
 #include "cc/base/switches.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/occlusion_tracker_test_common.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/tiled_layer_test_common.h"
+#include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_impl.h"
+#include "cc/trees/layer_tree_host_single_thread_client.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "ui/gfx/frame_time.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace cc {
 
 TestHooks::TestHooks() {}
 
 TestHooks::~TestHooks() {}
@@ skipping 153 matching lines @@
   virtual base::TimeDelta LowFrequencyAnimationInterval() const OVERRIDE {
     return test_hooks_->LowFrequencyAnimationInterval();
   }
 
  private:
   TestHooks* test_hooks_;
   bool block_notify_ready_to_activate_for_testing_;
   bool notify_ready_to_activate_was_blocked_;
 };
 
-// Adapts LayerTreeHost for test. Injects LayerTreeHostImplForTesting.
-class LayerTreeHostForTesting : public LayerTreeHost {
- public:
-  static scoped_ptr<LayerTreeHostForTesting> Create(
-      TestHooks* test_hooks,
-      LayerTreeHostClient* host_client,
-      const LayerTreeSettings& settings,
-      scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
-    scoped_ptr<LayerTreeHostForTesting> layer_tree_host(
-        new LayerTreeHostForTesting(test_hooks, host_client, settings));
-    bool success = layer_tree_host->Initialize(impl_task_runner);
-    EXPECT_TRUE(success);
-    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(),
-        rendering_stats_instrumentation()).PassAs<LayerTreeHostImpl>();
-  }
-
-  virtual void SetNeedsCommit() OVERRIDE {
-    if (!test_started_)
-      return;
-    LayerTreeHost::SetNeedsCommit();
-  }
-
-  void set_test_started(bool started) { test_started_ = started; }
-
-  virtual void DidDeferCommit() OVERRIDE {
-    test_hooks_->DidDeferCommit();
-  }
-
- private:
-  LayerTreeHostForTesting(TestHooks* test_hooks,
-                          LayerTreeHostClient* client,
-                          const LayerTreeSettings& settings)
-      : LayerTreeHost(client, NULL, settings),
-        test_hooks_(test_hooks),
-        test_started_(false) {}
-
-  TestHooks* test_hooks_;
-  bool test_started_;
-};
-
 // Implementation of LayerTreeHost callback interface.
-class LayerTreeHostClientForTesting : public LayerTreeHostClient {
+class LayerTreeHostClientForTesting : public LayerTreeHostClient,
+                                      public LayerTreeHostSingleThreadClient {
  public:
   static scoped_ptr<LayerTreeHostClientForTesting> Create(
       TestHooks* test_hooks) {
     return make_scoped_ptr(new LayerTreeHostClientForTesting(test_hooks));
   }
   virtual ~LayerTreeHostClientForTesting() {}
 
   virtual void WillBeginMainFrame() OVERRIDE {
     test_hooks_->WillBeginMainFrame();
   }
@@ skipping 40 matching lines @@
   }
 
   virtual void DidCompleteSwapBuffers() OVERRIDE {
     test_hooks_->DidCompleteSwapBuffers();
   }
 
   virtual void ScheduleComposite() OVERRIDE {
     test_hooks_->ScheduleComposite();
   }
 
+  virtual void DidPostSwapBuffers() OVERRIDE {}
+  virtual void DidAbortSwapBuffers() OVERRIDE {}
+
   virtual scoped_refptr<ContextProvider> OffscreenContextProvider() OVERRIDE {
     return test_hooks_->OffscreenContextProvider();
   }
 
  private:
   explicit LayerTreeHostClientForTesting(TestHooks* test_hooks)
       : test_hooks_(test_hooks) {}
 
   TestHooks* test_hooks_;
 };
 
+// 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));
+    bool success;
+    if (impl_task_runner.get())
+      success = layer_tree_host->InitializeThreaded(impl_task_runner);
+    else
+      success = layer_tree_host->InitializeSingleThreaded(client);
+    EXPECT_TRUE(success);
+    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(),
+        rendering_stats_instrumentation()).PassAs<LayerTreeHostImpl>();
+  }
+
+  virtual void SetNeedsCommit() OVERRIDE {
+    if (!test_started_)
+      return;
+    LayerTreeHost::SetNeedsCommit();
+  }
+
+  void set_test_started(bool started) { test_started_ = started; }
+
+  virtual void DidDeferCommit() OVERRIDE {
+    test_hooks_->DidDeferCommit();
+  }
+
+ private:
+  LayerTreeHostForTesting(TestHooks* test_hooks,
+                          LayerTreeHostClient* client,
+                          const LayerTreeSettings& settings)
+      : LayerTreeHost(client, NULL, settings),
+        test_hooks_(test_hooks),
+        test_started_(false) {}
+
+  TestHooks* test_hooks_;
+  bool test_started_;
+};
+
 LayerTreeTest::LayerTreeTest()
     : beginning_(false),
       end_when_begin_returns_(false),
       timed_out_(false),
       scheduled_(false),
       schedule_when_set_visible_true_(false),
       started_(false),
       ended_(false),
       delegating_renderer_(false),
       timeout_seconds_(0),
@@ skipping 329 matching lines @@
 }
 
 scoped_refptr<ContextProvider> LayerTreeTest::OffscreenContextProvider() {
   if (!compositor_contexts_.get() ||
       compositor_contexts_->DestroyedOnMainThread())
     compositor_contexts_ = TestContextProvider::Create();
   return compositor_contexts_;
 }
 
 }  // namespace cc