[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(PaintLayer::DoNotUseGeometryMapper)
+      .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(PaintLayer::DoNotUseGeometryMapper)
+      .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(PaintLayer::DoNotUseGeometryMapper)
+        .clearClipRectsIncludingDescendants();
   } else if (hasTransform) {
-    clipper().clearClipRectsIncludingDescendants(AbsoluteClipRects);
+    clipper(PaintLayer::DoNotUseGeometryMapper)
+        .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(PaintLayer::DoNotUseGeometryMapper)
+      .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(PaintLayer::DoNotUseGeometryMapper)
+      .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,
+    PaintLayer::GeometryMapperOption geometryMapperOption,
     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(geometryMapperOption)
+      .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,
+    PaintLayer::GeometryMapperOption geometryMapperOption,
     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,
-        overlayScrollbarClipBehavior, respectOverflowClip, offsetFromRoot,
-        subPixelAccumulation);
+        geometryMapperOption, overlayScrollbarClipBehavior, respectOverflowClip,
+        offsetFromRoot, subPixelAccumulation);
     return;
   }
 
   if (!shouldFragmentCompositedBounds(rootLayer)) {
     appendSingleFragmentIgnoringPagination(
         fragments, rootLayer, dirtyRect, clipRectsCacheSlot,
-        overlayScrollbarClipBehavior, respectOverflowClip, offsetFromRoot,
-        subPixelAccumulation);
+        geometryMapperOption, 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(geometryMapperOption)
+      .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(geometryMapperOption)
+                           .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(
-          ClipRectsContext(rootLayer, clipRectsCacheSlot,
-                           ExcludeOverlayScrollbarSizeForHitTesting));
+      ClipRect clipRect = clipper(PaintLayer::DoNotUseGeometryMapper)
+                              .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 83 matching lines @@
       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,
+        PaintLayer::DoNotUseGeometryMapper,
         ExcludeOverlayScrollbarSizeForHitTesting);
   else
     collectFragments(layerFragments, rootLayer, hitTestRect, clipRectsCacheSlot,
+                     PaintLayer::DoNotUseGeometryMapper,
                      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
@@ skipping 95 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,
+      PaintLayer::DoNotUseGeometryMapper,
       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(PaintLayer::DoNotUseGeometryMapper)
               .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(PaintLayer::DoNotUseGeometryMapper)
+                          .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(
+    GeometryMapperOption geometryMapperOption) const {
+  GeometryMapper* geometryMapper = nullptr;
+  if (geometryMapperOption == 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