Re-implement SVG transform paint property nodes [spv2]

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 "platform/transforms/TransformationMatrix.h"
 
 namespace blink {
 
 void PaintPropertyTreeBuilder::buildTreeRootNodes(FrameView& rootFrame, PaintPropertyTreeBuilderContext& context)
 {
     // Only create extra root clip and transform nodes when RLS is enabled, because the main frame
     // unconditionally create frame translation / clip nodes otherwise.
@@ skipping 35 matching lines @@
     context.paintOffsetForAbsolutePosition = LayoutPoint();
     context.containerForAbsolutePosition = nullptr;
 
     frameView.setPreTranslation(newTransformNodeForPreTranslation.release());
     frameView.setScrollTranslation(newTransformNodeForScrollTranslation.release());
     frameView.setContentClip(newClipNodeForContentClip.release());
 }
 
 void PaintPropertyTreeBuilder::updatePaintOffsetTranslation(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
-    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()) {
+    if (object.isBoxModelObject()) {
         // TODO(trchen): Eliminate PaintLayer dependency.
         PaintLayer* layer = toLayoutBoxModelObject(object).layer();
-        shouldCreatePaintOffsetTranslationNode = layer && layer->paintsWithTransform(GlobalPaintNormalPhase);
+        if (!layer || !layer->paintsWithTransform(GlobalPaintNormalPhase))
+            return;
     }
 
-    if (context.paintOffset == LayoutPoint() || !shouldCreatePaintOffsetTranslationNode)
+    if (context.paintOffset == LayoutPoint())
         return;
 
     RefPtr<TransformPaintPropertyNode> paintOffsetTranslation = TransformPaintPropertyNode::create(
         TransformationMatrix().translate(context.paintOffset.x(), context.paintOffset.y()),
         FloatPoint3D(), context.currentTransform);
     context.currentTransform = paintOffsetTranslation.get();
     context.paintOffset = LayoutPoint();
     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()),
         style.transformOriginZ());
 }
 
 void PaintPropertyTreeBuilder::updateTransform(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
+    if (object.isSVG() && !object.isSVGRoot()) {
+        // SVG does not use paint offset internally and the root should have already accounted for
+        // any paint offset in the root's svgLocalToBorderBox transform.
+        DCHECK(context.paintOffset == LayoutPoint());
+
+        // TODO(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.
+        const AffineTransform& transform = 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.currentTransform);
+        context.currentTransform = svgTransform.get();
+        object.getMutableForPainting().ensureObjectPaintProperties().setTransform(svgTransform.release());
+        return;
+    }
+
     const ComputedStyle& style = object.styleRef();
     if (!object.isBox() || !style.hasTransform())
         return;
     ASSERT(context.paintOffset == LayoutPoint());
 
     TransformationMatrix matrix;
     style.applyTransform(matrix, toLayoutBox(object).size(), ComputedStyle::ExcludeTransformOrigin,
         ComputedStyle::IncludeMotionPath, ComputedStyle::IncludeIndependentTransformProperties);
     RefPtr<TransformPaintPropertyNode> transformNode = TransformPaintPropertyNode::create(
         matrix, transformOrigin(toLayoutBox(object)), context.currentTransform);
@@ skipping 115 matching lines @@
         return;
 
     RefPtr<TransformPaintPropertyNode> perspective = TransformPaintPropertyNode::create(
         TransformationMatrix().applyPerspective(style.perspective()),
         perspectiveOrigin(toLayoutBox(object)) + toLayoutSize(context.paintOffset),
         context.currentTransform);
     context.currentTransform = perspective.get();
     object.getMutableForPainting().ensureObjectPaintProperties().setPerspective(perspective.release());
 }
 
-void PaintPropertyTreeBuilder::updateSvgLocalTransform(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
+void PaintPropertyTreeBuilder::updateSvgLocalToBorderBoxTransform(const LayoutObject& object, PaintPropertyTreeBuilderContext& context)
 {
-    if (!object.isSVG())
+    if (!object.isSVGRoot())
         return;
 
-    const AffineTransform& transform = object.localToSVGParentTransform();
+    AffineTransform transform = AffineTransform::translation(context.paintOffset.x().toFloat(), context.paintOffset.y().toFloat());
+    transform *= toLayoutSVGRoot(object).localToBorderBoxTransform();
     if (transform.isIdentity())
         return;
 
-    // The origin is included in the local transform, so use an empty origin.
-    RefPtr<TransformPaintPropertyNode> svgLocalTransform = TransformPaintPropertyNode::create(
+    RefPtr<TransformPaintPropertyNode> svgLocalToBorderBoxTransform = TransformPaintPropertyNode::create(
         transform, FloatPoint3D(0, 0, 0), context.currentTransform);
-    context.currentTransform = svgLocalTransform.get();
-    object.getMutableForPainting().ensureObjectPaintProperties().setSvgLocalTransform(svgLocalTransform.release());
+    context.currentTransform = svgLocalToBorderBoxTransform.get();
+    context.paintOffset = LayoutPoint();
+    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();
@@ skipping 78 matching lines @@
         context.paintOffset += boxModelObject.offsetForInFlowPosition();
         break;
     case FixedPosition:
         context.currentTransform = context.transformForFixedPosition;
         context.paintOffset = context.paintOffsetForFixedPosition;
         context.currentClip = context.clipForFixedPosition;
         break;
     default:
         ASSERT_NOT_REACHED();
     }
-    if (boxModelObject.isBox()) {
+    if (boxModelObject.isBox() && (boxModelObject.isSVGRoot() || !boxModelObject.isSVG())) {

[jbroman, 2016/06/10 18:33:52]

premature optimization: consider putting the !isSVG check first, because it's
more likely to be true and we can short-circuit the isSVGRoot call in that case.

[pdr., 2016/06/10 19:45:46]

Optimized!

Nevermind the TODO one line down about a O(n^2) hiding in this conditional
though :P

         // TODO(pdr): Several calls in this function walk back up the tree to calculate containers
         // (e.g., topLeftLocation, offsetForInFlowPosition*). The containing block and other
         // containers can be stored on PaintPropertyTreeBuilderContext instead of recomputing them.
         context.paintOffset.moveBy(toLayoutBox(boxModelObject).topLeftLocation());
         // This is a weird quirk that table cells paint as children of table rows,
         // but their location have the row's location baked-in.
         // Similar adjustment is done in LayoutTableCell::offsetFromContainer().
         if (boxModelObject.isTableCell()) {
             LayoutObject* parentRow = boxModelObject.parent();
             ASSERT(parentRow && parentRow->isTableRow());
@@ skipping 14 matching lines @@
     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);
-    updateSvgLocalTransform(object, context);
+    updateSvgLocalToBorderBoxTransform(object, context);
     updateScrollTranslation(object, context);
     updateOutOfFlowContext(object, context);
 }
 
 } // namespace blink