Use GeometryMapper in PaintInvalidator

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/LayoutObject.h"
 #include "core/layout/LayoutTable.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"
+#include "core/paint/PaintPropertyTreePrinter.h"

[chrishtr, 2016/08/12 18:20:53]

Remove

[Xianzhu, 2016/08/12 18:37:51]

Done.

(BTW do you know how to make the functions declared in
PaintPropertyTreePrinter.h available to gdb? I tried them (with and without
blink:: prefix) but gdb can't find the functions. Wondering why the compiler/gdb
treat them differently than showLayoutTree() etc.)

+#include "platform/graphics/paint/GeometryMapper.h"
 
 namespace blink {
 
-void PaintInvalidatorContext::mapLocalRectToPaintInvalidationBacking(const LayoutObject& object, LayoutRect& rect) const
+static LayoutRect mapLocalRectToPaintInvalidationBacking(const LayoutObject& object, const FloatRect& localRect, const PaintInvalidatorContext& context)
 {
-    // TODO(wangxianzhu): For now this is the same as the slow path in PaintInvalidationState.cpp
-    // (slowMapToVisualRectInAncestorSpace()). Should implement this with GeometryMapper.
+    // 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);
 
-    if (object.isLayoutView())
-        toLayoutView(object).mapToVisualRectInAncestorSpace(paintInvalidationContainer, rect, InputIsInFrameCoordinates, DefaultVisualRectFlags);
-    else
-        object.mapToVisualRectInAncestorSpace(paintInvalidationContainer, rect);
+    LayoutRect result;
+    if (object == context.paintInvalidationContainer) {
+        result = LayoutRect(rect);
+    } else {
+        rect.moveBy(FloatPoint(context.treeBuilderContext.current.paintOffset));
+
+        bool success = false;
+        PropertyTreeState currentTreeState(context.treeBuilderContext.current.transform, context.treeBuilderContext.current.clip, context.treeBuilderContext.currentEffect);
+        const PropertyTreeState& containerTreeState = context.paintInvalidationContainer->objectPaintProperties()->localBorderBoxProperties()->propertyTreeState;
+        result = LayoutRect(GeometryMapper().mapToVisualRectInDestinationSpace(rect, currentTreeState, containerTreeState, success));

[chrishtr, 2016/08/12 18:20:53]

This does use GeometryMapper, but it's not efficient. Note that in a comment
this is just an intermediate step?

[Xianzhu, 2016/08/12 18:37:51]

Oh I didn't think this is an intermediate step. What's the efficient way?

[chrishtr, 2016/08/12 18:40:28]

All of the caching in GeometryMapper is stored as instance variables. So you
should allocate one GeometryMapper object and use it throughout the paint
invalidation tree walk.

[Xianzhu, 2016/08/12 19:16:29]

Done.

+        DCHECK(success);
+    }
+
+    if (context.paintInvalidationContainer->layer()->groupedMapping())
+        PaintLayer::mapRectInPaintInvalidationContainerToBacking(*context.paintInvalidationContainer, result);
+    return result;
+}
+
+void PaintInvalidatorContext::mapLocalRectToPaintInvalidationBacking(const LayoutObject& object, LayoutRect& rect) const
+{
+    rect = blink::mapLocalRectToPaintInvalidationBacking(object, FloatRect(rect), *this);

[chrishtr, 2016/08/12 18:20:53]

What's the point of not inlining blink::mapLocalRectToPaintInvalidationBacking
here?

[Xianzhu, 2016/08/12 18:37:51]

Two reasons:

1. This method is for non-SVG path of code shared between old and new code which
provide a LayoutRect instead of a FloatRect. If changed the type to FloatRect,
we would have to change the legacy code to also convert LayoutRect to FloatRect.

2. This method is temporary and will be removed when we remove
PaintInvalidationState.

[chrishtr, 2016/08/12 18:40:28]

ok

 }
 
 static LayoutRect computePaintInvalidationRectInBacking(const LayoutObject& object, const PaintInvalidatorContext& context)
 {
-    if (object.isSVG() && !object.isSVGRoot()) {
-        // TODO(wangxianzhu): For now this is the same as the slow path in PaintInvalidationState.cpp
-        // (PaintInvalidationState::computePaintInvalidationRectInBackingForSVG()). Should implement this with GeometryMapper.
-        LayoutRect rect = SVGLayoutSupport::clippedOverflowRectForPaintInvalidation(object, *context.paintInvalidationContainer);
-        if (context.paintInvalidationContainer->layer()->groupedMapping())
-            PaintLayer::mapRectInPaintInvalidationContainerToBacking(*context.paintInvalidationContainer, rect);
-        return rect;
-    }
+    FloatRect localRect;
+    if (object.isSVG() && !object.isSVGRoot())
+        localRect = SVGLayoutSupport::localOverflowRectForPaintInvalidation(object);
+    else
+        localRect = FloatRect(object.localOverflowRectForPaintInvalidation());
 
-    LayoutRect rect = object.localOverflowRectForPaintInvalidation();
-    context.mapLocalRectToPaintInvalidationBacking(object, rect);
-    return rect;
+    return mapLocalRectToPaintInvalidationBacking(object, localRect, context);
 }
 
 static LayoutPoint computeLocationFromPaintInvalidationBacking(const LayoutObject& object, const PaintInvalidatorContext& context)
 {
-    // TODO(wangxianzhu): For now this is the same as the slow path in PaintInvalidationState.cpp
-    // (slowLocalToAncestorPoint()). Should implement this with GeometryMapper.
     FloatPoint point;
     if (object != context.paintInvalidationContainer) {
-        if (object.isLayoutView()) {
-            point = toLayoutView(object).localToAncestorPoint(point, context.paintInvalidationContainer, TraverseDocumentBoundaries | InputIsInFrameCoordinates);
-        } else {
-            point = object.localToAncestorPoint(point, context.paintInvalidationContainer, TraverseDocumentBoundaries);
-            // Paint invalidation does not include scroll of paintInvalidationContainer.
-            if (context.paintInvalidationContainer->isBox()) {
-                const LayoutBox* box = toLayoutBox(context.paintInvalidationContainer);
-                if (box->hasOverflowClip())
-                    point.move(box->scrolledContentOffset());
-            }
-        }
+        point.moveBy(FloatPoint(context.treeBuilderContext.current.paintOffset));
+
+        bool success = false;
+        PropertyTreeState currentTreeState(context.treeBuilderContext.current.transform, context.treeBuilderContext.current.clip, context.treeBuilderContext.currentEffect);
+        const PropertyTreeState& containerTreeState = context.paintInvalidationContainer->objectPaintProperties()->localBorderBoxProperties()->propertyTreeState;
+        point = GeometryMapper().mapRectToDestinationSpace(FloatRect(point, FloatSize()), currentTreeState, containerTreeState, success).location();
+        DCHECK(success);
     }
 
-
     if (context.paintInvalidationContainer->layer()->groupedMapping())
         PaintLayer::mapPointInPaintInvalidationContainerToBacking(*context.paintInvalidationContainer, point);
 
     return LayoutPoint(point);
 }
 
 static void updatePaintingLayer(const LayoutObject& object, PaintInvalidatorContext& context)
 {
     if (object.hasLayer() && toLayoutBoxModelObject(object).hasSelfPaintingLayer())
         context.paintingLayer = toLayoutBoxModelObject(object).layer();
@@ skipping 137 matching lines @@
     object.getMutableForPainting().clearPaintInvalidationFlags();
 }
 
 void PaintInvalidator::processPendingDelayedPaintInvalidations()
 {
     for (auto target : m_pendingDelayedPaintInvalidations)
         target->getMutableForPainting().setShouldDoFullPaintInvalidation(PaintInvalidationDelayedFull);
 }
 
 } // namespace blink