[SPInvalidation] Use GeometryMapper in PaintLayerClipper for paint.

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

 // Copyright 2014 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/PaintLayerPainter.h"
 
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ClipPathClipper.h"
 #include "core/paint/FilterPainter.h"
@@ skipping 209 matching lines @@
   // Repaint subsequence if the layer is marked for needing repaint.
   // We don't set needsResetEmptyPaintPhase here, but clear the empty paint
   // phase flags in PaintLayer::setNeedsPaintPhaseXXX(), to ensure that we won't
   // clear previousPaintPhaseXXXEmpty flags when unrelated things changed which
   // won't cause the paint phases to become non-empty.
   if (paintLayer.needsRepaint())
     needsRepaint = true;
 
   // Repaint if layer's clip changes.
   if (!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled()) {
-    ClipRects& clipRects = paintLayer.clipper().paintingClipRects(
-        paintingInfo.rootLayer, respectOverflowClip, subpixelAccumulation);
+    ClipRects& clipRects =
+        paintLayer.clipper(PaintLayer::DoNotUseGeometryMapper)

[pdr., 2017/02/10 23:19:20]

Should we use the mapper here since it's called through paintLayerContents?

[chrishtr, 2017/02/10 23:21:22]

No, because of line 229.

[pdr., 2017/02/10 23:23:37]

d'oh!

+            .paintingClipRects(paintingInfo.rootLayer, respectOverflowClip,
+                               subpixelAccumulation);
     ClipRects* previousClipRects = paintLayer.previousPaintingClipRects();
     if (&clipRects != previousClipRects &&
         (!previousClipRects || clipRects != *previousClipRects)) {
       needsRepaint = true;
       shouldClearEmptyPaintPhaseFlags = true;
     }
     paintLayer.setPreviousPaintingClipRects(clipRects);
   }
 
   // Repaint if previously the layer might be clipped by paintDirtyRect and
@@ skipping 188 matching lines @@
       // the clipper's layer to simplify coordinate system adjustments.
       // The change to rootLayer must persist to correctly record the clips.
       paintLayerForFragments =
           m_paintLayer.clippingContainer()->enclosingLayer();
       localPaintingInfo.rootLayer = paintLayerForFragments;
       m_paintLayer.convertToLayerCoords(localPaintingInfo.rootLayer,
                                         offsetToClipper);
       localPaintingInfo.paintDirtyRect.moveBy(offsetToClipper);
     }
 
+    PaintLayer::GeometryMapperOption geometryMapperOption =
+        PaintLayer::DoNotUseGeometryMapper;
+    if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled())
+      geometryMapperOption = PaintLayer::UseGeometryMapper;
+
     // TODO(trchen): We haven't decided how to handle visual fragmentation with
     // SPv2.  Related thread
     // https://groups.google.com/a/chromium.org/forum/#!topic/graphics-dev/81XuWFf-mxM
     if (fragmentPolicy == ForceSingleFragment ||
         RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       paintLayerForFragments->appendSingleFragmentIgnoringPagination(
           layerFragments, localPaintingInfo.rootLayer,
-          localPaintingInfo.paintDirtyRect, cacheSlot,
+          localPaintingInfo.paintDirtyRect, cacheSlot, geometryMapperOption,
           IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot,
           localPaintingInfo.subPixelAccumulation);
     } else if (isFixedPositionObjectInPagedMedia()) {
       PaintLayerFragments singleFragment;
       paintLayerForFragments->appendSingleFragmentIgnoringPagination(
           singleFragment, localPaintingInfo.rootLayer,
-          localPaintingInfo.paintDirtyRect, cacheSlot,
+          localPaintingInfo.paintDirtyRect, cacheSlot, geometryMapperOption,
           IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot,
           localPaintingInfo.subPixelAccumulation);
       repeatFixedPositionObjectInPages(singleFragment[0], paintingInfo,
                                        layerFragments);
     } else {
       paintLayerForFragments->collectFragments(
           layerFragments, localPaintingInfo.rootLayer,
-          localPaintingInfo.paintDirtyRect, cacheSlot,
+          localPaintingInfo.paintDirtyRect, cacheSlot, geometryMapperOption,
           IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot,
           localPaintingInfo.subPixelAccumulation);
     }
 
     if (paintFlags & PaintLayerPaintingAncestorClippingMaskPhase) {
       // Fragment offsets have been computed in the clipping container's
       // layer's coordinate system, but for the rest of painting we need
       // them in the layer coordinate. So move them and the foreground rect
       // that is also in the clipper's space.
       LayoutSize negativeOffset(-offsetToClipper.x(), -offsetToClipper.y());
@@ skipping 204 matching lines @@
       m_paintLayer.renderableTransform(paintingInfo.getGlobalPaintFlags());
   // If the transform can't be inverted, then don't paint anything.
   if (!layerTransform.isInvertible())
     return FullyPainted;
 
   // FIXME: We should make sure that we don't walk past paintingInfo.rootLayer
   // here.  m_paintLayer may be the "root", and then we should avoid looking at
   // its parent.
   PaintLayer* parentLayer = m_paintLayer.parent();
 
+  PaintLayer::GeometryMapperOption geometryMapperOption =
+      PaintLayer::DoNotUseGeometryMapper;
+  if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled())
+    geometryMapperOption = PaintLayer::UseGeometryMapper;
+
   PaintLayer* paginationLayer = m_paintLayer.enclosingPaginationLayer();
   PaintLayerFragments layerFragments;
   bool isFixedPositionObjectInPagedMedia =
       this->isFixedPositionObjectInPagedMedia();
   if (!paginationLayer || isFixedPositionObjectInPagedMedia) {
     // We don't need to collect any fragments in the regular way here. We have
     // already calculated a clip rectangle for the ancestry if it was needed,
     // and clipping this layer is something that can be done further down the
     // path, when the transform has been applied.
     PaintLayerFragment fragment;
@@ skipping 10 matching lines @@
                                        ? UncachedClipRects
                                        : PaintingClipRects;
     ShouldRespectOverflowClipType respectOverflowClip =
         shouldRespectOverflowClip(paintFlags, m_paintLayer.layoutObject());
     // Calculate the transformed bounding box in the current coordinate space,
     // to figure out which fragmentainers (e.g. columns) we need to visit.
     LayoutRect transformedExtent = PaintLayer::transparencyClipBox(
         &m_paintLayer, paginationLayer, PaintLayer::PaintingTransparencyClipBox,
         PaintLayer::RootOfTransparencyClipBox,
         paintingInfo.subPixelAccumulation, paintingInfo.getGlobalPaintFlags());
+
     // FIXME: we don't check if paginationLayer is within
     // paintingInfo.rootLayer
     // here.
     paginationLayer->collectFragments(
         layerFragments, paintingInfo.rootLayer, paintingInfo.paintDirtyRect,
-        cacheSlot, IgnoreOverlayScrollbarSize, respectOverflowClip, nullptr,
-        paintingInfo.subPixelAccumulation, &transformedExtent);
+        cacheSlot, geometryMapperOption, IgnoreOverlayScrollbarSize,
+        respectOverflowClip, nullptr, paintingInfo.subPixelAccumulation,
+        &transformedExtent);
   }
 
   Optional<DisplayItemCacheSkipper> cacheSkipper;
   if (layerFragments.size() > 1)
     cacheSkipper.emplace(context);
 
   ClipRect ancestorBackgroundClipRect;
   if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     if (parentLayer) {
       // Calculate the clip rectangle that the ancestors establish.
       ClipRectsContext clipRectsContext(
           paintingInfo.rootLayer,
           (paintFlags & PaintLayerUncachedClipRects) ? UncachedClipRects
                                                      : PaintingClipRects,
           IgnoreOverlayScrollbarSize);
       if (shouldRespectOverflowClip(paintFlags, m_paintLayer.layoutObject()) ==
           IgnoreOverflowClip)
         clipRectsContext.setIgnoreOverflowClip();
-      ancestorBackgroundClipRect =
-          m_paintLayer.clipper().backgroundClipRect(clipRectsContext);
+      ancestorBackgroundClipRect = m_paintLayer.clipper(geometryMapperOption)
+                                       .backgroundClipRect(clipRectsContext);
     }
   }
 
   PaintResult result = FullyPainted;
   for (const auto& fragment : layerFragments) {
     Optional<LayerClipRecorder> clipRecorder;
     if (parentLayer && !RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       ClipRect clipRectForFragment(ancestorBackgroundClipRect);
       // A fixed-position object is repeated on every page instead of paginated,
       // so we should apply the original ancestor clip rect.
@@ skipping 432 matching lines @@
           context, layoutObject, PaintPhaseClippingMask))
     return;
 
   IntRect snappedClipRect = pixelSnappedIntRect(clipRect.rect());
   LayoutObjectDrawingRecorder drawingRecorder(
       context, layoutObject, PaintPhaseClippingMask, snappedClipRect);
   context.fillRect(snappedClipRect, Color::black);
 }
 
 }  // namespace blink