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 682 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::locationSansOverflowScroll() const
+{
+    // Our m_location already has scroll offset baked-in. We have to revert it here.
+    IntSize scrollOffset;
+    if (DeprecatedPaintLayer* positionedParent = layoutObject()->isOutOfFlowPositioned() ? enclosingPositionedAncestor() : nullptr) {
+        if (positionedParent->layoutObject()->hasOverflowClip())
+            scrollOffset = positionedParent->layoutBox()->scrolledContentOffset();
+    } else if (parent() && parent()->layoutObject()->hasOverflowClip()) {
+        scrollOffset = parent()->layoutBox()->scrolledContentOffset();
+    }
+    return location() + LayoutSize(scrollOffset);

[pdr., 2015/08/25 20:47:55]

Shouldn't this be subtraction?

[trchen, 2015/08/26 07:39:04]

A layer moves up (subtraction) when it scrolls, so it is moving down (addition)
to revert scroll. ;)

+}
+
 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 572 matching lines @@
 void DeprecatedPaintLayer::convertToLayerCoords(const DeprecatedPaintLayer* ancestorLayer, LayoutPoint& location) const
 {
     if (ancestorLayer == this)
         return;
 
     const DeprecatedPaintLayer* currLayer = this;
     while (currLayer && currLayer != ancestorLayer)
         currLayer = accumulateOffsetTowardsAncestor(currLayer, ancestorLayer, location);
 }
 
+// TODO(trchen): Deduplicate.
+static inline const DeprecatedPaintLayer* accumulateOffsetTowardsAncestorSansOverflowScroll(const DeprecatedPaintLayer* layer, const DeprecatedPaintLayer* ancestorLayer, LayoutPoint& location)
+{
+    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->convertToLayerCoordsSansOverflowScroll(parentLayer, thisCoords);
+
+            LayoutPoint ancestorCoords;
+            ancestorLayer->convertToLayerCoordsSansOverflowScroll(parentLayer, ancestorCoords);
+
+            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->locationSansOverflowScroll();
+    return parentLayer;
+}
+
+// TODO(trchen): Deduplicate.
+void DeprecatedPaintLayer::convertToLayerCoordsSansOverflowScroll(const DeprecatedPaintLayer* ancestorLayer, LayoutPoint& location) const
+{
+    if (ancestorLayer == this)
+        return;
+
+    const DeprecatedPaintLayer* currLayer = this;
+    while (currLayer && currLayer != ancestorLayer)
+        currLayer = accumulateOffsetTowardsAncestorSansOverflowScroll(currLayer, ancestorLayer, location);
+}
+
 void DeprecatedPaintLayer::convertToLayerCoords(const DeprecatedPaintLayer* ancestorLayer, LayoutRect& rect) const
 {
     LayoutPoint delta;
     convertToLayerCoords(ancestorLayer, delta);
     rect.moveBy(delta);
 }
 
 LayoutPoint DeprecatedPaintLayer::visualOffsetFromAncestor(const DeprecatedPaintLayer* ancestorLayer) const
 {
     LayoutPoint offset;
@@ skipping 93 matching lines @@
     if (respectOverflowClip == IgnoreOverflowClip)
         paginationClipRectsContext.setIgnoreOverflowClip();
     LayoutRect layerBoundsInFlowThread;
     ClipRect backgroundRectInFlowThread;
     ClipRect foregroundRectInFlowThread;
     ClipRect outlineRectInFlowThread;
     clipper().calculateRects(paginationClipRectsContext, LayoutRect(LayoutRect::infiniteIntRect()), layerBoundsInFlowThread, backgroundRectInFlowThread, foregroundRectInFlowThread,
         outlineRectInFlowThread, &offsetWithinPaginatedLayer);
 
     // Take our bounding box within the flow thread and clip it.
-    LayoutRect layerBoundingBoxInFlowThread = layerBoundingBox ? *layerBoundingBox : physicalBoundingBox(enclosingPaginationLayer(), &offsetWithinPaginatedLayer);
+    LayoutRect layerBoundingBoxInFlowThread = layerBoundingBox ? *layerBoundingBox : physicalBoundingBox(nullptr, &offsetWithinPaginatedLayer);
     layerBoundingBoxInFlowThread.intersect(backgroundRectInFlowThread.rect());
 
     // Make the dirty rect relative to the fragmentation context (multicol container, etc.).
     LayoutFlowThread* enclosingFlowThread = toLayoutFlowThread(enclosingPaginationLayer()->layoutObject());
     LayoutPoint offsetOfPaginationLayerFromRoot; // Visual offset from the root layer to the nearest fragmentation context.
     bool rootLayerIsInsidePaginationLayer = rootLayer->enclosingPaginationLayer() == enclosingPaginationLayer();
     if (rootLayerIsInsidePaginationLayer) {
         // The root layer is in the same fragmentation context as this layer, so we need to look
         // inside it and subtract the offset between the fragmentation context and the root layer.
         offsetOfPaginationLayerFromRoot = -rootLayer->visualOffsetFromAncestor(enclosingPaginationLayer());
@@ skipping 588 matching lines @@
     // ASSERT(layoutObject()->document().lifecycle().state() >= DocumentLifecycle::LayoutClean);
 
     if (!layoutObject()->isLayoutBlock())
         return false;
 
     return toLayoutBlock(layoutObject())->shouldPaintSelectionGaps();
 }
 
 bool DeprecatedPaintLayer::intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const DeprecatedPaintLayer* rootLayer, const LayoutPoint* offsetFromRoot) const
 {
+    ASSERT(!(rootLayer && offsetFromRoot));
     // Always examine the canvas and the root.
     // FIXME: Could eliminate the isDocumentElement() check if we fix background painting so that the LayoutView
     // paints the root's background.
     if (isRootLayer() || layoutObject()->isDocumentElement())
         return true;
 
     // If we aren't an inline flow, and our layer bounds do intersect the damage rect, then we
     // can go ahead and return true.
     LayoutView* view = layoutObject()->view();
     ASSERT(view);
@@ skipping 48 matching lines @@
     LayoutRect result = boundingBox;
     if (layoutObjects->isBox())
         toLayoutBox(layoutObjects)->flipForWritingMode(result);
     else
         layoutObjects->containingBlock()->flipForWritingMode(result);
     return result;
 }
 
 LayoutRect DeprecatedPaintLayer::physicalBoundingBox(const DeprecatedPaintLayer* ancestorLayer, const LayoutPoint* offsetFromRoot) const
 {
+    ASSERT(!(ancestorLayer && offsetFromRoot));
     LayoutRect result = flippedLogicalBoundingBox(logicalBoundingBox(), layoutObject());
     if (offsetFromRoot)
         result.moveBy(*offsetFromRoot);
     else
         convertToLayerCoords(ancestorLayer, result);
     return result;
 }
 
 LayoutRect DeprecatedPaintLayer::fragmentsBoundingBox(const DeprecatedPaintLayer* ancestorLayer) const
 {
@@ skipping 27 matching lines @@
         // because those Layers don't paint into the graphics layer
         // for this Layer. For example, the bounds of squashed Layers
         // will be included in the computation of the appropriate squashing
         // GraphicsLayer.
         if (options != DeprecatedPaintLayer::ApplyBoundsChickenEggHacks && node->layer()->compositingState() != NotComposited)
             continue;
         result.unite(node->layer()->boundingBoxForCompositing(ancestorLayer, options));
     }
 }
 
-LayoutRect DeprecatedPaintLayer::physicalBoundingBoxIncludingReflectionAndStackingChildren(const DeprecatedPaintLayer* ancestorLayer, const LayoutPoint& offsetFromRoot) const
+LayoutRect DeprecatedPaintLayer::physicalBoundingBoxIncludingReflectionAndStackingChildren(const LayoutPoint& offsetFromRoot) const
 {
     LayoutPoint origin;
-    LayoutRect result = physicalBoundingBox(ancestorLayer, &origin);
+    LayoutRect result = physicalBoundingBox(nullptr, &origin);
 
     const_cast<DeprecatedPaintLayer*>(this)->stackingNode()->updateLayerListsIfNeeded();
 
     expandRectForReflectionAndStackingChildren(this, DoNotApplyBoundsChickenEggHacks, result);
 
     result.moveBy(offsetFromRoot);
     return result;
 }
 
 LayoutRect DeprecatedPaintLayer::boundingBoxForCompositing(const DeprecatedPaintLayer* ancestorLayer, CalculateBoundsOptions options) const
@@ skipping 14 matching lines @@
 
     // The layer created for the LayoutFlowThread is just a helper for painting and hit-testing,
     // and should not contribute to the bounding box. The LayoutMultiColumnSets will contribute
     // the correct size for the layout content of the multicol container.
     if (layoutObject()->isLayoutFlowThread())
         return LayoutRect();
 
     LayoutRect result = clipper().localClipRect();
     if (result == LayoutRect::infiniteIntRect()) {
         LayoutPoint origin;
-        result = physicalBoundingBox(ancestorLayer, &origin);
+        result = physicalBoundingBox(nullptr, &origin);
 
         const_cast<DeprecatedPaintLayer*>(this)->stackingNode()->updateLayerListsIfNeeded();
 
         // Reflections are implemented with Layers that hang off of the reflected layer. However,
         // the reflection layer subtree does not include the subtree of the parent Layer, so
         // a recursive computation of stacking children yields no results. This breaks cases when there are stacking
         // children of the parent, that need to be included in reflected composited bounds.
         // Fix this by including composited bounds of stacking children of the reflected Layer.
         if (hasCompositedDeprecatedPaintLayerMapping() && parent() && parent()->reflectionInfo() && parent()->reflectionInfo()->reflectionLayer() == this)
             expandRectForReflectionAndStackingChildren(parent(), options, result);
@@ skipping 490 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif