Update from https://crrev.com/307758

cc/trees/layer_tree_host_pixeltest_blending.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 "cc/layers/image_layer.h"
 #include "cc/layers/solid_color_layer.h"
-#include "cc/test/layer_tree_pixel_test.h"
+#include "cc/test/layer_tree_pixel_resource_test.h"
 #include "cc/test/pixel_comparator.h"
 
 #if !defined(OS_ANDROID)
 
 namespace cc {
 namespace {
 
 SkXfermode::Mode const kBlendModes[] = {
     SkXfermode::kSrcOver_Mode,   SkXfermode::kScreen_Mode,
     SkXfermode::kOverlay_Mode,   SkXfermode::kDarken_Mode,
@@ skipping 29 matching lines @@
 
 const int kBlendModesCount = arraysize(kBlendModes);
 const int kCSSTestColorsCount = arraysize(kCSSTestColors);
 
 using RenderPassOptions = uint32;
 const uint32 kUseMasks = 1 << 0;
 const uint32 kUseAntialiasing = 1 << 1;
 const uint32 kUseColorMatrix = 1 << 2;
 const uint32 kForceShaders = 1 << 3;
 
-class LayerTreeHostBlendingPixelTest : public LayerTreePixelTest {
+class LayerTreeHostBlendingPixelTest : public LayerTreeHostPixelResourceTest {
  public:
   LayerTreeHostBlendingPixelTest()
       : force_antialiasing_(false), force_blending_with_shaders_(false) {
     pixel_comparator_.reset(new FuzzyPixelOffByOneComparator(true));
   }
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->renderer_settings.force_antialiasing = force_antialiasing_;
     settings->renderer_settings.force_blending_with_shaders =
         force_blending_with_shaders_;
   }
 
  protected:
-  void RunBlendingWithRootPixelTestType(PixelTestType type) {
+  void RunBlendingWithRootPixelTestType(PixelResourceTestCase type) {
     const int kLaneWidth = 2;
     const int kLaneHeight = kLaneWidth;
     const int kRootWidth = (kBlendModesCount + 2) * kLaneWidth;
     const int kRootHeight = 2 * kLaneWidth + kLaneHeight;
+    InitializeFromTestCase(type);
 
     scoped_refptr<SolidColorLayer> background =
         CreateSolidColorLayer(gfx::Rect(kRootWidth, kRootHeight), kCSSOrange);
 
     // Orange child layers will blend with the green background
     for (int i = 0; i < kBlendModesCount; ++i) {
       gfx::Rect child_rect(
           (i + 1) * kLaneWidth, kLaneWidth, kLaneWidth, kLaneHeight);
       scoped_refptr<SolidColorLayer> green_lane =
           CreateSolidColorLayer(child_rect, kCSSGreen);
       background->AddChild(green_lane);
       green_lane->SetBlendMode(kBlendModes[i]);
     }
 
-    RunPixelTest(type,
-                 background,
-                 base::FilePath(FILE_PATH_LITERAL("blending_with_root.png")));
+    RunPixelResourceTest(
+        background,
+        base::FilePath(FILE_PATH_LITERAL("blending_with_root.png")));
   }
 
-  void RunBlendingWithTransparentPixelTestType(PixelTestType type) {
+  void RunBlendingWithTransparentPixelTestType(PixelResourceTestCase type) {
     const int kLaneWidth = 2;
     const int kLaneHeight = 3 * kLaneWidth;
     const int kRootWidth = (kBlendModesCount + 2) * kLaneWidth;
     const int kRootHeight = 2 * kLaneWidth + kLaneHeight;
+    InitializeFromTestCase(type);
 
     scoped_refptr<SolidColorLayer> root =
         CreateSolidColorLayer(gfx::Rect(kRootWidth, kRootHeight), kCSSBrown);
 
     scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
         gfx::Rect(0, kLaneWidth * 2, kRootWidth, kLaneWidth), kCSSOrange);
 
     root->AddChild(background);
     background->SetIsRootForIsolatedGroup(true);
 
     // Orange child layers will blend with the green background
     for (int i = 0; i < kBlendModesCount; ++i) {
       gfx::Rect child_rect(
           (i + 1) * kLaneWidth, -kLaneWidth, kLaneWidth, kLaneHeight);
       scoped_refptr<SolidColorLayer> green_lane =
           CreateSolidColorLayer(child_rect, kCSSGreen);
       background->AddChild(green_lane);
       green_lane->SetBlendMode(kBlendModes[i]);
     }
 
-    RunPixelTest(type,
-                 root,
-                 base::FilePath(FILE_PATH_LITERAL("blending_transparent.png")));
+    RunPixelResourceTest(
+        root, base::FilePath(FILE_PATH_LITERAL("blending_transparent.png")));
   }
 
   scoped_refptr<Layer> CreateColorfulBackdropLayer(int width, int height) {
     // Draw the backdrop with horizontal lanes.
     const int kLaneWidth = width;
     const int kLaneHeight = height / kCSSTestColorsCount;
     SkBitmap backing_store;
     backing_store.allocN32Pixels(width, height);
     SkCanvas canvas(backing_store);
     canvas.clear(SK_ColorTRANSPARENT);
@@ skipping 78 matching lines @@
       lane->SetForceRenderSurface(true);
       if (flags & kUseMasks)
         SetupMaskLayer(lane);
       if (flags & kUseColorMatrix) {
         SetupColorMatrix(lane);
       }
       background->AddChild(lane);
     }
   }
 
-  void RunBlendingWithRenderPass(PixelTestType type,
+  void RunBlendingWithRenderPass(PixelResourceTestCase type,
                                  const base::FilePath::CharType* expected_path,
                                  RenderPassOptions flags) {
     const int kLaneWidth = 8;
     const int kLaneHeight = kLaneWidth * kCSSTestColorsCount;
     const int kRootSize = kLaneHeight;
+    InitializeFromTestCase(type);
 
     scoped_refptr<SolidColorLayer> root =
         CreateSolidColorLayer(gfx::Rect(kRootSize, kRootSize), SK_ColorWHITE);
     scoped_refptr<Layer> background =
         CreateColorfulBackdropLayer(kRootSize, kRootSize);
 
     background->SetIsRootForIsolatedGroup(true);
     root->AddChild(background);
 
     CreateBlendingColorLayers(kLaneWidth, kLaneHeight, background.get(), flags);
 
     this->impl_side_painting_ = false;
     this->force_antialiasing_ = (flags & kUseAntialiasing);
     this->force_blending_with_shaders_ = (flags & kForceShaders);
 
-    if ((flags & kUseAntialiasing) && (type == PIXEL_TEST_GL)) {
+    if ((flags & kUseAntialiasing) && (test_type_ == PIXEL_TEST_GL)) {
       // Anti aliasing causes differences up to 8 pixels at the edges.
       int large_error_allowed = 8;
       // Blending results might differ with one pixel.
       int small_error_allowed = 1;
       // Most of the errors are one pixel errors.
       float percentage_pixels_small_error = 13.1f;
       // Because of anti-aliasing, around 10% of pixels (at the edges) have
       // bigger errors (from small_error_allowed + 1 to large_error_allowed).
       float percentage_pixels_error = 22.5f;
       // The average error is still close to 1.
       float average_error_allowed_in_bad_pixels = 1.4f;
 
       pixel_comparator_.reset(
           new FuzzyPixelComparator(false,  // discard_alpha
                                    percentage_pixels_error,
                                    percentage_pixels_small_error,
                                    average_error_allowed_in_bad_pixels,
                                    large_error_allowed,
                                    small_error_allowed));
     }
 
-    RunPixelTest(type, root, base::FilePath(expected_path));
+    RunPixelResourceTest(root, base::FilePath(expected_path));
   }
 
   bool force_antialiasing_;
   bool force_blending_with_shaders_;
 };
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRoot_GL) {
-  RunBlendingWithRootPixelTestType(PIXEL_TEST_GL);
+  RunBlendingWithRootPixelTestType(GL_ASYNC_UPLOAD_2D_DRAW);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRoot_Software) {
-  RunBlendingWithRootPixelTestType(PIXEL_TEST_SOFTWARE);
+  RunBlendingWithRootPixelTestType(SOFTWARE);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithBackgroundFilter) {
   const int kLaneWidth = 2;
   const int kLaneHeight = kLaneWidth;
   const int kRootWidth = (kBlendModesCount + 2) * kLaneWidth;
   const int kRootHeight = 2 * kLaneWidth + kLaneHeight;
+  InitializeFromTestCase(GL_ASYNC_UPLOAD_2D_DRAW);
 
   scoped_refptr<SolidColorLayer> background =
       CreateSolidColorLayer(gfx::Rect(kRootWidth, kRootHeight), kCSSOrange);
 
   // Orange child layers have a background filter set and they will blend with
   // the green background
   for (int i = 0; i < kBlendModesCount; ++i) {
     gfx::Rect child_rect(
         (i + 1) * kLaneWidth, kLaneWidth, kLaneWidth, kLaneHeight);
     scoped_refptr<SolidColorLayer> green_lane =
         CreateSolidColorLayer(child_rect, kCSSGreen);
     background->AddChild(green_lane);
 
     FilterOperations filters;
     filters.Append(FilterOperation::CreateGrayscaleFilter(.75));
     green_lane->SetBackgroundFilters(filters);
     green_lane->SetBlendMode(kBlendModes[i]);
   }
 
-  RunPixelTest(PIXEL_TEST_GL,
-               background,
-               base::FilePath(FILE_PATH_LITERAL("blending_and_filter.png")));
+  RunPixelResourceTest(
+      background, base::FilePath(FILE_PATH_LITERAL("blending_and_filter.png")));
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithTransparent_GL) {
-  RunBlendingWithTransparentPixelTestType(PIXEL_TEST_GL);
+  RunBlendingWithTransparentPixelTestType(GL_ASYNC_UPLOAD_2D_DRAW);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithTransparent_Software) {
-  RunBlendingWithTransparentPixelTestType(PIXEL_TEST_SOFTWARE);
+  RunBlendingWithTransparentPixelTestType(SOFTWARE);
 }
 
 // Tests for render passes
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPass_GL) {
-  RunBlendingWithRenderPass(
-      PIXEL_TEST_GL, FILE_PATH_LITERAL("blending_render_pass.png"), 0);
+  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
+                            FILE_PATH_LITERAL("blending_render_pass.png"), 0);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPass_Software) {
-  RunBlendingWithRenderPass(
-      PIXEL_TEST_SOFTWARE, FILE_PATH_LITERAL("blending_render_pass.png"), 0);
+  RunBlendingWithRenderPass(SOFTWARE,
+                            FILE_PATH_LITERAL("blending_render_pass.png"), 0);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassAA_GL) {
-  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassAA_Software) {
-  RunBlendingWithRenderPass(PIXEL_TEST_SOFTWARE,
+  RunBlendingWithRenderPass(SOFTWARE,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassWithMask_GL) {
-  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMask_Software) {
-  RunBlendingWithRenderPass(PIXEL_TEST_SOFTWARE,
-                            FILE_PATH_LITERAL("blending_render_pass_mask.png"),
-                            kUseMasks);
+  RunBlendingWithRenderPass(
+      SOFTWARE, FILE_PATH_LITERAL("blending_render_pass_mask.png"), kUseMasks);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassWithMaskAA_GL) {
-  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskAA_Software) {
-  RunBlendingWithRenderPass(PIXEL_TEST_SOFTWARE,
+  RunBlendingWithRenderPass(SOFTWARE,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassColorMatrix_GL) {
-  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassColorMatrix_Software) {
-  RunBlendingWithRenderPass(PIXEL_TEST_SOFTWARE,
-                            FILE_PATH_LITERAL("blending_render_pass.png"),
-                            kUseColorMatrix);
+  RunBlendingWithRenderPass(
+      SOFTWARE, FILE_PATH_LITERAL("blending_render_pass.png"), kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassColorMatrixAA_GL) {
-  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing | kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassColorMatrixAA_Software) {
-  RunBlendingWithRenderPass(PIXEL_TEST_SOFTWARE,
+  RunBlendingWithRenderPass(SOFTWARE,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing | kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskColorMatrix_GL) {
-  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskColorMatrix_Software) {
-  RunBlendingWithRenderPass(PIXEL_TEST_SOFTWARE,
+  RunBlendingWithRenderPass(SOFTWARE,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskColorMatrixAA_GL) {
-  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing | kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskColorMatrixAA_Software) {
-  RunBlendingWithRenderPass(PIXEL_TEST_SOFTWARE,
+  RunBlendingWithRenderPass(SOFTWARE,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing | kUseColorMatrix);
 }
 
 // Tests for render passes forcing shaders for all the blend modes.
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassShaders_GL) {
-  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassShadersAA_GL) {
-  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMask_GL) {
-  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMaskAA_GL) {
-  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersColorMatrix_GL) {
-  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseColorMatrix | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersColorMatrixAA_GL) {
-  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing | kUseColorMatrix | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMaskColorMatrix_GL) {
-  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+  RunBlendingWithRenderPass(GL_ASYNC_UPLOAD_2D_DRAW,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseColorMatrix | kForceShaders);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassShadersWithMaskColorMatrixAA_GL) {
   RunBlendingWithRenderPass(
-      PIXEL_TEST_GL, FILE_PATH_LITERAL("blending_render_pass_mask.png"),
+      GL_ASYNC_UPLOAD_2D_DRAW,
+      FILE_PATH_LITERAL("blending_render_pass_mask.png"),
       kUseMasks | kUseAntialiasing | kUseColorMatrix | kForceShaders);
 }
 
 }  // namespace
 }  // namespace cc
 
 #endif  // OS_ANDROID