cc: Test cleanup for layer tree pixel tests.

cc/trees/layer_tree_host_pixeltest_readback.cc

 // Copyright 2013 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 "build/build_config.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/test/layer_tree_pixel_test.h"
 #include "cc/test/paths.h"
 
 #if !defined(OS_ANDROID)
 
 namespace cc {
 namespace {
 
 class LayerTreeHostReadbackPixelTest : public LayerTreePixelTest {
  protected:
-  LayerTreeHostReadbackPixelTest() : force_readback_as_bitmap_(false) {}
-
   virtual scoped_ptr<CopyOutputRequest> CreateCopyOutputRequest() OVERRIDE {
     scoped_ptr<CopyOutputRequest> request;
-    if (force_readback_as_bitmap_) {
-      request = CopyOutputRequest::CreateBitmapRequest(
-          base::Bind(&LayerTreeHostReadbackPixelTest::ReadbackResultAsBitmap,
-                     base::Unretained(this)));
-    } else if (!use_gl_) {
-      request = CopyOutputRequest::CreateRequest(
-          base::Bind(&LayerTreeHostReadbackPixelTest::ReadbackResultAsBitmap,
-                     base::Unretained(this)));
-    } else {
-      request = CopyOutputRequest::CreateRequest(
-          base::Bind(&LayerTreeHostReadbackPixelTest::ReadbackResultAsTexture,
-                     base::Unretained(this)));
+
+    switch (test_type_) {
+      case GL_WITH_BITMAP:
+      case SOFTWARE_WITH_BITMAP:
+        request = CopyOutputRequest::CreateBitmapRequest(
+            base::Bind(&LayerTreeHostReadbackPixelTest::ReadbackResultAsBitmap,
+                       base::Unretained(this)));
+        break;
+      case SOFTWARE_WITH_DEFAULT:
+        request = CopyOutputRequest::CreateRequest(
+            base::Bind(&LayerTreeHostReadbackPixelTest::ReadbackResultAsBitmap,
+                       base::Unretained(this)));
+        break;
+      case GL_WITH_DEFAULT:
+        request = CopyOutputRequest::CreateRequest(
+            base::Bind(&LayerTreeHostReadbackPixelTest::ReadbackResultAsTexture,
+                       base::Unretained(this)));
+        break;
     }
 
     if (!copy_subrect_.IsEmpty())
       request->set_area(copy_subrect_);
     return request.Pass();
   }
 
   void ReadbackResultAsBitmap(scoped_ptr<CopyOutputResult> result) {
     EXPECT_TRUE(result->HasBitmap());
     result_bitmap_ = result->TakeBitmap().Pass();
     EndTest();
   }
 
   void ReadbackResultAsTexture(scoped_ptr<CopyOutputResult> result) {
     EXPECT_TRUE(result->HasTexture());
 
     scoped_ptr<TextureMailbox> texture_mailbox = result->TakeTexture().Pass();
     EXPECT_TRUE(texture_mailbox->IsValid());
     EXPECT_TRUE(texture_mailbox->IsTexture());
 
     scoped_ptr<SkBitmap> bitmap =
         CopyTextureMailboxToBitmap(result->size(), *texture_mailbox);
     ReadbackResultAsBitmap(CopyOutputResult::CreateBitmapResult(bitmap.Pass()));
 
     texture_mailbox->RunReleaseCallback(0, false);
   }
 
-  bool force_readback_as_bitmap_;
   gfx::Rect copy_subrect_;
 };
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayer_Software) {
-  use_gl_ = false;
-  force_readback_as_bitmap_ = false;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorGREEN);
   background->AddChild(green);
 
-  RunPixelTest(background,
+  RunPixelTest(SOFTWARE_WITH_DEFAULT,
+               background,
                base::FilePath(FILE_PATH_LITERAL(
                    "green.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayer_Software_Bitmap) {
-  use_gl_ = false;
-  force_readback_as_bitmap_ = true;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorGREEN);
   background->AddChild(green);
 
-  RunPixelTest(background,
+  RunPixelTest(SOFTWARE_WITH_BITMAP,
+               background,
                base::FilePath(FILE_PATH_LITERAL(
                    "green.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayer_GL_Bitmap) {
-  use_gl_ = true;
-  force_readback_as_bitmap_ = true;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorGREEN);
   background->AddChild(green);
 
-  RunPixelTest(background,
+  RunPixelTest(GL_WITH_BITMAP,
+               background,
                base::FilePath(FILE_PATH_LITERAL(
                    "green.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayer_GL) {
-  use_gl_ = true;
-  force_readback_as_bitmap_ = false;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorGREEN);
   background->AddChild(green);
 
-  RunPixelTest(background,
+  RunPixelTest(GL_WITH_DEFAULT,
+               background,
                base::FilePath(FILE_PATH_LITERAL(
                    "green.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest,
        ReadbackRootLayerWithChild_Software) {
-  use_gl_ = false;
-  force_readback_as_bitmap_ = false;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorGREEN);
   background->AddChild(green);
 
   scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
       gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
   green->AddChild(blue);
 
-  RunPixelTest(background,
+  RunPixelTest(SOFTWARE_WITH_DEFAULT,
+               background,
                base::FilePath(FILE_PATH_LITERAL(
                    "green_with_blue_corner.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayerWithChild_GL_Bitmap) {
-  use_gl_ = true;
-  force_readback_as_bitmap_ = true;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorGREEN);
   background->AddChild(green);
 
   scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
       gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
   green->AddChild(blue);
 
-  RunPixelTest(background,
+  RunPixelTest(GL_WITH_BITMAP,
+               background,
                base::FilePath(FILE_PATH_LITERAL(
                    "green_with_blue_corner.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackRootLayerWithChild_GL) {
-  use_gl_ = true;
-  force_readback_as_bitmap_ = false;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorGREEN);
   background->AddChild(green);
 
   scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
       gfx::Rect(150, 150, 50, 50), SK_ColorBLUE);
   green->AddChild(blue);
 
-  RunPixelTest(background,
+  RunPixelTest(GL_WITH_DEFAULT,
+               background,
                base::FilePath(FILE_PATH_LITERAL(
                    "green_with_blue_corner.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayer_Software) {
-  use_gl_ = false;
-  force_readback_as_bitmap_ = false;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorGREEN);
   background->AddChild(green);
 
-  RunPixelTestWithReadbackTarget(background,
+  RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
+                                 background,
                                  green.get(),
                                  base::FilePath(FILE_PATH_LITERAL(
                                      "green.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayer_GL_Bitmap) {
-  use_gl_ = true;
-  force_readback_as_bitmap_ = true;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorGREEN);
   background->AddChild(green);
 
-  RunPixelTestWithReadbackTarget(background,
+  RunPixelTestWithReadbackTarget(GL_WITH_BITMAP,
+                                 background,
                                  green.get(),
                                  base::FilePath(FILE_PATH_LITERAL(
                                      "green.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayer_GL) {
-  use_gl_ = true;
-  force_readback_as_bitmap_ = false;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorGREEN);
   background->AddChild(green);
 
-  RunPixelTestWithReadbackTarget(background,
+  RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
+                                 background,
                                  green.get(),
                                  base::FilePath(FILE_PATH_LITERAL(
                                      "green.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest,
        ReadbackSmallNonRootLayer_Software) {
-  use_gl_ = false;
-  force_readback_as_bitmap_ = false;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
   background->AddChild(green);
 
-  RunPixelTestWithReadbackTarget(background,
+  RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
+                                 background,
                                  green.get(),
                                  base::FilePath(FILE_PATH_LITERAL(
                                      "green_small.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSmallNonRootLayer_GL_Bitmap) {
-  use_gl_ = true;
-  force_readback_as_bitmap_ = true;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
   background->AddChild(green);
 
-  RunPixelTestWithReadbackTarget(background,
+  RunPixelTestWithReadbackTarget(GL_WITH_BITMAP,
+                                 background,
                                  green.get(),
                                  base::FilePath(FILE_PATH_LITERAL(
                                      "green_small.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSmallNonRootLayer_GL) {
-  use_gl_ = true;
-  force_readback_as_bitmap_ = false;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
   background->AddChild(green);
 
-  RunPixelTestWithReadbackTarget(background,
+  RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
+                                 background,
                                  green.get(),
                                  base::FilePath(FILE_PATH_LITERAL(
                                      "green_small.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest,
        ReadbackSmallNonRootLayerWithChild_Software) {
-  use_gl_ = false;
-  force_readback_as_bitmap_ = false;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
   background->AddChild(green);
 
   scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
       gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
   green->AddChild(blue);
 
-  RunPixelTestWithReadbackTarget(background,
+  RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
+                                 background,
                                  green.get(),
                                  base::FilePath(FILE_PATH_LITERAL(
                                      "green_small_with_blue_corner.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest,
        ReadbackSmallNonRootLayerWithChild_GL_Bitmap) {
-  use_gl_ = true;
-  force_readback_as_bitmap_ = true;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
   background->AddChild(green);
 
   scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
       gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
   green->AddChild(blue);
 
-  RunPixelTestWithReadbackTarget(background,
+  RunPixelTestWithReadbackTarget(GL_WITH_BITMAP,
+                                 background,
                                  green.get(),
                                  base::FilePath(FILE_PATH_LITERAL(
                                      "green_small_with_blue_corner.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSmallNonRootLayerWithChild_GL) {
-  use_gl_ = true;
-  force_readback_as_bitmap_ = false;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(100, 100, 100, 100), SK_ColorGREEN);
   background->AddChild(green);
 
   scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
       gfx::Rect(50, 50, 50, 50), SK_ColorBLUE);
   green->AddChild(blue);
 
-  RunPixelTestWithReadbackTarget(background,
+  RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
+                                 background,
                                  green.get(),
                                  base::FilePath(FILE_PATH_LITERAL(
                                      "green_small_with_blue_corner.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSubrect_Software) {
-  use_gl_ = false;
-  force_readback_as_bitmap_ = false;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorGREEN);
   background->AddChild(green);
 
   scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
       gfx::Rect(100, 100, 50, 50), SK_ColorBLUE);
   green->AddChild(blue);
 
   // Grab the middle of the viewport.
   copy_subrect_ = gfx::Rect(50, 50, 100, 100);
 
-  RunPixelTest(background,
+  RunPixelTest(SOFTWARE_WITH_DEFAULT,
+               background,
                base::FilePath(FILE_PATH_LITERAL(
                    "green_small_with_blue_corner.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSubrect_GL_Bitmap) {
-  use_gl_ = true;
-  force_readback_as_bitmap_ = true;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorGREEN);
   background->AddChild(green);
 
   scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
       gfx::Rect(100, 100, 50, 50), SK_ColorBLUE);
   green->AddChild(blue);
 
   // Grab the middle of the viewport.
   copy_subrect_ = gfx::Rect(50, 50, 100, 100);
 
-  RunPixelTest(background,
+  RunPixelTest(GL_WITH_BITMAP,
+               background,
                base::FilePath(FILE_PATH_LITERAL(
                    "green_small_with_blue_corner.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackSubrect_GL) {
-  use_gl_ = true;
-  force_readback_as_bitmap_ = false;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorGREEN);
   background->AddChild(green);
 
   scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
       gfx::Rect(100, 100, 50, 50), SK_ColorBLUE);
   green->AddChild(blue);
 
   // Grab the middle of the viewport.
   copy_subrect_ = gfx::Rect(50, 50, 100, 100);
 
-  RunPixelTest(background,
+  RunPixelTest(GL_WITH_DEFAULT,
+               background,
                base::FilePath(FILE_PATH_LITERAL(
                    "green_small_with_blue_corner.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayerSubrect_Software) {
-  use_gl_ = false;
-  force_readback_as_bitmap_ = false;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(25, 25, 150, 150), SK_ColorGREEN);
   background->AddChild(green);
 
   scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
       gfx::Rect(75, 75, 50, 50), SK_ColorBLUE);
   green->AddChild(blue);
 
   // Grab the middle of the viewport.
   copy_subrect_ = gfx::Rect(25, 25, 100, 100);
 
-  RunPixelTestWithReadbackTarget(background,
+  RunPixelTestWithReadbackTarget(SOFTWARE_WITH_DEFAULT,
+                                 background,
                                  green.get(),
                                  base::FilePath(FILE_PATH_LITERAL(
                                      "green_small_with_blue_corner.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayerSubrect_GL_Bitmap) {
-  use_gl_ = true;
-  force_readback_as_bitmap_ = true;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(25, 25, 150, 150), SK_ColorGREEN);
   background->AddChild(green);
 
   scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
       gfx::Rect(75, 75, 50, 50), SK_ColorBLUE);
   green->AddChild(blue);
 
   // Grab the middle of the viewport.
   copy_subrect_ = gfx::Rect(25, 25, 100, 100);
 
-  RunPixelTestWithReadbackTarget(background,
+  RunPixelTestWithReadbackTarget(GL_WITH_BITMAP,
+                                 background,
                                  green.get(),
                                  base::FilePath(FILE_PATH_LITERAL(
                                      "green_small_with_blue_corner.png")));
 }
 
 TEST_F(LayerTreeHostReadbackPixelTest, ReadbackNonRootLayerSubrect_GL) {
-  use_gl_ = true;
-  force_readback_as_bitmap_ = true;
-
   scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
       gfx::Rect(200, 200), SK_ColorWHITE);
 
   scoped_refptr<SolidColorLayer> green = CreateSolidColorLayer(
       gfx::Rect(25, 25, 150, 150), SK_ColorGREEN);
   background->AddChild(green);
 
   scoped_refptr<SolidColorLayer> blue = CreateSolidColorLayer(
       gfx::Rect(75, 75, 50, 50), SK_ColorBLUE);
   green->AddChild(blue);
 
   // Grab the middle of the viewport.
   copy_subrect_ = gfx::Rect(25, 25, 100, 100);
 
-  RunPixelTestWithReadbackTarget(background,
+  RunPixelTestWithReadbackTarget(GL_WITH_DEFAULT,
+                                 background,
                                  green.get(),
                                  base::FilePath(FILE_PATH_LITERAL(
                                      "green_small_with_blue_corner.png")));
 }
 
 }  // namespace
 }  // namespace cc
 
 #endif  // OS_ANDROID