Reuse existing paint property node is possible

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositorTest.cpp

 // Copyright 2016 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/compositing/PaintArtifactCompositor.h"
 
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/layers/layer.h"
 #include "cc/test/fake_output_surface.h"
@@ skipping 19 matching lines @@
 
 gfx::Transform translation(SkMScalar x, SkMScalar y)
 {
     gfx::Transform transform;
     transform.Translate(x, y);
     return transform;
 }
 
 EffectPaintPropertyNode* dummyRootEffect()
 {
-    DEFINE_STATIC_REF(EffectPaintPropertyNode, node, EffectPaintPropertyNode::create(1.0));
+    DEFINE_STATIC_REF(EffectPaintPropertyNode, node, EffectPaintPropertyNode::create(nullptr, 1.0));
     return node;
 }
 
 class PaintArtifactCompositorTest : public ::testing::Test {
 protected:
     void SetUp() override
     {
         RuntimeEnabledFeatures::setSlimmingPaintV2Enabled(true);
 
         // Delay constructing the compositor until after the feature is set.
@@ skipping 44 matching lines @@
     EXPECT_THAT(child->GetPicture(),
         Pointee(drawsRectangle(FloatRect(0, 0, 100, 100), Color::white)));
     EXPECT_EQ(translation(50, -50), child->transform());
     EXPECT_EQ(gfx::Size(100, 100), child->bounds());
 }
 
 TEST_F(PaintArtifactCompositorTest, OneTransform)
 {
     // A 90 degree clockwise rotation about (100, 100).
     RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(
-        TransformationMatrix().rotate(90), FloatPoint3D(100, 100, 0));
+        nullptr, TransformationMatrix().rotate(90), FloatPoint3D(100, 100, 0));
 
     TestPaintArtifact artifact;
     artifact.chunk(transform, nullptr, dummyRootEffect())
         .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
     artifact.chunk(nullptr, nullptr, dummyRootEffect())
         .rectDrawing(FloatRect(0, 0, 100, 100), Color::gray);
     artifact.chunk(transform, nullptr, dummyRootEffect())
         .rectDrawing(FloatRect(100, 100, 200, 100), Color::black);
     update(artifact.build());
 
@@ skipping 19 matching lines @@
         gfx::RectF mappedRect(0, 0, 200, 100);
         layer->transform().TransformRect(&mappedRect);
         EXPECT_EQ(gfx::RectF(0, 100, 100, 200), mappedRect);
     }
 }
 
 TEST_F(PaintArtifactCompositorTest, TransformCombining)
 {
     // A translation by (5, 5) within a 2x scale about (10, 10).
     RefPtr<TransformPaintPropertyNode> transform1 = TransformPaintPropertyNode::create(
-        TransformationMatrix().scale(2), FloatPoint3D(10, 10, 0));
+        nullptr, TransformationMatrix().scale(2), FloatPoint3D(10, 10, 0));
     RefPtr<TransformPaintPropertyNode> transform2 = TransformPaintPropertyNode::create(
-        TransformationMatrix().translate(5, 5), FloatPoint3D(), transform1);
+        transform1, TransformationMatrix().translate(5, 5), FloatPoint3D());
 
     TestPaintArtifact artifact;
     artifact.chunk(transform1, nullptr, dummyRootEffect())
         .rectDrawing(FloatRect(0, 0, 300, 200), Color::white);
     artifact.chunk(transform2, nullptr, dummyRootEffect())
         .rectDrawing(FloatRect(0, 0, 300, 200), Color::black);
     update(artifact.build());
 
     ASSERT_EQ(2u, rootLayer()->children().size());
     {
@@ skipping 10 matching lines @@
             Pointee(drawsRectangle(FloatRect(0, 0, 300, 200), Color::black)));
         gfx::RectF mappedRect(0, 0, 300, 200);
         layer->transform().TransformRect(&mappedRect);
         EXPECT_EQ(gfx::RectF(0, 0, 600, 400), mappedRect);
     }
 }
 
 TEST_F(PaintArtifactCompositorTest, LayerOriginCancellation)
 {
     RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
-        nullptr, FloatRoundedRect(100, 100, 100, 100));
+        nullptr, nullptr, FloatRoundedRect(100, 100, 100, 100));
     RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(
-        TransformationMatrix().scale(2), FloatPoint3D());
+        nullptr, TransformationMatrix().scale(2), FloatPoint3D());
 
     TestPaintArtifact artifact;
     artifact.chunk(transform, clip, nullptr)
         .rectDrawing(FloatRect(12, 34, 56, 78), Color::white);
     update(artifact.build());
 
     ASSERT_EQ(1u, rootLayer()->children().size());
     cc::Layer* clipLayer = rootLayer()->child_at(0);
     EXPECT_EQ(gfx::Size(100, 100), clipLayer->bounds());
     EXPECT_EQ(translation(100, 100), clipLayer->transform());
     EXPECT_TRUE(clipLayer->masks_to_bounds());
 
     ASSERT_EQ(1u, clipLayer->children().size());
     cc::Layer* layer = clipLayer->child_at(0);
     EXPECT_EQ(gfx::Size(56, 78), layer->bounds());
     gfx::Transform expectedTransform;
     expectedTransform.Translate(-100, -100);
     expectedTransform.Scale(2, 2);
     expectedTransform.Translate(12, 34);
     EXPECT_EQ(expectedTransform, layer->transform());
 }
 
 TEST_F(PaintArtifactCompositorTest, OneClip)
 {
     RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
-        nullptr, FloatRoundedRect(100, 100, 300, 200));
+        nullptr, nullptr, FloatRoundedRect(100, 100, 300, 200));
 
     TestPaintArtifact artifact;
     artifact.chunk(nullptr, clip, nullptr)
         .rectDrawing(FloatRect(220, 80, 300, 200), Color::black);
     update(artifact.build());
 
     ASSERT_EQ(1u, rootLayer()->children().size());
     cc::Layer* clipLayer = rootLayer()->child_at(0);
     EXPECT_TRUE(clipLayer->masks_to_bounds());
     EXPECT_EQ(gfx::Size(300, 200), clipLayer->bounds());
     EXPECT_EQ(translation(100, 100), clipLayer->transform());
 
     ASSERT_EQ(1u, clipLayer->children().size());
     const cc::Layer* layer = clipLayer->child_at(0);
     EXPECT_THAT(layer->GetPicture(),
         Pointee(drawsRectangle(FloatRect(0, 0, 300, 200), Color::black)));
     EXPECT_EQ(translation(120, -20), layer->transform());
 }
 
 TEST_F(PaintArtifactCompositorTest, NestedClips)
 {
     RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::create(
-        nullptr, FloatRoundedRect(100, 100, 700, 700));
+        nullptr, nullptr, FloatRoundedRect(100, 100, 700, 700));
     RefPtr<ClipPaintPropertyNode> clip2 = ClipPaintPropertyNode::create(
-        nullptr, FloatRoundedRect(200, 200, 700, 100), clip1);
+        clip1, nullptr, FloatRoundedRect(200, 200, 700, 100));
 
     TestPaintArtifact artifact;
     artifact.chunk(nullptr, clip1, dummyRootEffect())
         .rectDrawing(FloatRect(300, 350, 100, 100), Color::white);
     artifact.chunk(nullptr, clip2, dummyRootEffect())
         .rectDrawing(FloatRect(300, 350, 100, 100), Color::lightGray);
     artifact.chunk(nullptr, clip1, dummyRootEffect())
         .rectDrawing(FloatRect(300, 350, 100, 100), Color::darkGray);
     artifact.chunk(nullptr, clip2, dummyRootEffect())
         .rectDrawing(FloatRect(300, 350, 100, 100), Color::black);
@@ skipping 40 matching lines @@
             Pointee(drawsRectangle(FloatRect(0, 0, 100, 100), Color::black)));
         EXPECT_EQ(translation(100, 150), blackLayer->transform());
     }
 }
 
 TEST_F(PaintArtifactCompositorTest, DeeplyNestedClips)
 {
     Vector<RefPtr<ClipPaintPropertyNode>> clips;
     for (unsigned i = 1; i <= 10; i++) {
         clips.append(ClipPaintPropertyNode::create(
-            nullptr, FloatRoundedRect(5 * i, 0, 100, 200 - 10 * i),
-            clips.isEmpty() ? nullptr : clips.last()));
+            clips.isEmpty() ? nullptr : clips.last(),
+            nullptr, FloatRoundedRect(5 * i, 0, 100, 200 - 10 * i)));
     }
 
     TestPaintArtifact artifact;
     artifact.chunk(nullptr, clips.last(), nullptr)
         .rectDrawing(FloatRect(0, 0, 200, 200), Color::white);
     update(artifact.build());
 
     // Check the clip layers.
     cc::Layer* layer = rootLayer();
     for (const auto& clipNode : clips) {
         ASSERT_EQ(1u, layer->children().size());
         layer = layer->child_at(0);
         EXPECT_EQ(clipNode->clipRect().rect().width(), layer->bounds().width());
         EXPECT_EQ(clipNode->clipRect().rect().height(), layer->bounds().height());
         EXPECT_EQ(translation(5, 0), layer->transform());
     }
 
     // Check the drawing layer.
     ASSERT_EQ(1u, layer->children().size());
     cc::Layer* drawingLayer = layer->child_at(0);
     EXPECT_THAT(drawingLayer->GetPicture(),
         Pointee(drawsRectangle(FloatRect(0, 0, 200, 200), Color::white)));
     EXPECT_EQ(translation(-50, 0), drawingLayer->transform());
 }
 
 TEST_F(PaintArtifactCompositorTest, SiblingClips)
 {
     RefPtr<ClipPaintPropertyNode> commonClip = ClipPaintPropertyNode::create(
-        nullptr, FloatRoundedRect(0, 0, 800, 600));
+        nullptr, nullptr, FloatRoundedRect(0, 0, 800, 600));
     RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::create(
-        nullptr, FloatRoundedRect(0, 0, 400, 600), commonClip);
+        commonClip, nullptr, FloatRoundedRect(0, 0, 400, 600));
     RefPtr<ClipPaintPropertyNode> clip2 = ClipPaintPropertyNode::create(
-        nullptr, FloatRoundedRect(400, 0, 400, 600), commonClip);
+        commonClip, nullptr, FloatRoundedRect(400, 0, 400, 600));
 
     TestPaintArtifact artifact;
     artifact.chunk(nullptr, clip1, nullptr)
         .rectDrawing(FloatRect(0, 0, 640, 480), Color::white);
     artifact.chunk(nullptr, clip2, nullptr)
         .rectDrawing(FloatRect(0, 0, 640, 480), Color::black);
     update(artifact.build());
 
     ASSERT_EQ(1u, rootLayer()->children().size());
     cc::Layer* commonClipLayer = rootLayer()->child_at(0);
@@ skipping 110 matching lines @@
     EXPECT_THAT(child->GetPicture(),
         Pointee(drawsRectangle(FloatRect(0, 0, 100, 100), Color::white)));
     EXPECT_EQ(translation(50, -50), child->screen_space_transform());
     EXPECT_EQ(gfx::Size(100, 100), child->bounds());
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, OneTransform)
 {
     // A 90 degree clockwise rotation about (100, 100).
     RefPtr<TransformPaintPropertyNode> transform = TransformPaintPropertyNode::create(
-        TransformationMatrix().rotate(90), FloatPoint3D(100, 100, 0));
+        nullptr, TransformationMatrix().rotate(90), FloatPoint3D(100, 100, 0));
 
     TestPaintArtifact artifact;
     artifact.chunk(transform, nullptr, dummyRootEffect())
         .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
     artifact.chunk(nullptr, nullptr, dummyRootEffect())
         .rectDrawing(FloatRect(0, 0, 100, 100), Color::gray);
     artifact.chunk(transform, nullptr, dummyRootEffect())
         .rectDrawing(FloatRect(100, 100, 200, 100), Color::black);
     update(artifact.build());
 
@@ skipping 19 matching lines @@
         gfx::RectF mappedRect(0, 0, 200, 100);
         layer->screen_space_transform().TransformRect(&mappedRect);
         EXPECT_EQ(gfx::RectF(0, 100, 100, 200), mappedRect);
     }
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, TransformCombining)
 {
     // A translation by (5, 5) within a 2x scale about (10, 10).
     RefPtr<TransformPaintPropertyNode> transform1 = TransformPaintPropertyNode::create(
-        TransformationMatrix().scale(2), FloatPoint3D(10, 10, 0));
+        nullptr, TransformationMatrix().scale(2), FloatPoint3D(10, 10, 0));
     RefPtr<TransformPaintPropertyNode> transform2 = TransformPaintPropertyNode::create(
-        TransformationMatrix().translate(5, 5), FloatPoint3D(), transform1);
+        transform1, TransformationMatrix().translate(5, 5), FloatPoint3D());
 
     TestPaintArtifact artifact;
     artifact.chunk(transform1, nullptr, dummyRootEffect())
         .rectDrawing(FloatRect(0, 0, 300, 200), Color::white);
     artifact.chunk(transform2, nullptr, dummyRootEffect())
         .rectDrawing(FloatRect(0, 0, 300, 200), Color::black);
     update(artifact.build());
 
     ASSERT_EQ(2u, contentLayerCount());
     {
@@ skipping 13 matching lines @@
         EXPECT_EQ(gfx::RectF(0, 0, 600, 400), mappedRect);
     }
     EXPECT_NE(
         contentLayerAt(0)->transform_tree_index(),
         contentLayerAt(1)->transform_tree_index());
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, OneClip)
 {
     RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
-        nullptr, FloatRoundedRect(100, 100, 300, 200));
+        nullptr, nullptr, FloatRoundedRect(100, 100, 300, 200));
 
     TestPaintArtifact artifact;
     artifact.chunk(nullptr, clip, nullptr)
         .rectDrawing(FloatRect(220, 80, 300, 200), Color::black);
     update(artifact.build());
 
     ASSERT_EQ(1u, contentLayerCount());
     const cc::Layer* layer = contentLayerAt(0);
     EXPECT_THAT(layer->GetPicture(),
         Pointee(drawsRectangle(FloatRect(0, 0, 300, 200), Color::black)));
     EXPECT_EQ(translation(220, 80), layer->screen_space_transform());
 
     const cc::ClipNode* clipNode = propertyTrees().clip_tree.Node(layer->clip_tree_index());
     EXPECT_TRUE(clipNode->applies_local_clip);
     EXPECT_TRUE(clipNode->layers_are_clipped);
     EXPECT_EQ(gfx::RectF(100, 100, 300, 200), clipNode->clip);
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, NestedClips)
 {
     RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::create(
-        nullptr, FloatRoundedRect(100, 100, 700, 700));
+        nullptr, nullptr, FloatRoundedRect(100, 100, 700, 700));
     RefPtr<ClipPaintPropertyNode> clip2 = ClipPaintPropertyNode::create(
-        nullptr, FloatRoundedRect(200, 200, 700, 100), clip1);
+        clip1, nullptr, FloatRoundedRect(200, 200, 700, 100));
 
     TestPaintArtifact artifact;
     artifact.chunk(nullptr, clip1, dummyRootEffect())
         .rectDrawing(FloatRect(300, 350, 100, 100), Color::white);
     artifact.chunk(nullptr, clip2, dummyRootEffect())
         .rectDrawing(FloatRect(300, 350, 100, 100), Color::lightGray);
     artifact.chunk(nullptr, clip1, dummyRootEffect())
         .rectDrawing(FloatRect(300, 350, 100, 100), Color::darkGray);
     artifact.chunk(nullptr, clip2, dummyRootEffect())
         .rectDrawing(FloatRect(300, 350, 100, 100), Color::black);
@@ skipping 33 matching lines @@
     EXPECT_TRUE(innerClip->layers_are_clipped);
     EXPECT_EQ(gfx::RectF(200, 200, 700, 100), innerClip->clip);
     EXPECT_EQ(outerClip->id, innerClip->parent_id);
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, DeeplyNestedClips)
 {
     Vector<RefPtr<ClipPaintPropertyNode>> clips;
     for (unsigned i = 1; i <= 10; i++) {
         clips.append(ClipPaintPropertyNode::create(
-            nullptr, FloatRoundedRect(5 * i, 0, 100, 200 - 10 * i),
-            clips.isEmpty() ? nullptr : clips.last()));
+            clips.isEmpty() ? nullptr : clips.last(),
+            nullptr, FloatRoundedRect(5 * i, 0, 100, 200 - 10 * i)));
     }
 
     TestPaintArtifact artifact;
     artifact.chunk(nullptr, clips.last(), dummyRootEffect())
         .rectDrawing(FloatRect(0, 0, 200, 200), Color::white);
     update(artifact.build());
 
     // Check the drawing layer.
     ASSERT_EQ(1u, contentLayerCount());
     const cc::Layer* drawingLayer = contentLayerAt(0);
     EXPECT_THAT(drawingLayer->GetPicture(),
         Pointee(drawsRectangle(FloatRect(0, 0, 200, 200), Color::white)));
     EXPECT_EQ(gfx::Transform(), drawingLayer->screen_space_transform());
 
     // Check the clip nodes.
     const cc::ClipNode* clipNode = propertyTrees().clip_tree.Node(drawingLayer->clip_tree_index());
     for (auto it = clips.rbegin(); it != clips.rend(); ++it) {
         const ClipPaintPropertyNode* paintClipNode = it->get();
         EXPECT_TRUE(clipNode->applies_local_clip);
         EXPECT_TRUE(clipNode->layers_are_clipped);
         EXPECT_EQ(paintClipNode->clipRect().rect(), clipNode->clip);
         clipNode = propertyTrees().clip_tree.Node(clipNode->parent_id);
     }
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, SiblingClips)
 {
     RefPtr<ClipPaintPropertyNode> commonClip = ClipPaintPropertyNode::create(
-        nullptr, FloatRoundedRect(0, 0, 800, 600));
+        nullptr, nullptr, FloatRoundedRect(0, 0, 800, 600));
     RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::create(
-        nullptr, FloatRoundedRect(0, 0, 400, 600), commonClip);
+        commonClip, nullptr, FloatRoundedRect(0, 0, 400, 600));
     RefPtr<ClipPaintPropertyNode> clip2 = ClipPaintPropertyNode::create(
-        nullptr, FloatRoundedRect(400, 0, 400, 600), commonClip);
+        commonClip, nullptr, FloatRoundedRect(400, 0, 400, 600));
 
     TestPaintArtifact artifact;
     artifact.chunk(nullptr, clip1, dummyRootEffect())
         .rectDrawing(FloatRect(0, 0, 640, 480), Color::white);
     artifact.chunk(nullptr, clip2, dummyRootEffect())
         .rectDrawing(FloatRect(0, 0, 640, 480), Color::black);
     update(artifact.build());
 
     ASSERT_EQ(2u, contentLayerCount());
 
@@ skipping 32 matching lines @@
     update(artifact.build());
 
     ASSERT_EQ(1u, contentLayerCount());
     EXPECT_EQ(layer, contentLayerAt(0));
     EXPECT_EQ(gfx::Size(400, 300), layer->bounds());
     EXPECT_EQ(translation(50, 100), layer->screen_space_transform());
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, EffectTreeConversion)
 {
-    RefPtr<EffectPaintPropertyNode> effect1 = EffectPaintPropertyNode::create(0.5, dummyRootEffect());
-    RefPtr<EffectPaintPropertyNode> effect2 = EffectPaintPropertyNode::create(0.3, effect1.get());
-    RefPtr<EffectPaintPropertyNode> effect3 = EffectPaintPropertyNode::create(0.2, dummyRootEffect());
+    RefPtr<EffectPaintPropertyNode> effect1 = EffectPaintPropertyNode::create(dummyRootEffect(), 0.5);
+    RefPtr<EffectPaintPropertyNode> effect2 = EffectPaintPropertyNode::create(effect1, 0.3);
+    RefPtr<EffectPaintPropertyNode> effect3 = EffectPaintPropertyNode::create(dummyRootEffect(), 0.2);
 
     TestPaintArtifact artifact;
     artifact.chunk(nullptr, nullptr, effect2.get())
         .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
     artifact.chunk(nullptr, nullptr, effect1.get())
         .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
     artifact.chunk(nullptr, nullptr, effect3.get())
         .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
     update(artifact.build());
 
@@ skipping 19 matching lines @@
     EXPECT_EQ(convertedDummyRootEffect.id, convertedEffect3.parent_id);
     EXPECT_FLOAT_EQ(0.2, convertedEffect3.opacity);
 
     EXPECT_EQ(convertedEffect2.id, contentLayerAt(0)->effect_tree_index());
     EXPECT_EQ(convertedEffect1.id, contentLayerAt(1)->effect_tree_index());
     EXPECT_EQ(convertedEffect3.id, contentLayerAt(2)->effect_tree_index());
 }
 
 } // namespace
 } // namespace blink