Run all LayerTreeHost tests with a delegating renderer.

cc/trees/layer_tree_host_unittest.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/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/synchronization/lock.h"
 #include "cc/animation/timing_function.h"
@@ skipping 938 matching lines @@
       default:
         NOTREACHED();
         break;
     }
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(
         impl->output_surface()->context3d());
 
-    // Number of textures used for draw should always be one for each layer.
+    // We draw/ship one texture each frame for each layer.
     EXPECT_EQ(2u, context->NumUsedTextures());
     context->ResetUsedTextures();
   }
 
   virtual void Layout() OVERRIDE {
     layer_->SetNeedsDisplay();
     scrollbar_->SetNeedsDisplay();
   }
 
   virtual void AfterTest() OVERRIDE {}
@@ skipping 206 matching lines @@
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> parent_;
   scoped_refptr<FakeContentLayer> child_;
   scoped_refptr<FakeScrollbarLayer> scrollbar_with_paints_;
   scoped_refptr<FakeScrollbarLayer> scrollbar_without_paints_;
   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:
   LayerTreeHostTestFinishAllRendering() : once_(false), draw_count_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetNeedsRedraw();
     PostSetNeedsCommitToMainThread();
   }
 
@@ skipping 132 matching lines @@
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> root_layer_;
   scoped_refptr<FakeContentLayer> surface_layer1_;
   scoped_refptr<FakeContentLayer> replica_layer1_;
   scoped_refptr<FakeContentLayer> surface_layer2_;
   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 {
  public:
   static scoped_refptr<EvictionTestLayer> Create() {
     return make_scoped_refptr(new EvictionTestLayer());
   }
 
   virtual void Update(ResourceUpdateQueue*,
                       const OcclusionTracker*,
@@ skipping 529 matching lines @@
   scoped_refptr<PictureLayer> layer_;
   skia::RefPtr<SkPicture> picture_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestCapturePicture);
 
 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,
                 proxy->MaxFramesPendingForTesting());
     }
     EndTest();
   }
 
   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
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestShutdownWithOnlySomeResourcesEvicted()
       : root_layer_(FakeContentLayer::Create(&client_)),
         child_layer1_(FakeContentLayer::Create(&client_)),
         child_layer2_(FakeContentLayer::Create(&client_)),
         num_commits_(0) {}
@@ skipping 720 matching lines @@
         make_scoped_ptr(new SoftwareOutputDevice)).PassAs<OutputSurface>();
   }
 
   bool use_gl_renderer_;
   std::vector<gfx::Size> callbacks_;
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> root;
   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 {
  protected:
   virtual void SetupTree() OVERRIDE {
     root_ = FakeContentLayer::Create(&client_);
     root_->SetBounds(gfx::Size(20, 20));
 
     main_destroyed_ = FakeContentLayer::Create(&client_);
     main_destroyed_->SetBounds(gfx::Size(15, 15));
@@ skipping 73 matching lines @@
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> root_;
   scoped_refptr<FakeContentLayer> main_destroyed_;
   scoped_refptr<FakeContentLayer> impl_destroyed_;
 };
 
 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)
   // Round 4: composite & readback (2 commits, no draw/swap)
   // Round 5: commit + draw
 
   virtual void DidCommit() OVERRIDE {
     int commit = layer_tree_host()->commit_number();
     switch (commit) {
       case 2:
@@ skipping 38 matching lines @@
   }
 
   virtual void SwapBuffersCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     const ThreadProxy* proxy = static_cast<ThreadProxy*>(impl->proxy());
     EXPECT_EQ(0, proxy->NumFramesPendingForTesting());
   }
 
   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
 }  // namespace cc