Update from chromium 62675d9fb31fb8cedc40f68e78e8445a74f362e7

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/pixel_comparator.h"
 
 #if !defined(OS_ANDROID)
@@ skipping 213 matching lines @@
         CreateColorfulBackdropLayer(kRootSize, kRootSize);
 
     background->SetIsRootForIsolatedGroup(true);
     root->AddChild(background);
 
     CreateBlendingColorLayers(kRootSize, kRootSize, background.get(), flags);
 
     this->impl_side_painting_ = false;
     this->force_antialiasing_ = (flags & kUseAntialiasing);
 
-    if ((flags & kUseAntialiasing) && (type == GL_WITH_BITMAP)) {
+    if ((flags & kUseAntialiasing) && (type == PIXEL_TEST_GL)) {
       // Anti aliasing causes differences up to 7 pixels at the edges.
       int large_error_allowed = 7;
       // 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 = 12.5f;
       // Because of anti-aliasing, around 3% of pixels (at the edges) have
       // bigger errors (from small_error_allowed + 1 to large_error_allowed).
       float percentage_pixels_error = 15.0f;
       // The average error is still close to 1.
@@ skipping 13 matching lines @@
       if (!(flags & kUseMasks))
         large_error_allowed = 255;
 
       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));
-    } else if ((flags & kUseColorMatrix) && (type == GL_WITH_BITMAP)) {
+    } else if ((flags & kUseColorMatrix) && (type == PIXEL_TEST_GL)) {
       float percentage_pixels_error = 100.f;
       float percentage_pixels_small_error = 0.f;
       float average_error_allowed_in_bad_pixels = 1.f;
       int large_error_allowed = 2;
       int small_error_allowed = 0;
       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));
   }
 
   bool force_antialiasing_ = false;
 };
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRoot_GL) {
-  RunBlendingWithRootPixelTestType(GL_WITH_BITMAP);
+  RunBlendingWithRootPixelTestType(PIXEL_TEST_GL);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRoot_Software) {
-  RunBlendingWithRootPixelTestType(SOFTWARE_WITH_BITMAP);
+  RunBlendingWithRootPixelTestType(PIXEL_TEST_SOFTWARE);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithBackgroundFilter) {
   const int kLaneWidth = 15;
   const int kLaneHeight = kBlendModesCount * kLaneWidth;
   const int kRootSize = (kBlendModesCount + 2) * kLaneWidth;
 
   scoped_refptr<SolidColorLayer> background =
       CreateSolidColorLayer(gfx::Rect(kRootSize, kRootSize), 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(GL_WITH_BITMAP,
+  RunPixelTest(PIXEL_TEST_GL,
                background,
                base::FilePath(FILE_PATH_LITERAL("blending_and_filter.png")));
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithTransparent_GL) {
-  RunBlendingWithTransparentPixelTestType(GL_WITH_BITMAP);
+  RunBlendingWithTransparentPixelTestType(PIXEL_TEST_GL);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithTransparent_Software) {
-  RunBlendingWithTransparentPixelTestType(SOFTWARE_WITH_BITMAP);
+  RunBlendingWithTransparentPixelTestType(PIXEL_TEST_SOFTWARE);
 }
 
 // Tests for render passes
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPass_GL) {
   RunBlendingWithRenderPass(
-      GL_WITH_BITMAP, FILE_PATH_LITERAL("blending_render_pass.png"), 0);
+      PIXEL_TEST_GL, FILE_PATH_LITERAL("blending_render_pass.png"), 0);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPass_Software) {
   RunBlendingWithRenderPass(
-      SOFTWARE_WITH_BITMAP, FILE_PATH_LITERAL("blending_render_pass.png"), 0);
+      PIXEL_TEST_SOFTWARE, FILE_PATH_LITERAL("blending_render_pass.png"), 0);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassAA_GL) {
-  RunBlendingWithRenderPass(GL_WITH_BITMAP,
+  RunBlendingWithRenderPass(PIXEL_TEST_GL,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassAA_Software) {
-  RunBlendingWithRenderPass(SOFTWARE_WITH_BITMAP,
+  RunBlendingWithRenderPass(PIXEL_TEST_SOFTWARE,
                             FILE_PATH_LITERAL("blending_render_pass.png"),
                             kUseAntialiasing);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassWithMask_GL) {
-  RunBlendingWithRenderPass(GL_WITH_BITMAP,
+  RunBlendingWithRenderPass(PIXEL_TEST_GL,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMask_Software) {
-  RunBlendingWithRenderPass(SOFTWARE_WITH_BITMAP,
+  RunBlendingWithRenderPass(PIXEL_TEST_SOFTWARE,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassWithMaskAA_GL) {
-  RunBlendingWithRenderPass(GL_WITH_BITMAP,
+  RunBlendingWithRenderPass(PIXEL_TEST_GL,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskAA_Software) {
-  RunBlendingWithRenderPass(SOFTWARE_WITH_BITMAP,
+  RunBlendingWithRenderPass(PIXEL_TEST_SOFTWARE,
                             FILE_PATH_LITERAL("blending_render_pass_mask.png"),
                             kUseMasks | kUseAntialiasing);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassColorMatrix_GL) {
-  RunBlendingWithRenderPass(GL_WITH_BITMAP,
+  RunBlendingWithRenderPass(PIXEL_TEST_GL,
                             FILE_PATH_LITERAL("blending_render_pass_cm.png"),
                             kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassColorMatrix_Software) {
-  RunBlendingWithRenderPass(SOFTWARE_WITH_BITMAP,
+  RunBlendingWithRenderPass(PIXEL_TEST_SOFTWARE,
                             FILE_PATH_LITERAL("blending_render_pass_cm.png"),
                             kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassColorMatrixAA_GL) {
-  RunBlendingWithRenderPass(GL_WITH_BITMAP,
+  RunBlendingWithRenderPass(PIXEL_TEST_GL,
                             FILE_PATH_LITERAL("blending_render_pass_cm.png"),
                             kUseAntialiasing | kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassColorMatrixAA_Software) {
-  RunBlendingWithRenderPass(SOFTWARE_WITH_BITMAP,
+  RunBlendingWithRenderPass(PIXEL_TEST_SOFTWARE,
                             FILE_PATH_LITERAL("blending_render_pass_cm.png"),
                             kUseAntialiasing | kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskColorMatrix_GL) {
   RunBlendingWithRenderPass(
-      GL_WITH_BITMAP,
+      PIXEL_TEST_GL,
       FILE_PATH_LITERAL("blending_render_pass_mask_cm.png"),
       kUseMasks | kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskColorMatrix_Software) {
   RunBlendingWithRenderPass(
-      SOFTWARE_WITH_BITMAP,
+      PIXEL_TEST_SOFTWARE,
       FILE_PATH_LITERAL("blending_render_pass_mask_cm.png"),
       kUseMasks | kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskColorMatrixAA_GL) {
   RunBlendingWithRenderPass(
-      GL_WITH_BITMAP,
+      PIXEL_TEST_GL,
       FILE_PATH_LITERAL("blending_render_pass_mask_cm.png"),
       kUseMasks | kUseAntialiasing | kUseColorMatrix);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskColorMatrixAA_Software) {
   RunBlendingWithRenderPass(
-      SOFTWARE_WITH_BITMAP,
+      PIXEL_TEST_SOFTWARE,
       FILE_PATH_LITERAL("blending_render_pass_mask_cm.png"),
       kUseMasks | kUseAntialiasing | kUseColorMatrix);
 }
 
 }  // namespace
 }  // namespace cc
 
 #endif  // OS_ANDROID