Implement SVG's transform and effect paint property nodes

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 "config.h"
 #include "core/paint/PaintPropertyTreeBuilder.h"
 
 #include "core/frame/FrameView.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ObjectPaintProperties.h"
@@ skipping 61 matching lines @@
     localContext.currentTransform = localContext.transformForOutOfFlowPositioned = newTransformNodeForScrollTranslation.get();
     localContext.paintOffset = localContext.paintOffsetForOutOfFlowPositioned = LayoutPoint();
 
     frameView.setPreTranslation(newTransformNodeForPreTranslation.release());
     frameView.setScrollTranslation(newTransformNodeForScrollTranslation.release());
 
     if (LayoutView* layoutView = frameView.layoutView())
         walk(*layoutView, localContext);
 }
 
-static void deriveBorderBoxFromContainerContext(const LayoutBoxModelObject& object, PaintPropertyTreeBuilderContext& context)
+static void deriveBorderBoxFromContainerContext(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
+    if (!object.isBoxModelObject())
+        return;
+
+    const LayoutBoxModelObject& boxModelObject = toLayoutBoxModelObject(object);
+
     // TODO(trchen): There is some insanity going on with tables. Double check results.
     switch (object.styleRef().position()) {
     case StaticPosition:
         break;
     case RelativePosition:
-        context.paintOffset += object.offsetForInFlowPosition();
+        context.paintOffset += boxModelObject.offsetForInFlowPosition();
         break;
     case AbsolutePosition:
         context.currentTransform = context.transformForOutOfFlowPositioned;
         context.paintOffset = context.paintOffsetForOutOfFlowPositioned;
         break;
     case StickyPosition:
-        context.paintOffset += object.offsetForInFlowPosition();
+        context.paintOffset += boxModelObject.offsetForInFlowPosition();
         break;
     case FixedPosition:
         context.currentTransform = context.transformForFixedPositioned;
         context.paintOffset = context.paintOffsetForFixedPositioned;
         break;
     default:
         ASSERT_NOT_REACHED();
     }
-    if (object.isBox())
-        context.paintOffset += toLayoutBox(object).locationOffset();
+    if (boxModelObject.isBox())
+        context.paintOffset += toLayoutBox(boxModelObject).locationOffset();
 }
 
-static PassRefPtr<TransformPaintPropertyNode> createPaintOffsetTranslationIfNeeded(const LayoutBoxModelObject& object, PaintPropertyTreeBuilderContext& context)
+static PassRefPtr<TransformPaintPropertyNode> createPaintOffsetTranslationIfNeeded(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
-    // TODO(trchen): Eliminate PaintLayer dependency.
-    bool shouldCreatePaintOffsetTranslationNode = object.layer() && object.layer()->paintsWithTransform(GlobalPaintNormalPhase);
+    bool shouldCreatePaintOffsetTranslationNode = false;
+    if (object.isSVGRoot()) {
+        // SVG doesn't use paint offset internally so emit a paint offset at the html->svg boundary.
+        shouldCreatePaintOffsetTranslationNode = true;
+    } else if (object.isBoxModelObject()) {
+        // TODO(trchen): Eliminate PaintLayer dependency.
+        PaintLayer* layer = toLayoutBoxModelObject(object).layer();
+        shouldCreatePaintOffsetTranslationNode = layer && layer->paintsWithTransform(GlobalPaintNormalPhase);
+    }
 
     if (context.paintOffset == LayoutPoint() || !shouldCreatePaintOffsetTranslationNode)
         return nullptr;
 
     RefPtr<TransformPaintPropertyNode> newTransformNodeForPaintOffsetTranslation = TransformPaintPropertyNode::create(
         TransformationMatrix().translate(context.paintOffset.x(), context.paintOffset.y()),
         FloatPoint3D(), context.currentTransform);
     context.currentTransform = newTransformNodeForPaintOffsetTranslation.get();
     context.paintOffset = LayoutPoint();
     return newTransformNodeForPaintOffsetTranslation.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()),
         style.transformOriginZ());
 }
 
-static PassRefPtr<TransformPaintPropertyNode> createTransformIfNeeded(const LayoutBoxModelObject& object, PaintPropertyTreeBuilderContext& context)
+static PassRefPtr<TransformPaintPropertyNode> createTransformIfNeeded(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
+    if (object.isSVG() && !object.isSVGRoot()) {
+        const AffineTransform& transform = object.localToParentTransform();
+        if (transform.isIdentity())
+            return nullptr;
+
+        // SVG's transform origin is baked into the localToParentTransform.
+        RefPtr<TransformPaintPropertyNode> newTransformNodeForTransform = TransformPaintPropertyNode::create(
+            transform, FloatPoint3D(0, 0, 0), context.currentTransform);
+        context.currentTransform = newTransformNodeForTransform.get();
+        return newTransformNodeForTransform.release();
+    }
+
     const ComputedStyle& style = object.styleRef();
     if (!object.isBox() || !style.hasTransform())
         return nullptr;
 
     ASSERT(context.paintOffset == LayoutPoint());
 
     TransformationMatrix matrix;
     style.applyTransform(matrix, toLayoutBox(object).size(), ComputedStyle::ExcludeTransformOrigin,
         ComputedStyle::IncludeMotionPath, ComputedStyle::IncludeIndependentTransformProperties);
     RefPtr<TransformPaintPropertyNode> newTransformNodeForTransform = TransformPaintPropertyNode::create(
         matrix, transformOrigin(toLayoutBox(object)), context.currentTransform);
     context.currentTransform = newTransformNodeForTransform.get();
     return newTransformNodeForTransform.release();
 }
 
-static PassRefPtr<EffectPaintPropertyNode> createEffectIfNeeded(const LayoutBoxModelObject& object, PaintPropertyTreeBuilderContext& context)
+static PassRefPtr<EffectPaintPropertyNode> createEffectIfNeeded(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     const ComputedStyle& style = object.styleRef();
-    if (!object.isBox() || !style.hasOpacity())
+    if (!style.hasOpacity())
         return nullptr;
     RefPtr<EffectPaintPropertyNode> newEffectNode = EffectPaintPropertyNode::create(style.opacity(), context.currentEffect);
     context.currentEffect = newEffectNode.get();
     return newEffectNode.release();
 }
 
 static FloatPoint perspectiveOrigin(const LayoutBox& box)
 {
     const ComputedStyle& style = box.styleRef();
     FloatSize borderBoxSize(box.size());
     return FloatPoint(
         floatValueForLength(style.perspectiveOriginX(), borderBoxSize.width()),
         floatValueForLength(style.perspectiveOriginY(), borderBoxSize.height()));
 }
 
-static PassRefPtr<TransformPaintPropertyNode> createPerspectiveIfNeeded(const LayoutBoxModelObject& object, PaintPropertyTreeBuilderContext& context)
+static PassRefPtr<TransformPaintPropertyNode> createPerspectiveIfNeeded(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
     const ComputedStyle& style = object.styleRef();
     if (!object.isBox() || !style.hasPerspective())
         return nullptr;
 
     RefPtr<TransformPaintPropertyNode> newTransformNodeForPerspective = TransformPaintPropertyNode::create(
         TransformationMatrix().applyPerspective(style.perspective()),
         perspectiveOrigin(toLayoutBox(object)) + toLayoutSize(context.paintOffset), context.currentTransform);
     context.currentTransform = newTransformNodeForPerspective.get();
     return newTransformNodeForPerspective.release();
 }
 
-static PassRefPtr<TransformPaintPropertyNode> createScrollTranslationIfNeeded(const LayoutBoxModelObject& object, PaintPropertyTreeBuilderContext& context)
+static PassRefPtr<TransformPaintPropertyNode> createScrollTranslationIfNeeded(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
-    if (!object.hasOverflowClip())
+    if (!object.isBoxModelObject() || !object.hasOverflowClip())
         return nullptr;
 
-    PaintLayer* layer = object.layer();
+    PaintLayer* layer = toLayoutBoxModelObject(object).layer();
     ASSERT(layer);
     DoubleSize scrollOffset = layer->scrollableArea()->scrollOffset();
     if (scrollOffset.isZero() && !layer->scrollsOverflow())
         return nullptr;
 
     RefPtr<TransformPaintPropertyNode> newTransformNodeForScrollTranslation = TransformPaintPropertyNode::create(
         TransformationMatrix().translate(-scrollOffset.width(), -scrollOffset.height()),
         FloatPoint3D(), context.currentTransform);
     context.currentTransform = newTransformNodeForScrollTranslation.get();
     return newTransformNodeForScrollTranslation.release();
 }
 
-static void updateOutOfFlowContext(const LayoutBoxModelObject& object, PaintPropertyTreeBuilderContext& context)
+static void updateOutOfFlowContext(const LayoutObject& object, bool createdNewTransform, PaintPropertyTreeBuilderContext& context)
 {
-    const ComputedStyle& style = object.styleRef();
-    bool hasTransform = object.isBox() && style.hasTransform();
-    if (style.position() != StaticPosition || hasTransform) {
+    // At the html->svg boundary (see: createPaintOffsetTranslationIfNeeded) the currentTransform is
+    // up-to-date for all children of the svg root element. Additionally, inside SVG, all positioning
+    // uses transforms. Therefore, we only need to check createdNewTransform and isSVGRoot() to
+    // ensure out-of-flow and fixed positioning is correct at the svg->html boundary.
+
+    if (object.styleRef().position() != StaticPosition || createdNewTransform || object.isSVGRoot()) {

[jbroman, 2015/11/23 17:51:00]

Out of curiosity (arguably out of scope for this patch, but I didn't previously
notice it), isn't "object.styleRef().position() != StaticPosition" equivalent to
"object.isPositioned()", which is shorter to write and faster to run IIUC?

[trchen, 2015/11/23 19:28:29]

I think yes. Looks like it's pretty safe to use.

         context.transformForOutOfFlowPositioned = context.currentTransform;
         context.paintOffsetForOutOfFlowPositioned = context.paintOffset;
     }
-    if (hasTransform) {
+
+    if (createdNewTransform || object.isSVGRoot()) {
         context.transformForFixedPositioned = context.currentTransform;
         context.paintOffsetForFixedPositioned = context.paintOffset;
     }
 }
 
-void PaintPropertyTreeBuilder::walk(LayoutBoxModelObject& object, const PaintPropertyTreeBuilderContext& context)
+void PaintPropertyTreeBuilder::walk(LayoutObject& object, const PaintPropertyTreeBuilderContext& context)
 {
-    ASSERT(object.isBox() != object.isLayoutInline()); // Either or.
-
     PaintPropertyTreeBuilderContext localContext(context);
 
     deriveBorderBoxFromContainerContext(object, localContext);
     RefPtr<TransformPaintPropertyNode> newTransformNodeForPaintOffsetTranslation = createPaintOffsetTranslationIfNeeded(object, localContext);
     RefPtr<TransformPaintPropertyNode> newTransformNodeForTransform = createTransformIfNeeded(object, localContext);
     RefPtr<EffectPaintPropertyNode> newEffectNode = createEffectIfNeeded(object, localContext);
     RefPtr<TransformPaintPropertyNode> newTransformNodeForPerspective = createPerspectiveIfNeeded(object, localContext);
     RefPtr<TransformPaintPropertyNode> newTransformNodeForScrollTranslation = createScrollTranslationIfNeeded(object, localContext);
-    updateOutOfFlowContext(object, localContext);
+    updateOutOfFlowContext(object, newTransformNodeForTransform, localContext);
 
     if (newTransformNodeForPaintOffsetTranslation || newTransformNodeForTransform || newEffectNode || newTransformNodeForPerspective || newTransformNodeForScrollTranslation) {
         OwnPtr<ObjectPaintProperties> updatedPaintProperties = ObjectPaintProperties::create(
             newTransformNodeForPaintOffsetTranslation.release(),
             newTransformNodeForTransform.release(),
             newEffectNode.release(),
             newTransformNodeForPerspective.release(),
             newTransformNodeForScrollTranslation.release());
         object.setObjectPaintProperties(updatedPaintProperties.release());
     } else {
         object.clearObjectPaintProperties();
     }
 
     // TODO(trchen): Walk subframes for LayoutFrame.
 
-    // TODO(trchen): Implement SVG walk.
-    if (object.isSVGRoot()) {
-        return;
-    }
-
     for (LayoutObject* child = object.slowFirstChild(); child; child = child->nextSibling()) {
-        if (child->isText())
-            continue;
-        walk(toLayoutBoxModelObject(*child), localContext);
+        if (child->isBoxModelObject() || child->isSVG())
+            walk(*child, localContext);
     }
 }
 
 } // namespace blink