Run all LayerTreeHost tests with a delegating renderer.

cc/trees/layer_tree_host_unittest.cc

Index: cc/trees/layer_tree_host_unittest.cc
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index 40983ced67bfcd2fefb460feca931c53318c106a..f0f1f83b000bd267ebe6676239b0fa06a281070d 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -1183,7 +1183,9 @@ class LayerTreeHostTestAtomicCommitWithPartialUpdate
   int num_commits_;
 };
 
-MULTI_THREAD_TEST_F(LayerTreeHostTestAtomicCommitWithPartialUpdate);
+// Partial updates are not possible with a delegating renderer.
+MULTI_THREAD_TEST_DIRECT_RENDERER_F(
+    LayerTreeHostTestAtomicCommitWithPartialUpdate);
 
 class LayerTreeHostTestFinishAllRendering : public LayerTreeHostTest {
  public:
@@ -1336,7 +1338,8 @@ class LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit
   scoped_refptr<FakeContentLayer> replica_layer2_;
 };
 
-SINGLE_AND_MULTI_THREAD_TEST_F(
+  // Surfaces don't exist with a delegated renderer.
+SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit);
 
 class EvictionTestLayer : public Layer {
@@ -1886,19 +1889,13 @@ class LayerTreeHostTestMaxPendingFrames : public LayerTreeHostTest {
  public:
   LayerTreeHostTestMaxPendingFrames() : LayerTreeHostTest() {}
 
-  virtual scoped_ptr<OutputSurface> CreateOutputSurface() OVERRIDE {
-    if (delegating_renderer_)
-      return FakeOutputSurface::CreateDelegating3d().PassAs<OutputSurface>();
-    return FakeOutputSurface::Create3d().PassAs<OutputSurface>();
-  }
-
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     DCHECK(host_impl->proxy()->HasImplThread());
 
     const ThreadProxy* proxy = static_cast<ThreadProxy*>(host_impl->proxy());
-    if (delegating_renderer_) {
+    if (delegating_renderer()) {
       EXPECT_EQ(1, proxy->MaxFramesPendingForTesting());
     } else {
       EXPECT_EQ(FrameRateController::DEFAULT_MAX_FRAMES_PENDING,
@@ -1908,19 +1905,14 @@ class LayerTreeHostTestMaxPendingFrames : public LayerTreeHostTest {
   }
 
   virtual void AfterTest() OVERRIDE {}
-
- protected:
-  bool delegating_renderer_;
 };
 
 TEST_F(LayerTreeHostTestMaxPendingFrames, DelegatingRenderer) {
-  delegating_renderer_ = true;
-  RunTest(true);
+  RunTest(true, true);
 }
 
 TEST_F(LayerTreeHostTestMaxPendingFrames, GLRenderer) {
-  delegating_renderer_ = false;
-  RunTest(true);
+  RunTest(true, false);
 }
 
 class LayerTreeHostTestShutdownWithOnlySomeResourcesEvicted
@@ -2661,24 +2653,25 @@ class LayerTreeHostTestAsyncReadback : public LayerTreeHostTest {
   scoped_refptr<FakeContentLayer> child;
 };
 
+// Readback can't be done with a delegating renderer.
 TEST_F(LayerTreeHostTestAsyncReadback, GLRenderer_RunSingleThread) {
   use_gl_renderer_ = true;
-  RunTest(false);
+  RunTest(false, false);
 }
 
 TEST_F(LayerTreeHostTestAsyncReadback, GLRenderer_RunMultiThread) {
   use_gl_renderer_ = true;
-  RunTest(true);
+  RunTest(true, false);
 }
 
 TEST_F(LayerTreeHostTestAsyncReadback, SoftwareRenderer_RunSingleThread) {
   use_gl_renderer_ = false;
-  RunTest(false);
+  RunTest(false, false);
 }
 
 TEST_F(LayerTreeHostTestAsyncReadback, SoftwareRenderer_RunMultiThread) {
   use_gl_renderer_ = false;
-  RunTest(true);
+  RunTest(true, false);
 }
 
 class LayerTreeHostTestAsyncReadbackLayerDestroyed : public LayerTreeHostTest {
@@ -2772,18 +2765,11 @@ SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestAsyncReadbackLayerDestroyed);
 
 class LayerTreeHostTestNumFramesPending : public LayerTreeHostTest {
  public:
-  LayerTreeHostTestNumFramesPending()
-      : delegating_renderer_(false),
-        frame_(0) {}
-
-  virtual scoped_ptr<OutputSurface> CreateOutputSurface() OVERRIDE {
-    if (delegating_renderer_)
-      return FakeOutputSurface::CreateDelegating3d().PassAs<OutputSurface>();
-    return FakeOutputSurface::Create3d().PassAs<OutputSurface>();
+  virtual void BeginTest() OVERRIDE {
+    frame_ = 0;
+    PostSetNeedsCommitToMainThread();
   }
 
-  virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
-
   // Round 1: commit + draw
   // Round 2: commit only (no draw/swap)
   // Round 3: draw only (no commit)
@@ -2842,18 +2828,15 @@ class LayerTreeHostTestNumFramesPending : public LayerTreeHostTest {
   virtual void AfterTest() OVERRIDE {}
 
  protected:
-  bool delegating_renderer_;
   int frame_;
 };
 
 TEST_F(LayerTreeHostTestNumFramesPending, DelegatingRenderer) {
-  delegating_renderer_ = true;
-  RunTest(true);
+  RunTest(true, true);
 }
 
 TEST_F(LayerTreeHostTestNumFramesPending, GLRenderer) {
-  delegating_renderer_ = false;
-  RunTest(true);
+  RunTest(true, false);
 }
 
 }  // namespace