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 1122 matching lines @@
         // 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->fragmentsBoundingBox(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 792 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::physicalBoundingBox(const RenderLayer* ancestorLayer, const LayoutPoint* offsetFromRoot) const
+{
+    LayoutRect result = flippedLogicalBoundingBox();
+    if (offsetFromRoot)
+        result.moveBy(*offsetFromRoot);
+    else
+        convertToLayerCoords(ancestorLayer, result);
+    return result;
+}
+
+LayoutRect RenderLayer::fragmentsBoundingBox(const RenderLayer* ancestorLayer) const
+{
+    if (!enclosingPaginationLayer())
+        return physicalBoundingBox(ancestorLayer);
+
+    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);
+    enclosingPaginationLayer()->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
@@ skipping 595 matching lines @@
     }
 }
 
 void showLayerTree(const blink::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif