Run all LayerTreeHost tests with a delegating renderer.

cc/trees/layer_tree_host_unittest_context.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/basictypes.h"
 #include "cc/base/thread_impl.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/heads_up_display_layer.h"
@@ skipping 461 matching lines @@
   }
 
  protected:
   bool use_surface_;
   FakeContentLayerClient client_;
   scoped_refptr<Layer> root_;
   scoped_refptr<ContentLayer> content_;
 };
 
 TEST_F(LayerTreeHostContextTestLostContextSucceedsWithContent,
-       NoSurface_SingleThread) {
+       NoSurface_SingleThread_DirectRenderer) {
   use_surface_ = false;
-  RunTest(false);
+  RunTest(false, false);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextSucceedsWithContent,
-       NoSurface_MultiThread) {
+       NoSurface_SingleThread_DelegatingRenderer) {
   use_surface_ = false;
-  RunTest(true);
+  RunTest(false, true);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextSucceedsWithContent,
-       WithSurface_SingleThread) {
-  use_surface_ = true;
-  RunTest(false);
+       NoSurface_MultiThread_DirectRenderer) {
+  use_surface_ = false;
+  RunTest(true, false);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextSucceedsWithContent,
-       WithSurface_MultiThread) {
+       NoSurface_MultiThread_DelegatingRenderer) {
+  use_surface_ = false;
+  RunTest(true, true);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextSucceedsWithContent,
+       WithSurface_SingleThread_DirectRenderer) {
   use_surface_ = true;
-  RunTest(true);
+  RunTest(false, false);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextSucceedsWithContent,
+       WithSurface_SingleThread_DelegatingRenderer) {
+  use_surface_ = true;
+  RunTest(false, true);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextSucceedsWithContent,
+       WithSurface_MultiThread_DirectRenderer) {
+  use_surface_ = true;
+  RunTest(true, false);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextSucceedsWithContent,
+       WithSurface_MultiThread_DelegatingRenderer) {
+  use_surface_ = true;
+  RunTest(true, true);
 }
 
 class LayerTreeHostContextTestOffscreenContextFails
     : public LayerTreeHostContextTest {
  public:
   virtual void SetupTree() OVERRIDE {
     root_ = Layer::Create();
     root_->SetBounds(gfx::Size(10, 10));
     root_->SetAnchorPoint(gfx::PointF());
     root_->SetIsDrawable(true);
@@ skipping 82 matching lines @@
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   int num_commits_;
   bool first_initialized_;
 };
 
 TEST_F(LayerTreeHostContextTestLostContextFails,
-       FailReinitialize100_SingleThread) {
+       FailReinitialize100_SingleThread_DirectRenderer) {
   times_to_fail_reinitialize_ = 100;
   times_to_fail_recreate_ = 0;
   times_to_lose_on_recreate_ = 0;
-  RunTest(false);
+  RunTest(false, false);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextFails,
-       FailReinitialize100_MultiThread) {
+       FailReinitialize100_SingleThread_DelegatingRenderer) {
   times_to_fail_reinitialize_ = 100;
   times_to_fail_recreate_ = 0;
   times_to_lose_on_recreate_ = 0;
-  RunTest(true);
+  RunTest(false, true);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextFails,
-       FailRecreate100_SingleThread) {
+       FailReinitialize100_MultiThread_DirectRenderer) {
+  times_to_fail_reinitialize_ = 100;
+  times_to_fail_recreate_ = 0;
+  times_to_lose_on_recreate_ = 0;
+  RunTest(true, false);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       FailReinitialize100_MultiThread_DelegatingRenderer) {
+  times_to_fail_reinitialize_ = 100;
+  times_to_fail_recreate_ = 0;
+  times_to_lose_on_recreate_ = 0;
+  RunTest(true, true);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       FailRecreate100_SingleThread_DirectRenderer) {
   times_to_fail_reinitialize_ = 0;
   times_to_fail_recreate_ = 100;
   times_to_lose_on_recreate_ = 0;
-  RunTest(false);
+  RunTest(false, false);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextFails,
-       FailRecreate100_MultiThread) {
+       FailRecreate100_SingleThread_DelegatingRenderer) {
   times_to_fail_reinitialize_ = 0;
   times_to_fail_recreate_ = 100;
   times_to_lose_on_recreate_ = 0;
-  RunTest(true);
+  RunTest(false, true);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextFails,
-       LoseOnRecreate100_SingleThread) {
+       FailRecreate100_MultiThread_DirectRenderer) {
+  times_to_fail_reinitialize_ = 0;
+  times_to_fail_recreate_ = 100;
+  times_to_lose_on_recreate_ = 0;
+  RunTest(true, false);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       FailRecreate100_MultiThread_DelegatingRenderer) {
+  times_to_fail_reinitialize_ = 0;
+  times_to_fail_recreate_ = 100;
+  times_to_lose_on_recreate_ = 0;
+  RunTest(true, true);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       LoseOnRecreate100_SingleThread_DirectRenderer) {
   times_to_fail_reinitialize_ = 0;
   times_to_fail_recreate_ = 0;
   times_to_lose_on_recreate_ = 100;
-  RunTest(false);
+  RunTest(false, false);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextFails,
-       LoseOnRecreate100_MultiThread) {
+       LoseOnRecreate100_SingleThread_DelegatingRenderer) {
   times_to_fail_reinitialize_ = 0;
   times_to_fail_recreate_ = 0;
   times_to_lose_on_recreate_ = 100;
-  RunTest(true);
+  RunTest(false, true);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       LoseOnRecreate100_MultiThread_DirectRenderer) {
+  times_to_fail_reinitialize_ = 0;
+  times_to_fail_recreate_ = 0;
+  times_to_lose_on_recreate_ = 100;
+  RunTest(true, false);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextFails,
+       LoseOnRecreate100_MultiThread_DelegatingRenderer) {
+  times_to_fail_reinitialize_ = 0;
+  times_to_fail_recreate_ = 0;
+  times_to_lose_on_recreate_ = 100;
+  RunTest(true, true);
 }
 
 class LayerTreeHostContextTestFinishAllRenderingAfterLoss
     : public LayerTreeHostContextTest {
  public:
   virtual void BeginTest() OVERRIDE {
     // Lose the context until the compositor gives up on it.
     first_initialized_ = false;
     times_to_lose_during_commit_ = 1;
     times_to_fail_reinitialize_ = 10;
@@ skipping 83 matching lines @@
 
  protected:
   bool lose_after_evict_;
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> layer_;
   LayerTreeHostImpl* impl_host_;
   int num_commits_;
 };
 
 TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
-       LoseAfterEvict_SingleThread) {
+       LoseAfterEvict_SingleThread_DirectRenderer) {
   lose_after_evict_ = true;
-  RunTest(false);
+  RunTest(false, false);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
-       LoseAfterEvict_MultiThread) {
+       LoseAfterEvict_SingleThread_DelegatingRenderer) {
   lose_after_evict_ = true;
-  RunTest(true);
+  RunTest(false, true);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
-       LoseBeforeEvict_SingleThread) {
-  lose_after_evict_ = false;
-  RunTest(false);
+       LoseAfterEvict_MultiThread_DirectRenderer) {
+  lose_after_evict_ = true;
+  RunTest(true, false);
 }
 
 TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
-       LoseBeforeEvict_MultiThread) {
+       LoseAfterEvict_MultiThread_DelegatingRenderer) {
+  lose_after_evict_ = true;
+  RunTest(true, true);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
+       LoseBeforeEvict_SingleThread_DirectRenderer) {
   lose_after_evict_ = false;
-  RunTest(true);
+  RunTest(false, false);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
+       LoseBeforeEvict_SingleThread_DelegatingRenderer) {
+  lose_after_evict_ = false;
+  RunTest(false, true);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
+       LoseBeforeEvict_MultiThread_DirectRenderer) {
+  lose_after_evict_ = false;
+  RunTest(true, false);
+}
+
+TEST_F(LayerTreeHostContextTestLostContextAndEvictTextures,
+       LoseBeforeEvict_MultiThread_DelegatingRenderer) {
+  lose_after_evict_ = false;
+  RunTest(true, true);
 }
 
 class LayerTreeHostContextTestLostContextWhileUpdatingResources
     : public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestLostContextWhileUpdatingResources()
       : parent_(FakeContentLayer::Create(&client_)),
         num_children_(50),
         times_to_lose_on_end_query_(3) {}
 
@@ skipping 582 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestFailsToCreateSurface);
 
 // Not reusing LayerTreeTest because it expects creating LTH to always succeed.
 class LayerTreeHostTestCannotCreateIfCannotCreateOutputSurface
     : public testing::Test,
       public FakeLayerTreeHostClient {
  public:
   LayerTreeHostTestCannotCreateIfCannotCreateOutputSurface()
       : FakeLayerTreeHostClient(FakeLayerTreeHostClient::DIRECT_3D) {}
 
-  // FakeLayerTreeHostClient
+  // FakeLayerTreeHostClient implementation.
   virtual scoped_ptr<OutputSurface> CreateOutputSurface() OVERRIDE {
     return scoped_ptr<OutputSurface>();
   }
 
-  void RunTest(bool threaded) {
+  void RunTest(bool threaded, bool delegating_renderer) {
     scoped_ptr<base::Thread> impl_thread;
     scoped_ptr<cc::Thread> impl_ccthread(NULL);
     if (threaded) {
       impl_thread.reset(new base::Thread("LayerTreeTest"));
       impl_ccthread = cc::ThreadImpl::CreateForDifferentThread(
           impl_thread->message_loop_proxy());
       ASSERT_TRUE(impl_ccthread);
     }
 
     LayerTreeSettings settings;
     scoped_ptr<LayerTreeHost> layer_tree_host =
         LayerTreeHost::Create(this, settings, impl_ccthread.Pass());
     EXPECT_FALSE(layer_tree_host);
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestCannotCreateIfCannotCreateOutputSurface);
 
 }  // namespace
 }  // namespace cc