SVG root viewport clip in paint property tree

third_party/WebKit/Source/core/paint/PaintInvalidator.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 "core/paint/PaintInvalidator.h"
 
 #include "core/editing/FrameSelection.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTable.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/svg/SVGLayoutSupport.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintLayer.h"
 #include "core/paint/PaintLayerScrollableArea.h"
 #include "core/paint/PaintPropertyTreeBuilder.h"
 
 namespace blink {
 
-static void slowMapToVisualRectInAncestorSpace(const LayoutObject& object, const LayoutBoxModelObject& ancestor, LayoutRect& rect)
+static LayoutRect slowMapToVisualRectInAncestorSpace(const LayoutObject& object, const LayoutBoxModelObject& ancestor, const FloatRect& rect)
 {
+    if (object.isSVG() && !object.isSVGRoot()) {
+        LayoutRect result;
+        SVGLayoutSupport::mapToVisualRectInAncestorSpace(object, &ancestor, rect, result);

[pdr., 2016/09/14 22:42:39]

If we override this in all SVG subclasses, will this special-case be needed? I'd
prefer if we could rely on this working through the
object.mapToVisualRectInAncestorSpace call below, but I'm not sure if it is
possible. We already override LayoutSVGBlock::mapToVisualRectInAncestorSpace, do
we just need to override it in LayoutSVGModelObject, LayoutSVGBlock, and
LayoutSVGInline too?

[Xianzhu, 2016/09/14 23:35:31]

We didn't override mapToVisualRectInAncestorSpace in other SVG objects because
they were never called. SVGLayoutSupport::mapToVisualRectInAncestorSpace() was
used by only LayoutSVGBlock::mapToVisualRectInAncestorSpace() (which may be
called from HTML descendants) and
SVGLayoutSupport::clippedOverflowRectForPaintInvalidation(). Its input rect is a
FloatRect so if we match it to LayoutObject::mapToVisualRectInAncestorSpace() we
may lose accuracy.

I would keep this special case for now because this code is temporary for
filters before paint property tree supports filters.

+        return result;
+    }
+
+    LayoutRect result(rect);
     if (object.isLayoutView())
-        toLayoutView(object).mapToVisualRectInAncestorSpace(&ancestor, rect, InputIsInFrameCoordinates, DefaultVisualRectFlags);
+        toLayoutView(object).mapToVisualRectInAncestorSpace(&ancestor, result, InputIsInFrameCoordinates, DefaultVisualRectFlags);
     else
-        object.mapToVisualRectInAncestorSpace(&ancestor, rect);
+        object.mapToVisualRectInAncestorSpace(&ancestor, result);
+    return result;
 }
 
 // TODO(wangxianzhu): Combine this into PaintInvalidator::mapLocalRectToPaintInvalidationBacking() when removing PaintInvalidationState.
 static LayoutRect mapLocalRectToPaintInvalidationBacking(GeometryMapper& geometryMapper, const LayoutObject& object, const FloatRect& localRect, const PaintInvalidatorContext& context)
 {
     // TODO(wkorman): The flip below is required because visual rects are
     // currently in "physical coordinates with flipped block-flow direction"
     // (see LayoutBoxModelObject.h) but we need them to be in physical
     // coordinates.
     FloatRect rect = localRect;
     if (object.isBox())
         toLayoutBox(object).flipForWritingMode(rect);
 
     LayoutRect result;
     if (context.forcedSubtreeInvalidationFlags & PaintInvalidatorContext::ForcedSubtreeSlowPathRect) {
-        result = LayoutRect(rect);
-        slowMapToVisualRectInAncestorSpace(object, *context.paintInvalidationContainer, result);
+        result = slowMapToVisualRectInAncestorSpace(object, *context.paintInvalidationContainer, rect);
     } else if (object == context.paintInvalidationContainer) {
         result = LayoutRect(rect);
     } else {
         PropertyTreeState currentTreeState(context.treeBuilderContext.current.transform, context.treeBuilderContext.current.clip, context.treeBuilderContext.currentEffect);
         PropertyTreeState containerTreeState;
         const ObjectPaintProperties* containerPaintProperties = context.paintInvalidationContainer->objectPaintProperties();
         containerPaintProperties->getContentsProperties(containerTreeState);
 
         rect.moveBy(FloatPoint(context.treeBuilderContext.current.paintOffset));
         bool success = false;
@@ skipping 222 matching lines @@
     object.getMutableForPainting().clearPaintInvalidationFlags();
 }
 
 void PaintInvalidator::processPendingDelayedPaintInvalidations()
 {
     for (auto target : m_pendingDelayedPaintInvalidations)
         target->getMutableForPainting().setShouldDoFullPaintInvalidation(PaintInvalidationDelayedFull);
 }
 
 } // namespace blink