[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"
@@ skipping 50 matching lines @@
         existingScrollTranslation->update(frameView.preTranslation(), frameScroll, FloatPoint3D());
     else
         frameView.setScrollTranslation(TransformPaintPropertyNode::create(frameView.preTranslation(), frameScroll, FloatPoint3D()));
 
     // 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 = frameView.scrollTranslation();
     context.current.paintOffset = LayoutPoint();
     context.current.clip = frameView.contentClip();
+    context.current.renderingContextID = 0;
+    context.current.shouldFlattenInheritedTransform = true;
     context.absolutePosition = context.current;
     context.containerForAbsolutePosition = nullptr;
     context.fixedPosition = context.current;
     context.fixedPosition.transform = frameView.preTranslation();
 }
 
 template <typename PropertyNode, void (ObjectPaintProperties::*Setter)(PassRefPtr<PropertyNode>)>
 void PaintPropertyTreeBuilder::clearPaintProperty(const LayoutObject& object)
 {
     if (ObjectPaintProperties* existingProperties = object.objectPaintProperties())
@@ skipping 27 matching lines @@
         if (layer && layer->paintsWithTransform(GlobalPaintNormalPhase)) {
             // 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);
 
             updateOrCreatePaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::paintOffsetTranslation, &ObjectPaintProperties::setPaintOffsetTranslation>(
-                object, context, context.current.transform, TransformationMatrix().translate(roundedPaintOffset.x(), roundedPaintOffset.y()), FloatPoint3D());
+                object, context, context.current.transform, TransformationMatrix().translate(roundedPaintOffset.x(), roundedPaintOffset.y()), FloatPoint3D(),
+                context.current.shouldFlattenInheritedTransform, context.current.renderingContextID);
             context.current.paintOffset = fractionalPaintOffset;
             return;
         }
     }
     clearPaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::setPaintOffsetTranslation>(object);
 }
 
 static FloatPoint3D transformOrigin(const LayoutBox& box)
 {
     const ComputedStyle& style = box.styleRef();
@@ skipping 12 matching lines @@
 
         // FIXME(pdr): Check for the presence of a transform instead of the value. Checking for an
         // identity matrix will cause the property tree structure to change during animations if
         // 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()) {
             // The origin is included in the local transform, so leave origin empty.
             updateOrCreatePaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::transform, &ObjectPaintProperties::setTransform>(
                 object, context, context.current.transform, TransformationMatrix(transform), FloatPoint3D());
+            context.current.renderingContextID = 0;
+            context.current.shouldFlattenInheritedTransform = false;
             return;
         }
     } else {
         const ComputedStyle& style = object.styleRef();
-        if (object.isBox() && style.hasTransform()) {
+        if (object.isBox() && (style.hasTransform() || style.preserves3D())) {
             TransformationMatrix matrix;
             style.applyTransform(matrix, toLayoutBox(object).size(), ComputedStyle::ExcludeTransformOrigin,
                 ComputedStyle::IncludeMotionPath, ComputedStyle::IncludeIndependentTransformProperties);
             FloatPoint3D origin = transformOrigin(toLayoutBox(object));
+
+            unsigned renderingContextID = context.current.renderingContextID;
+            unsigned renderingContextIDForChildren = 0;
+            bool flattensInheritedTransform = context.current.shouldFlattenInheritedTransform;
+            bool childrenFlattenInheritedTransform = true;
+
+            // TODO(trchen): transform-style should only be respected if a PaintLayer is
+            // created.
+            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;
+            }
+
             updateOrCreatePaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::transform, &ObjectPaintProperties::setTransform>(
-                object, context, context.current.transform, matrix, origin);
+                object, context, context.current.transform, matrix, origin, flattensInheritedTransform, renderingContextID);
+            context.current.renderingContextID = renderingContextIDForChildren;
+            context.current.shouldFlattenInheritedTransform = childrenFlattenInheritedTransform;
             return;
         }
     }
     clearPaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::setTransform>(object);
 }
 
 void PaintPropertyTreeBuilder::updateEffect(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (!object.styleRef().hasOpacity()) {
         clearPaintProperty<EffectPaintPropertyNode, &ObjectPaintProperties::setEffect>(object);
@@ skipping 96 matching lines @@
 }
 
 void PaintPropertyTreeBuilder::updatePerspective(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     const ComputedStyle& style = object.styleRef();
     if (!object.isBox() || !style.hasPerspective()) {
         clearPaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::setPerspective>(object);
         return;
     }
 
+    // The perspective node must not flatten (else nothing will get
+    // perspective), but it should still extend the rendering context as most
+    // transform nodes do.
+    TransformationMatrix matrix = TransformationMatrix().applyPerspective(style.perspective());
     FloatPoint3D origin = perspectiveOrigin(toLayoutBox(object)) + toLayoutSize(context.current.paintOffset);
     updateOrCreatePaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::perspective, &ObjectPaintProperties::setPerspective>(
-        object, context, context.current.transform, TransformationMatrix().applyPerspective(style.perspective()), origin);
+        object, context, context.current.transform, matrix, origin, context.current.shouldFlattenInheritedTransform, context.current.renderingContextID);
+    context.current.shouldFlattenInheritedTransform = false;
 }
 
 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()) {
         clearPaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::setSvgLocalToBorderBoxTransform>(object);
         return;
     }
 
     updateOrCreatePaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::svgLocalToBorderBoxTransform, &ObjectPaintProperties::setSvgLocalToBorderBoxTransform>(
         object, context, context.current.transform, transformToBorderBox, FloatPoint3D());
+    context.current.shouldFlattenInheritedTransform = false;
+    context.current.renderingContextID = 0;
 }
 
 void PaintPropertyTreeBuilder::updateScrollTranslation(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (object.isBoxModelObject() && object.hasOverflowClip()) {
         PaintLayer* layer = toLayoutBoxModelObject(object).layer();
         DCHECK(layer);
         DoubleSize scrollOffset = layer->getScrollableArea()->scrollOffset();
 
         if (!scrollOffset.isZero() || layer->scrollsOverflow()) {
             TransformationMatrix matrix = TransformationMatrix().translate(-scrollOffset.width(), -scrollOffset.height());
             updateOrCreatePaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::scrollTranslation, &ObjectPaintProperties::setScrollTranslation>(
-                object, context, context.current.transform, matrix, FloatPoint3D());
+                object, context, context.current.transform, matrix, FloatPoint3D(), context.current.shouldFlattenInheritedTransform, context.current.renderingContextID);
+            context.current.shouldFlattenInheritedTransform = false;
             return;
         }
     }
     clearPaintProperty<TransformPaintPropertyNode, &ObjectPaintProperties::setScrollTranslation>(object);
 }
 
 void PaintPropertyTreeBuilder::updateOutOfFlowContext(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     if (object.canContainAbsolutePositionObjects()) {
         context.absolutePosition = context.current;
@@ skipping 81 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