[cc] Add SkBlendMode::kDstIn support to cc::Layer

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 <stdint.h>
 
 #include "cc/layers/picture_image_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/test/layer_tree_pixel_resource_test.h"
 #include "cc/test/pixel_comparator.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkSurface.h"
 
 #if !defined(OS_ANDROID)
 
 namespace cc {
 namespace {
 
 SkBlendMode const kBlendModes[] = {
     SkBlendMode::kSrcOver,   SkBlendMode::kScreen,
     SkBlendMode::kOverlay,   SkBlendMode::kDarken,
     SkBlendMode::kLighten,   SkBlendMode::kColorDodge,
     SkBlendMode::kColorBurn, SkBlendMode::kHardLight,
     SkBlendMode::kSoftLight, SkBlendMode::kDifference,
     SkBlendMode::kExclusion, SkBlendMode::kMultiply,
     SkBlendMode::kHue,       SkBlendMode::kSaturation,
-    SkBlendMode::kColor,     SkBlendMode::kLuminosity};
+    SkBlendMode::kColor,     SkBlendMode::kLuminosity,
+    SkBlendMode::kDstIn};
 
 SkColor kCSSTestColors[] = {
     0xffff0000,  // red
     0xff00ff00,  // lime
     0xff0000ff,  // blue
     0xff00ffff,  // aqua
     0xffff00ff,  // fuchsia
     0xffffff00,  // yellow
     0xff008000,  // green
     0xff800000,  // maroon
@@ skipping 135 matching lines @@
   void SetupColorMatrix(scoped_refptr<Layer> layer) {
     FilterOperations filter_operations;
     filter_operations.Append(FilterOperation::CreateSepiaFilter(.001f));
     layer->SetFilters(filter_operations);
   }
 
   void CreateBlendingColorLayers(int lane_width,
                                  int lane_height,
                                  scoped_refptr<Layer> background,
                                  RenderPassOptions flags) {
-    const int kLanesCount = kBlendModesCount + 4;
+    const int kLanesCount = kBlendModesCount + 6;
     const SkColor kMiscOpaqueColor = 0xffc86464;
     const SkColor kMiscTransparentColor = 0x80c86464;
     const SkBlendMode kCoeffBlendMode = SkBlendMode::kScreen;
     const SkBlendMode kShaderBlendMode = SkBlendMode::kColorBurn;
     // add vertical lanes with each of the blend modes
     for (int i = 0; i < kLanesCount; ++i) {
       gfx::Rect child_rect(i * lane_width, 0, lane_width, lane_height);
       SkBlendMode blend_mode = SkBlendMode::kSrcOver;
       float opacity = 1.f;
       SkColor color = kMiscOpaqueColor;
 
       if (i < kBlendModesCount) {
         blend_mode = kBlendModes[i];
       } else if (i == kBlendModesCount) {
         blend_mode = kCoeffBlendMode;
         opacity = 0.5f;
       } else if (i == kBlendModesCount + 1) {
         blend_mode = kCoeffBlendMode;
         color = kMiscTransparentColor;
       } else if (i == kBlendModesCount + 2) {
         blend_mode = kShaderBlendMode;
         opacity = 0.5f;
       } else if (i == kBlendModesCount + 3) {
         blend_mode = kShaderBlendMode;
         color = kMiscTransparentColor;
+      } else if (i == kBlendModesCount + 4) {
+        blend_mode = SkBlendMode::kDstIn;
+        opacity = 0.5f;
+      } else if (i == kBlendModesCount + 5) {
+        blend_mode = SkBlendMode::kDstIn;
+        color = kMiscTransparentColor;
       }
 
       scoped_refptr<SolidColorLayer> lane =
           CreateSolidColorLayer(child_rect, color);
       lane->SetBlendMode(blend_mode);
       lane->SetOpacity(opacity);
       lane->SetForceRenderSurfaceForTesting(true);
-      if (flags & kUseMasks)
+      // Layers with kDstIn blend mode with a mask is not supported.
+      if (flags & kUseMasks && blend_mode != SkBlendMode::kDstIn)
         SetupMaskLayer(lane);
       if (flags & kUseColorMatrix) {
         SetupColorMatrix(lane);
       }
       background->AddChild(lane);
     }
   }
 
   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;
+    const int kRootWidth = kLaneWidth * (kBlendModesCount + 6);
+    const int kRootHeight = kLaneWidth * kCSSTestColorsCount;
     InitializeFromTestCase(type);
 
-    scoped_refptr<SolidColorLayer> root =
-        CreateSolidColorLayer(gfx::Rect(kRootSize, kRootSize), SK_ColorWHITE);
+    scoped_refptr<SolidColorLayer> root = CreateSolidColorLayer(
+        gfx::Rect(kRootWidth, kRootHeight), SK_ColorWHITE);
     scoped_refptr<Layer> background =
-        CreateColorfulBackdropLayer(kRootSize, kRootSize);
+        CreateColorfulBackdropLayer(kRootWidth, kRootHeight);
 
     background->SetIsRootForIsolatedGroup(true);
     root->AddChild(background);
 
-    CreateBlendingColorLayers(kLaneWidth, kLaneHeight, background.get(), flags);
+    CreateBlendingColorLayers(kLaneWidth, kRootHeight, background.get(), flags);
 
     this->force_antialiasing_ = (flags & kUseAntialiasing);
     this->force_blending_with_shaders_ = (flags & kForceShaders);
 
     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.
@@ skipping 240 matching lines @@
   RunBlendingWithRenderPass(
       GL_ZERO_COPY_RECT_DRAW,
       FILE_PATH_LITERAL("blending_render_pass_mask.png"),
       kUseMasks | kUseAntialiasing | kUseColorMatrix | kForceShaders);
 }
 
 }  // namespace
 }  // namespace cc
 
 #endif  // OS_ANDROID