[SPInvalidation] Use GeometryMapper in PaintLayerClipper for paint.

third_party/WebKit/Source/core/paint/PaintLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
  * reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
@@ skipping 262 matching lines @@
 
 void PaintLayer::setSubpixelAccumulation(const LayoutSize& size) {
   if (m_rareData || !size.isZero())
     ensureRareData().subpixelAccumulation = size;
 }
 
 void PaintLayer::updateLayerPositionsAfterLayout() {
   TRACE_EVENT0("blink,benchmark",
                "PaintLayer::updateLayerPositionsAfterLayout");
 
-  clipper().clearClipRectsIncludingDescendants();
+  clipper(false).clearClipRectsIncludingDescendants();
   updateLayerPositionRecursive();
 
   {
     // FIXME: Remove incremental compositing updates after fixing the
     // chicken/egg issues, https://crbug.com/343756
     DisableCompositingQueryAsserts disabler;
     updatePaginationRecursive(enclosingPaginationLayer());
   }
 }
 
@@ skipping 67 matching lines @@
           (!ancestorScrollingLayer() || ancestorScrollingLayer() == root()));
 }
 
 bool PaintLayer::scrollsWithRespectTo(const PaintLayer* other) const {
   if (sticksToViewport() != other->sticksToViewport())
     return true;
   return ancestorScrollingLayer() != other->ancestorScrollingLayer();
 }
 
 void PaintLayer::updateLayerPositionsAfterOverflowScroll() {
-  clipper().clearClipRectsIncludingDescendants();
+  clipper(false).clearClipRectsIncludingDescendants();
   updateLayerPositionRecursive();
 }
 
 void PaintLayer::updateTransformationMatrix() {
   if (TransformationMatrix* transform = this->transform()) {
     LayoutBox* box = layoutBox();
     DCHECK(box);
     transform->makeIdentity();
     box->style()->applyTransform(
         *transform, box->size(), ComputedStyle::IncludeTransformOrigin,
@@ skipping 16 matching lines @@
 
   bool hadTransform = transform();
   if (hasTransform != hadTransform) {
     if (hasTransform)
       ensureRareData().transform = TransformationMatrix::create();
     else
       m_rareData->transform.reset();
 
     // PaintLayers with transforms act as clip rects roots, so clear the cached
     // clip rects here.
-    clipper().clearClipRectsIncludingDescendants();
+    clipper(false).clearClipRectsIncludingDescendants();
   } else if (hasTransform) {
-    clipper().clearClipRectsIncludingDescendants(AbsoluteClipRects);
+    clipper(false).clearClipRectsIncludingDescendants(AbsoluteClipRects);
   }
 
   updateTransformationMatrix();
 
   if (had3DTransform != has3DTransform())
     markAncestorChainForDescendantDependentFlagsUpdate();
 
   if (FrameView* frameView = layoutObject()->document().view())
     frameView->setNeedsUpdateWidgetGeometries();
 }
@@ skipping 901 matching lines @@
       didSetPaintInvalidation = true;
     }
   }
 
   if (!didSetPaintInvalidation && isSelfPaintingLayer()) {
     if (PaintLayer* enclosingSelfPaintingLayer =
             m_parent->enclosingSelfPaintingLayer())
       enclosingSelfPaintingLayer->mergeNeedsPaintPhaseFlagsFrom(*this);
   }
 
-  clipper().clearClipRectsIncludingDescendants();
+  clipper(false).clearClipRectsIncludingDescendants();
 
   PaintLayer* nextSib = nextSibling();
 
   // Now walk our kids and reattach them to our parent.
   PaintLayer* current = m_first;
   while (current) {
     PaintLayer* next = current->nextSibling();
     removeChild(current);
     m_parent->addChild(current, nextSib);
 
@@ skipping 43 matching lines @@
     }
   }
 
   if (!didSetPaintInvalidation && isSelfPaintingLayer() && m_parent) {
     if (PaintLayer* enclosingSelfPaintingLayer =
             m_parent->enclosingSelfPaintingLayer())
       mergeNeedsPaintPhaseFlagsFrom(*enclosingSelfPaintingLayer);
   }
 
   // Clear out all the clip rects.
-  clipper().clearClipRectsIncludingDescendants();
+  clipper(false).clearClipRectsIncludingDescendants();
 }
 
 // Returns the layer reached on the walk up towards the ancestor.
 static inline const PaintLayer* accumulateOffsetTowardsAncestor(
     const PaintLayer* layer,
     const PaintLayer* ancestorLayer,
     LayoutPoint& location) {
   DCHECK(ancestorLayer != layer);
 
   const LayoutBoxModelObject* layoutObject = layer->layoutObject();
@@ skipping 102 matching lines @@
   return m_scrollableArea && (m_scrollableArea->hasScrollbar() ||
                               m_scrollableArea->scrollCorner() ||
                               layoutObject()->style()->resize() != RESIZE_NONE);
 }
 
 void PaintLayer::appendSingleFragmentIgnoringPagination(
     PaintLayerFragments& fragments,
     const PaintLayer* rootLayer,
     const LayoutRect& dirtyRect,
     ClipRectsCacheSlot clipRectsCacheSlot,
+    bool useGeometryMapper,
     OverlayScrollbarClipBehavior overlayScrollbarClipBehavior,
     ShouldRespectOverflowClipType respectOverflowClip,
     const LayoutPoint* offsetFromRoot,
     const LayoutSize& subPixelAccumulation) {
   PaintLayerFragment fragment;
   ClipRectsContext clipRectsContext(rootLayer, clipRectsCacheSlot,
                                     overlayScrollbarClipBehavior,
                                     subPixelAccumulation);
   if (respectOverflowClip == IgnoreOverflowClip)
     clipRectsContext.setIgnoreOverflowClip();
-  clipper().calculateRects(clipRectsContext, dirtyRect, fragment.layerBounds,
-                           fragment.backgroundRect, fragment.foregroundRect,
-                           offsetFromRoot);
+  clipper(useGeometryMapper)
+      .calculateRects(clipRectsContext, dirtyRect, fragment.layerBounds,
+                      fragment.backgroundRect, fragment.foregroundRect,
+                      offsetFromRoot);
   fragments.push_back(fragment);
 }
 
 bool PaintLayer::shouldFragmentCompositedBounds(
     const PaintLayer* compositingLayer) const {
   // Composited layers may not be fragmented.
   return enclosingPaginationLayer() &&
          !compositingLayer->enclosingPaginationLayer();
 }
 
 void PaintLayer::collectFragments(
     PaintLayerFragments& fragments,
     const PaintLayer* rootLayer,
     const LayoutRect& dirtyRect,
     ClipRectsCacheSlot clipRectsCacheSlot,
+    bool useGeometryMapper,
     OverlayScrollbarClipBehavior overlayScrollbarClipBehavior,
     ShouldRespectOverflowClipType respectOverflowClip,
     const LayoutPoint* offsetFromRoot,
     const LayoutSize& subPixelAccumulation,
     const LayoutRect* layerBoundingBox) {
   if (!enclosingPaginationLayer()) {
     // For unpaginated layers, there is only one fragment.
     appendSingleFragmentIgnoringPagination(
-        fragments, rootLayer, dirtyRect, clipRectsCacheSlot,
+        fragments, rootLayer, dirtyRect, clipRectsCacheSlot, useGeometryMapper,
         overlayScrollbarClipBehavior, respectOverflowClip, offsetFromRoot,
         subPixelAccumulation);
     return;
   }
 
   if (!shouldFragmentCompositedBounds(rootLayer)) {
     appendSingleFragmentIgnoringPagination(
-        fragments, rootLayer, dirtyRect, clipRectsCacheSlot,
+        fragments, rootLayer, dirtyRect, clipRectsCacheSlot, useGeometryMapper,
         overlayScrollbarClipBehavior, respectOverflowClip, offsetFromRoot,
         subPixelAccumulation);
     return;
   }
 
   // Compute our offset within the enclosing pagination layer.
   LayoutPoint offsetWithinPaginatedLayer;
   convertToLayerCoords(enclosingPaginationLayer(), offsetWithinPaginatedLayer);
 
   // Calculate clip rects relative to the enclosingPaginationLayer. The purpose
   // of this call is to determine our bounds clipped to intermediate layers
   // between us and the pagination context. It's important to minimize the
   // number of fragments we need to create and this helps with that.
   ClipRectsContext paginationClipRectsContext(enclosingPaginationLayer(),
                                               clipRectsCacheSlot,
                                               overlayScrollbarClipBehavior);
   if (respectOverflowClip == IgnoreOverflowClip)
     paginationClipRectsContext.setIgnoreOverflowClip();
   LayoutRect layerBoundsInFlowThread;
   ClipRect backgroundRectInFlowThread;
   ClipRect foregroundRectInFlowThread;
-  clipper().calculateRects(
-      paginationClipRectsContext, LayoutRect(LayoutRect::infiniteIntRect()),
-      layerBoundsInFlowThread, backgroundRectInFlowThread,
-      foregroundRectInFlowThread, &offsetWithinPaginatedLayer);
+  clipper(useGeometryMapper)
+      .calculateRects(paginationClipRectsContext,
+                      LayoutRect(LayoutRect::infiniteIntRect()),
+                      layerBoundsInFlowThread, backgroundRectInFlowThread,
+                      foregroundRectInFlowThread, &offsetWithinPaginatedLayer);
 
   // Take our bounding box within the flow thread and clip it.
   LayoutRect layerBoundingBoxInFlowThread =
       layerBoundingBox ? *layerBoundingBox
                        : physicalBoundingBox(offsetWithinPaginatedLayer);
   layerBoundingBoxInFlowThread.intersect(backgroundRectInFlowThread.rect());
 
   LayoutFlowThread* enclosingFlowThread =
       toLayoutFlowThread(enclosingPaginationLayer()->layoutObject());
   // Visual offset from the root layer to the nearest fragmentation context.
@@ skipping 30 matching lines @@
   // intersect with that when painting column contents.
   ClipRect ancestorClipRect = dirtyRect;
   if (const PaintLayer* paginationParentLayer =
           enclosingPaginationLayer()->parent()) {
     const PaintLayer* ancestorLayer =
         rootLayerIsInsidePaginationLayer ? paginationParentLayer : rootLayer;
     ClipRectsContext clipRectsContext(ancestorLayer, clipRectsCacheSlot,
                                       overlayScrollbarClipBehavior);
     if (respectOverflowClip == IgnoreOverflowClip)
       clipRectsContext.setIgnoreOverflowClip();
-    ancestorClipRect = enclosingPaginationLayer()->clipper().backgroundClipRect(
-        clipRectsContext);
+    ancestorClipRect = enclosingPaginationLayer()
+                           ->clipper(useGeometryMapper)
+                           .backgroundClipRect(clipRectsContext);
     if (rootLayerIsInsidePaginationLayer)
       ancestorClipRect.moveBy(
           -rootLayer->visualOffsetFromAncestor(ancestorLayer));
     ancestorClipRect.intersect(dirtyRect);
   }
 
   const LayoutSize subPixelAccumulationIfNeeded =
       offsetFromRoot ? subPixelAccumulation : LayoutSize();
   for (; !iterator.atEnd(); iterator.advance()) {
     PaintLayerFragment fragment;
@@ skipping 230 matching lines @@
 
   // Apply a transform if we have one.
   if (transform() && !appliedTransform) {
     if (enclosingPaginationLayer())
       return hitTestTransformedLayerInFragments(
           rootLayer, containerLayer, result, hitTestRect, hitTestLocation,
           transformState, zOffset, clipRectsCacheSlot);
 
     // Make sure the parent's clip rects have been calculated.
     if (parent()) {
-      ClipRect clipRect = clipper().backgroundClipRect(
+      ClipRect clipRect = clipper(false).backgroundClipRect(
           ClipRectsContext(rootLayer, clipRectsCacheSlot,
                            ExcludeOverlayScrollbarSizeForHitTesting));
       // Go ahead and test the enclosing clip now.
       if (!clipRect.intersects(hitTestLocation))
         return nullptr;
     }
 
     return hitTestLayerByApplyingTransform(rootLayer, containerLayer, result,
                                            hitTestRect, hitTestLocation,
                                            transformState, zOffset);
@@ skipping 84 matching lines @@
     if (!depthSortDescendants)
       return hitLayer;
     candidateLayer = hitLayer;
   }
 
   // Collect the fragments. This will compute the clip rectangles for each layer
   // fragment.
   PaintLayerFragments layerFragments;
   if (appliedTransform)
     appendSingleFragmentIgnoringPagination(
-        layerFragments, rootLayer, hitTestRect, clipRectsCacheSlot,
+        layerFragments, rootLayer, hitTestRect, clipRectsCacheSlot, false,
         ExcludeOverlayScrollbarSizeForHitTesting);
   else
     collectFragments(layerFragments, rootLayer, hitTestRect, clipRectsCacheSlot,
-                     ExcludeOverlayScrollbarSizeForHitTesting);
+                     false, ExcludeOverlayScrollbarSizeForHitTesting);
 
   if (m_scrollableArea &&
       m_scrollableArea->hitTestResizerInFragments(layerFragments,
                                                   hitTestLocation)) {
     layoutObject()->updateHitTestResult(result, hitTestLocation.point());
     return this;
   }
 
   // Next we want to see if the mouse pos is inside the child LayoutObjects of
   // the layer. Check every fragment in reverse order.
@@ skipping 94 matching lines @@
     double* zOffset,
     ClipRectsCacheSlot clipRectsCacheSlot) {
   PaintLayerFragments enclosingPaginationFragments;
   LayoutPoint offsetOfPaginationLayerFromRoot;
   // FIXME: We're missing a sub-pixel offset here crbug.com/348728
   LayoutRect transformedExtent = transparencyClipBox(
       this, enclosingPaginationLayer(), HitTestingTransparencyClipBox,
       PaintLayer::RootOfTransparencyClipBox, LayoutSize());
   enclosingPaginationLayer()->collectFragments(
       enclosingPaginationFragments, rootLayer, hitTestRect, clipRectsCacheSlot,
-      ExcludeOverlayScrollbarSizeForHitTesting, RespectOverflowClip,
+      false, ExcludeOverlayScrollbarSizeForHitTesting, RespectOverflowClip,
       &offsetOfPaginationLayerFromRoot, LayoutSize(), &transformedExtent);
 
   for (int i = enclosingPaginationFragments.size() - 1; i >= 0; --i) {
     const PaintLayerFragment& fragment = enclosingPaginationFragments.at(i);
 
     // Apply the page/column clip for this fragment, as well as any clips
     // established by layers in between us and the enclosing pagination layer.
     LayoutRect clipRect = fragment.backgroundRect.rect();
 
     // Now compute the clips within a given fragment
     if (parent() != enclosingPaginationLayer()) {
       enclosingPaginationLayer()->convertToLayerCoords(
           rootLayer, offsetOfPaginationLayerFromRoot);
       LayoutRect parentClipRect =
-          clipper()
+          clipper(RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled())
               .backgroundClipRect(ClipRectsContext(
                   enclosingPaginationLayer(), clipRectsCacheSlot,
                   ExcludeOverlayScrollbarSizeForHitTesting))
               .rect();
       parentClipRect.moveBy(fragment.paginationOffset +
                             offsetOfPaginationLayerFromRoot);
       clipRect.intersect(parentClipRect);
     }
 
     if (!hitTestLocation.intersects(clipRect))
@@ skipping 363 matching lines @@
   // and hit-testing, and should not contribute to the bounding box. The
   // LayoutMultiColumnSets will contribute the correct size for the layout
   // content of the multicol container.
   if (layoutObject()->isLayoutFlowThread())
     return LayoutRect();
 
   const_cast<PaintLayer*>(this)->stackingNode()->updateLayerListsIfNeeded();
 
   // If there is a clip applied by an ancestor to this PaintLayer but below or
   // equal to |ancestorLayer|, apply that clip.
-  LayoutRect result = clipper().localClipRect(compositedLayer);
+  LayoutRect result = clipper(false).localClipRect(compositedLayer);
 
   result.intersect(physicalBoundingBox(LayoutPoint()));
 
   expandRectForStackingChildren(compositedLayer, result, options);
 
   // Only enlarge by the filter outsets if we know the filter is going to be
   // rendered in software.  Accelerated filters will handle their own outsets.
   if (paintsWithFilters())
     result = mapLayoutRectForFilter(result);
 
@@ skipping 413 matching lines @@
   updateSelfPaintingLayer();
 
   updateTransform(oldStyle, layoutObject()->styleRef());
   updateFilters(oldStyle, layoutObject()->styleRef());
   updateClipPath(oldStyle, layoutObject()->styleRef());
 
   setNeedsCompositingInputsUpdate();
   layoutObject()->setNeedsPaintPropertyUpdate();
 }
 
+PaintLayerClipper PaintLayer::clipper(bool useGeometryMapper) const {

[pdr., 2017/02/10 20:51:07]

Can you add an enum for UseGeometryMapper to make the false/true's easier to
understand?

I worry we're failing to use the mapper in some cases and using it when we
shouldn't in others. Instead of passing this in at the callsites, could this
function pass a geometrymapper if the document lifecycle allows it, and not
otherwise? If there are cases when recursion should disallow it, maybe an
optional argument could be used for that?

IOW, something like:
PaintLayerClipper PaintLayer::clipper() const {
  GeometryMapper* geometryMapper = nullptr;
  if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled()) {
    if (m_layoutObject->document()->lifecycle() >= InPrePaint)
      geometryMapper = ...
  }
  return PaintLayerClipper(*this, geometryMapper);
}

[chrishtr, 2017/02/10 22:56:36]

Done.
To date we do not have code which is conditional on lifecycle state, to my
knowledge. 
Instead we use it only for assertions.

+  GeometryMapper* geometryMapper = nullptr;
+  if (useGeometryMapper) {
+    DCHECK(RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
+    if (FrameView* frameView = m_layoutObject->document().view())
+      geometryMapper = frameView->geometryMapper();
+  }
+  return PaintLayerClipper(*this, geometryMapper);
+}
+
 bool PaintLayer::scrollsOverflow() const {
   if (PaintLayerScrollableArea* scrollableArea = this->getScrollableArea())
     return scrollableArea->scrollsOverflow();
 
   return false;
 }
 
 FilterOperations PaintLayer::addReflectionToFilterOperations(
     const ComputedStyle& style) const {
   FilterOperations filterOperations = style.filter();
@@ skipping 233 matching lines @@
 }
 
 void showLayerTree(const blink::LayoutObject* layoutObject) {
   if (!layoutObject) {
     LOG(INFO) << "Cannot showLayerTree. Root is (nil)";
     return;
   }
   showLayerTree(layoutObject->enclosingLayer());
 }
 #endif