CC pixel tests for blending with GL_EXT_blend_minmax

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"
+#include "cc/test/test_in_process_context_provider.h"
 
 #if !defined(OS_ANDROID)
 
 namespace cc {
 namespace {
 
 SkXfermode::Mode const kBlendModes[] = {
     SkXfermode::kSrcOver_Mode,   SkXfermode::kScreen_Mode,
     SkXfermode::kOverlay_Mode,   SkXfermode::kDarken_Mode,
     SkXfermode::kLighten_Mode,   SkXfermode::kColorDodge_Mode,
@@ skipping 26 matching lines @@
     0x00000000   // transparent
 };
 
 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 kUseBlendMinMax = 1 << 3;
+
+class BlendingTestInProcessContextProvider
+    : public TestInProcessContextProvider {
+ public:
+  BlendingTestInProcessContextProvider(bool minmax) : blend_minmax_(minmax) {}
+  virtual ContextProvider::Capabilities ContextCapabilities() override {
+    ContextProvider::Capabilities caps = ContextProvider::Capabilities();
+    caps.gpu.blend_minmax = blend_minmax_;
+    return caps;
+  }
+
+ private:
+  virtual ~BlendingTestInProcessContextProvider() {}
+  bool blend_minmax_;
+};
 
 class LayerTreeHostBlendingPixelTest : public LayerTreePixelTest {
  public:
   LayerTreeHostBlendingPixelTest() {
     pixel_comparator_.reset(new FuzzyPixelOffByOneComparator(true));
   }
 
+  virtual scoped_refptr<ContextProvider> CreteTestContextProvider() override {
+    return new BlendingTestInProcessContextProvider(blend_minmax_);
+  }
+
   virtual void InitializeSettings(LayerTreeSettings* settings) override {
     settings->force_antialiasing = force_antialiasing_;
   }
 
  protected:
   void RunBlendingWithRootPixelTestType(PixelTestType type) {
     const int kLaneWidth = 15;
     const int kLaneHeight = kBlendModesCount * kLaneWidth;
     const int kRootSize = (kBlendModesCount + 2) * kLaneWidth;
 
@@ skipping 151 matching lines @@
     scoped_refptr<Layer> background =
         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);
+    this->blend_minmax_ = (flags & kUseBlendMinMax);
 
     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).
@@ skipping 34 matching lines @@
                                    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;
+  bool blend_minmax_ = false;
 };
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRoot_GL) {
   RunBlendingWithRootPixelTestType(PIXEL_TEST_GL);
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRoot_Software) {
   RunBlendingWithRootPixelTestType(PIXEL_TEST_SOFTWARE);
 }
 
@@ skipping 133 matching lines @@
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest,
        BlendingWithRenderPassWithMaskColorMatrixAA_Software) {
   RunBlendingWithRenderPass(
       PIXEL_TEST_SOFTWARE,
       FILE_PATH_LITERAL("blending_render_pass_mask_cm.png"),
       kUseMasks | kUseAntialiasing | kUseColorMatrix);
 }
 
+// Tests for render passes with GL_EXT_blend_minmax enabled.
+TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPass_MMGL) {
+  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+                            FILE_PATH_LITERAL("blending_render_pass.png"),
+                            kUseBlendMinMax);
+}
+
+TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassAA_MMGL) {
+  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+                            FILE_PATH_LITERAL("blending_render_pass.png"),
+                            kUseAntialiasing | kUseBlendMinMax);
+}
+
+TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassWithMask_MMGL) {
+  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+                            FILE_PATH_LITERAL("blending_render_pass_mask.png"),
+                            kUseMasks | kUseBlendMinMax);
+}
+
+TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassWithMaskAA_MMGL) {
+  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+                            FILE_PATH_LITERAL("blending_render_pass_mask.png"),
+                            kUseMasks | kUseAntialiasing | kUseBlendMinMax);
+}
+
+TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRenderPassColorMatrix_MMGL) {
+  RunBlendingWithRenderPass(PIXEL_TEST_GL,
+                            FILE_PATH_LITERAL("blending_render_pass_cm.png"),
+                            kUseColorMatrix | kUseBlendMinMax);
+}
+
+TEST_F(LayerTreeHostBlendingPixelTest,
+       BlendingWithRenderPassColorMatrixAA_MMGL) {
+  RunBlendingWithRenderPass(
+      PIXEL_TEST_GL,
+      FILE_PATH_LITERAL("blending_render_pass_cm.png"),
+      kUseAntialiasing | kUseColorMatrix | kUseBlendMinMax);
+}
+
+TEST_F(LayerTreeHostBlendingPixelTest,
+       BlendingWithRenderPassWithMaskColorMatrix_MMGL) {
+  RunBlendingWithRenderPass(
+      PIXEL_TEST_GL,
+      FILE_PATH_LITERAL("blending_render_pass_mask_cm.png"),
+      kUseMasks | kUseColorMatrix | kUseBlendMinMax);
+}
+
+TEST_F(LayerTreeHostBlendingPixelTest,
+       BlendingWithRenderPassWithMaskColorMatrixAA_MMGL) {
+  RunBlendingWithRenderPass(
+      PIXEL_TEST_GL,
+      FILE_PATH_LITERAL("blending_render_pass_mask_cm.png"),
+      kUseMasks | kUseAntialiasing | kUseColorMatrix | kUseBlendMinMax);
+}
+
 }  // namespace
 }  // namespace cc
 
 #endif  // OS_ANDROID