Make scroll translation transform nodes reference scroll nodes

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 154 matching lines @@
               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(
           TransformPaintPropertyNode::root(), TransformationMatrix().rotate(90),
-          FloatPoint3D(100, 100, 0), false, 0, CompositingReason3DTransform);
+          FloatPoint3D(100, 100, 0), nullptr, false, 0,
+          CompositingReason3DTransform);
 
   TestPaintArtifact artifact;
   artifact
       .chunk(transform, ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   artifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::gray);
@@ skipping 25 matching lines @@
         Pointee(drawsRectangle(FloatRect(0, 0, 100, 100), Color::gray)));
     EXPECT_EQ(gfx::Transform(), layer->screen_space_transform());
   }
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, TransformCombining) {
   // A translation by (5, 5) within a 2x scale about (10, 10).
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(), TransformationMatrix().scale(2),
-          FloatPoint3D(10, 10, 0), false, 0, CompositingReason3DTransform);
+          FloatPoint3D(10, 10, 0), nullptr, false, 0,
+          CompositingReason3DTransform);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(
           transform1, TransformationMatrix().translate(5, 5), FloatPoint3D(),
-          false, 0, CompositingReason3DTransform);
+          nullptr, false, 0, CompositingReason3DTransform);
 
   TestPaintArtifact artifact;
   artifact
       .chunk(transform1, ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 300, 200), Color::white);
   artifact
       .chunk(transform2, ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 300, 200), Color::black);
@@ skipping 35 matching lines @@
         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);
+            FloatPoint3D(), nullptr, transformIsFlattened);
 
     TestPaintArtifact artifact;
     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);
@@ skipping 26 matching lines @@
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, SortingContextID) {
   // Has no 3D rendering context.
   RefPtr<TransformPaintPropertyNode> transform1 =
       TransformPaintPropertyNode::create(TransformPaintPropertyNode::root(),
                                          TransformationMatrix(),
                                          FloatPoint3D());
   // Establishes a 3D rendering context.
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(transform1, TransformationMatrix(),
-                                         FloatPoint3D(), false, 1,
+                                         FloatPoint3D(), nullptr, false, 1,
                                          CompositingReason3DTransform);
   // Extends the 3D rendering context of transform2.
   RefPtr<TransformPaintPropertyNode> transform3 =
       TransformPaintPropertyNode::create(transform2, TransformationMatrix(),
-                                         FloatPoint3D(), false, 1,
+                                         FloatPoint3D(), nullptr, false, 1,
                                          CompositingReason3DTransform);
   // Establishes a 3D rendering context distinct from transform2.
   RefPtr<TransformPaintPropertyNode> transform4 =
       TransformPaintPropertyNode::create(transform2, TransformationMatrix(),
-                                         FloatPoint3D(), false, 2,
+                                         FloatPoint3D(), nullptr, false, 2,
                                          CompositingReason3DTransform);
 
   TestPaintArtifact artifact;
   artifact
       .chunk(transform1, ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 300, 200), Color::white);
   artifact
       .chunk(transform2, ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
@@ skipping 313 matching lines @@
   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<ScrollPaintPropertyNode> scroll = ScrollPaintPropertyNode::create(
+      ScrollPaintPropertyNode::root(), IntSize(11, 13), IntSize(27, 31), true,
+      false, 0 /* mainThreadScrollingReasons */);
+  CompositorElementId expectedCompositorElementId = CompositorElementId(2, 0);
   RefPtr<TransformPaintPropertyNode> scrollTranslation =
-      TransformPaintPropertyNode::create(TransformPaintPropertyNode::root(),
-                                         TransformationMatrix().translate(7, 9),
-                                         FloatPoint3D());
-  CompositorElementId expectedCompositorElementId = CompositorElementId(2, 0);
-  RefPtr<ScrollPaintPropertyNode> scroll = ScrollPaintPropertyNode::create(
-      ScrollPaintPropertyNode::root(), scrollTranslation, IntSize(11, 13),
-      IntSize(27, 31), true, false, 0 /* mainThreadScrollingReasons */,
-      expectedCompositorElementId);
+      TransformPaintPropertyNode::create(
+          TransformPaintPropertyNode::root(),
+          TransformationMatrix().translate(7, 9), FloatPoint3D(), scroll.get(),
+          false, 0, CompositingReasonNone, expectedCompositorElementId);
 
   TestPaintArtifact artifact;
   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.
@@ skipping 16 matching lines @@
   EXPECT_EQ(gfx::ScrollOffset(-7, -9), transformNode.scroll_offset);
 
   EXPECT_EQ(MainThreadScrollingReason::kNotScrollingOnMain,
             scrollNode.main_thread_scrolling_reasons);
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, NestedScrollNodes) {
   RefPtr<EffectPaintPropertyNode> effect =
       createOpacityOnlyEffect(EffectPaintPropertyNode::root(), 0.5);
 
+  RefPtr<ScrollPaintPropertyNode> scrollA = ScrollPaintPropertyNode::create(
+      ScrollPaintPropertyNode::root(), IntSize(2, 3), IntSize(5, 7), false,
+      true, MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
   CompositorElementId expectedCompositorElementIdA = CompositorElementId(2, 0);
-  CompositorElementId expectedCompositorElementIdB = CompositorElementId(3, 0);
   RefPtr<TransformPaintPropertyNode> scrollTranslationA =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(),
-          TransformationMatrix().translate(11, 13), FloatPoint3D());
-  RefPtr<ScrollPaintPropertyNode> scrollA = ScrollPaintPropertyNode::create(
-      ScrollPaintPropertyNode::root(), scrollTranslationA, IntSize(2, 3),
-      IntSize(5, 7), false, true,
-      MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects,
-      expectedCompositorElementIdA);
+          TransformationMatrix().translate(11, 13), FloatPoint3D(),
+          scrollA.get(), false, 0, CompositingReasonNone,
+          expectedCompositorElementIdA);
+  RefPtr<ScrollPaintPropertyNode> scrollB = ScrollPaintPropertyNode::create(
+      scrollA, IntSize(19, 23), IntSize(29, 31), true, false,
+      0 /* mainThreadScrollingReasons */);
+  CompositorElementId expectedCompositorElementIdB = CompositorElementId(3, 0);
   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, 0 /* mainThreadScrollingReasons */, expectedCompositorElementIdB);
+          FloatPoint3D(), scrollB.get(), false, 0, CompositingReasonNone,
+          expectedCompositorElementIdB);
   TestPaintArtifact artifact;
   artifact
       .chunk(scrollTranslationA, ClipPaintPropertyNode::root(), effect, scrollA)
       .rectDrawing(FloatRect(7, 11, 13, 17), Color::white);
   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;
@@ skipping 114 matching lines @@
     const cc::Layer* layer = contentLayerAt(0);
     EXPECT_THAT(layer->GetPicture(), Pointee(drawsRectangles(rectsWithColor)));
   }
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, Merge2DTransform) {
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(),
           TransformationMatrix().translate(50, 50), FloatPoint3D(100, 100, 0),
-          false, 0);
+          nullptr, false, 0);
 
   TestPaintArtifact testArtifact;
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   testArtifact
       .chunk(transform.get(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::black);
@@ skipping 28 matching lines @@
     const cc::Layer* layer = contentLayerAt(0);
     EXPECT_THAT(layer->GetPicture(), Pointee(drawsRectangles(rectsWithColor)));
   }
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
        Merge2DTransformDirectAncestor) {
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(), TransformationMatrix(),
-          FloatPoint3D(), false, 0, CompositingReason3DTransform);
+          FloatPoint3D(), nullptr, false, 0, CompositingReason3DTransform);
 
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(
           transform.get(), TransformationMatrix().translate(50, 50),
-          FloatPoint3D(100, 100, 0), false, 0);
+          FloatPoint3D(100, 100, 0), nullptr, false, 0);
 
   TestPaintArtifact testArtifact;
   testArtifact
       .chunk(transform.get(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   // The second chunk can merge into the first because it has a descendant
   // state of the first's transform and no direct compositing reason.
   testArtifact
       .chunk(transform2.get(), ClipPaintPropertyNode::root(),
@@ skipping 18 matching lines @@
     rectsWithColor.push_back(
         RectWithColor(FloatRect(50, 50, 100, 100), Color::black));
 
     const cc::Layer* layer = contentLayerAt(0);
     EXPECT_THAT(layer->GetPicture(), Pointee(drawsRectangles(rectsWithColor)));
   }
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, MergeTransformOrigin) {
   RefPtr<TransformPaintPropertyNode> transform =
-      TransformPaintPropertyNode::create(TransformPaintPropertyNode::root(),
-                                         TransformationMatrix().rotate(45),
-                                         FloatPoint3D(100, 100, 0), false, 0);
+      TransformPaintPropertyNode::create(
+          TransformPaintPropertyNode::root(), TransformationMatrix().rotate(45),
+          FloatPoint3D(100, 100, 0), nullptr, false, 0);
 
   TestPaintArtifact testArtifact;
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   testArtifact
       .chunk(transform.get(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::black);
@@ skipping 80 matching lines @@
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, MergeNested) {
   // Tests merging of an opacity effect, inside of a clip, inside of a
   // transform.
 
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(),
           TransformationMatrix().translate(50, 50), FloatPoint3D(100, 100, 0),
-          false, 0);
+          nullptr, false, 0);
 
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
       ClipPaintPropertyNode::root(), transform.get(),
       FloatRoundedRect(10, 20, 50, 60));
 
   float opacity = 2.0 / 255.0;
   RefPtr<EffectPaintPropertyNode> effect = EffectPaintPropertyNode::create(
       EffectPaintPropertyNode::root(), transform.get(), clip.get(),
       CompositorFilterOperations(), opacity, SkBlendMode::kSrcOver);
 
@@ skipping 39 matching lines @@
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, ClipPushedUp) {
   // Tests merging of an element which has a clipapplied to it,
   // but has an ancestor transform of them. This can happen for fixed-
   // or absolute-position elements which escape scroll transforms.
 
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(),
           TransformationMatrix().translate(20, 25), FloatPoint3D(100, 100, 0),
-          false, 0);
+          nullptr, false, 0);
 
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(
           transform.get(), TransformationMatrix().translate(20, 25),
-          FloatPoint3D(100, 100, 0), false, 0);
+          FloatPoint3D(100, 100, 0), nullptr, false, 0);
 
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
       ClipPaintPropertyNode::root(), transform2.get(),
       FloatRoundedRect(10, 20, 50, 60));
 
   TestPaintArtifact testArtifact;
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
@@ skipping 36 matching lines @@
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, EffectPushedUp) {
   // Tests merging of an element which has an effect applied to it,
   // but has an ancestor transform of them. This can happen for fixed-
   // or absolute-position elements which escape scroll transforms.
 
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(),
           TransformationMatrix().translate(20, 25), FloatPoint3D(100, 100, 0),
-          false, 0);
+          nullptr, false, 0);
 
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(
           transform.get(), TransformationMatrix().translate(20, 25),
-          FloatPoint3D(100, 100, 0), false, 0);
+          FloatPoint3D(100, 100, 0), nullptr, false, 0);
 
   float opacity = 2.0 / 255.0;
   RefPtr<EffectPaintPropertyNode> effect = EffectPaintPropertyNode::create(
       EffectPaintPropertyNode::root(), transform2.get(),
       ClipPaintPropertyNode::root(), CompositorFilterOperations(), opacity,
       SkBlendMode::kSrcOver);
 
   TestPaintArtifact testArtifact;
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
@@ skipping 37 matching lines @@
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, EffectAndClipPushedUp) {
   // Tests merging of an element which has an effect applied to it,
   // but has an ancestor transform of them. This can happen for fixed-
   // or absolute-position elements which escape scroll transforms.
 
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(),
           TransformationMatrix().translate(20, 25), FloatPoint3D(100, 100, 0),
-          false, 0);
+          nullptr, false, 0);
 
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(
           transform.get(), TransformationMatrix().translate(20, 25),
-          FloatPoint3D(100, 100, 0), false, 0);
+          FloatPoint3D(100, 100, 0), nullptr, false, 0);
 
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
       ClipPaintPropertyNode::root(), transform.get(),
       FloatRoundedRect(10, 20, 50, 60));
 
   float opacity = 2.0 / 255.0;
   RefPtr<EffectPaintPropertyNode> effect = EffectPaintPropertyNode::create(
       EffectPaintPropertyNode::root(), transform2.get(), clip.get(),
       CompositorFilterOperations(), opacity, SkBlendMode::kSrcOver);
 
@@ skipping 143 matching lines @@
     const cc::Layer* layer = contentLayerAt(0);
     EXPECT_THAT(layer->GetPicture(), Pointee(drawsRectangles(rectsWithColor)));
   }
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, TwoTransformsClipBetween) {
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(),
           TransformationMatrix().translate(20, 25), FloatPoint3D(100, 100, 0),
-          false, 0);
+          nullptr, false, 0);
   RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
       ClipPaintPropertyNode::root(), TransformPaintPropertyNode::root(),
       FloatRoundedRect(0, 0, 50, 60));
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(
           transform.get(), TransformationMatrix().translate(20, 25),
-          FloatPoint3D(100, 100, 0), false, 0);
+          FloatPoint3D(100, 100, 0), nullptr, false, 0);
   TestPaintArtifact testArtifact;
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   testArtifact
       .chunk(transform2.get(), clip.get(), EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 300, 400), Color::black);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
@@ skipping 20 matching lines @@
     const cc::Layer* layer = contentLayerAt(0);
     EXPECT_THAT(layer->GetPicture(), Pointee(drawsRectangles(rectsWithColor)));
   }
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, OverlapTransform) {
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(),
           TransformationMatrix().translate(50, 50), FloatPoint3D(100, 100, 0),
-          false, 0, CompositingReason3DTransform);
+          nullptr, false, 0, CompositingReason3DTransform);
 
   TestPaintArtifact testArtifact;
   testArtifact.chunk(defaultPaintChunkProperties())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   testArtifact
       .chunk(transform.get(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::black);
   testArtifact.chunk(defaultPaintChunkProperties())
       .rectDrawing(FloatRect(0, 0, 200, 300), Color::gray);
@@ skipping 34 matching lines @@
 
   GeometryMapper geometryMapper;
   PaintArtifactCompositor::PendingLayer pendingLayer(paintChunk);
   EXPECT_TRUE(PaintArtifactCompositor::mightOverlap(paintChunk2, pendingLayer,
                                                     geometryMapper));
 
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(),
           TransformationMatrix().translate(99, 0), FloatPoint3D(100, 100, 0),
-          false);
+          nullptr, false);
 
   paintChunk2.properties.propertyTreeState.setTransform(transform.get());
   EXPECT_TRUE(PaintArtifactCompositor::mightOverlap(paintChunk2, pendingLayer,
                                                     geometryMapper));
 
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(),
           TransformationMatrix().translate(100, 0), FloatPoint3D(100, 100, 0),
-          false);
+          nullptr, false);
   paintChunk2.properties.propertyTreeState.setTransform(transform2.get());
 
   EXPECT_FALSE(PaintArtifactCompositor::mightOverlap(paintChunk2, pendingLayer,
                                                      geometryMapper));
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, PendingLayer) {
   PaintChunk chunk1;
   chunk1.properties.propertyTreeState = PropertyTreeState(
       TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
@@ skipping 30 matching lines @@
   EXPECT_TRUE(pendingLayer.backfaceHidden);
   EXPECT_FALSE(pendingLayer.knownToBeOpaque);
   EXPECT_BLINK_FLOAT_RECT_EQ(FloatRect(-5, -25, 45, 85), pendingLayer.bounds);
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, PendingLayerWithGeometry) {
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(),
           TransformationMatrix().translate(20, 25), FloatPoint3D(100, 100, 0),
-          false, 0);
+          nullptr, false, 0);
 
   PaintChunk chunk1;
   chunk1.properties.propertyTreeState = PropertyTreeState(
       TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
       EffectPaintPropertyNode::root(), ScrollPaintPropertyNode::root());
   chunk1.bounds = FloatRect(0, 0, 30, 40);
 
   PaintArtifactCompositor::PendingLayer pendingLayer(chunk1);
 
   EXPECT_BLINK_FLOAT_RECT_EQ(FloatRect(0, 0, 30, 40), pendingLayer.bounds);
@@ skipping 36 matching lines @@
 
   // Chunk 3 covers the entire layer, so now it's opaque.
   EXPECT_TRUE(pendingLayer.knownToBeOpaque);
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, TransformWithElementId) {
   CompositorElementId expectedCompositorElementId(2, 0);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(), TransformationMatrix().rotate(90),
-          FloatPoint3D(100, 100, 0), false, 0, CompositingReason3DTransform,
-          expectedCompositorElementId);
+          FloatPoint3D(100, 100, 0), nullptr, false, 0,
+          CompositingReason3DTransform, expectedCompositorElementId);
 
   TestPaintArtifact artifact;
   artifact
       .chunk(transform, ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(100, 100, 200, 100), Color::black);
   update(artifact.build());
 
   EXPECT_EQ(2, elementIdToTransformNodeIndex(expectedCompositorElementId));
 }
@@ skipping 11 matching lines @@
   artifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              effect.get())
       .rectDrawing(FloatRect(100, 100, 200, 100), Color::black);
   update(artifact.build());
 
   EXPECT_EQ(2, elementIdToEffectNodeIndex(expectedCompositorElementId));
 }
 
 }  // namespace blink