Move all fast-path paint invalidation mapping into PaintInvalidationState

third_party/WebKit/Source/core/layout/LayoutObject.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 77 matching lines @@
 enum MarkingBehavior {
     MarkOnlyThis,
     MarkContainerChain,
 };
 
 enum MapCoordinatesMode {
     IsFixed = 1 << 0,
     UseTransforms = 1 << 1,
     ApplyContainerFlip = 1 << 2,
     TraverseDocumentBoundaries = 1 << 3,
+    // Disable view clipping and scroll offset adjustment, used when map a rect from a LayoutView's
+    // viewRect space (e.g. viewRect() itself or frame scrollbars).
+    // TODO(wangxianzhu): Remove this when root-layer-scrolls launches.
+    DontApplyFrameScrollOffsetAndClip = 1 << 4,

[trchen, 2016/03/25 01:08:49]

Just had an offline discussion with Xianzhu. I suggest that we name this flag
"InputIsInFrameCoordinate", and add a comment that the flag only applies when
the source object is a LayoutView.

The core problem of due to in traditional scrolling without RLS, there is no way
to specify frame coordinate space. Supposedly the frame scrolls but the
LayoutView doesn't, so the local border box space of LayoutView is equivalent to
absolute coordinate space. For frame scrollbars that kind of stuff, they paint
in frame coordinate space, but we can't pass the FrameView to the conversion
function because FrameView is not a LayoutObject.

"DontApplyFrameScrollOffsetAndClip" is unclear because it doesn't say which
scroll offset is getting skipped. Let's say we have 3 nested iframes, and we map
from the innermost to the outermost, do we also ignore scroll offset of the
middle frame?

[Xianzhu, 2016/03/25 16:35:55]

Thanks for the input. Renamed to InputIsInFrameCoordinates and updated comments.

 };
 typedef unsigned MapCoordinatesFlags;
 
 enum ScheduleRelayoutBehavior {
     ScheduleRelayout,
     DontScheduleRelayout
 };
 
 const LayoutUnit& caretWidth();
 
@@ skipping 208 matching lines @@
 #endif
         ASSERT_WITH_SECURITY_IMPLICATION(!needsLayout());
     }
 
     void assertSubtreeIsLaidOut() const
     {
         for (const LayoutObject* layoutObject = this; layoutObject; layoutObject = layoutObject->nextInPreOrder())
             layoutObject->assertLaidOut();
     }
 
-    void assertClearedPaintInvalidationState() const
+    void assertClearedPaintInvalidationFlags() const
     {
 #ifndef NDEBUG
         if (paintInvalidationStateIsDirty()) {
             showLayoutTreeForThis();
             ASSERT_NOT_REACHED();
         }
 #endif
     }
 
-    void assertSubtreeClearedPaintInvalidationState() const
+    void assertSubtreeClearedPaintInvalidationFlags() const
     {
         for (const LayoutObject* layoutObject = this; layoutObject; layoutObject = layoutObject->nextInPreOrder())
-            layoutObject->assertClearedPaintInvalidationState();
+            layoutObject->assertClearedPaintInvalidationFlags();
     }
 
 #endif
 
     // Correct version of !layoutObjectHasNoBoxEffectObsolete().
     bool hasBoxEffect() const
     {
         return hasBoxDecorationBackground() || style()->hasVisualOverflowingEffect();
     }
 
@@ skipping 634 matching lines @@
     {
         return ancestorToLocalQuad(nullptr, quad, mode);
     }
 
     // Convert a local quad into the coordinate system of container, taking transforms into account.
     // If the LayoutBoxModelObject ancestor is non-null, the result will be in the space of the ancestor.
     // Otherwise:
     //   If TraverseDocumentBoundaries is specified, the result will be in the space of the local root frame.
     //   Otherwise, the result will be in the space of the containing frame.
     FloatQuad localToAncestorQuad(const FloatQuad&, const LayoutBoxModelObject* ancestor, MapCoordinatesFlags = 0, bool* wasFixed = nullptr) const;
-    FloatPoint localToAncestorPoint(const FloatPoint&, const LayoutBoxModelObject* ancestor, MapCoordinatesFlags = 0, bool* wasFixed = nullptr, const PaintInvalidationState* = nullptr) const;
+    FloatPoint localToAncestorPoint(const FloatPoint&, const LayoutBoxModelObject* ancestor, MapCoordinatesFlags = 0, bool* wasFixed = nullptr) const;
     void localToAncestorRects(Vector<LayoutRect>&, const LayoutBoxModelObject* ancestor, const LayoutPoint& preOffset, const LayoutPoint& postOffset) const;
 
     // Return the transformation matrix to map points from local to the coordinate system of a container, taking transforms into account.
     // Passing null for |ancestor| behaves the same as localToAncestorQuad.
     TransformationMatrix localToAncestorTransform(const LayoutBoxModelObject* ancestor, MapCoordinatesFlags = 0, bool* wasFixed = nullptr) const;
     TransformationMatrix localToAbsoluteTransform(MapCoordinatesFlags mode = 0, bool* wasFixed = nullptr) const
     {
         return localToAncestorTransform(nullptr, mode, wasFixed);
     }
 
@@ skipping 91 matching lines @@
     // is responsible for painting this object. The function crosses
     // frames boundaries so the returned value can be in a
     // different document.
     //
     // This is the container that should be passed to
     // the '*forPaintInvalidation' methods.
     const LayoutBoxModelObject& containerForPaintInvalidation() const;
 
     bool isPaintInvalidationContainer() const;
 
-    LayoutRect computePaintInvalidationRect()
-    {
-        return computePaintInvalidationRect(containerForPaintInvalidation());
-    }
-
-    // Returns the paint invalidation rect for this LayoutObject in the coordinate space of the paint backing (typically a GraphicsLayer) for |paintInvalidationContainer|.
-    LayoutRect computePaintInvalidationRect(const LayoutBoxModelObject& paintInvalidationContainer, const PaintInvalidationState* = nullptr) const;
-
-    // Returns the rect bounds needed to invalidate the paint of this object, in the coordinate space of the layoutObject backing of |paintInvalidationContainer|
-    LayoutRect boundsRectForPaintInvalidation(const LayoutBoxModelObject& paintInvalidationContainer, const PaintInvalidationState* = nullptr) const;
-
     // Actually do the paint invalidate of rect r for this object which has been computed in the coordinate space
     // of the GraphicsLayer backing of |paintInvalidationContainer|. Note that this coordinaten space is not the same
     // as the local coordinate space of |paintInvalidationContainer| in the presence of layer squashing.
     void invalidatePaintUsingContainer(const LayoutBoxModelObject& paintInvalidationContainer, const LayoutRect&, PaintInvalidationReason) const;
 
     // Invalidate the paint of a specific subrectangle within a given object. The rect is in the object's coordinate space.
     void invalidatePaintRectangle(const LayoutRect&) const;
     void invalidatePaintRectangleNotInvalidatingDisplayItemClients(const LayoutRect&) const;
 
     // Walk the tree after layout issuing paint invalidations for layoutObjects that have changed or moved, updating bounds that have changed, and clearing paint invalidation state.
     virtual void invalidateTreeIfNeeded(const PaintInvalidationState&);
 
     // This function only invalidates the visual overflow.
     //
     // Note that overflow is a box concept but this function
     // is only supported for block-flow.
     virtual void invalidatePaintForOverflow();
     void invalidatePaintForOverflowIfNeeded();
 
     void invalidatePaintIncludingNonCompositingDescendants();
     void invalidatePaintIncludingNonSelfPaintingLayerDescendants(const LayoutBoxModelObject& paintInvalidationContainer);
     void setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
 
     // Returns the rect that should have paint invalidated whenever this object changes. The rect is in the view's
     // coordinate space. This method deals with outlines and overflow.
     virtual LayoutRect absoluteClippedOverflowRect() const;
-    virtual LayoutRect clippedOverflowRectForPaintInvalidation(const LayoutBoxModelObject* paintInvalidationContainer, const PaintInvalidationState* = nullptr) const;
+
+    // Returns the rect that should have paint invalidated whenever this object changes. The rect is in the object's
+    // local coordinate space.
+    virtual LayoutRect localOverflowRectForPaintInvalidation() const;
 
     // Given a rect in the object's coordinate space, compute a rect in the coordinate space of |ancestor|.  If
     // intermediate containers have clipping or scrolling of any kind, it is applied; but overflow clipping is *not*
     // applied for |ancestor| itself. The output rect is suitable for purposes such as paint invalidation.
-    virtual void mapToVisibleRectInAncestorSpace(const LayoutBoxModelObject* ancestor, LayoutRect&, const PaintInvalidationState*) const;
+    virtual void mapToVisibleRectInAncestorSpace(const LayoutBoxModelObject* ancestor, LayoutRect&) const;
 
     // Return the offset to the column in which the specified point (in flow-thread coordinates)
     // lives. This is used to convert a flow-thread point to a visual point.
     virtual LayoutSize columnOffset(const LayoutPoint&) const { return LayoutSize(); }
 
     virtual unsigned length() const { return 1; }
 
     bool isFloatingOrOutOfFlowPositioned() const { return (isFloating() || isOutOfFlowPositioned()); }
 
     bool isTransparent() const { return style()->hasOpacity(); }
     float opacity() const { return style()->opacity(); }
 
     bool hasReflection() const { return m_bitfields.hasReflection(); }
 
     // The current selection state for an object.  For blocks, the state refers to the state of the leaf
     // descendants (as described above in the SelectionState enum declaration).
     SelectionState getSelectionState() const { return m_bitfields.getSelectionState(); }
     virtual void setSelectionState(SelectionState state) { m_bitfields.setSelectionState(state); }
     inline void setSelectionStateIfNeeded(SelectionState);
     bool canUpdateSelectionOnRootLineBoxes() const;
 
     // A single rectangle that encompasses all of the selected objects within this object.  Used to determine the tightest
-    // possible bounding box for the selection. The rect returned is in the coordinate space of the paint invalidation container's backing.
-    virtual LayoutRect selectionRectForPaintInvalidation(const LayoutBoxModelObject* /* paintInvalidationContainer */) const { return LayoutRect(); }
+    // possible bounding box for the selection. The rect returned is in the object's local coordinate space.
+    virtual LayoutRect localSelectionRect() const { return LayoutRect(); }
 
     // View coordinates means the coordinate space of |view()|.
     LayoutRect selectionRectInViewCoordinates() const;
 
     virtual bool canBeSelectionLeaf() const { return false; }
     bool hasSelectedChildren() const { return getSelectionState() != SelectionNone; }
 
     bool isSelectable() const;
     // Obtains the selection colors that should be used when painting a selection.
     Color selectionBackgroundColor() const;
@@ skipping 55 matching lines @@
         if (parent())
             parent()->removeChild(this);
     }
 
     bool visibleToHitTestRequest(const HitTestRequest& request) const { return style()->visibility() == VISIBLE && (request.ignorePointerEventsNone() || style()->pointerEvents() != PE_NONE) && !isInert(); }
 
     bool visibleToHitTesting() const { return style()->visibility() == VISIBLE && style()->pointerEvents() != PE_NONE && !isInert(); }
 
     // Map points and quads through elements, potentially via 3d transforms. You should never need to call these directly; use
     // localToAbsolute/absoluteToLocal methods instead.
-    virtual void mapLocalToAncestor(const LayoutBoxModelObject* ancestor, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, bool* wasFixed = nullptr, const PaintInvalidationState* = nullptr) const;
+    virtual void mapLocalToAncestor(const LayoutBoxModelObject* ancestor, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, bool* wasFixed = nullptr) const;
     // If the LayoutBoxModelObject ancestor is non-null, the input quad is in the space of the ancestor.
     // Otherwise:
     //   If TraverseDocumentBoundaries is specified, the input quad is in the space of the local root frame.
     //   Otherwise, the input quad is in the space of the containing frame.
     virtual void mapAncestorToLocal(const LayoutBoxModelObject*, TransformState&, MapCoordinatesFlags = ApplyContainerFlip) const;
     void mapAbsoluteToLocalPoint(MapCoordinatesFlags flags, TransformState& transformState) const
     {
         return mapAncestorToLocal(nullptr, transformState, flags);
     }
 
@@ skipping 96 matching lines @@
         return paintInvalidationState.forcedSubtreeInvalidationWithinContainer()
             || paintInvalidationState.forcedSubtreeInvalidationRectUpdateWithinContainer()
             || shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState();
     }
 
     bool shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState() const
     {
         return mayNeedPaintInvalidation() || shouldDoFullPaintInvalidation() || shouldInvalidateSelection() || m_bitfields.childShouldCheckForPaintInvalidation();
     }
 
-    virtual bool supportsPaintInvalidationStateCachedOffsets() const { return !hasTransformRelatedProperty() && !hasReflection() && !style()->isFlippedBlocksWritingMode(); }
-
     virtual LayoutRect viewRect() const;
 
     void invalidateDisplayItemClient(const DisplayItemClient&) const;
     void invalidateDisplayItemClientsIncludingNonCompositingDescendants(const LayoutBoxModelObject* paintInvalidationContainer, PaintInvalidationReason) const;
 
     // Called before anonymousChild.setStyle(). Override to set custom styles for the child.
     virtual void updateAnonymousChildStyle(const LayoutObject& anonymousChild, ComputedStyle& style) const { }
 
     // Painters can use const methods only, except for these explicitly declared methods.
     class MutableForPainting {
@@ skipping 788 matching lines @@
 void showTree(const blink::LayoutObject*);
 void showLineTree(const blink::LayoutObject*);
 void showLayoutTree(const blink::LayoutObject* object1);
 // We don't make object2 an optional parameter so that showLayoutTree
 // can be called from gdb easily.
 void showLayoutTree(const blink::LayoutObject* object1, const blink::LayoutObject* object2);
 
 #endif
 
 #endif // LayoutObject_h