[SPv2] Respect transform-style in the Blink and cc property trees.

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/layer_tree_host.h"
 #include "cc/trees/layer_tree_settings.h"
+#include "cc/trees/transform_node.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/paint/PaintArtifact.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 "wtf/PtrUtil.h"
 #include <memory>
 
@@ skipping 377 matching lines @@
         settings.use_layer_lists = true;
         m_webLayerTreeView = wrapUnique(new WebLayerTreeViewWithOutputSurface(settings));
         m_webLayerTreeView->setRootLayer(*getPaintArtifactCompositor().getWebLayer());
     }
 
     const cc::PropertyTrees& propertyTrees()
     {
         return *m_webLayerTreeView->layerTreeHost()->property_trees();
     }
 
+    const cc::TransformNode& transformNode(const cc::Layer* layer)
+    {
+        return *propertyTrees().transform_tree.Node(layer->transform_tree_index());
+    }
+
     void update(const PaintArtifact& artifact)
     {
         PaintArtifactCompositorTest::update(artifact);
         m_webLayerTreeView->layerTreeHost()->LayoutAndUpdateLayers();
     }
 
 private:
     scoped_refptr<base::TestSimpleTaskRunner> m_taskRunner;
     base::ThreadTaskRunnerHandle m_taskRunnerHandle;
     std::unique_ptr<WebLayerTreeViewWithOutputSurface> m_webLayerTreeView;
@@ skipping 91 matching lines @@
             Pointee(drawsRectangle(FloatRect(0, 0, 300, 200), Color::black)));
         gfx::RectF mappedRect(0, 0, 300, 200);
         layer->screen_space_transform().TransformRect(&mappedRect);
         EXPECT_EQ(gfx::RectF(0, 0, 600, 400), mappedRect);
     }
     EXPECT_NE(
         contentLayerAt(0)->transform_tree_index(),
         contentLayerAt(1)->transform_tree_index());
 }
 
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees, FlattensInheritedTransform)
+{
+    for (auto transformStyle : { TransformPaintPropertyNode::FlattenTransform, TransformPaintPropertyNode::Preserve3D }) {
+        SCOPED_TRACE(transformStyle);
+
+        // 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(
+            TransformationMatrix(), FloatPoint3D(), nullptr,
+            TransformPaintPropertyNode::DontEstablishNewRenderingContext, nullptr,
+            TransformPaintPropertyNode::FlattenTransform);
+        RefPtr<TransformPaintPropertyNode> transform2 = TransformPaintPropertyNode::create(
+            TransformationMatrix().rotate3d(0, 45, 0), FloatPoint3D(), transform1,
+            transformStyle == TransformPaintPropertyNode::Preserve3D
+                ? TransformPaintPropertyNode::EstablishNewRenderingContext
+                : TransformPaintPropertyNode::DontEstablishNewRenderingContext,
+            nullptr, transformStyle);
+        RefPtr<TransformPaintPropertyNode> transform3 = TransformPaintPropertyNode::create(
+            TransformationMatrix().rotate3d(0, 45, 0), FloatPoint3D(), transform2,
+            TransformPaintPropertyNode::DontEstablishNewRenderingContext, nullptr,
+            TransformPaintPropertyNode::FlattenTransform);
+
+        TestPaintArtifact artifact;
+        artifact.chunk(transform3, 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
+        // flattens.
+        const cc::TransformNode* transformNode3 = propertyTrees().transform_tree.Node(layer->transform_tree_index());
+        EXPECT_EQ(transform2->flattensTransform(), transformNode3->flattens_inherited_transform);
+
+        // Whereas its ancestors always flatten.
+        const cc::TransformNode* transformNode2 = propertyTrees().transform_tree.parent(transformNode3);
+        EXPECT_TRUE(transformNode2->flattens_inherited_transform);
+        const cc::TransformNode* transformNode1 = propertyTrees().transform_tree.parent(transformNode2);
+        EXPECT_TRUE(transformNode1->flattens_inherited_transform);
+
+        // Given this, we should expect the correct screen space transform for
+        // each case. If the transform was flattened, we should see it getting
+        // an effective horizontal scale of 1/sqrt(2) each time, thus it gets
+        // half as wide. If the transform was not flattened, we should see an
+        // empty rectangle (as the total 90 degree rotation makes it
+        // perpendicular to the viewport).
+        gfx::RectF rect(0, 0, 100, 100);
+        layer->screen_space_transform().TransformRect(&rect);
+        switch (transformStyle) {
+        case TransformPaintPropertyNode::FlattenTransform:
+            EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 50, 100), rect);
+            break;
+        case TransformPaintPropertyNode::Preserve3D:
+            EXPECT_TRUE(rect.IsEmpty());
+            break;
+        }
+    }
+}
+
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees, SortingContextID)
+{
+    // Has no 3D rendering context.
+    RefPtr<TransformPaintPropertyNode> transform1 = TransformPaintPropertyNode::create(
+        TransformationMatrix(), FloatPoint3D(), nullptr,
+        TransformPaintPropertyNode::DontEstablishNewRenderingContext, nullptr,
+        TransformPaintPropertyNode::FlattenTransform);
+    // Establishes a 3D rendering context.
+    RefPtr<TransformPaintPropertyNode> transform2 = TransformPaintPropertyNode::create(
+        TransformationMatrix(), FloatPoint3D(), transform1,
+        TransformPaintPropertyNode::EstablishNewRenderingContext, nullptr,
+        TransformPaintPropertyNode::Preserve3D);
+    // Extends the 3D rendering context of transform2.
+    RefPtr<TransformPaintPropertyNode> transform3 = TransformPaintPropertyNode::create(
+        TransformationMatrix(), FloatPoint3D(), transform2,
+        TransformPaintPropertyNode::DontEstablishNewRenderingContext, transform2.get(),
+        TransformPaintPropertyNode::Preserve3D);
+    // Establishes a 3D rendering context distinct from transform2.
+    RefPtr<TransformPaintPropertyNode> transform4 = TransformPaintPropertyNode::create(
+        TransformationMatrix(), FloatPoint3D(), transform2,
+        TransformPaintPropertyNode::EstablishNewRenderingContext, nullptr,
+        TransformPaintPropertyNode::Preserve3D);
+
+    TestPaintArtifact artifact;
+    artifact.chunk(transform1, nullptr, nullptr)
+        .rectDrawing(FloatRect(0, 0, 300, 200), Color::white);
+    artifact.chunk(transform2, nullptr, nullptr)
+        .rectDrawing(FloatRect(0, 0, 300, 200), Color::lightGray);
+    artifact.chunk(transform3, nullptr, nullptr)
+        .rectDrawing(FloatRect(0, 0, 300, 200), Color::darkGray);
+    artifact.chunk(transform4, nullptr, 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;
+    EXPECT_EQ(whiteLayer->sorting_context_id(), whiteSortingContextId);
+    EXPECT_EQ(0, whiteSortingContextId);
+
+    // The light gray layer is 3D sorted.
+    const cc::Layer* lightGrayLayer = contentLayerAt(1);
+    EXPECT_THAT(lightGrayLayer->GetPicture(),
+        Pointee(drawsRectangle(FloatRect(0, 0, 300, 200), Color::lightGray)));
+    int lightGraySortingContextId = transformNode(lightGrayLayer).sorting_context_id;
+    EXPECT_EQ(lightGrayLayer->sorting_context_id(), lightGraySortingContextId);
+    EXPECT_NE(0, lightGraySortingContextId);
+
+    // The dark gray layer is 3D sorted with the light gray layer, but has a
+    // separate transform node.
+    const cc::Layer* darkGrayLayer = contentLayerAt(2);
+    EXPECT_THAT(darkGrayLayer->GetPicture(),
+        Pointee(drawsRectangle(FloatRect(0, 0, 300, 200), Color::darkGray)));
+    int darkGraySortingContextId = transformNode(darkGrayLayer).sorting_context_id;
+    EXPECT_EQ(darkGrayLayer->sorting_context_id(), darkGraySortingContextId);
+    EXPECT_EQ(lightGraySortingContextId, darkGraySortingContextId);
+    EXPECT_NE(lightGrayLayer->transform_tree_index(), darkGrayLayer->transform_tree_index());
+
+    // The black layer is 3D sorted, but in a separate context from the previous
+    // layers.
+    const cc::Layer* blackLayer = contentLayerAt(3);
+    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, FloatRoundedRect(100, 100, 300, 200));
 
     TestPaintArtifact artifact;
     artifact.chunk(nullptr, clip, nullptr)
         .rectDrawing(FloatRect(220, 80, 300, 200), Color::black);
     update(artifact.build());
 
@@ skipping 148 matching lines @@
     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());
 }
 
 } // namespace
 } // namespace blink