First step of PaintInvalidator implementation

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/svg/SVGLayoutSupport.h"
+#include "core/paint/PaintLayer.h"
+#include "core/paint/PaintLayerScrollableArea.h"
 
 namespace blink {
 
-void PaintInvalidator::invalidatePaintIfNeeded(FrameView& frameView, const PaintPropertyTreeBuilderContext& treeContext, Optional<PaintInvalidatorContext>& paintInvalidatorContext)
-{
-    paintInvalidatorContext.emplace(*frameView.layoutView(), m_pendingDelayedPaintInvalidations);
-    frameView.invalidatePaintIfNeeded(*paintInvalidatorContext);
-}
-
-void PaintInvalidator::invalidatePaintIfNeeded(const LayoutObject& layoutObject, const PaintPropertyTreeBuilderContext& treeContext, const PaintInvalidatorContext& parentPaintInvalidatorContext, Optional<PaintInvalidatorContext>& paintInvalidatorContext)
-{
-    if (!layoutObject.shouldCheckForPaintInvalidation(parentPaintInvalidatorContext))
+void PaintInvalidatorContext::mapLocalRectToPaintInvalidationBacking(const LayoutObject& object, LayoutRect& rect) const
+{
+    // TODO(wangxianzhu): For now this is the same as the slow path in PaintInvalidationState.
+    // Should implement this with GeometryMapper.
+    if (object.isBox())
+        toLayoutBox(object).flipForWritingMode(rect);
+
+    if (object.isLayoutView())
+        toLayoutView(object).mapToVisualRectInAncestorSpace(paintInvalidationContainer, rect, InputIsInFrameCoordinates, DefaultVisualRectFlags);
+    else
+        object.mapToVisualRectInAncestorSpace(paintInvalidationContainer, rect);
+}
+
+static LayoutRect computePaintInvalidationRectInBacking(const LayoutObject& object, const PaintInvalidatorContext& context)
+{
+    // TODO(wangxianzhu): For now this is the same as the slow path in PaintInvalidationState.
+    // Should implement this with GeometryMapper.
+    if (object.isSVG() && !object.isSVGRoot()) {
+        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;
+}
+
+static LayoutPoint computeLocationFromPaintInvalidationBacking(const LayoutObject& object, const PaintInvalidatorContext& context)
+{
+    // TODO(wangxianzhu): For now this is the same as the slow path in PaintInvalidationState.
+    // 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);
+    }
+
+    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();
+
+    if (object.isLayoutBlockFlow() && toLayoutBlockFlow(object).containsFloats())
+        context.paintingLayer->setNeedsPaintPhaseFloat();
+
+    if (object == context.paintingLayer->layoutObject())
         return;
 
-    paintInvalidatorContext.emplace(parentPaintInvalidatorContext, layoutObject);
-
-    if (layoutObject.mayNeedPaintInvalidationSubtree())
-        paintInvalidatorContext->setForceSubtreeInvalidationCheckingWithinContainer();
-
-    PaintInvalidationReason reason = layoutObject.getMutableForPainting().invalidatePaintIfNeeded(*paintInvalidatorContext);
-    layoutObject.getMutableForPainting().clearPaintInvalidationFlags(*paintInvalidatorContext);
-
-    paintInvalidatorContext->updateForChildren(reason);
+    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();
+    }
+}
+
+static void 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.

[chrishtr, 2016/08/10 20:47:33]

I know you're copying this comment, but is this really true? An element in a
grandchild can z-index below the frame or above it?

[Xianzhu, 2016/08/10 22:16:43]

No. It means a frame breaks the relationship between the ancestor stacking
context and descendant stacked contents.

The following example can explain the comment:

<div id="paint-invalidation-container-for-stacked-contents">
  <div id="paint-invalidation-container">
    <div class="stacked">This uses
"paint-invalidation-container-for-stacked-contents"</div>
    <div id="stacking-context-but-not-paint-invalidation-container">
      <div class="stacked">This uses
"paint-invalidation-container-for-stacked-contents"</div>
    </div>
    <iframe>
      [<!-- iframe contents -->
      <div class="stacked">This uses "paint-invalidation-container"</div>
      <!-- ^^^^ This is what the comment is about ^^^^ -->
      ]
    </iframe>
  </div>
</div>  

[chrishtr, 2016/08/10 23:23:22]

Isn't this equivalent to the situation in line 91 in the new file then? Isn't it
simply that LayoutViews are stacking contexts?

[Xianzhu, 2016/08/10 23:48:31]

The case at line 91 is for a paint invalidation container establishing a
stacking context. If an stacking-context object is not a paint invalidation
container, the situation is different if the object is a LayoutView or not, as
shown in the above example for the third and the second class="stacked" divs.

+        // Contents stacked in the root stacking context in this frame should use this frame's paintInvalidationContainer.
+        context.paintInvalidationContainerForStackedContents = context.paintInvalidationContainer;
+    } else if (object.styleRef().isStacked()
+        // This is to exclude some objects (e.g. LayoutText) inheriting stacked style from parent but aren't actually stacked.
+        && object.hasLayer()
+        && context.paintInvalidationContainer != context.paintInvalidationContainerForStackedContents) {
+        // The current object is stacked, so we should use m_paintInvalidationContainerForStackedContents as its
+        // paint invalidation container on which the current object is painted.
+        context.paintInvalidationContainer = context.paintInvalidationContainerForStackedContents;
+        if (context.forcedSubtreeInvalidationFlags & PaintInvalidatorContext::ForcedSubtreeFullInvalidationForStackedContents)
+            context.forcedSubtreeInvalidationFlags |= PaintInvalidatorContext::ForcedSubtreeFullInvalidation;
+    }
+
+    if (object == context.paintInvalidationContainer) {
+        // When we hit a new paint invalidation container, we don't need to
+        // continue forcing a check for paint invalidation, since we're
+        // descending into a different invalidation container. (For instance if
+        // our parents were moved, the entire container will just move.)
+        if (object != context.paintInvalidationContainerForStackedContents) {
+            // However, we need to keep the ForcedSubtreeFullInvalidationForStackedContents flag
+            // if the current object isn't the paint invalidation container of stacked contents.
+            context.forcedSubtreeInvalidationFlags &= PaintInvalidatorContext::ForcedSubtreeFullInvalidationForStackedContents;
+        } else {
+            context.forcedSubtreeInvalidationFlags = 0;
+        }
+    }
+
+    DCHECK(context.paintInvalidationContainer == object.containerForPaintInvalidation());
+    DCHECK(context.paintingLayer == object.paintingLayer());
+
+    if (object.mayNeedPaintInvalidationSubtree())

[chrishtr, 2016/08/10 20:47:33]

This is previously in LayoutBoxModelObject::invalidateTreeIfNeeded. Does this
need to be conditioned on that subclass for any reason?

[Xianzhu, 2016/08/10 22:16:43]

The reason was that mayNeedPaintInvalidationSubtree() is set on
LayoutBoxModelObjects only. This doesn't matter if the condition is checked for
any object.

+        context.forcedSubtreeInvalidationFlags |= PaintInvalidatorContext::ForcedSubtreeInvalidationChecking;
+
+    context.oldBounds = object.previousPaintInvalidationRect();
+    context.oldLocation = object.previousPositionFromPaintInvalidationBacking();
+    context.newBounds = computePaintInvalidationRectInBacking(object, context);
+    context.newLocation = computeLocationFromPaintInvalidationBacking(object, context);
+
+    // Composited scrolling should not be included in the bounds and position tracking, because the graphics layer backing the scroller
+    // does not move on scroll.
+    // TODO(chrishtr): can we just avoid adding in the scroll in the first place in LayoutBox::mapScrollingContentsRectToBoxSpace?

[chrishtr, 2016/08/10 20:47:33]

I landed the patch to remove this...

[Xianzhu, 2016/08/10 22:16:43]

My fault when dealing with conflicts.

Fixed.

+    if (object.compositedScrollsWithRespectTo(*context.paintInvalidationContainer)) {
+        LayoutSize inverseOffset(toLayoutBox(context.paintInvalidationContainer)->scrolledContentOffset());
+        context.newLocation.move(inverseOffset);
+        context.newBounds.move(inverseOffset);
+    }
+
+    object.getMutableForPainting().setPreviousPaintInvalidationRect(context.newBounds);
+    object.getMutableForPainting().setPreviousPositionFromPaintInvalidationBacking(context.newLocation);
+}
+
+void PaintInvalidator::invalidatePaintIfNeeded(FrameView& frameView, PaintInvalidatorContext& context)
+{
+    LayoutView* layoutView = frameView.layoutView();
+    CHECK(layoutView);
+
+    context.paintInvalidationContainer = context.paintInvalidationContainerForStackedContents = &layoutView->containerForPaintInvalidation();
+    context.paintingLayer = layoutView->layer();
+
+    if (!frameView.frame().settings() || !frameView.frame().settings()->rootLayerScrolls())
+        frameView.invalidatePaintOfScrollControlsIfNeeded(context);
+
+    if (frameView.frame().selection().isCaretBoundsDirty())
+        frameView.frame().selection().invalidateCaretRect();
+
+    // Temporary callback for crbug.com/487345,402044
+    // TODO(ojan): Make this more general to be used by PositionObserver
+    // and rAF throttling.
+    IntRect visibleRect = frameView.rootFrameToContents(frameView.computeVisibleArea());
+    layoutView->sendMediaPositionChangeNotifications(visibleRect);
+}
+
+void PaintInvalidator::invalidatePaintIfNeeded(const LayoutObject& object, PaintInvalidatorContext& context)
+{
+    if (!context.forcedSubtreeInvalidationFlags && !object.shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState())
+        return;
+
+    updatePaintingLayer(object, context);
+
+    if (object.document().printing())
+        return; // Don't invalidate paints if we're printing.
+
+    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"), "PaintInvalidator::invalidatePaintIfNeeded()", "object", object.debugName().ascii());
+
+    updateContext(object, context);
+
+    if (!object.shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState() && context.forcedSubtreeInvalidationFlags == PaintInvalidatorContext::ForcedSubtreeInvalidationRectUpdate) {
+        // We are done updating the paint invalidation rect. No other paint invalidation work to do for this object.
+        return;
+    }
+
+    switch (object.invalidatePaintIfNeeded(context)) {
+    case PaintInvalidationDelayedFull:
+        m_pendingDelayedPaintInvalidations.append(&object);
+        break;
+    case PaintInvalidationSubtree:
+        context.forcedSubtreeInvalidationFlags |= (PaintInvalidatorContext::ForcedSubtreeFullInvalidation | PaintInvalidatorContext::ForcedSubtreeFullInvalidationForStackedContents);
+        break;
+    case PaintInvalidationSVGResourceChange:
+        context.forcedSubtreeInvalidationFlags |= PaintInvalidatorContext::ForcedSubtreeInvalidationChecking;
+        break;
+    default:
+        break;
+    }
+
+    if (context.oldLocation != context.newLocation)
+        context.forcedSubtreeInvalidationFlags |= PaintInvalidatorContext::ForcedSubtreeInvalidationChecking;
+
+    object.getMutableForPainting().clearPaintInvalidationFlags();
 }
 
 void PaintInvalidator::processPendingDelayedPaintInvalidations()
 {
     for (auto target : m_pendingDelayedPaintInvalidations)
-        target->getMutableForPainting().setShouldDoDelayedFullPaintInvalidation();
+        target->getMutableForPainting().setShouldDoFullPaintInvalidation(PaintInvalidationDelayedFull);
 }
 
 } // namespace blink