Run all LayerTreeHost tests with a delegating renderer.

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/base/thread_impl.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_context_provider.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/tiled_layer_test_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace cc {
 
-TestHooks::TestHooks()
-    : fake_client_(
-          new FakeLayerTreeHostClient(FakeLayerTreeHostClient::DIRECT_3D)) {}
+TestHooks::TestHooks() {}
 
 TestHooks::~TestHooks() {}
 
 bool TestHooks::PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                       LayerTreeHostImpl::FrameData* frame_data,
                                       bool result) {
   return true;
 }
 
 bool TestHooks::CanActivatePendingTree() {
   return true;
 }
 
-scoped_ptr<OutputSurface> TestHooks::CreateOutputSurface() {
-  return CreateFakeOutputSurface();
-}
-
-scoped_refptr<cc::ContextProvider> TestHooks::
-    OffscreenContextProviderForMainThread() {
-  return fake_client_->OffscreenContextProviderForMainThread();
-}
-
-scoped_refptr<cc::ContextProvider> TestHooks::
-    OffscreenContextProviderForCompositorThread() {
-  return fake_client_->OffscreenContextProviderForCompositorThread();
-}
-
 // 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,
       RenderingStatsInstrumentation* stats_instrumentation) {
     return make_scoped_ptr(
@@ skipping 473 matching lines @@
   if (!layer_tree_host_->visible()) {
     schedule_when_set_visible_true_ = true;
     return;
   }
 
   schedule_when_set_visible_true_ = false;
   base::TimeTicks now = base::TimeTicks::Now();
   layer_tree_host_->Composite(now);
 }
 
-void LayerTreeTest::RunTest(bool threaded) {
+void LayerTreeTest::RunTest(bool threaded, bool delegating_renderer) {
   if (threaded) {
     impl_thread_.reset(new base::Thread("Compositor"));
     ASSERT_TRUE(impl_thread_->Start());
   }
 
   main_ccthread_ = cc::ThreadImpl::CreateForCurrentThread();
 
+  delegating_renderer_ = delegating_renderer;
+
   // Spend less time waiting for vsync because the output is mocked out.
   settings_.refresh_rate = 200.0;
   InitializeSettings(&settings_);
 
   main_ccthread_->PostTask(
       base::Bind(&LayerTreeTest::DoBeginTest, base::Unretained(this)));
 
   if (timeout_seconds_) {
     timeout_.Reset(base::Bind(&LayerTreeTest::Timeout, base::Unretained(this)));
     main_ccthread_->PostDelayedTask(
@@ skipping 10 matching lines @@
 
   ASSERT_FALSE(layer_tree_host_.get());
   client_.reset();
   if (timed_out_) {
     FAIL() << "Test timed out";
     return;
   }
   AfterTest();
 }
 
+scoped_ptr<OutputSurface> LayerTreeTest::CreateOutputSurface() {
+  if (delegating_renderer_)
+    return FakeOutputSurface::CreateDelegating3d().PassAs<OutputSurface>();
+  return FakeOutputSurface::Create3d().PassAs<OutputSurface>();
+}
+
+scoped_refptr<cc::ContextProvider> LayerTreeTest::
+    OffscreenContextProviderForMainThread() {
+  if (!main_thread_contexts_ ||
+      main_thread_contexts_->DestroyedOnMainThread()) {
+    main_thread_contexts_ = FakeContextProvider::Create();
+    if (!main_thread_contexts_->BindToCurrentThread())
+      main_thread_contexts_ = NULL;
+  }
+  return main_thread_contexts_;
+}
+
+scoped_refptr<cc::ContextProvider> LayerTreeTest::
+    OffscreenContextProviderForCompositorThread() {
+  if (!compositor_thread_contexts_ ||
+      compositor_thread_contexts_->DestroyedOnMainThread())
+    compositor_thread_contexts_ = FakeContextProvider::Create();
+  return compositor_thread_contexts_;
+}
+
 }  // namespace cc