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"
 
 namespace blink {
 
-void PaintInvalidatorContext::mapLocalRectToPaintInvalidationBacking(const LayoutObject& object, LayoutRect& rect) const
+// 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(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));
+        DCHECK(success);
+    }
+
+    if (context.paintInvalidationContainer->layer()->groupedMapping())
+        PaintLayer::mapRectInPaintInvalidationContainerToBacking(*context.paintInvalidationContainer, result);
+    return result;
 }
 
-static LayoutRect computePaintInvalidationRectInBacking(const LayoutObject& object, const PaintInvalidatorContext& context)
+void PaintInvalidatorContext::mapLocalRectToPaintInvalidationBacking(const LayoutObject& object, LayoutRect& rect) const
 {
-    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;
-    }
-
-    LayoutRect rect = object.localOverflowRectForPaintInvalidation();
-    context.mapLocalRectToPaintInvalidationBacking(object, rect);
-    return rect;
+    GeometryMapper geometryMapper;
+    rect = blink::mapLocalRectToPaintInvalidationBacking(geometryMapper, object, FloatRect(rect), *this);
 }
 
-static LayoutPoint computeLocationFromPaintInvalidationBacking(const LayoutObject& object, const PaintInvalidatorContext& context)
+LayoutRect PaintInvalidator::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
-    // (slowLocalToAncestorPoint()). Should implement this with GeometryMapper.
+    return blink::mapLocalRectToPaintInvalidationBacking(m_geometryMapper, object, localRect, context);
+}
+
+LayoutRect PaintInvalidator::computePaintInvalidationRectInBacking(const LayoutObject& object, const PaintInvalidatorContext& context)
+{
+    FloatRect localRect;
+    if (object.isSVG() && !object.isSVGRoot())
+        localRect = SVGLayoutSupport::localOverflowRectForPaintInvalidation(object);
+    else
+        localRect = FloatRect(object.localOverflowRectForPaintInvalidation());
+
+    return mapLocalRectToPaintInvalidationBacking(object, localRect, context);
+}
+
+LayoutPoint PaintInvalidator::computeLocationFromPaintInvalidationBacking(const LayoutObject& object, const PaintInvalidatorContext& context)
+{
     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();

[chrishtr, 2016/08/12 19:46:11]

What about this one?

[Xianzhu, 2016/08/13 00:51:16]

Sorry, missed this one. Change to m_geometryMapper.

+        DCHECK(success);
     }
 
-
     if (context.paintInvalidationContainer->layer()->groupedMapping())
         PaintLayer::mapPointInPaintInvalidationContainerToBacking(*context.paintInvalidationContainer, point);
 
     return LayoutPoint(point);
 }
 
-static void updatePaintingLayer(const LayoutObject& object, PaintInvalidatorContext& context)
+void PaintInvalidator::updatePaintingLayer(const LayoutObject& object, PaintInvalidatorContext& context)
 {
     if (object.hasLayer() && toLayoutBoxModelObject(object).hasSelfPaintingLayer())
         context.paintingLayer = toLayoutBoxModelObject(object).layer();
 
     if (object.isLayoutBlockFlow() && toLayoutBlockFlow(object).containsFloats())
         context.paintingLayer->setNeedsPaintPhaseFloat();
 
     if (object == context.paintingLayer->layoutObject())
         return;
 
     if (object.styleRef().hasOutline())
         context.paintingLayer->setNeedsPaintPhaseDescendantOutlines();
 
     if (object.hasBoxDecorationBackground()
         // We also paint overflow controls in background phase.
         || (object.hasOverflowClip() && toLayoutBox(object).getScrollableArea()->hasOverflowControls())) {
         context.paintingLayer->setNeedsPaintPhaseDescendantBlockBackgrounds();
     }
 
     if (object.isTable()) {
         const LayoutTable& table = toLayoutTable(object);
         if (table.collapseBorders() && !table.collapsedBorders().isEmpty())
             context.paintingLayer->setNeedsPaintPhaseDescendantBlockBackgrounds();
     }
 }
 
-static void updateContext(const LayoutObject& object, PaintInvalidatorContext& context)
+void PaintInvalidator::updateContext(const LayoutObject& object, PaintInvalidatorContext& context)
 {
     if (object.isPaintInvalidationContainer()) {
         context.paintInvalidationContainer = toLayoutBoxModelObject(&object);
         if (object.styleRef().isStackingContext())
             context.paintInvalidationContainerForStackedContents = toLayoutBoxModelObject(&object);
     } else if (object.isLayoutView()) {
         // paintInvalidationContainerForStackedContents is only for stacked descendants in its own frame,
         // because it doesn't establish stacking context for stacked contents in sub-frames.
         // Contents stacked in the root stacking context in this frame should use this frame's paintInvalidationContainer.
         context.paintInvalidationContainerForStackedContents = context.paintInvalidationContainer;
@@ skipping 103 matching lines @@
     object.getMutableForPainting().clearPaintInvalidationFlags();
 }
 
 void PaintInvalidator::processPendingDelayedPaintInvalidations()
 {
     for (auto target : m_pendingDelayedPaintInvalidations)
         target->getMutableForPainting().setShouldDoFullPaintInvalidation(PaintInvalidationDelayedFull);
 }
 
 } // namespace blink