Move scroll paint property nodes to be owned by the transform tree

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 24 matching lines @@
     EXPECT_FLOAT_EQ((expected).x(), (actual).x());           \
     EXPECT_FLOAT_EQ((expected).y(), (actual).y());           \
     EXPECT_FLOAT_EQ((expected).width(), (actual).width());   \
     EXPECT_FLOAT_EQ((expected).height(), (actual).height()); \
   } while (false)
 
 using ::blink::testing::createOpacityOnlyEffect;
 using ::testing::Pointee;
 
 PaintChunkProperties defaultPaintChunkProperties() {
-  PropertyTreeState propertyTreeState(
-      TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
-      EffectPaintPropertyNode::root(), ScrollPaintPropertyNode::root());
+  PropertyTreeState propertyTreeState(TransformPaintPropertyNode::root(),
+                                      ClipPaintPropertyNode::root(),
+                                      EffectPaintPropertyNode::root());
   return PaintChunkProperties(propertyTreeState);
 }
 
 gfx::Transform translation(SkMScalar x, SkMScalar y) {
   gfx::Transform transform;
   transform.Translate(x, y);
   return transform;
 }
 
 class WebLayerTreeViewWithCompositorFrameSink
@@ skipping 103 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), nullptr, false, 0,
-          CompositingReason3DTransform);
+          FloatPoint3D(100, 100, 0), 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), nullptr, false, 0,
-          CompositingReason3DTransform);
+          FloatPoint3D(10, 10, 0), false, 0, CompositingReason3DTransform);
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(
           transform1, TransformationMatrix().translate(5, 5), FloatPoint3D(),
-          nullptr, false, 0, CompositingReason3DTransform);
+          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(), nullptr, transformIsFlattened);
+            FloatPoint3D(), 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(), nullptr, false, 1,
+                                         FloatPoint3D(), false, 1,
                                          CompositingReason3DTransform);
   // Extends the 3D rendering context of transform2.
   RefPtr<TransformPaintPropertyNode> transform3 =
       TransformPaintPropertyNode::create(transform2, TransformationMatrix(),
-                                         FloatPoint3D(), nullptr, false, 1,
+                                         FloatPoint3D(), false, 1,
                                          CompositingReason3DTransform);
   // Establishes a 3D rendering context distinct from transform2.
   RefPtr<TransformPaintPropertyNode> transform4 =
       TransformPaintPropertyNode::create(transform2, TransformationMatrix(),
-                                         FloatPoint3D(), nullptr, false, 2,
+                                         FloatPoint3D(), 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::createScrollTranslation(
           TransformPaintPropertyNode::root(),
-          TransformationMatrix().translate(7, 9), FloatPoint3D(), scroll.get(),
-          false, 0, CompositingReasonNone, expectedCompositorElementId);
+          TransformationMatrix().translate(7, 9), FloatPoint3D(), false, 0,
+          CompositingReasonNone, expectedCompositorElementId,
+          ScrollPaintPropertyNode::root(), IntSize(11, 13), IntSize(27, 31),
+          true, false, 0 /* mainThreadScrollingReasons */);
 
   TestPaintArtifact artifact;
   artifact
       .chunk(scrollTranslation, ClipPaintPropertyNode::root(),
-             EffectPaintPropertyNode::root(), scroll)
+             EffectPaintPropertyNode::root())
       .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 11 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);
   RefPtr<TransformPaintPropertyNode> scrollTranslationA =
-      TransformPaintPropertyNode::create(
+      TransformPaintPropertyNode::createScrollTranslation(
           TransformPaintPropertyNode::root(),
-          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 */);
+          TransformationMatrix().translate(11, 13), FloatPoint3D(), false, 0,
+          CompositingReasonNone, expectedCompositorElementIdA,
+          ScrollPaintPropertyNode::root(), IntSize(2, 3), IntSize(5, 7), false,
+          true,
+          MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
+
   CompositorElementId expectedCompositorElementIdB = CompositorElementId(3, 0);
   RefPtr<TransformPaintPropertyNode> scrollTranslationB =
-      TransformPaintPropertyNode::create(
+      TransformPaintPropertyNode::createScrollTranslation(
           scrollTranslationA, TransformationMatrix().translate(37, 41),
-          FloatPoint3D(), scrollB.get(), false, 0, CompositingReasonNone,
-          expectedCompositorElementIdB);
+          FloatPoint3D(), false, 0, CompositingReasonNone,
+          expectedCompositorElementIdB, scrollTranslationA->scrollNode(),
+          IntSize(19, 23), IntSize(29, 31), true, false,
+          0 /* mainThreadScrollingReasons */);
   TestPaintArtifact artifact;
-  artifact
-      .chunk(scrollTranslationA, ClipPaintPropertyNode::root(), effect, scrollA)
+  artifact.chunk(scrollTranslationA, ClipPaintPropertyNode::root(), effect)
       .rectDrawing(FloatRect(7, 11, 13, 17), Color::white);
-  artifact
-      .chunk(scrollTranslationB, ClipPaintPropertyNode::root(), effect, scrollB)
+  artifact.chunk(scrollTranslationB, ClipPaintPropertyNode::root(), effect)
       .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);
-  EXPECT_TRUE(scrollNodeA.user_scrollable_vertical);
-  EXPECT_EQ(1, scrollNodeA.parent_id);
-  const cc::ScrollNode& scrollNodeB = *scrollTree.Node(3);
-  EXPECT_EQ(gfx::Size(19, 23), scrollNodeB.scroll_clip_layer_bounds);
-  EXPECT_EQ(gfx::Size(29, 31), scrollNodeB.bounds);
-  EXPECT_TRUE(scrollNodeB.user_scrollable_horizontal);
-  EXPECT_FALSE(scrollNodeB.user_scrollable_vertical);
-  EXPECT_EQ(scrollNodeA.id, scrollNodeB.parent_id);
-  EXPECT_EQ(expectedCompositorElementIdA, scrollNodeA.element_id);
-  EXPECT_EQ(scrollNodeA.id,
+  ASSERT_EQ(3u, scrollTree.size());
+  const cc::ScrollNode& scrollNode = *scrollTree.Node(2);
+  EXPECT_EQ(gfx::Size(2, 3), scrollNode.scroll_clip_layer_bounds);
+  EXPECT_EQ(gfx::Size(5, 7), scrollNode.bounds);
+  EXPECT_FALSE(scrollNode.user_scrollable_horizontal);
+  EXPECT_TRUE(scrollNode.user_scrollable_vertical);
+  EXPECT_EQ(1, scrollNode.parent_id);
+  EXPECT_EQ(expectedCompositorElementIdA, scrollNode.element_id);
+  EXPECT_EQ(scrollNode.id,
             elementIdToScrollNodeIndex(expectedCompositorElementIdA));
-  EXPECT_EQ(expectedCompositorElementIdB, scrollNodeB.element_id);
-  EXPECT_EQ(scrollNodeB.id,
-            elementIdToScrollNodeIndex(expectedCompositorElementIdB));
+
   EXPECT_EQ(expectedCompositorElementIdA, contentLayerAt(0)->element_id());
-  EXPECT_EQ(expectedCompositorElementIdB, contentLayerAt(1)->element_id());
 
   const cc::TransformTree& transformTree = propertyTrees().transform_tree;
   const cc::TransformNode& transformNodeA =
-      *transformTree.Node(scrollNodeA.transform_id);
+      *transformTree.Node(scrollNode.transform_id);
   EXPECT_TRUE(transformNodeA.local.IsIdentity());
   EXPECT_EQ(gfx::ScrollOffset(-11, -13), transformNodeA.scroll_offset);
 
-  const cc::TransformNode& transformNodeB =
-      *transformTree.Node(scrollNodeB.transform_id);
-  EXPECT_EQ(gfx::ScrollOffset(-37, -41), transformNodeB.scroll_offset);
-
-  EXPECT_TRUE(scrollNodeA.main_thread_scrolling_reasons &
+  EXPECT_TRUE(scrollNode.main_thread_scrolling_reasons &
               MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
-  EXPECT_FALSE(scrollNodeB.main_thread_scrolling_reasons &
-               MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, MergeSimpleChunks) {
   TestPaintArtifact testArtifact;
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
              EffectPaintPropertyNode::root())
       .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
   testArtifact
       .chunk(TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
@@ skipping 67 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),
-          nullptr, false, 0);
+          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(), nullptr, false, 0, CompositingReason3DTransform);
+          FloatPoint3D(), false, 0, CompositingReason3DTransform);
 
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(
           transform.get(), TransformationMatrix().translate(50, 50),
-          FloatPoint3D(100, 100, 0), nullptr, false, 0);
+          FloatPoint3D(100, 100, 0), 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), nullptr, false, 0);
+      TransformPaintPropertyNode::create(TransformPaintPropertyNode::root(),
+                                         TransformationMatrix().rotate(45),
+                                         FloatPoint3D(100, 100, 0), 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),
-          nullptr, false, 0);
+          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),
-          nullptr, false, 0);
+          false, 0);
 
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(
           transform.get(), TransformationMatrix().translate(20, 25),
-          FloatPoint3D(100, 100, 0), nullptr, false, 0);
+          FloatPoint3D(100, 100, 0), 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),
-          nullptr, false, 0);
+          false, 0);
 
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(
           transform.get(), TransformationMatrix().translate(20, 25),
-          FloatPoint3D(100, 100, 0), nullptr, false, 0);
+          FloatPoint3D(100, 100, 0), 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),
-          nullptr, false, 0);
+          false, 0);
 
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(
           transform.get(), TransformationMatrix().translate(20, 25),
-          FloatPoint3D(100, 100, 0), nullptr, false, 0);
+          FloatPoint3D(100, 100, 0), 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),
-          nullptr, false, 0);
+          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), nullptr, false, 0);
+          FloatPoint3D(100, 100, 0), 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),
-          nullptr, false, 0, CompositingReason3DTransform);
+          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),
-          nullptr, false);
+          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),
-          nullptr, false);
+          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(),
-      EffectPaintPropertyNode::root(), ScrollPaintPropertyNode::root());
+      EffectPaintPropertyNode::root());
   chunk1.properties.backfaceHidden = true;
   chunk1.knownToBeOpaque = true;
   chunk1.bounds = FloatRect(0, 0, 30, 40);
 
   PaintArtifactCompositor::PendingLayer pendingLayer(chunk1);
 
   EXPECT_TRUE(pendingLayer.backfaceHidden);
   EXPECT_TRUE(pendingLayer.knownToBeOpaque);
   EXPECT_BLINK_FLOAT_RECT_EQ(FloatRect(0, 0, 30, 40), pendingLayer.bounds);
 
@@ skipping 19 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),
-          nullptr, false, 0);
+          false, 0);
 
   PaintChunk chunk1;
   chunk1.properties.propertyTreeState = PropertyTreeState(
       TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
-      EffectPaintPropertyNode::root(), ScrollPaintPropertyNode::root());
+      EffectPaintPropertyNode::root());
   chunk1.bounds = FloatRect(0, 0, 30, 40);
 
   PaintArtifactCompositor::PendingLayer pendingLayer(chunk1);
 
   EXPECT_BLINK_FLOAT_RECT_EQ(FloatRect(0, 0, 30, 40), pendingLayer.bounds);
 
   PaintChunk chunk2;
   chunk2.properties.propertyTreeState = chunk1.properties.propertyTreeState;
   chunk2.properties.propertyTreeState.setTransform(transform);
   chunk2.bounds = FloatRect(0, 0, 50, 60);
   GeometryMapper geometryMapper;
   pendingLayer.add(chunk2, &geometryMapper);
 
   EXPECT_BLINK_FLOAT_RECT_EQ(FloatRect(0, 0, 70, 85), pendingLayer.bounds);
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, PendingLayerKnownOpaque) {
   PaintChunk chunk1;
   chunk1.properties.propertyTreeState = PropertyTreeState(
       TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
-      EffectPaintPropertyNode::root(), ScrollPaintPropertyNode::root());
+      EffectPaintPropertyNode::root());
   chunk1.bounds = FloatRect(0, 0, 30, 40);
   chunk1.knownToBeOpaque = false;
   PaintArtifactCompositor::PendingLayer pendingLayer(chunk1);
 
   EXPECT_FALSE(pendingLayer.knownToBeOpaque);
 
   PaintChunk chunk2;
   chunk2.properties.propertyTreeState = chunk1.properties.propertyTreeState;
   chunk2.bounds = FloatRect(0, 0, 25, 35);
   chunk2.knownToBeOpaque = true;
@@ skipping 10 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), nullptr, false, 0,
-          CompositingReason3DTransform, expectedCompositorElementId);
+          FloatPoint3D(100, 100, 0), 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