[SPv2] Refactor PaintArtifactorCompositor root node creation

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_compositor_frame_sink.h"
@@ skipping 13 matching lines @@
 #include "platform/testing/WebLayerTreeViewImplForTesting.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <memory>
 
 namespace blink {
 namespace {
 
 using ::testing::Pointee;
 
+PaintChunkProperties defaultPaintChunkProperties() {
+  PaintChunkProperties properties;
+  properties.transform = TransformPaintPropertyNode::root();
+  properties.clip = ClipPaintPropertyNode::root();
+  properties.effect = EffectPaintPropertyNode::root();
+  properties.scroll = ScrollPaintPropertyNode::root();
+  return properties;
+}
+
 gfx::Transform translation(SkMScalar x, SkMScalar y) {
   gfx::Transform transform;
   transform.Translate(x, y);
   return transform;
 }
 
 class WebLayerTreeViewWithCompositorFrameSink
     : public WebLayerTreeViewImplForTesting {
  public:
   WebLayerTreeViewWithCompositorFrameSink(const cc::LayerTreeSettings& settings)
@@ skipping 67 matching lines @@
 };
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, EmptyPaintArtifact) {
   PaintArtifact emptyArtifact;
   update(emptyArtifact);
   EXPECT_TRUE(rootLayer()->children().empty());
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, OneChunkWithAnOffset) {
   TestPaintArtifact artifact;
-  artifact.chunk(PaintChunkProperties())
+  artifact.chunk(defaultPaintChunkProperties())
       .rectDrawing(FloatRect(50, -50, 100, 100), Color::white);
   update(artifact.build());
 
   ASSERT_EQ(1u, contentLayerCount());
   const cc::Layer* child = contentLayerAt(0);
   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(nullptr,
+      TransformPaintPropertyNode::create(TransformPaintPropertyNode::root(),
                                          TransformationMatrix().rotate(90),
                                          FloatPoint3D(100, 100, 0));
 
   TestPaintArtifact artifact;
-  artifact.chunk(transform, nullptr, EffectPaintPropertyNode::root())
+  artifact
+      .chunk(transform, ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
-  artifact.chunk(nullptr, nullptr, EffectPaintPropertyNode::root())
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::gray);
-  artifact.chunk(transform, nullptr, EffectPaintPropertyNode::root())
+  artifact
+      .chunk(transform, ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(100, 100, 200, 100), Color::black);
   update(artifact.build());
 
   ASSERT_EQ(3u, contentLayerCount());
   {
     const cc::Layer* layer = contentLayerAt(0);
     EXPECT_THAT(
         layer->GetPicture(),
         Pointee(drawsRectangle(FloatRect(0, 0, 100, 100), Color::white)));
     gfx::RectF mappedRect(0, 0, 100, 100);
@@ skipping 14 matching lines @@
         Pointee(drawsRectangle(FloatRect(0, 0, 200, 100), Color::black)));
     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(
-          nullptr, TransformationMatrix().scale(2), FloatPoint3D(10, 10, 0));
+      TransformPaintPropertyNode::create(TransformPaintPropertyNode::root(),
+                                         TransformationMatrix().scale(2),
+                                         FloatPoint3D(10, 10, 0));
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(
           transform1, TransformationMatrix().translate(5, 5), FloatPoint3D());
 
   TestPaintArtifact artifact;
-  artifact.chunk(transform1, nullptr, EffectPaintPropertyNode::root())
+  artifact
+      .chunk(transform1, ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 300, 200), Color::white);
-  artifact.chunk(transform2, nullptr, EffectPaintPropertyNode::root())
+  artifact
+      .chunk(transform2, ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 300, 200), Color::black);
   update(artifact.build());
 
   ASSERT_EQ(2u, contentLayerCount());
   {
     const cc::Layer* layer = contentLayerAt(0);
     EXPECT_THAT(
         layer->GetPicture(),
         Pointee(drawsRectangle(FloatRect(0, 0, 300, 200), Color::white)));
     gfx::RectF mappedRect(0, 0, 300, 200);
@@ skipping 16 matching lines @@
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
        FlattensInheritedTransform) {
   for (bool transformIsFlattened : {true, false}) {
     SCOPED_TRACE(transformIsFlattened);
 
     // The flattens_inherited_transform bit corresponds to whether the _parent_
     // transform node flattens the transform. This is because Blink's notion of
     // flattening determines whether content within the node's local transform
     // is flattened, while cc's notion applies in the parent's coordinate space.
     RefPtr<TransformPaintPropertyNode> transform1 =
-        TransformPaintPropertyNode::create(nullptr, TransformationMatrix(),
+        TransformPaintPropertyNode::create(TransformPaintPropertyNode::root(),
+                                           TransformationMatrix(),
                                            FloatPoint3D());
     RefPtr<TransformPaintPropertyNode> transform2 =
         TransformPaintPropertyNode::create(
             transform1, TransformationMatrix().rotate3d(0, 45, 0),
             FloatPoint3D());
     RefPtr<TransformPaintPropertyNode> transform3 =
         TransformPaintPropertyNode::create(
             transform2, TransformationMatrix().rotate3d(0, 45, 0),
             FloatPoint3D(), transformIsFlattened);
 
     TestPaintArtifact artifact;
-    artifact.chunk(transform3, nullptr, nullptr)
+    artifact
+        .chunk(transform3, ClipPaintPropertyNode::root(),
+               EffectPaintPropertyNode::root())
         .rectDrawing(FloatRect(0, 0, 300, 200), Color::white);
     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::white)));
 
     // The leaf transform node should flatten its inherited transform node
@@ skipping 15 matching lines @@
     if (transformIsFlattened)
       EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 50, 100), rect);
     else
       EXPECT_TRUE(rect.IsEmpty());
   }
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, SortingContextID) {
   // Has no 3D rendering context.
   RefPtr<TransformPaintPropertyNode> transform1 =
-      TransformPaintPropertyNode::create(nullptr, TransformationMatrix(),
+      TransformPaintPropertyNode::create(TransformPaintPropertyNode::root(),
+                                         TransformationMatrix(),
                                          FloatPoint3D());
   // Establishes a 3D rendering context.
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(transform1, TransformationMatrix(),
                                          FloatPoint3D(), false, 1);
   // Extends the 3D rendering context of transform2.
   RefPtr<TransformPaintPropertyNode> transform3 =
       TransformPaintPropertyNode::create(transform2, TransformationMatrix(),
                                          FloatPoint3D(), false, 1);
   // Establishes a 3D rendering context distinct from transform2.
   RefPtr<TransformPaintPropertyNode> transform4 =
       TransformPaintPropertyNode::create(transform2, TransformationMatrix(),
                                          FloatPoint3D(), false, 2);
 
   TestPaintArtifact artifact;
-  artifact.chunk(transform1, nullptr, EffectPaintPropertyNode::root())
+  artifact
+      .chunk(transform1, ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 300, 200), Color::white);
-  artifact.chunk(transform2, nullptr, EffectPaintPropertyNode::root())
+  artifact
+      .chunk(transform2, ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 300, 200), Color::lightGray);
-  artifact.chunk(transform3, nullptr, EffectPaintPropertyNode::root())
+  artifact
+      .chunk(transform3, ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 300, 200), Color::darkGray);
-  artifact.chunk(transform4, nullptr, EffectPaintPropertyNode::root())
+  artifact
+      .chunk(transform4, ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 300, 200), Color::black);
   update(artifact.build());
 
   ASSERT_EQ(4u, contentLayerCount());
 
   // The white layer is not 3D sorted.
   const cc::Layer* whiteLayer = contentLayerAt(0);
   EXPECT_THAT(whiteLayer->GetPicture(),
               Pointee(drawsRectangle(FloatRect(0, 0, 300, 200), Color::white)));
   int whiteSortingContextId = transformNode(whiteLayer).sorting_context_id;
@@ skipping 29 matching lines @@
   EXPECT_THAT(blackLayer->GetPicture(),
               Pointee(drawsRectangle(FloatRect(0, 0, 300, 200), Color::black)));
   int blackSortingContextId = transformNode(blackLayer).sorting_context_id;
   EXPECT_EQ(blackLayer->sorting_context_id(), blackSortingContextId);
   EXPECT_NE(0, blackSortingContextId);
   EXPECT_NE(lightGraySortingContextId, blackSortingContextId);
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, OneClip) {
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
-      nullptr, nullptr, FloatRoundedRect(100, 100, 300, 200));
+      ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
+      FloatRoundedRect(100, 100, 300, 200));
 
   TestPaintArtifact artifact;
-  artifact.chunk(nullptr, clip, nullptr)
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), clip,
+             EffectPaintPropertyNode::root())
       .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_EQ(cc::ClipNode::ClipType::APPLIES_LOCAL_CLIP, clipNode->clip_type);
   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, nullptr, FloatRoundedRect(100, 100, 700, 700));
-  RefPtr<ClipPaintPropertyNode> clip2 = ClipPaintPropertyNode::create(
-      clip1, nullptr, FloatRoundedRect(200, 200, 700, 100));
+      ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
+      FloatRoundedRect(100, 100, 700, 700));
+  RefPtr<ClipPaintPropertyNode> clip2 =
+      ClipPaintPropertyNode::create(clip1, TransformPaintPropertyNode::root(),
+                                    FloatRoundedRect(200, 200, 700, 100));
 
   TestPaintArtifact artifact;
-  artifact.chunk(nullptr, clip1, EffectPaintPropertyNode::root())
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), clip1,
+             EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(300, 350, 100, 100), Color::white);
-  artifact.chunk(nullptr, clip2, EffectPaintPropertyNode::root())
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), clip2,
+             EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(300, 350, 100, 100), Color::lightGray);
-  artifact.chunk(nullptr, clip1, EffectPaintPropertyNode::root())
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), clip1,
+             EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(300, 350, 100, 100), Color::darkGray);
-  artifact.chunk(nullptr, clip2, EffectPaintPropertyNode::root())
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), clip2,
+             EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(300, 350, 100, 100), Color::black);
   update(artifact.build());
 
   ASSERT_EQ(4u, contentLayerCount());
 
   const cc::Layer* whiteLayer = contentLayerAt(0);
   EXPECT_THAT(whiteLayer->GetPicture(),
               Pointee(drawsRectangle(FloatRect(0, 0, 100, 100), Color::white)));
   EXPECT_EQ(translation(300, 350), whiteLayer->screen_space_transform());
 
@@ skipping 27 matching lines @@
   EXPECT_EQ(cc::ClipNode::ClipType::APPLIES_LOCAL_CLIP, innerClip->clip_type);
   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(
-        clips.isEmpty() ? nullptr : clips.last(), nullptr,
+        clips.isEmpty() ? ClipPaintPropertyNode::root() : clips.last(),
+        TransformPaintPropertyNode::root(),
         FloatRoundedRect(5 * i, 0, 100, 200 - 10 * i)));
   }
 
   TestPaintArtifact artifact;
-  artifact.chunk(nullptr, clips.last(), EffectPaintPropertyNode::root())
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), clips.last(),
+             EffectPaintPropertyNode::root())
       .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_EQ(cc::ClipNode::ClipType::APPLIES_LOCAL_CLIP, clipNode->clip_type);
     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, nullptr, FloatRoundedRect(0, 0, 800, 600));
+      ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
+      FloatRoundedRect(0, 0, 800, 600));
   RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::create(
-      commonClip, nullptr, FloatRoundedRect(0, 0, 400, 600));
+      commonClip, TransformPaintPropertyNode::root(),
+      FloatRoundedRect(0, 0, 400, 600));
   RefPtr<ClipPaintPropertyNode> clip2 = ClipPaintPropertyNode::create(
-      commonClip, nullptr, FloatRoundedRect(400, 0, 400, 600));
+      commonClip, TransformPaintPropertyNode::root(),
+      FloatRoundedRect(400, 0, 400, 600));
 
   TestPaintArtifact artifact;
-  artifact.chunk(nullptr, clip1, EffectPaintPropertyNode::root())
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), clip1,
+             EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 640, 480), Color::white);
-  artifact.chunk(nullptr, clip2, EffectPaintPropertyNode::root())
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), clip2,
+             EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 640, 480), Color::black);
   update(artifact.build());
 
   ASSERT_EQ(2u, contentLayerCount());
 
   const cc::Layer* whiteLayer = contentLayerAt(0);
   EXPECT_THAT(whiteLayer->GetPicture(),
               Pointee(drawsRectangle(FloatRect(0, 0, 640, 480), Color::white)));
   EXPECT_EQ(gfx::Transform(), whiteLayer->screen_space_transform());
   const cc::ClipNode* whiteClip =
@@ skipping 19 matching lines @@
             commonClipNode->clip_type);
   EXPECT_TRUE(commonClipNode->layers_are_clipped);
   ASSERT_EQ(gfx::RectF(0, 0, 800, 600), commonClipNode->clip);
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
        ForeignLayerPassesThrough) {
   scoped_refptr<cc::Layer> layer = cc::Layer::Create();
 
   TestPaintArtifact artifact;
-  artifact.chunk(PaintChunkProperties())
+  artifact.chunk(defaultPaintChunkProperties())
       .foreignLayer(FloatPoint(50, 100), IntSize(400, 300), layer);
   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(
       EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
       ClipPaintPropertyNode::root(), CompositorFilterOperations(), 0.5);
   RefPtr<EffectPaintPropertyNode> effect2 = EffectPaintPropertyNode::create(
       effect1, TransformPaintPropertyNode::root(),
       ClipPaintPropertyNode::root(), CompositorFilterOperations(), 0.3);
   RefPtr<EffectPaintPropertyNode> effect3 = EffectPaintPropertyNode::create(
       EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
       ClipPaintPropertyNode::root(), CompositorFilterOperations(), 0.2);
 
   TestPaintArtifact artifact;
-  artifact.chunk(nullptr, nullptr, effect2.get())
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             effect2.get())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
-  artifact.chunk(nullptr, nullptr, effect1.get())
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             effect1.get())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
-  artifact.chunk(nullptr, nullptr, effect3.get())
+  artifact
+      .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
+             effect3.get())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   update(artifact.build());
 
   ASSERT_EQ(3u, contentLayerCount());
 
   const cc::EffectTree& effectTree = propertyTrees().effect_tree;
   // Node #0 reserved for null; #1 for root render surface; #2 for
   // EffectPaintPropertyNode::root(), plus 3 nodes for those created by
   // this test.
-  ASSERT_EQ(6u, effectTree.size());
+  ASSERT_EQ(5u, effectTree.size());
 
-  const cc::EffectNode& convertedDummyRootEffect = *effectTree.Node(2);
-  EXPECT_EQ(1, convertedDummyRootEffect.parent_id);
+  const cc::EffectNode& convertedRootEffect = *effectTree.Node(1);
+  EXPECT_EQ(-1, convertedRootEffect.parent_id);
 
-  const cc::EffectNode& convertedEffect1 = *effectTree.Node(3);
-  EXPECT_EQ(convertedDummyRootEffect.id, convertedEffect1.parent_id);
+  const cc::EffectNode& convertedEffect1 = *effectTree.Node(2);
+  EXPECT_EQ(convertedRootEffect.id, convertedEffect1.parent_id);
   EXPECT_FLOAT_EQ(0.5, convertedEffect1.opacity);
 
-  const cc::EffectNode& convertedEffect2 = *effectTree.Node(4);
+  const cc::EffectNode& convertedEffect2 = *effectTree.Node(3);
   EXPECT_EQ(convertedEffect1.id, convertedEffect2.parent_id);
   EXPECT_FLOAT_EQ(0.3, convertedEffect2.opacity);
 
-  const cc::EffectNode& convertedEffect3 = *effectTree.Node(5);
-  EXPECT_EQ(convertedDummyRootEffect.id, convertedEffect3.parent_id);
+  const cc::EffectNode& convertedEffect3 = *effectTree.Node(4);
+  EXPECT_EQ(convertedRootEffect.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());
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, OneScrollNode) {
   RefPtr<TransformPaintPropertyNode> scrollTranslation =
-      TransformPaintPropertyNode::create(
-          nullptr, TransformationMatrix().translate(7, 9), FloatPoint3D());
+      TransformPaintPropertyNode::create(TransformPaintPropertyNode::root(),
+                                         TransformationMatrix().translate(7, 9),
+                                         FloatPoint3D());
   RefPtr<ScrollPaintPropertyNode> scroll = ScrollPaintPropertyNode::create(
-      nullptr, scrollTranslation, IntSize(11, 13), IntSize(27, 31), true,
-      false);
+      ScrollPaintPropertyNode::root(), scrollTranslation, IntSize(11, 13),
+      IntSize(27, 31), true, false);
 
   TestPaintArtifact artifact;
-  artifact.chunk(scrollTranslation, nullptr, nullptr, scroll)
+  artifact
+      .chunk(scrollTranslation, ClipPaintPropertyNode::root(),
+             EffectPaintPropertyNode::root(), scroll)
       .rectDrawing(FloatRect(11, 13, 17, 19), Color::white);
   update(artifact.build());
 
   const cc::ScrollTree& scrollTree = propertyTrees().scroll_tree;
   // Node #0 reserved for null; #1 for root render surface.
   ASSERT_EQ(3u, scrollTree.size());
   const cc::ScrollNode& scrollNode = *scrollTree.Node(2);
   EXPECT_EQ(gfx::Size(11, 13), scrollNode.scroll_clip_layer_bounds);
   EXPECT_EQ(gfx::Size(27, 31), scrollNode.bounds);
   EXPECT_TRUE(scrollNode.user_scrollable_horizontal);
@@ skipping 12 matching lines @@
             scrollNode.main_thread_scrolling_reasons);
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, NestedScrollNodes) {
   RefPtr<EffectPaintPropertyNode> effect = EffectPaintPropertyNode::create(
       EffectPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
       ClipPaintPropertyNode::root(), CompositorFilterOperations(), 0.5);
 
   RefPtr<TransformPaintPropertyNode> scrollTranslationA =
       TransformPaintPropertyNode::create(
-          nullptr, TransformationMatrix().translate(11, 13), FloatPoint3D());
+          TransformPaintPropertyNode::root(),
+          TransformationMatrix().translate(11, 13), FloatPoint3D());
   RefPtr<ScrollPaintPropertyNode> scrollA = ScrollPaintPropertyNode::create(
-      nullptr, scrollTranslationA, IntSize(2, 3), IntSize(5, 7), false, true);
+      ScrollPaintPropertyNode::root(), scrollTranslationA, IntSize(2, 3),
+      IntSize(5, 7), false, true);
   scrollA->addMainThreadScrollingReasons(
       MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
   RefPtr<TransformPaintPropertyNode> scrollTranslationB =
       TransformPaintPropertyNode::create(
           scrollTranslationA, TransformationMatrix().translate(37, 41),
           FloatPoint3D());
   RefPtr<ScrollPaintPropertyNode> scrollB = ScrollPaintPropertyNode::create(
       scrollA, scrollTranslationB, IntSize(19, 23), IntSize(29, 31), true,
       false);
   TestPaintArtifact artifact;
-  artifact.chunk(scrollTranslationA, nullptr, effect, scrollA)
+  artifact
+      .chunk(scrollTranslationA, ClipPaintPropertyNode::root(), effect, scrollA)
       .rectDrawing(FloatRect(7, 11, 13, 17), Color::white);
-  artifact.chunk(scrollTranslationB, nullptr, effect, scrollB)
+  artifact
+      .chunk(scrollTranslationB, ClipPaintPropertyNode::root(), effect, scrollB)
       .rectDrawing(FloatRect(1, 2, 3, 5), Color::white);
   update(artifact.build());
 
   const cc::ScrollTree& scrollTree = propertyTrees().scroll_tree;
   // Node #0 reserved for null; #1 for root render surface.
   ASSERT_EQ(4u, scrollTree.size());
   const cc::ScrollNode& scrollNodeA = *scrollTree.Node(2);
   EXPECT_EQ(gfx::Size(2, 3), scrollNodeA.scroll_clip_layer_bounds);
   EXPECT_EQ(gfx::Size(5, 7), scrollNodeA.bounds);
   EXPECT_FALSE(scrollNodeA.user_scrollable_horizontal);
@@ skipping 20 matching lines @@
             scrollTree.current_scroll_offset(contentLayerAt(1)->id()));
 
   EXPECT_TRUE(scrollNodeA.main_thread_scrolling_reasons &
               MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
   EXPECT_FALSE(scrollNodeB.main_thread_scrolling_reasons &
                MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
 }
 
 }  // namespace
 }  // namespace blink