Use fragmented bounding box for hit-test/paint clipping.

Source/core/rendering/RenderLayer.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 1103 matching lines @@
         layer->convertToLayerCoords(rootLayerForTransform, delta);
 
         delta.move(subPixelAccumulation);
         IntPoint pixelSnappedDelta = roundedIntPoint(delta);
         TransformationMatrix transform;
         transform.translate(pixelSnappedDelta.x(), pixelSnappedDelta.y());
         transform = transform * *layer->transform();
 
         // We don't use fragment boxes when collecting a transformed layer's bounding box, since it always
         // paints unfragmented.
-        LayoutRect clipRect = layer->physicalBoundingBox(layer);
+        LayoutRect clipRect = layer->boundingBox(layer);
         expandClipRectForDescendantsAndReflection(clipRect, layer, layer, transparencyBehavior, subPixelAccumulation, paintBehavior);
         layer->renderer()->style()->filterOutsets().expandRect(clipRect);
         LayoutRect result = transform.mapRect(clipRect);
         if (!paginationLayer)
             return result;
 
         // We have to break up the transformed extent across our columns.
         // Split our box up into the actual fragment boxes that render in the columns/pages and unite those together to
         // get our true bounding box.
         RenderFlowThread* enclosingFlowThread = toRenderFlowThread(paginationLayer->renderer());
         result = enclosingFlowThread->fragmentsBoundingBox(result);
 
         LayoutPoint rootLayerDelta;
         paginationLayer->convertToLayerCoords(rootLayer, rootLayerDelta);
         result.moveBy(rootLayerDelta);
         return result;
     }
 
-    LayoutRect clipRect = layer->physicalBoundingBox(rootLayer);
+    LayoutRect clipRect = layer->fragmentedBoundingBox(rootLayer);
     expandClipRectForDescendantsAndReflection(clipRect, layer, rootLayer, transparencyBehavior, subPixelAccumulation, paintBehavior);
     layer->renderer()->style()->filterOutsets().expandRect(clipRect);
     clipRect.move(subPixelAccumulation);
     return clipRect;
 }
 
 LayoutRect RenderLayer::paintingExtent(const RenderLayer* rootLayer, const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior)
 {
     return intersection(transparencyClipBox(this, rootLayer, PaintingTransparencyClipBox, RootOfTransparencyClipBox, subPixelAccumulation, paintBehavior), paintDirtyRect);
 }
@@ skipping 251 matching lines @@
 
     const RenderLayer* currLayer = this;
     while (currLayer && currLayer != ancestorLayer)
         currLayer = accumulateOffsetTowardsAncestor(currLayer, ancestorLayer, location);
 }
 
 void RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutRect& rect) const
 {
     LayoutPoint delta;
     convertToLayerCoords(ancestorLayer, delta);
-    rect.move(-delta.x(), -delta.y());
+    rect.moveBy(delta);
 }
 
 void RenderLayer::didUpdateNeedsCompositedScrolling()
 {
     updateSelfPaintingLayer();
 }
 
 void RenderLayer::updateReflectionInfo(const RenderStyle* oldStyle)
 {
     ASSERT(!oldStyle || !renderer()->style()->reflectionDataEquivalent(oldStyle));
@@ skipping 53 matching lines @@
     if (respectOverflowClip == IgnoreOverflowClip)
         paginationClipRectsContext.setIgnoreOverflowClip();
     LayoutRect layerBoundsInFlowThread;
     ClipRect backgroundRectInFlowThread;
     ClipRect foregroundRectInFlowThread;
     ClipRect outlineRectInFlowThread;
     clipper().calculateRects(paginationClipRectsContext, PaintInfo::infiniteRect(), 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 : boundingBox(enclosingPaginationLayer(), &offsetWithinPaginatedLayer);
     layerBoundingBoxInFlowThread.intersect(backgroundRectInFlowThread.rect());
 
     // Shift the dirty rect into flow thread coordinates.
     LayoutPoint offsetOfPaginationLayerFromRoot;
     enclosingPaginationLayer()->convertToLayerCoords(rootLayer, offsetOfPaginationLayerFromRoot);
     LayoutRect dirtyRectInFlowThread(dirtyRect);
     dirtyRectInFlowThread.moveBy(-offsetOfPaginationLayerFromRoot);
 
     // Tell the flow thread to collect the fragments. We pass enough information to create a minimal number of fragments based off the pages/columns
     // that intersect the actual dirtyRect as well as the pages/columns that intersect our layer's bounding box.
@@ skipping 679 matching lines @@
     // can go ahead and return true.
     RenderView* view = renderer()->view();
     ASSERT(view);
     if (view && !renderer()->isRenderInline()) {
         if (layerBounds.intersects(damageRect))
             return true;
     }
 
     // Otherwise we need to compute the bounding box of this single layer and see if it intersects
     // the damage rect.
-    return physicalBoundingBox(rootLayer, offsetFromRoot).intersects(damageRect);
+    return boundingBox(rootLayer, offsetFromRoot).intersects(damageRect);
 }
 
 LayoutRect RenderLayer::logicalBoundingBox() const
 {
     // There are three special cases we need to consider.
     // (1) Inline Flows.  For inline flows we will create a bounding box that fully encompasses all of the lines occupied by the
     // inline.  In other words, if some <span> wraps to three lines, we'll create a bounding box that fully encloses the
     // line boxes of all three lines (including overflow on those lines).
     // (2) Left/Top Overflow.  The width/height of layers already includes right/bottom overflow.  However, in the case of left/top
     // overflow, we have to create a bounding box that will extend to include this overflow.
@@ skipping 18 matching lines @@
         RenderBox* box = renderBox();
         ASSERT(box);
         result = box->borderBoxRect();
         result.unite(box->visualOverflowRect());
     }
 
     ASSERT(renderer()->view());
     return result;
 }
 
-LayoutRect RenderLayer::physicalBoundingBox(const RenderLayer* ancestorLayer, const LayoutPoint* offsetFromRoot) const
+LayoutRect RenderLayer::flippedLogicalBoundingBox() const
 {
     LayoutRect result = logicalBoundingBox();
     if (m_renderer->isBox())
         renderBox()->flipForWritingMode(result);
     else
         m_renderer->containingBlock()->flipForWritingMode(result);
-
-    LayoutPoint delta;
-    if (offsetFromRoot)
-        delta = *offsetFromRoot;
-    else
-        convertToLayerCoords(ancestorLayer, delta);
-
-    result.moveBy(delta);
     return result;
 }
 
+LayoutRect RenderLayer::boundingBox(const RenderLayer* ancestorLayer, const LayoutPoint* offsetFromRoot) const
+{
+    LayoutRect result = flippedLogicalBoundingBox();
+    if (offsetFromRoot)
+        result.moveBy(*offsetFromRoot);
+    else
+        convertToLayerCoords(ancestorLayer, result);
+    return result;
+}
+
+LayoutRect RenderLayer::fragmentedBoundingBox(const RenderLayer* ancestorLayer, const LayoutPoint* offsetFromRoot) const

[andersr, 2014/10/02 11:01:21]

Is fragmentsBoundingBox a better name? (Like
RenderFlowThread::fragmentsBoundingBox). That way it doesn't sound like the
bounding box itself is fragmented.

[rune, 2014/10/02 11:17:34]

Yes.

[rune, 2014/10/03 09:15:46]

Done.

+{
+    if (!enclosingPaginationLayer())
+        return boundingBox(ancestorLayer, offsetFromRoot);
+
+    LayoutRect result = flippedLogicalBoundingBox();
+
+    // Split our box up into the actual fragment boxes that render in the columns/pages and unite those together to
+    // get our true bounding box.
+    LayoutPoint offsetWithinPaginationLayer;
+    convertToLayerCoords(enclosingPaginationLayer(), offsetWithinPaginationLayer);
+    result.moveBy(offsetWithinPaginationLayer);
+
+    RenderFlowThread* enclosingFlowThread = toRenderFlowThread(enclosingPaginationLayer()->renderer());
+    result = enclosingFlowThread->fragmentsBoundingBox(result);
+

[mstensho (USE GERRIT), 2014/10/02 12:43:59]

At this point, |result| is a nice visual rectangle, relative to the multicol
container. You have already added the offset between the layer and the flow
thread (pagination layer). The code that follows will add the offset from the
layer to some ancestor, which means that the offset from the layer to the flow
thread will be added twice.

The cheapest solution is to add a result.moveBy(-offsetWithinPaginationLayer)
here.

[rune, 2014/10/03 09:15:46]

Done.

I also removed the offsetFromRoot pointer, since that was passed as 0 from the
only caller.

+    if (offsetFromRoot)
+        result.moveBy(*offsetFromRoot);
+    else
+        convertToLayerCoords(ancestorLayer, result);
+    return result;
+}
+
 static void expandRectForReflectionAndStackingChildren(const RenderLayer* ancestorLayer, RenderLayer::CalculateBoundsOptions options, LayoutRect& result)
 {
     if (ancestorLayer->reflectionInfo() && !ancestorLayer->reflectionInfo()->reflectionLayer()->hasCompositedLayerMapping())
         result.unite(ancestorLayer->reflectionInfo()->reflectionLayer()->boundingBoxForCompositing(ancestorLayer));
 
     ASSERT(ancestorLayer->stackingNode()->isStackingContext() || !ancestorLayer->stackingNode()->hasPositiveZOrderList());
 
 #if ENABLE(ASSERT)
     LayerListMutationDetector mutationChecker(const_cast<RenderLayer*>(ancestorLayer)->stackingNode());
 #endif
 
     RenderLayerStackingNodeIterator iterator(*ancestorLayer->stackingNode(), AllChildren);
     while (RenderLayerStackingNode* node = iterator.next()) {
         // Here we exclude both directly composited layers and squashing layers
         // because those RenderLayers don't paint into the graphics layer
         // for this RenderLayer. For example, the bounds of squashed RenderLayers
         // will be included in the computation of the appropriate squashing
         // GraphicsLayer.
         if (options != RenderLayer::ApplyBoundsChickenEggHacks && node->layer()->compositingState() != NotComposited)
             continue;
         result.unite(node->layer()->boundingBoxForCompositing(ancestorLayer, options));
     }
 }
 
-LayoutRect RenderLayer::physicalBoundingBoxIncludingReflectionAndStackingChildren(const RenderLayer* ancestorLayer, const LayoutPoint& offsetFromRoot) const
+LayoutRect RenderLayer::boundingBoxIncludingReflectionAndStackingChildren(const RenderLayer* ancestorLayer, const LayoutPoint& offsetFromRoot) const
 {
     LayoutPoint origin;
-    LayoutRect result = physicalBoundingBox(ancestorLayer, &origin);
+    LayoutRect result = boundingBox(ancestorLayer, &origin);
 
     const_cast<RenderLayer*>(this)->stackingNode()->updateLayerListsIfNeeded();
 
     expandRectForReflectionAndStackingChildren(this, DoNotApplyBoundsChickenEggHacks, result);
 
     result.moveBy(offsetFromRoot);
     return result;
 }
 
 LayoutRect RenderLayer::boundingBoxForCompositing(const RenderLayer* ancestorLayer, CalculateBoundsOptions options) const
@@ skipping 25 matching lines @@
         if (shouldIncludeTransform)
             localClipRect = transform()->mapRect(localClipRect);
 
         LayoutPoint delta;
         convertToLayerCoords(ancestorLayer, delta);
         localClipRect.moveBy(delta);
         return localClipRect;
     }
 
     LayoutPoint origin;
-    LayoutRect result = physicalBoundingBox(ancestorLayer, &origin);
+    LayoutRect result = boundingBox(ancestorLayer, &origin);
 
     const_cast<RenderLayer*>(this)->stackingNode()->updateLayerListsIfNeeded();
 
     // Reflections are implemented with RenderLayers that hang off of the reflected layer. However,
     // the reflection layer subtree does not include the subtree of the parent RenderLayer, 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 RenderLayer.
     if (hasCompositedLayerMapping() && parent() && parent()->reflectionInfo() && parent()->reflectionInfo()->reflectionLayer() == this)
         expandRectForReflectionAndStackingChildren(parent(), options, result);
@@ skipping 472 matching lines @@
             // as well as they may be on another composited layer. Skip reporting contents
             // for non-composited layers as they'll get projected to the same layer as the
             // bounding box.
             if (compositingState() != NotComposited)
                 rect.append(m_scrollableArea->overflowRect());
 
             rects.set(this, rect);
             if (const RenderLayer* parentLayer = parent()) {
                 LayerHitTestRects::iterator iter = rects.find(parentLayer);
                 if (iter == rects.end()) {
-                    rects.add(parentLayer, Vector<LayoutRect>()).storedValue->value.append(physicalBoundingBox(parentLayer));
+                    rects.add(parentLayer, Vector<LayoutRect>()).storedValue->value.append(boundingBox(parentLayer));
                 } else {
-                    iter->value.append(physicalBoundingBox(parentLayer));
+                    iter->value.append(boundingBox(parentLayer));
                 }
             }
         } else {
             rect.append(logicalBoundingBox());
             rects.set(this, rect);
         }
     }
 }
 
 void RenderLayer::setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants()
@@ skipping 26 matching lines @@
     }
 }
 
 void showLayerTree(const blink::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif