DisplayItemPropertyTreeBuilder: Support (2D) transform and scroll display items.

Source/platform/graphics/paint/DisplayItemPropertyTreeBuilderTest.cpp

 // Copyright 2015 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 "config.h"
 #include "platform/graphics/paint/DisplayItemPropertyTreeBuilder.h"
 
 #include "platform/graphics/paint/DisplayItem.h"
 #include "platform/graphics/paint/DisplayItemClient.h"
 #include "platform/graphics/paint/DisplayItemClipTree.h"
 #include "platform/graphics/paint/DisplayItemTransformTree.h"
+#include "platform/graphics/paint/ScrollDisplayItem.h"
 #include "platform/graphics/paint/Transform3DDisplayItem.h"
+#include "platform/graphics/paint/TransformDisplayItem.h"
 #include "platform/transforms/TransformTestHelper.h"
 #include "platform/transforms/TransformationMatrix.h"
 #include "public/platform/WebDisplayItemTransformTree.h"
 #include "wtf/OwnPtr.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 namespace blink {
 namespace {
 
@@ skipping 42 matching lines @@
     const DummyClient& processBeginTransform3D(const TransformationMatrix& transform)
     {
         const DummyClient& client = newDummyClient();
         processDisplayItem(BeginTransform3DDisplayItem(client, DisplayItem::Transform3DElementTransform, transform));
         return client;
     }
     void processEndTransform3D(const DummyClient& client)
     {
         processDisplayItem(EndTransform3DDisplayItem(client, DisplayItem::transform3DTypeToEndTransform3DType(DisplayItem::Transform3DElementTransform)));
     }
+    const DummyClient& processBeginTransform(const AffineTransform& transform)
+    {
+        const DummyClient& client = newDummyClient();
+        processDisplayItem(BeginTransformDisplayItem(client, transform));
+        return client;
+    }
+    void processEndTransform(const DummyClient& client)
+    {
+        processDisplayItem(EndTransformDisplayItem(client));
+    }
+    const DummyClient& processBeginScroll(int offsetX, int offsetY)
+    {
+        const DummyClient& client = newDummyClient();
+        processDisplayItem(BeginScrollDisplayItem(client, DisplayItem::ScrollFirst, IntSize(offsetX, offsetY)));
+        return client;
+    }
+    void processEndScroll(const DummyClient& client)
+    {
+        processDisplayItem(EndScrollDisplayItem(client, DisplayItem::EndScrollFirst));
+    }
 
     void finishPropertyTrees()
     {
         m_transformTree = m_builder.releaseTransformTree();
         m_clipTree = m_builder.releaseClipTree();
         m_rangeRecords = m_builder.releaseRangeRecords();
     }
 
 private:
     // This makes empty objects which can be used as display item clients.
@@ skipping 227 matching lines @@
     processEndTransform3D(transform1);
     finishPropertyTrees();
 
     const auto& transformNode = transformTree().nodeAt(rangeRecords()[0].transformNodeIndex);
     ASSERT_FALSE(transformNode.isRoot());
     EXPECT_TRANSFORMS_ALMOST_EQ(matrix2, transformNode.matrix);
     const auto& parentNode = transformTree().nodeAt(transformNode.parentNodeIndex);
     EXPECT_TRANSFORMS_ALMOST_EQ(matrix1, parentNode.matrix);
 }
 
+TEST_F(DisplayItemPropertyTreeBuilderTest, TransformDisplayItemCreatesTransformNode)
+{
+    // 2D transform display items should create a transform node as well,
+    // unless the transform is a 2D translation only.
+    AffineTransform rotation;
+    rotation.rotate(45);
+
+    processDummyDisplayItem();
+    auto transformClient = processBeginTransform(rotation);
+    processDummyDisplayItem();
+    processEndTransform(transformClient);
+    processDummyDisplayItem();
+    finishPropertyTrees();
+
+    // There should be two transform nodes.
+    ASSERT_EQ(2u, transformTree().nodeCount());
+    EXPECT_TRUE(transformTree().nodeAt(0).isRoot());
+    EXPECT_EQ(0u, transformTree().nodeAt(1).parentNodeIndex);
+    EXPECT_TRANSFORMS_ALMOST_EQ(TransformationMatrix(rotation), transformTree().nodeAt(1).matrix);
+
+    // There should be three range records, the middle one affected by the
+    // rotation.
+    EXPECT_THAT(rangeRecordsAsStdVector(), ElementsAre(
+        AllOf(hasRange(0, 1), hasTransformNode(0)),
+        AllOf(hasRange(2, 3), hasTransformNode(1)),
+        AllOf(hasRange(4, 5), hasTransformNode(0))));
+}
+
+TEST_F(DisplayItemPropertyTreeBuilderTest, TransformDisplayItemOnly2DTranslation)
+{
+    // In this case no transform node should be created for the 2D translation.
+    AffineTransform translation = AffineTransform::translation(10, -40);
+
+    processDummyDisplayItem();
+    auto transformClient = processBeginTransform(translation);
+    processDummyDisplayItem();
+    processEndTransform(transformClient);
+    processDummyDisplayItem();
+    finishPropertyTrees();
+
+    // There should be only one transform node.
+    ASSERT_EQ(1u, transformTree().nodeCount());
+    EXPECT_TRUE(transformTree().nodeAt(0).isRoot());
+
+    // There should be three range records, the middle one affected by the
+    // translation.
+    EXPECT_THAT(rangeRecordsAsStdVector(), ElementsAre(
+        AllOf(hasRange(0, 1), hasTransformNode(0), hasOffset(FloatSize(0, 0))),
+        AllOf(hasRange(2, 3), hasTransformNode(0), hasOffset(FloatSize(10, -40))),
+        AllOf(hasRange(4, 5), hasTransformNode(0), hasOffset(FloatSize(0, 0)))));
+}
+
+TEST_F(DisplayItemPropertyTreeBuilderTest, ScrollDisplayItemIs2DTranslation)
+{
+    processDummyDisplayItem();
+    auto scrollClient = processBeginScroll(-90, 400);
+    processDummyDisplayItem();
+    processEndScroll(scrollClient);
+    processDummyDisplayItem();
+    finishPropertyTrees();
+
+    // There should be only one transform node.
+    ASSERT_EQ(1u, transformTree().nodeCount());
+    EXPECT_TRUE(transformTree().nodeAt(0).isRoot());
+
+    // There should be three range records, the middle one affected by the
+    // scroll. Note that the translation due to scroll is the negative of the
+    // scroll offset.
+    EXPECT_THAT(rangeRecordsAsStdVector(), ElementsAre(
+        AllOf(hasRange(0, 1), hasTransformNode(0), hasOffset(FloatSize(0, 0))),
+        AllOf(hasRange(2, 3), hasTransformNode(0), hasOffset(FloatSize(90, -400))),
+        AllOf(hasRange(4, 5), hasTransformNode(0), hasOffset(FloatSize(0, 0)))));
+}
+
 } // namespace
 } // namespace blink