[SPv2] Create effect nodes for CSS filter

third_party/WebKit/Source/platform/graphics/paint/PaintArtifactToSkCanvasTest.cpp

 // Copyright 2015 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 "platform/graphics/paint/PaintArtifactToSkCanvas.h"
 
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/paint/DisplayItem.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
 #include "platform/graphics/paint/PaintArtifact.h"
 #include "platform/testing/TestPaintArtifact.h"
 #include "platform/transforms/TransformationMatrix.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkRect.h"
 
 using testing::_;
 using testing::Eq;
 using testing::Pointee;
 using testing::Property;
 using testing::ResultOf;
 
 namespace blink {
+
 namespace {
+TransformPaintPropertyNode* dummyRootTransform() {
+  DEFINE_STATIC_REF(TransformPaintPropertyNode, rootTransform,
+                    (TransformPaintPropertyNode::create(
+                        nullptr, TransformationMatrix(), FloatPoint3D())));
+  return rootTransform;
+}
+
+ClipPaintPropertyNode* dummyRootClip() {
+  DEFINE_STATIC_REF(ClipPaintPropertyNode, rootClip,
+                    (ClipPaintPropertyNode::create(
+                        nullptr, dummyRootTransform(),
+                        FloatRoundedRect(LayoutRect::infiniteIntRect()))));
+  return rootClip;
+}
+
+EffectPaintPropertyNode* dummyRootEffect() {
+  DEFINE_STATIC_REF(EffectPaintPropertyNode, rootEffect,
+                    (EffectPaintPropertyNode::create(
+                        nullptr, dummyRootTransform(), dummyRootClip(),
+                        CompositorFilterOperations(), 1.0)));
+  return rootEffect;
+}
 
 static const int kCanvasWidth = 800;
 static const int kCanvasHeight = 600;
 
 class MockCanvas : public SkCanvas {
  public:
   MockCanvas(int width, int height) : SkCanvas(width, height) {}
 
   MOCK_METHOD3(onDrawRect, void(const SkRect&, const SkPaint&, MockCanvas*));
   MOCK_METHOD2(willSaveLayer, void(unsigned alpha, MockCanvas*));
@@ skipping 88 matching lines @@
       .rectDrawing(FloatRect(0, 0, 300, 200), SK_ColorBLUE);
   paintArtifactToSkCanvas(artifact.build(), &canvas);
 }
 
 TEST_F(PaintArtifactToSkCanvasTest, OpacityEffectsCombining) {
   unsigned expectedFirstOpacity = 127;  // floor(0.5 * 255)
   unsigned expectedSecondOpacity = 63;  // floor(0.25 * 255)
   MockCanvas canvas(kCanvasWidth, kCanvasHeight);
   {
     testing::InSequence sequence;
+    EXPECT_CALL(canvas, willSaveLayer(255, _));
     EXPECT_CALL(canvas, willSaveLayer(expectedFirstOpacity, _));
     EXPECT_CALL(canvas,
                 onDrawRect(SkRect::MakeWH(300, 200),
                            Property(&SkPaint::getColor, SK_ColorRED), _));
     EXPECT_CALL(canvas, willSaveLayer(expectedSecondOpacity, _));
     EXPECT_CALL(canvas,
                 onDrawRect(SkRect::MakeWH(300, 200),
                            Property(&SkPaint::getColor, SK_ColorBLUE), _));
   }
 
   // Build an opacity effect tree.
   RefPtr<EffectPaintPropertyNode> opacityEffect1 =
-      EffectPaintPropertyNode::create(nullptr, 0.5);
+      EffectPaintPropertyNode::create(dummyRootEffect(), dummyRootTransform(),
+                                      dummyRootClip(),
+                                      CompositorFilterOperations(), 0.5);
   RefPtr<EffectPaintPropertyNode> opacityEffect2 =
-      EffectPaintPropertyNode::create(opacityEffect1, 0.25);
+      EffectPaintPropertyNode::create(opacityEffect1, dummyRootTransform(),
+                                      dummyRootClip(),
+                                      CompositorFilterOperations(), 0.25);
 
   TestPaintArtifact artifact;
-  artifact.chunk(nullptr, nullptr, opacityEffect1.get())
+  artifact.chunk(dummyRootTransform(), dummyRootClip(), opacityEffect1.get())
       .rectDrawing(FloatRect(0, 0, 300, 200), SK_ColorRED);
-  artifact.chunk(nullptr, nullptr, opacityEffect2.get())
+  artifact.chunk(dummyRootTransform(), dummyRootClip(), opacityEffect2.get())
       .rectDrawing(FloatRect(0, 0, 300, 200), SK_ColorBLUE);
   paintArtifactToSkCanvas(artifact.build(), &canvas);
 }
 
 TEST_F(PaintArtifactToSkCanvasTest, ChangingOpacityEffects) {
   unsigned expectedAOpacity = 25;   // floor(0.1 * 255)
   unsigned expectedBOpacity = 51;   // floor(0.2 * 255)
   unsigned expectedCOpacity = 76;   // floor(0.3 * 255)
   unsigned expectedDOpacity = 102;  // floor(0.4 * 255)
   MockCanvas canvas(kCanvasWidth, kCanvasHeight);
   {
     testing::InSequence sequence;
+    EXPECT_CALL(canvas, willSaveLayer(255, _));
     EXPECT_CALL(canvas, willSaveLayer(expectedAOpacity, _));
     EXPECT_CALL(canvas, willSaveLayer(expectedBOpacity, _));
     EXPECT_CALL(canvas,
                 onDrawRect(SkRect::MakeWH(300, 200),
                            Property(&SkPaint::getColor, SK_ColorRED), _));
     EXPECT_CALL(canvas, willSaveLayer(expectedCOpacity, _));
     EXPECT_CALL(canvas, willSaveLayer(expectedDOpacity, _));
     EXPECT_CALL(canvas,
                 onDrawRect(SkRect::MakeWH(300, 200),
                            Property(&SkPaint::getColor, SK_ColorBLUE), _));
   }
 
   // Build an opacity effect tree with the following structure:
   //       _root_
   //      |      |
   // 0.1  a      c  0.3
   //      |      |
   // 0.2  b      d  0.4
   RefPtr<EffectPaintPropertyNode> opacityEffectA =
-      EffectPaintPropertyNode::create(nullptr, 0.1);
+      EffectPaintPropertyNode::create(dummyRootEffect(), dummyRootTransform(),
+                                      dummyRootClip(),
+                                      CompositorFilterOperations(), 0.1);
   RefPtr<EffectPaintPropertyNode> opacityEffectB =
-      EffectPaintPropertyNode::create(opacityEffectA, 0.2);
+      EffectPaintPropertyNode::create(opacityEffectA, dummyRootTransform(),
+                                      dummyRootClip(),
+                                      CompositorFilterOperations(), 0.2);
   RefPtr<EffectPaintPropertyNode> opacityEffectC =
-      EffectPaintPropertyNode::create(nullptr, 0.3);
+      EffectPaintPropertyNode::create(dummyRootEffect(), dummyRootTransform(),
+                                      dummyRootClip(),
+                                      CompositorFilterOperations(), 0.3);
   RefPtr<EffectPaintPropertyNode> opacityEffectD =
-      EffectPaintPropertyNode::create(opacityEffectC, 0.4);
+      EffectPaintPropertyNode::create(opacityEffectC, dummyRootTransform(),
+                                      dummyRootClip(),
+                                      CompositorFilterOperations(), 0.4);
 
   // Build a two-chunk artifact directly.
   // chunk1 references opacity node b, chunk2 references opacity node d.
   TestPaintArtifact artifact;
-  artifact.chunk(nullptr, nullptr, opacityEffectB.get())
+  artifact.chunk(dummyRootTransform(), dummyRootClip(), opacityEffectB.get())
       .rectDrawing(FloatRect(0, 0, 300, 200), SK_ColorRED);
-  artifact.chunk(nullptr, nullptr, opacityEffectD.get())
+  artifact.chunk(dummyRootTransform(), dummyRootClip(), opacityEffectD.get())
       .rectDrawing(FloatRect(0, 0, 300, 200), SK_ColorBLUE);
   paintArtifactToSkCanvas(artifact.build(), &canvas);
 }
 
 static SkRegion getCanvasClipAsRegion(SkCanvas* canvas) {
   SkIRect clipRect;
   canvas->getClipDeviceBounds(&clipRect);
 
   SkRegion clipRegion;
   clipRegion.setRect(clipRect);
@@ skipping 35 matching lines @@
                          ResultOf(&getCanvasClipAsRegion, Eq(totalClip))));
 
   TestPaintArtifact artifact;
   artifact.chunk(nullptr, clip2.get(), nullptr)
       .rectDrawing(FloatRect(0, 0, 300, 200), SK_ColorRED);
   paintArtifactToSkCanvas(artifact.build(), &canvas);
 }
 
 }  // namespace
 }  // namespace blink