SPv2: Use GeometryMapper to implement PaintLayerClipper.

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/LayoutInline.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ClipPathClipper.h"
@@ skipping 85 matching lines @@
     return FullyPainted;
 
   // If this layer is totally invisible then there is nothing to paint.
   if (!m_paintLayer.layoutObject()->opacity() &&
       !m_paintLayer.layoutObject()->hasBackdropFilter())
     return FullyPainted;
 
   if (m_paintLayer.paintsWithTransparency(paintingInfo.getGlobalPaintFlags()))
     paintFlags |= PaintLayerHaveTransparency;
 
-  // Transforms will be applied by property nodes directly for SPv2.
-  if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
-      m_paintLayer.paintsWithTransform(paintingInfo.getGlobalPaintFlags()) &&
+  if (m_paintLayer.paintsWithTransform(paintingInfo.getGlobalPaintFlags()) &&

[chrishtr, 2016/10/05 23:28:32]

Need to call paintLayerWithTransform even for SPv2, in order to map the cull
rect to the new space.

       !(paintFlags & PaintLayerAppliedTransform))
     return paintLayerWithTransform(context, paintingInfo, paintFlags);
 
   return paintLayerContentsCompositingAllPhases(context, paintingInfo,
                                                 paintFlags);
 }
 
 PaintLayerPainter::PaintResult
 PaintLayerPainter::paintLayerContentsCompositingAllPhases(
     GraphicsContext& context,
@@ skipping 68 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.
-  ClipRects& clipRects = paintLayer.clipper().paintingClipRects(
-      paintingInfo.rootLayer, respectOverflowClip, subpixelAccumulation);
-  ClipRects* previousClipRects = paintLayer.previousPaintingClipRects();
-  if (&clipRects != previousClipRects &&
-      (!previousClipRects || clipRects != *previousClipRects)) {
-    needsRepaint = true;
-    shouldClearEmptyPaintPhaseFlags = true;
+  // TODO(chrishtr): implement detecting clipping changes in SPv2. crbug.com/645667
+  if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+    ClipRects& clipRects = paintLayer.clipper().paintingClipRects(
+        paintingInfo.rootLayer, respectOverflowClip, subpixelAccumulation);
+    ClipRects* previousClipRects = paintLayer.previousPaintingClipRects();
+    if (&clipRects != previousClipRects &&
+        (!previousClipRects || clipRects != *previousClipRects)) {
+      needsRepaint = true;
+      shouldClearEmptyPaintPhaseFlags = true;
+    }
+    paintLayer.setPreviousPaintingClipRects(clipRects);
   }
-  paintLayer.setPreviousPaintingClipRects(clipRects);
 
   // Repaint if previously the layer might be clipped by paintDirtyRect and
   // paintDirtyRect changes.
   if (paintLayer.previousPaintResult() ==
           PaintLayerPainter::MayBeClippedByPaintDirtyRect &&
       paintLayer.previousPaintDirtyRect() != paintingInfo.paintDirtyRect) {
     needsRepaint = true;
     shouldClearEmptyPaintPhaseFlags = true;
   }
   paintLayer.setPreviousPaintDirtyRect(paintingInfo.paintDirtyRect);
@@ skipping 173 matching lines @@
           localPaintingInfo.paintDirtyRect, cacheSlot,
           IgnoreOverlayScrollbarSize, respectOverflowClip, &offsetFromRoot,
           localPaintingInfo.subPixelAccumulation);
     else
       m_paintLayer.collectFragments(layerFragments, localPaintingInfo.rootLayer,
                                     localPaintingInfo.paintDirtyRect, cacheSlot,
                                     IgnoreOverlayScrollbarSize,
                                     respectOverflowClip, &offsetFromRoot,
                                     localPaintingInfo.subPixelAccumulation);
 
-    // TODO(trchen): Needs to adjust cull rect between transform spaces.
-    // https://crbug.com/593596
-    // Disables layer culling for SPv2 for now because the space of the cull
-    // rect doesn't match the space we paint in. Clipping will still be done by
-    // clip nodes, so this won't cause rendering issues, only performance.
-    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
-      layerFragments[0].backgroundRect =
-          LayoutRect(LayoutRect::infiniteIntRect());
-      layerFragments[0].foregroundRect =
-          LayoutRect(LayoutRect::infiniteIntRect());
-    }
-
     if (shouldPaintContent) {
       // TODO(wangxianzhu): This is for old slow scrolling. Implement similar
       // optimization for slimming paint v2.
       shouldPaintContent = atLeastOneFragmentIntersectsDamageRect(
           layerFragments, localPaintingInfo, paintFlags, offsetFromRoot);
       if (!shouldPaintContent)
         result = MayBeClippedByPaintDirtyRect;
     }
   }
 
@@ skipping 136 matching lines @@
                                           newOffsetFromRoot))
       return true;
   }
   return false;
 }
 
 PaintLayerPainter::PaintResult PaintLayerPainter::paintLayerWithTransform(
     GraphicsContext& context,
     const PaintLayerPaintingInfo& paintingInfo,
     PaintLayerFlags paintFlags) {
-  // Transforms will be applied by property nodes directly for SPv2.
-  ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
-
   TransformationMatrix layerTransform =
       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();
 
-  ClipRect ancestorBackgroundClipRect;
-  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);
-  }
-
   LayoutObject* object = m_paintLayer.layoutObject();
   LayoutView* view = object->view();
   bool isFixedPosObjectInPagedMedia =
       object->style()->position() == FixedPosition &&
       object->container() == view && view->pageLogicalHeight();
   PaintLayer* paginationLayer = m_paintLayer.enclosingPaginationLayer();
   PaintLayerFragments fragments;
   // TODO(crbug.com/619094): Figure out the correct behaviour for fixed position
   // objects in paged media with vertical writing modes.
   if (isFixedPosObjectInPagedMedia && view->isHorizontalWritingMode()) {
@@ skipping 37 matching lines @@
     // path, when the transform has been applied.
     PaintLayerFragment fragment;
     fragment.backgroundRect = paintingInfo.paintDirtyRect;
     fragments.append(fragment);
   }
 
   Optional<DisplayItemCacheSkipper> cacheSkipper;
   if (fragments.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);
+    }
+  }
+
   PaintResult result = FullyPainted;
   for (const auto& fragment : fragments) {
     Optional<LayerClipRecorder> clipRecorder;
-    if (parentLayer) {
+    if (parentLayer && !RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       ClipRect clipRectForFragment(ancestorBackgroundClipRect);
       // A fixed-position object is repeated on every page, but if it is clipped
       // by an ancestor layer then the repetitions are clipped out.
       if (!isFixedPosObjectInPagedMedia)
         clipRectForFragment.moveBy(fragment.paginationOffset);
       clipRectForFragment.intersect(fragment.backgroundRect);
       if (clipRectForFragment.isEmpty())
         continue;
       if (needsToClip(paintingInfo, clipRectForFragment)) {
         if (m_paintLayer.layoutObject()->isPositioned() &&
@@ skipping 16 matching lines @@
   }
   return result;
 }
 
 PaintLayerPainter::PaintResult
 PaintLayerPainter::paintFragmentByApplyingTransform(
     GraphicsContext& context,
     const PaintLayerPaintingInfo& paintingInfo,
     PaintLayerFlags paintFlags,
     const LayoutPoint& fragmentTranslation) {
-  // Transforms will be applied by property nodes directly for SPv2.
-  ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
-
   // This involves subtracting out the position of the layer in our current
   // coordinate space, but preserving the accumulated error for sub-pixel
   // layout.
   LayoutPoint delta;
   m_paintLayer.convertToLayerCoords(paintingInfo.rootLayer, delta);
   delta.moveBy(fragmentTranslation);
   TransformationMatrix transform(
       m_paintLayer.renderableTransform(paintingInfo.getGlobalPaintFlags()));
   IntPoint roundedDelta = roundedIntPoint(delta);
   transform.translateRight(roundedDelta.x(), roundedDelta.y());
   LayoutSize adjustedSubPixelAccumulation =
       paintingInfo.subPixelAccumulation + (delta - roundedDelta);
 
   // TODO(jbroman): Put the real transform origin here, instead of using a
   // matrix with the origin baked in.
   FloatPoint3D transformOrigin;
   Transform3DRecorder transform3DRecorder(
       context, *m_paintLayer.layoutObject(),
       DisplayItem::kTransform3DElementTransform, transform, transformOrigin);
-
   // Now do a paint with the root layer shifted to be us.
   PaintLayerPaintingInfo transformedPaintingInfo(
       &m_paintLayer, LayoutRect(enclosingIntRect(transform.inverse().mapRect(
                          paintingInfo.paintDirtyRect))),
       paintingInfo.getGlobalPaintFlags(), adjustedSubPixelAccumulation);
   transformedPaintingInfo.ancestorHasClipPathClipping =
       paintingInfo.ancestorHasClipPathClipping;
 
   // Remove skip root background flag when we're painting with a new root.
   if (&m_paintLayer != paintingInfo.rootLayer)
@@ skipping 78 matching lines @@
   Optional<DisplayItemCacheSkipper> cacheSkipper;
   if (layerFragments.size() > 1)
     cacheSkipper.emplace(context);
 
   for (auto& fragment : layerFragments) {
     // We need to apply the same clips and transforms that
     // paintFragmentWithPhase would have.
     LayoutRect cullRect = fragment.backgroundRect.rect();
 
     Optional<LayerClipRecorder> clipRecorder;
-    if (needsToClip(localPaintingInfo, fragment.backgroundRect))
+    if (needsToClip(localPaintingInfo, fragment.backgroundRect)) {
       clipRecorder.emplace(context, *m_paintLayer.layoutObject(),
                            DisplayItem::kClipLayerOverflowControls,
                            fragment.backgroundRect, &localPaintingInfo,
                            fragment.paginationOffset, paintFlags);
+    }
 
     Optional<ScrollRecorder> scrollRecorder;
     if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
         !localPaintingInfo.scrollOffsetAccumulation.isZero()) {
       cullRect.move(localPaintingInfo.scrollOffsetAccumulation);
       scrollRecorder.emplace(context, *m_paintLayer.layoutObject(),
                              DisplayItem::kScrollOverflowControls,
                              localPaintingInfo.scrollOffsetAccumulation);
     }
 
@@ skipping 42 matching lines @@
   LayoutRect newCullRect(clipRect.rect());
   Optional<ScrollRecorder> scrollRecorder;
   LayoutPoint paintOffset = -m_paintLayer.layoutBoxLocation();
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     const ObjectPaintProperties* objectPaintProperties =
         m_paintLayer.layoutObject()->objectPaintProperties();
     ASSERT(objectPaintProperties &&
            objectPaintProperties->localBorderBoxProperties());
     paintOffset +=
         toSize(objectPaintProperties->localBorderBoxProperties()->paintOffset);
+    newCullRect.move(paintingInfo.scrollOffsetAccumulation);
   } else {
     paintOffset += toSize(fragment.layerBounds.location());
     if (!paintingInfo.scrollOffsetAccumulation.isZero()) {
       // As a descendant of the root layer, m_paintLayer's painting is not
       // controlled by the ScrollRecorders created by BlockPainter of the
       // ancestor layers up to the root layer, so we need to issue
       // ScrollRecorder for this layer seperately, with the scroll offset
       // accumulated from the root layer to the parent of this layer, to get the
       // same result as ScrollRecorder in BlockPainter.
       paintOffset += paintingInfo.scrollOffsetAccumulation;
@@ skipping 185 matching lines @@
 
   PaintLayerPaintingInfo paintingInfo(&m_paintLayer,
                                       LayoutRect(enclosingIntRect(damageRect)),
                                       paintFlags, LayoutSize());
   paintLayer(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
 
   m_paintLayer.setContainsDirtyOverlayScrollbars(false);
 }
 
 }  // namespace blink