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

third_party/WebKit/Source/core/paint/PaintPropertyTreeBuilder.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 "core/paint/PaintPropertyTreeBuilder.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintLayer.h"
 #include "core/paint/SVGRootPainter.h"
 #include "platform/transforms/TransformationMatrix.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
+namespace {
+
+// Creates a transform node which uses the current rendering context ID and
+// flattening behavior from the tree builder context.
+PassRefPtr<TransformPaintPropertyNode> createTransformNode(
+    const PaintPropertyTreeBuilderContext& context,
+    const TransformationMatrix& matrix,
+    const FloatPoint3D& origin,
+    PassRefPtr<TransformPaintPropertyNode> parent)
+{
+    return TransformPaintPropertyNode::create(
+        matrix, origin, parent,
+        context.current.shouldFlattenInheritedTransform,
+        context.current.renderingContextID);
+}
+
+} // namespace
+
 void PaintPropertyTreeBuilder::buildTreeRootNodes(FrameView& rootFrame, PaintPropertyTreeBuilderContext& context)
 {
-    RefPtr<TransformPaintPropertyNode> transformRoot = TransformPaintPropertyNode::create(TransformationMatrix(), FloatPoint3D(), nullptr);
+    RefPtr<TransformPaintPropertyNode> transformRoot = TransformPaintPropertyNode::create(TransformationMatrix(), FloatPoint3D(), nullptr, true);
     context.current.transform = context.absolutePosition.transform = context.fixedPosition.transform = transformRoot.get();
     rootFrame.setRootTransform(std::move(transformRoot));
 
     RefPtr<ClipPaintPropertyNode> clipRoot = ClipPaintPropertyNode::create(transformRoot, FloatRoundedRect(LayoutRect::infiniteIntRect()), nullptr);
     context.current.clip = context.absolutePosition.clip = context.fixedPosition.clip = clipRoot.get();
     rootFrame.setRootClip(std::move(clipRoot));
 
     RefPtr<EffectPaintPropertyNode> effectRoot = EffectPaintPropertyNode::create(1.0, nullptr);
     context.currentEffect = effectRoot.get();
     rootFrame.setRootEffect(std::move(effectRoot));
 }
 
 void PaintPropertyTreeBuilder::buildTreeNodes(FrameView& frameView, PaintPropertyTreeBuilderContext& context)
 {
     // TODO(pdr): Creating paint properties for FrameView here will not be
     // needed once settings()->rootLayerScrolls() is enabled.
     // TODO(pdr): Make this conditional on the rootLayerScrolls setting.
 
     TransformationMatrix frameTranslate;
     frameTranslate.translate(frameView.x() + context.current.paintOffset.x(), frameView.y() + context.current.paintOffset.y());
-    RefPtr<TransformPaintPropertyNode> newTransformNodeForPreTranslation = TransformPaintPropertyNode::create(frameTranslate, FloatPoint3D(), context.current.transform);
+    RefPtr<TransformPaintPropertyNode> newTransformNodeForPreTranslation = createTransformNode(context, frameTranslate, FloatPoint3D(), context.current.transform);
 
     FloatRoundedRect contentClip(IntRect(IntPoint(), frameView.visibleContentSize()));
     RefPtr<ClipPaintPropertyNode> newClipNodeForContentClip = ClipPaintPropertyNode::create(newTransformNodeForPreTranslation.get(), contentClip, context.current.clip);
 
     DoubleSize scrollOffset = frameView.scrollOffsetDouble();
     TransformationMatrix frameScroll;
     frameScroll.translate(-scrollOffset.width(), -scrollOffset.height());
     RefPtr<TransformPaintPropertyNode> newTransformNodeForScrollTranslation = TransformPaintPropertyNode::create(frameScroll, FloatPoint3D(), newTransformNodeForPreTranslation);
 
     // Initialize the context for current, absolute and fixed position cases.
     // They are the same, except that scroll translation does not apply to
     // fixed position descendants.
     context.current.transform = newTransformNodeForScrollTranslation.get();
     context.current.paintOffset = LayoutPoint();
     context.current.clip = newClipNodeForContentClip.get();
+    context.current.renderingContextID = 0;
+    context.current.shouldFlattenInheritedTransform = true;
     context.absolutePosition = context.current;
     context.containerForAbsolutePosition = nullptr;
     context.fixedPosition = context.current;
     context.fixedPosition.transform = newTransformNodeForPreTranslation.get();
 
     frameView.setPreTranslation(newTransformNodeForPreTranslation.release());
     frameView.setScrollTranslation(newTransformNodeForScrollTranslation.release());
     frameView.setContentClip(newClipNodeForContentClip.release());
 }
 
@@ skipping 10 matching lines @@
         return;
 
     // We should use the same subpixel paint offset values for snapping regardless of whether a
     // transform is present. If there is a transform we round the paint offset but keep around
     // the residual fractional component for the transformed content to paint with.
     // In spv1 this was called "subpixel accumulation". For more information, see
     // PaintLayer::subpixelAccumulation() and PaintLayerPainter::paintFragmentByApplyingTransform.
     IntPoint roundedPaintOffset = roundedIntPoint(context.current.paintOffset);
     LayoutPoint fractionalPaintOffset = LayoutPoint(context.current.paintOffset - roundedPaintOffset);
 
-    RefPtr<TransformPaintPropertyNode> paintOffsetTranslation = TransformPaintPropertyNode::create(
+    RefPtr<TransformPaintPropertyNode> paintOffsetTranslation = createTransformNode(
+        context,
         TransformationMatrix().translate(roundedPaintOffset.x(), roundedPaintOffset.y()),
         FloatPoint3D(), context.current.transform);
     context.current.transform = paintOffsetTranslation.get();
     context.current.paintOffset = fractionalPaintOffset;
+    context.current.shouldFlattenInheritedTransform = false;
     object.getMutableForPainting().ensureObjectPaintProperties().setPaintOffsetTranslation(paintOffsetTranslation.release());
 }
 
 static FloatPoint3D transformOrigin(const LayoutBox& box)
 {
     const ComputedStyle& style = box.styleRef();
     FloatSize borderBoxSize(box.size());
     return FloatPoint3D(
         floatValueForLength(style.transformOriginX(), borderBoxSize.width()),
         floatValueForLength(style.transformOriginY(), borderBoxSize.height()),
@@ skipping 11 matching lines @@
         // the animation passes through the identity matrix.
         // FIXME(pdr): Refactor this so all non-root SVG objects use the same transform function.
         const AffineTransform& transform = object.isSVGForeignObject() ? object.localSVGTransform() : object.localToSVGParentTransform();
         if (transform.isIdentity())
             return;
 
         // The origin is included in the local transform, so use an empty origin.
         RefPtr<TransformPaintPropertyNode> svgTransform = TransformPaintPropertyNode::create(
             transform, FloatPoint3D(0, 0, 0), context.current.transform);
         context.current.transform = svgTransform.get();
+        context.current.renderingContextID = 0;
+        context.current.shouldFlattenInheritedTransform = false;
         object.getMutableForPainting().ensureObjectPaintProperties().setTransform(svgTransform.release());
         return;
     }
 
+    if (!object.isBox())
+        return;
     const ComputedStyle& style = object.styleRef();
-    if (!object.isBox() || !style.hasTransform())
+    if (!style.hasTransform() && !style.preserves3D())
         return;
 
     TransformationMatrix matrix;
     style.applyTransform(matrix, toLayoutBox(object).size(), ComputedStyle::ExcludeTransformOrigin,
         ComputedStyle::IncludeMotionPath, ComputedStyle::IncludeIndependentTransformProperties);
+
+    unsigned renderingContextID = context.current.renderingContextID;
+    unsigned renderingContextIDForChildren = 0;
+    bool flattensInheritedTransform = context.current.shouldFlattenInheritedTransform;
+    bool childrenFlattenInheritedTransform = true;
+
+    if (style.preserves3D()) {
+        // If a node with transform-style: preserve-3d does not exist in an
+        // existing rendering context, it establishes a new one.
+        if (!renderingContextID)
+            renderingContextID = PtrHash<const LayoutObject>::hash(&object);
+        renderingContextIDForChildren = renderingContextID;
+        childrenFlattenInheritedTransform = false;

[trchen, 2016/07/19 22:19:42]

Note: transform-style should be respected if and only if a PaintLayer is
created, but let's ignore the little details for now.

[jbroman, 2016/07/20 15:30:56]

Are you asking for a TODO, a bug, or would you like this as-is?

+    }
+
     RefPtr<TransformPaintPropertyNode> transformNode = TransformPaintPropertyNode::create(
-        matrix, transformOrigin(toLayoutBox(object)), context.current.transform);
+        matrix, transformOrigin(toLayoutBox(object)), context.current.transform,
+        flattensInheritedTransform, renderingContextID);
     context.current.transform = transformNode.get();
+    context.current.renderingContextID = renderingContextIDForChildren;
+    context.current.shouldFlattenInheritedTransform = childrenFlattenInheritedTransform;
     object.getMutableForPainting().ensureObjectPaintProperties().setTransform(transformNode.release());
 }
 
 void PaintPropertyTreeBuilder::updateEffect(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (!object.styleRef().hasOpacity())
         return;
     RefPtr<EffectPaintPropertyNode> effectNode = EffectPaintPropertyNode::create(object.styleRef().opacity(), context.currentEffect);
     context.currentEffect = effectNode.get();
     object.getMutableForPainting().ensureObjectPaintProperties().setEffect(effectNode.release());
@@ skipping 93 matching lines @@
         floatValueForLength(style.perspectiveOriginX(), borderBoxSize.width()),
         floatValueForLength(style.perspectiveOriginY(), borderBoxSize.height()));
 }
 
 void PaintPropertyTreeBuilder::updatePerspective(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     const ComputedStyle& style = object.styleRef();
     if (!object.isBox() || !style.hasPerspective())
         return;
 
-    RefPtr<TransformPaintPropertyNode> perspective = TransformPaintPropertyNode::create(
+    // The perspective node must not flatten (else nothing will get
+    // perspective), but it should still extend the rendering context as most
+    // transform nodes do.
+    RefPtr<TransformPaintPropertyNode> perspective = createTransformNode(
+        context,
         TransformationMatrix().applyPerspective(style.perspective()),
         perspectiveOrigin(toLayoutBox(object)) + toLayoutSize(context.current.paintOffset),
         context.current.transform);
     context.current.transform = perspective.get();
+    context.current.shouldFlattenInheritedTransform = false;
+
     object.getMutableForPainting().ensureObjectPaintProperties().setPerspective(perspective.release());
 }
 
 void PaintPropertyTreeBuilder::updateSvgLocalToBorderBoxTransform(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (!object.isSVGRoot())
         return;
 
     AffineTransform transformToBorderBox = SVGRootPainter(toLayoutSVGRoot(object)).transformToPixelSnappedBorderBox(context.current.paintOffset);
 
     // The paint offset is included in |transformToBorderBox| so SVG does not need to handle paint
     // offset internally.
     context.current.paintOffset = LayoutPoint();
 
     if (transformToBorderBox.isIdentity())
         return;
 
     RefPtr<TransformPaintPropertyNode> svgLocalToBorderBoxTransform = TransformPaintPropertyNode::create(
         transformToBorderBox, FloatPoint3D(0, 0, 0), context.current.transform);
     context.current.transform = svgLocalToBorderBoxTransform.get();
     context.current.paintOffset = LayoutPoint();
+    context.current.renderingContextID = 0;
+    context.current.shouldFlattenInheritedTransform = false;
     object.getMutableForPainting().ensureObjectPaintProperties().setSvgLocalToBorderBoxTransform(svgLocalToBorderBoxTransform.release());
 }
 
 void PaintPropertyTreeBuilder::updateScrollTranslation(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (!object.isBoxModelObject() || !object.hasOverflowClip())
         return;
 
     PaintLayer* layer = toLayoutBoxModelObject(object).layer();
     ASSERT(layer);
     DoubleSize scrollOffset = layer->getScrollableArea()->scrollOffset();
     if (scrollOffset.isZero() && !layer->scrollsOverflow())
         return;
 
-    RefPtr<TransformPaintPropertyNode> scrollTranslation = TransformPaintPropertyNode::create(
+    RefPtr<TransformPaintPropertyNode> scrollTranslation = createTransformNode(
+        context,
         TransformationMatrix().translate(-scrollOffset.width(), -scrollOffset.height()),
         FloatPoint3D(),
         context.current.transform);
     context.current.transform = scrollTranslation.get();
+    context.current.shouldFlattenInheritedTransform = false;
     object.getMutableForPainting().ensureObjectPaintProperties().setScrollTranslation(scrollTranslation.release());
 }
 
 void PaintPropertyTreeBuilder::updateOutOfFlowContext(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (object.canContainAbsolutePositionObjects()) {
         context.absolutePosition = context.current;
         context.containerForAbsolutePosition = &object;
     }
 
@@ skipping 83 matching lines @@
 
     deriveBorderBoxFromContainerContext(object, context);
 
     updatePaintOffsetTranslation(object, context);
     updateTransform(object, context);
     updateEffect(object, context);
     updateCssClip(object, context);
     updateLocalBorderBoxContext(object, context);
     updateScrollbarPaintOffset(object, context);
     updateOverflowClip(object, context);
-    // TODO(trchen): Insert flattening transform here, as specified by
-    // http://www.w3.org/TR/css3-transforms/#transform-style-property
     updatePerspective(object, context);
     updateSvgLocalToBorderBoxTransform(object, context);
     updateScrollTranslation(object, context);
     updateOutOfFlowContext(object, context);
 }
 
 } // namespace blink