Generate scroll/clip display item hierarchy for SPv2

Source/core/paint/DeprecatedPaintLayer.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>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 693 matching lines @@
     }
 
     // If we live in a 3d hierarchy, then the layer at the root of that hierarchy needs
     // the m_has3DTransformedDescendant set.
     if (preserves3D())
         return has3DTransform() || m_has3DTransformedDescendant;
 
     return has3DTransform();
 }
 
+LayoutPoint DeprecatedPaintLayer::locationExcludeOverflowScroll() const
+{
+    // Our m_location already has scroll offset baked-in. We have to revert it here.

[pdr., 2015/09/08 04:23:53]

Ok, lets keep this and LocationQueryBehavior bug lets ASSERT(spv2) here to keep
other folks from making a mistake and using this too early.

[trchen, 2015/09/15 04:48:40]

Done.

+    IntSize scrollOffset;
+    if (DeprecatedPaintLayer* positionedParent = layoutObject()->isOutOfFlowPositioned() ? enclosingPositionedAncestor() : nullptr) {

[pdr., 2015/09/08 04:23:53]

Nit: temporary code, but can we rewrite it like so?
LayoutPoint DeprecatedPaintLayer::locationExcludeOverflowScroll() const
{
    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());

    // Our m_location already has scroll offset baked-in. We have to revert it
here.
    DeprecatedPaintLayer* scrollParent = layoutObject()->isOutOfFlowPositioned()
? enclosingPositionedAncestor() : parent();
    if (scrollParent && scrollParent->layoutObject()->hasOverflowClip())
        return m_location +
LayoutSize(scrollParent->layoutBox()->scrolledContentOffset())
    return m_location;
}

[trchen, 2015/09/15 04:48:40]

Done.

+        if (positionedParent->layoutObject()->hasOverflowClip())
+            scrollOffset = positionedParent->layoutBox()->scrolledContentOffset();
+    } else if (parent() && parent()->layoutObject()->hasOverflowClip()) {
+        scrollOffset = parent()->layoutBox()->scrolledContentOffset();
+    }
+    return m_location + LayoutSize(scrollOffset);
+}
+
 bool DeprecatedPaintLayer::updateLayerPosition()
 {
     LayoutPoint localPoint;
     LayoutPoint inlineBoundingBoxOffset; // We don't put this into the Layer x/y for inlines, so we need to subtract it out when done.
 
     if (layoutObject()->isInline() && layoutObject()->isLayoutInline()) {
         LayoutInline* inlineFlow = toLayoutInline(layoutObject());
         IntRect lineBox = inlineFlow->linesBoundingBox();
         m_size = lineBox.size();
         inlineBoundingBoxOffset = lineBox.location();
@@ skipping 513 matching lines @@
 
     // Remove all descendant layers from the hierarchy and add them to the new position.
     for (LayoutObject* curr = layoutObject()->slowFirstChild(); curr; curr = curr->nextSibling())
         curr->moveLayers(m_parent, this);
 
     // Clear out all the clip rects.
     m_clipper.clearClipRectsIncludingDescendants();
 }
 
 // Returns the layer reached on the walk up towards the ancestor.
-static inline const DeprecatedPaintLayer* accumulateOffsetTowardsAncestor(const DeprecatedPaintLayer* layer, const DeprecatedPaintLayer* ancestorLayer, LayoutPoint& location)
+static inline const DeprecatedPaintLayer* accumulateOffsetTowardsAncestor(const DeprecatedPaintLayer* layer, const DeprecatedPaintLayer* ancestorLayer, LayoutPoint& location, DeprecatedPaintLayer::LocationQueryBehavior behavior)
 {
     ASSERT(ancestorLayer != layer);
 
     const LayoutBoxModelObject* layoutObject = layer->layoutObject();
     EPosition position = layoutObject->style()->position();
 
     if (position == FixedPosition && (!ancestorLayer || ancestorLayer == layoutObject->view()->layer())) {
         // If the fixed layer's container is the root, just add in the offset of the view. We can obtain this by calling
         // localToAbsolute() on the LayoutView.
         FloatPoint absPos = layoutObject->localToAbsolute(FloatPoint(), IsFixed);
         location += LayoutSize(absPos.x(), absPos.y());
         return ancestorLayer;
     }
 
     DeprecatedPaintLayer* parentLayer;
     if (position == AbsolutePosition || position == FixedPosition) {
         bool foundAncestorFirst;
         parentLayer = layer->enclosingPositionedAncestor(ancestorLayer, &foundAncestorFirst);
 
         if (foundAncestorFirst) {
             // Found ancestorLayer before the container of the out-of-flow object, so compute offset
             // of both relative to the container and subtract.
 
             LayoutPoint thisCoords;
-            layer->convertToLayerCoords(parentLayer, thisCoords);
+            layer->convertToLayerCoords(parentLayer, thisCoords, behavior);
 
             LayoutPoint ancestorCoords;
-            ancestorLayer->convertToLayerCoords(parentLayer, ancestorCoords);
+            ancestorLayer->convertToLayerCoords(parentLayer, ancestorCoords, behavior);
 
             location += (thisCoords - ancestorCoords);
             return ancestorLayer;
         }
     } else if (layoutObject->isColumnSpanAll()) {
         LayoutBlock* multicolContainer = layoutObject->containingBlock();
         ASSERT(toLayoutBlockFlow(multicolContainer)->multiColumnFlowThread());
         parentLayer = multicolContainer->layer();
         ASSERT(parentLayer);
     } else {
         parentLayer = layer->parent();
     }
 
     if (!parentLayer)
         return nullptr;
 
-    location += layer->location();
+    location += layer->location(behavior);
     return parentLayer;
 }
 
-void DeprecatedPaintLayer::convertToLayerCoords(const DeprecatedPaintLayer* ancestorLayer, LayoutPoint& location) const
+void DeprecatedPaintLayer::convertToLayerCoords(const DeprecatedPaintLayer* ancestorLayer, LayoutPoint& location, LocationQueryBehavior behavior) const
 {
     if (ancestorLayer == this)
         return;
 
     const DeprecatedPaintLayer* currLayer = this;
     while (currLayer && currLayer != ancestorLayer)
-        currLayer = accumulateOffsetTowardsAncestor(currLayer, ancestorLayer, location);
+        currLayer = accumulateOffsetTowardsAncestor(currLayer, ancestorLayer, location, behavior);
 }
 
 void DeprecatedPaintLayer::convertToLayerCoords(const DeprecatedPaintLayer* ancestorLayer, LayoutRect& rect) const
 {
     LayoutPoint delta;
     convertToLayerCoords(ancestorLayer, delta);
     rect.moveBy(delta);
 }
 
 LayoutPoint DeprecatedPaintLayer::visualOffsetFromAncestor(const DeprecatedPaintLayer* ancestorLayer) const
@@ skipping 1012 matching lines @@
     return m_compositedDeprecatedPaintLayerMapping && m_compositedDeprecatedPaintLayerMapping->hasMaskLayer();
 }
 
 bool DeprecatedPaintLayer::hasCompositedClippingMask() const
 {
     return m_compositedDeprecatedPaintLayerMapping && m_compositedDeprecatedPaintLayerMapping->hasChildClippingMaskLayer();
 }
 
 bool DeprecatedPaintLayer::paintsWithTransform(GlobalPaintFlags globalPaintFlags) const
 {
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+        return hasTransformRelatedProperty();
+
     return (transform() || layoutObject()->style()->position() == FixedPosition) && ((globalPaintFlags & GlobalPaintFlattenCompositingLayers) || compositingState() != PaintsIntoOwnBacking);
 }
 
 bool DeprecatedPaintLayer::backgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) const
 {
     if (!isSelfPaintingLayer() && !hasSelfPaintingLayerDescendant())
         return false;
 
     if (paintsWithTransparency(GlobalPaintNormalPhase))
         return false;
@@ skipping 396 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif