WIP: Construct SPV2's scroll paint property 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_output_surface.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/trees/clip_node.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_host.h"
+#include "cc/trees/scroll_node.h"
 #include "cc/trees/transform_node.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/paint/EffectPaintPropertyNode.h"
 #include "platform/graphics/paint/PaintArtifact.h"
+#include "platform/graphics/paint/ScrollPaintPropertyNode.h"
 #include "platform/testing/PictureMatchers.h"
 #include "platform/testing/TestPaintArtifact.h"
 #include "platform/testing/WebLayerTreeViewImplForTesting.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <memory>
 
 namespace blink {
 namespace {
 
@@ skipping 110 matching lines @@
     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, TransformationMatrix().rotate(90), FloatPoint3D(100, 100, 0));
 
     TestPaintArtifact artifact;
-    artifact.chunk(transform, nullptr, dummyRootEffect())
+    artifact.chunk(transform, nullptr, dummyRootEffect(), nullptr)
         .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
-    artifact.chunk(nullptr, nullptr, dummyRootEffect())
+    artifact.chunk(nullptr, nullptr, dummyRootEffect(), nullptr)
         .rectDrawing(FloatRect(0, 0, 100, 100), Color::gray);
-    artifact.chunk(transform, nullptr, dummyRootEffect())
+    artifact.chunk(transform, nullptr, dummyRootEffect(), nullptr)
         .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);
         layer->screen_space_transform().TransformRect(&mappedRect);
@@ skipping 17 matching lines @@
 
 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));
     RefPtr<TransformPaintPropertyNode> transform2 = TransformPaintPropertyNode::create(
         transform1, TransformationMatrix().translate(5, 5), FloatPoint3D());
 
     TestPaintArtifact artifact;
-    artifact.chunk(transform1, nullptr, dummyRootEffect())
+    artifact.chunk(transform1, nullptr, dummyRootEffect(), nullptr)
         .rectDrawing(FloatRect(0, 0, 300, 200), Color::white);
-    artifact.chunk(transform2, nullptr, dummyRootEffect())
+    artifact.chunk(transform2, nullptr, dummyRootEffect(), nullptr)
         .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);
         layer->screen_space_transform().TransformRect(&mappedRect);
@@ skipping 23 matching lines @@
         // is flattened, while cc's notion applies in the parent's coordinate space.
         RefPtr<TransformPaintPropertyNode> transform1 = TransformPaintPropertyNode::create(
             nullptr, 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, nullptr, nullptr, nullptr)
             .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
         // if and only if the intermediate rotation transform in the Blink tree
@@ skipping 25 matching lines @@
     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, dummyRootEffect())
+    artifact.chunk(transform1, nullptr, dummyRootEffect(), nullptr)
         .rectDrawing(FloatRect(0, 0, 300, 200), Color::white);
-    artifact.chunk(transform2, nullptr, dummyRootEffect())
+    artifact.chunk(transform2, nullptr, dummyRootEffect(), nullptr)
         .rectDrawing(FloatRect(0, 0, 300, 200), Color::lightGray);
-    artifact.chunk(transform3, nullptr, dummyRootEffect())
+    artifact.chunk(transform3, nullptr, dummyRootEffect(), nullptr)
         .rectDrawing(FloatRect(0, 0, 300, 200), Color::darkGray);
-    artifact.chunk(transform4, nullptr, dummyRootEffect())
+    artifact.chunk(transform4, nullptr, dummyRootEffect(), nullptr)
         .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 28 matching lines @@
     EXPECT_NE(0, blackSortingContextId);
     EXPECT_NE(lightGraySortingContextId, blackSortingContextId);
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, OneClip)
 {
     RefPtr<ClipPaintPropertyNode> clip = ClipPaintPropertyNode::create(
         nullptr, nullptr, FloatRoundedRect(100, 100, 300, 200));
 
     TestPaintArtifact artifact;
-    artifact.chunk(nullptr, clip, nullptr)
+    artifact.chunk(nullptr, clip, nullptr, 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, nullptr, FloatRoundedRect(100, 100, 700, 700));
     RefPtr<ClipPaintPropertyNode> clip2 = ClipPaintPropertyNode::create(
         clip1, nullptr, FloatRoundedRect(200, 200, 700, 100));
 
     TestPaintArtifact artifact;
-    artifact.chunk(nullptr, clip1, dummyRootEffect())
+    artifact.chunk(nullptr, clip1, dummyRootEffect(), nullptr)
         .rectDrawing(FloatRect(300, 350, 100, 100), Color::white);
-    artifact.chunk(nullptr, clip2, dummyRootEffect())
+    artifact.chunk(nullptr, clip2, dummyRootEffect(), nullptr)
         .rectDrawing(FloatRect(300, 350, 100, 100), Color::lightGray);
-    artifact.chunk(nullptr, clip1, dummyRootEffect())
+    artifact.chunk(nullptr, clip1, dummyRootEffect(), nullptr)
         .rectDrawing(FloatRect(300, 350, 100, 100), Color::darkGray);
-    artifact.chunk(nullptr, clip2, dummyRootEffect())
+    artifact.chunk(nullptr, clip2, dummyRootEffect(), nullptr)
         .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 29 matching lines @@
 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, FloatRoundedRect(5 * i, 0, 100, 200 - 10 * i)));
     }
 
     TestPaintArtifact artifact;
-    artifact.chunk(nullptr, clips.last(), dummyRootEffect())
+    artifact.chunk(nullptr, clips.last(), dummyRootEffect(), nullptr)
         .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());
 
@@ skipping 11 matching lines @@
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, SiblingClips)
 {
     RefPtr<ClipPaintPropertyNode> commonClip = ClipPaintPropertyNode::create(
         nullptr, nullptr, FloatRoundedRect(0, 0, 800, 600));
     RefPtr<ClipPaintPropertyNode> clip1 = ClipPaintPropertyNode::create(
         commonClip, nullptr, FloatRoundedRect(0, 0, 400, 600));
     RefPtr<ClipPaintPropertyNode> clip2 = ClipPaintPropertyNode::create(
         commonClip, nullptr, FloatRoundedRect(400, 0, 400, 600));
 
     TestPaintArtifact artifact;
-    artifact.chunk(nullptr, clip1, dummyRootEffect())
+    artifact.chunk(nullptr, clip1, dummyRootEffect(), nullptr)
         .rectDrawing(FloatRect(0, 0, 640, 480), Color::white);
-    artifact.chunk(nullptr, clip2, dummyRootEffect())
+    artifact.chunk(nullptr, clip2, dummyRootEffect(), nullptr)
         .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 = propertyTrees().clip_tree.Node(whiteLayer->clip_tree_index());
@@ skipping 32 matching lines @@
     EXPECT_EQ(translation(50, 100), layer->screen_space_transform());
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, EffectTreeConversion)
 {
     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())
+    artifact.chunk(nullptr, nullptr, effect2.get(), nullptr)
         .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
-    artifact.chunk(nullptr, nullptr, effect1.get())
+    artifact.chunk(nullptr, nullptr, effect1.get(), nullptr)
         .rectDrawing(FloatRect(0, 0, 100, 100), Color::white);
-    artifact.chunk(nullptr, nullptr, effect3.get())
+    artifact.chunk(nullptr, nullptr, effect3.get(), nullptr)
         .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 dummyRootEffect,
     // plus 3 nodes for those created by this test.
     ASSERT_EQ(6u, effectTree.size());
 
@@ skipping 10 matching lines @@
 
     const cc::EffectNode& convertedEffect3 = *effectTree.Node(5);
     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());
 }
 
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees, OneScrollNode)
+{
+    RefPtr<TransformPaintPropertyNode> scrollTranslation = TransformPaintPropertyNode::create(
+        nullptr, TransformationMatrix().translate(7, 9), FloatPoint3D());
+    RefPtr<ScrollPaintPropertyNode> scroll = ScrollPaintPropertyNode::create(
+        nullptr, scrollTranslation, FloatSize(), FloatSize(), true, true);
+
+    TestPaintArtifact artifact;
+    artifact.chunk(scrollTranslation, nullptr, nullptr, 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(1, scrollNode.parent_id);
+
+    const cc::TransformTree& transformTree = propertyTrees().transform_tree;
+    const cc::TransformNode& transformNode = *transformTree.Node(scrollNode.transform_id);
+    // TransformNode no longer contain the scroll translation as a transform but instead as a scroll offset.
+    EXPECT_TRUE(transformNode.local.IsIdentity());
+    EXPECT_EQ(gfx::ScrollOffset(7, -9), transformNode.scroll_offset);
+}
+
 } // namespace
 } // namespace blink