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 clippedRectInLocalSpace(
+        applyOverflowClipToBackgroundRectWithGeometryMapper(
+            context, clipRectWithGeometryMapper(context, false))
+            .rect());
 
     // The rect now needs to be transformed to the local space of this
     // PaintLayer.
-    bool success = false;
-    FloatRect clippedRectInLocalSpace =
-        m_geometryMapper->mapRectToDestinationSpace(
-            FloatRect(clipRect.rect()), *clippingRootLayer->layoutObject()
-                                             ->paintProperties()
-                                             ->localBorderBoxProperties(),
-            *m_layer.layoutObject()
-                 ->paintProperties()
-                 ->localBorderBoxProperties(),
-            success);
-    DCHECK(success);
+    LayoutPoint clippingRootOffset;

[chrishtr, 2017/01/12 00:16:27]

The simplest thing to do here is to just offset to the other layer.
The only use case of this method is boundingBoxForCompositing, which is not
really called at all by SPv2 (it is, but that's a bug in ViewPainter), which
I'll remove soon.

[chrishtr, 2017/01/12 00:28:14]

This statement is incorrect.
PaintLayer::physicalBoundingBoxIncludingStackingChildren will still have
callers, which in turn calls boundingBoxForCompositing. Fixing..

[chrishtr, 2017/01/12 00:42:54]

Fixed.

+    m_layer.convertToLayerCoords(clippingRootLayer, clippingRootOffset);
+    clippedRectInLocalSpace.moveBy(-clippingRootOffset);
 
-    return LayoutRect(clippedRectInLocalSpace);
+    return 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) {

[chrishtr, 2017/01/12 00:16:26]

Overflow clips are applied if

1. We're not ignoring the clip by the context setting plus the layer in question
being the rootLayer.
2. We're computing the foreground rect, not the background one.

+    // Set the overflow clip for |propertyTreeState| so that it differs from
+    // destinationPropertyTreeState| in its clip.
+    if (isForeground && context.respectOverflowClip == RespectOverflowClip &&
+        properties->overflowClip())
+      propertyTreeState.setClip(properties->overflowClip());
+  } else {
+    // Set the clip of |destinationPropertyTreeState| to be inside the
+    // ancestor's

[wkorman, 2017/01/12 00:29:18]

fix wrapping

[chrishtr, 2017/01/12 00:42:54]

Done.

+    // 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