Fix paint offset and clips in SPv2

third_party/WebKit/Source/core/paint/PaintLayerClipper.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 192 matching lines @@
     for (const PaintLayer* layer = currentLayer->firstChild(); layer;
          layer = layer->nextSibling())
       layers.push(layer);
   }
 }
 
 LayoutRect PaintLayerClipper::localClipRect(
     const PaintLayer* clippingRootLayer) const {
   ClipRectsContext context(clippingRootLayer, PaintingClipRects);
   if (m_geometryMapper) {
-    ClipRect clipRect = applyOverflowClipToBackgroundRectWithGeometryMapper(
-        context, clipRectWithGeometryMapper(context, false));
+    LayoutRect premappedRect =
+        applyOverflowClipToBackgroundRectWithGeometryMapper(
+            context, clipRectWithGeometryMapper(context, false))
+            .rect();
 
     // The rect now needs to be transformed to the local space of this
-    // PaintLayer.
+    // PaintLayer.4

[wkorman, 2017/01/12 22:37:35]

nit: '4' typo end of line

[chrishtr, 2017/01/13 00:24:03]

Fixed.

     bool success = false;
+    premappedRect.moveBy(context.rootLayer->layoutObject()->paintOffset());
     FloatRect clippedRectInLocalSpace =
         m_geometryMapper->mapRectToDestinationSpace(
-            FloatRect(clipRect.rect()), *clippingRootLayer->layoutObject()
-                                             ->paintProperties()
-                                             ->localBorderBoxProperties(),
+            FloatRect(premappedRect), *clippingRootLayer->layoutObject()
+                                           ->paintProperties()
+                                           ->localBorderBoxProperties(),
             *m_layer.layoutObject()
                  ->paintProperties()
                  ->localBorderBoxProperties(),
             success);
     DCHECK(success);
-
+    clippedRectInLocalSpace.moveBy(
+        -FloatPoint(m_layer.layoutObject()->paintOffset()));
     return LayoutRect(clippedRectInLocalSpace);
   }
 
   LayoutRect layerBounds;
   ClipRect backgroundRect, foregroundRect;
   calculateRects(context, LayoutRect(LayoutRect::infiniteIntRect()),
                  layerBounds, backgroundRect, foregroundRect);
 
   LayoutRect clipRect = backgroundRect.rect();
   // TODO(chrishtr): avoid converting to IntRect and back.
   if (clipRect == LayoutRect(LayoutRect::infiniteIntRect()))
     return clipRect;
 
   LayoutPoint clippingRootOffset;
   m_layer.convertToLayerCoords(clippingRootLayer, clippingRootOffset);
   clipRect.moveBy(-clippingRootOffset);
 
   return clipRect;
 }
 
 #ifdef CHECK_CLIP_RECTS
 #define CHECK_RECTS_EQ(expected, actual)                                \
   CHECK((expected.isEmpty() && actual.isEmpty()) || expected == actual) \
       << "expected=" << expected.toString() << " actual=" << actual.toString()
 #endif
 
 void PaintLayerClipper::mapLocalToRootWithGeometryMapper(
     const ClipRectsContext& context,
-    LayoutRect& layoutRect) const {
+    LayoutRect& rectToMap) const {
   DCHECK(m_geometryMapper);
   bool success;
 
   const auto* layerBorderBoxProperties =
       m_layer.layoutObject()->paintProperties()->localBorderBoxProperties();
-  FloatRect localRect(layoutRect);
+  FloatRect localRect(rectToMap);
   localRect.moveBy(FloatPoint(m_layer.layoutObject()->paintOffset()));
 
-  layoutRect = LayoutRect(m_geometryMapper->mapRectToDestinationSpace(
+  rectToMap = LayoutRect(m_geometryMapper->mapRectToDestinationSpace(
       localRect, *layerBorderBoxProperties, *context.rootLayer->layoutObject()
                                                  ->paintProperties()
                                                  ->localBorderBoxProperties(),
       success));
   DCHECK(success);
+  rectToMap.moveBy(-context.rootLayer->layoutObject()->paintOffset());
 }
 
 void PaintLayerClipper::calculateRectsWithGeometryMapper(
     const ClipRectsContext& context,
     const LayoutRect& paintDirtyRect,
     LayoutRect& layerBounds,
     ClipRect& backgroundRect,
     ClipRect& foregroundRect,
     const LayoutPoint* offsetFromRoot) const {
   backgroundRect = applyOverflowClipToBackgroundRectWithGeometryMapper(
@@ skipping 147 matching lines @@
 }
 
 ClipRect PaintLayerClipper::clipRectWithGeometryMapper(
     const ClipRectsContext& context,
     bool isForeground) const {
   DCHECK(m_geometryMapper);
   LayoutRect source(LayoutRect::infiniteIntRect());
   bool success = false;
   const auto* properties = m_layer.layoutObject()->paintProperties();
   DCHECK(properties && properties->localBorderBoxProperties());
+
   PropertyTreeState propertyTreeState = *properties->localBorderBoxProperties();
-
-  if (isForeground && shouldClipOverflow(context) && properties->overflowClip())
-    propertyTreeState.setClip(properties->overflowClip());
-
   const auto* ancestorProperties =
       context.rootLayer->layoutObject()->paintProperties();
   DCHECK(ancestorProperties && ancestorProperties->localBorderBoxProperties());
   PropertyTreeState destinationPropertyTreeState =
       *ancestorProperties->localBorderBoxProperties();
-  if (!context.rootLayer->clipper().shouldRespectOverflowClip(context)) {
-    if (ancestorProperties->overflowClip())
+
+  if (&m_layer == context.rootLayer) {
+    // Set the overflow clip for |propertyTreeState| so that it differs from
+    // destinationPropertyTreeState| in its clip.

[wkorman, 2017/01/12 22:37:35]

nit: missing '|' prefix on destinationPropertyTreeState

+    if (isForeground && context.respectOverflowClip == RespectOverflowClip &&
+        properties->overflowClip())
+      propertyTreeState.setClip(properties->overflowClip());
+  } else {
+    // Set the clip of |destinationPropertyTreeState| to be inside the
+    // ancestor's overflow clip, so that that clip is not applied.
+    if (context.respectOverflowClip == IgnoreOverflowClip &&
+        ancestorProperties->overflowClip())
       destinationPropertyTreeState.setClip(ancestorProperties->overflowClip());
+
+    // Set the overflow clip for |propertyTreeState| so that it differs from
+    // destinationPropertyTreeState| in its clip.
+    if (isForeground && properties->overflowClip())
+      propertyTreeState.setClip(properties->overflowClip());
   }
+
   FloatRect clippedRectInRootLayerSpace =
       m_geometryMapper->mapToVisualRectInDestinationSpace(
           FloatRect(source), propertyTreeState, destinationPropertyTreeState,
           success);
   DCHECK(success);
+  clippedRectInRootLayerSpace.moveBy(
+      -FloatPoint(context.rootLayer->layoutObject()->paintOffset()));
   return ClipRect(LayoutRect(clippedRectInRootLayerSpace));
 }
 
 ClipRect PaintLayerClipper::applyOverflowClipToBackgroundRectWithGeometryMapper(
     const ClipRectsContext& context,
     const ClipRect& clip) const {
   const LayoutObject& layoutObject = *m_layer.layoutObject();
   FloatRect clipRect(clip.rect());
   if (shouldClipOverflow(context)) {
     LayoutRect layerBoundsWithVisualOverflow =
@@ skipping 83 matching lines @@
     const LayoutSize& subpixelAccumulation) const {
   DCHECK(!m_geometryMapper);
   ClipRectsContext context(rootLayer, PaintingClipRects,
                            IgnoreOverlayScrollbarSize, subpixelAccumulation);
   if (respectOverflowClip == IgnoreOverflowClip)
     context.setIgnoreOverflowClip();
   return getClipRects(context);
 }
 
 }  // namespace blink