Adding support for blending in cc::SoftwareRenderer

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/solid_color_layer.h"
 #include "cc/layers/texture_layer.h"
 #include "cc/test/layer_tree_pixel_test.h"
+#include "cc/test/pixel_test.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,
     SkXfermode::kColorBurn_Mode, SkXfermode::kHardLight_Mode,
     SkXfermode::kSoftLight_Mode, SkXfermode::kDifference_Mode,
     SkXfermode::kExclusion_Mode, SkXfermode::kMultiply_Mode,
     SkXfermode::kHue_Mode,       SkXfermode::kSaturation_Mode,
     SkXfermode::kColor_Mode,     SkXfermode::kLuminosity_Mode};
 
 const int kBlendModesCount = arraysize(kBlendModes);
 
+// All pixels can be off by one, but any more than that is an error.
+class FuzzyPixelOffByOneComparator : public FuzzyPixelComparator {

[enne (OOO), 2014/09/05 17:49:08]

I feel like this is duplicated elsewhere.  Can you move this to some common
location?

[rosca, 2014/09/05 20:52:27]

Done.

+ public:
+  explicit FuzzyPixelOffByOneComparator(bool discard_alpha)
+      : FuzzyPixelComparator(discard_alpha, 100.f, 0.f, 1.f, 1, 0) {}
+};
+
 class LayerTreeHostBlendingPixelTest : public LayerTreePixelTest {
  protected:
   void RunBlendingWithRootPixelTestType(PixelTestType type) {
     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 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]);
     }
 
+    if (type == SOFTWARE_WITH_BITMAP)

[enne (OOO), 2014/09/05 17:49:08]

I'd be ok with making all the blending tests use an off-by-one comparator.  It's
not clear to me that the mesa version is right and the software renderer version
is wrong.

[rosca, 2014/09/05 20:52:28]

Done.

+      pixel_comparator_.reset(new FuzzyPixelOffByOneComparator(true));
+
     RunPixelTest(type,
                  background,
                  base::FilePath(FILE_PATH_LITERAL("blending_with_root.png")));
   }
 
   void RunBlendingWithTransparentPixelTestType(PixelTestType type) {
     const int kLaneWidth = 15;
     const int kLaneHeight = kBlendModesCount * kLaneWidth;
     const int kRootSize = (kBlendModesCount + 2) * kLaneWidth;
 
     scoped_refptr<SolidColorLayer> root =
         CreateSolidColorLayer(gfx::Rect(kRootSize, kRootSize), kCSSBrown);
 
     scoped_refptr<SolidColorLayer> background = CreateSolidColorLayer(
         gfx::Rect(0, kLaneWidth * 2, kRootSize, 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]);
     }
 
+    if (type == SOFTWARE_WITH_BITMAP)
+      pixel_comparator_.reset(new FuzzyPixelOffByOneComparator(true));
+
     RunPixelTest(type,
                  root,
                  base::FilePath(FILE_PATH_LITERAL("blending_transparent.png")));
   }
 };
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRoot_GL) {
   RunBlendingWithRootPixelTestType(GL_WITH_BITMAP);
 }
 
+TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithRoot_Software) {
+  RunBlendingWithRootPixelTestType(SOFTWARE_WITH_BITMAP);
+}
+
 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
@@ skipping 12 matching lines @@
 
   RunPixelTest(GL_WITH_BITMAP,
                background,
                base::FilePath(FILE_PATH_LITERAL("blending_and_filter.png")));
 }
 
 TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithTransparent_GL) {
   RunBlendingWithTransparentPixelTestType(GL_WITH_BITMAP);
 }
 
+TEST_F(LayerTreeHostBlendingPixelTest, BlendingWithTransparent_Software) {
+  RunBlendingWithTransparentPixelTestType(SOFTWARE_WITH_BITMAP);
+}
+
 }  // namespace
 }  // namespace cc
 
 #endif  // OS_ANDROID