Replace collectLayerFragments() with FragmentainerIterator.

third_party/WebKit/Source/core/paint/PaintLayer.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 35 matching lines @@
 #include "core/CSSPropertyNames.h"
 #include "core/HTMLNames.h"
 #include "core/css/PseudoStyleRequest.h"
 #include "core/dom/Document.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/frame/DeprecatedScheduleStyleRecalcDuringLayout.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLFrameElement.h"
+#include "core/layout/FragmentainerIterator.h"
 #include "core/layout/HitTestRequest.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/HitTestingTransformState.h"
 #include "core/layout/LayoutFlowThread.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutReplica.h"
 #include "core/layout/LayoutTreeAsText.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/compositing/CompositedLayerMapping.h"
@@ skipping 1463 matching lines @@
         // 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());
     } else {
         offsetOfPaginationLayerFromRoot = enclosingPaginationLayer()->visualOffsetFromAncestor(rootLayer);
     }
     // Make the dirty rect relative to the fragmentation context (multicol container, etc.).
     LayoutRect dirtyRectInMulticolContainer(dirtyRect);
     dirtyRectInMulticolContainer.move(enclosingPaginationLayer()->location() - 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.
-    enclosingFlowThread->collectLayerFragments(fragments, layerBoundingBoxInFlowThread, dirtyRectInMulticolContainer);
-
-    if (fragments.isEmpty())
+    // Slice the layer into fragments. Each fragment needs to be processed (e.g. painted)
+    // separately. We pass enough information to walk a minimal number of fragments based on the
+    // pages/columns that intersect the actual dirtyRect as well as the pages/columns that
+    // intersect our layer's bounding box.
+    FragmentainerIterator iterator(*enclosingFlowThread, layerBoundingBoxInFlowThread, dirtyRectInMulticolContainer);
+    if (iterator.atEnd())
         return;
 
     // Get the parent clip rects of the pagination layer, since we need to intersect with that when painting column contents.
     ClipRect ancestorClipRect = dirtyRect;
     if (const PaintLayer* paginationParentLayer = enclosingPaginationLayer()->parent()) {
         const PaintLayer* ancestorLayer = rootLayerIsInsidePaginationLayer ? paginationParentLayer : rootLayer;
         ClipRectsContext clipRectsContext(ancestorLayer, clipRectsCacheSlot, overlayScrollbarClipBehavior);
         if (respectOverflowClip == IgnoreOverflowClip)
             clipRectsContext.setIgnoreOverflowClip();
         ancestorClipRect = enclosingPaginationLayer()->clipper().backgroundClipRect(clipRectsContext);
         if (rootLayerIsInsidePaginationLayer)
             ancestorClipRect.moveBy(-rootLayer->visualOffsetFromAncestor(ancestorLayer));
         ancestorClipRect.intersect(dirtyRect);
     }
 
     const LayoutSize subPixelAccumulationIfNeeded = offsetFromRoot ? subPixelAccumulation : LayoutSize();
-    for (size_t i = 0; i < fragments.size(); ++i) {
-        PaintLayerFragment& fragment = fragments.at(i);
+    for (; !iterator.atEnd(); iterator.advance()) {
+        PaintLayerFragment fragment;
+        fragment.paginationOffset = toLayoutPoint(iterator.paginationOffset());
+        fragment.paginationClip = iterator.clipRectInFlowThread();
 
         // Set our four rects with all clipping applied that was internal to the flow thread.
         fragment.setRects(layerBoundsInFlowThread, backgroundRectInFlowThread, foregroundRectInFlowThread);
 
         // Shift to the root-relative physical position used when painting the flow thread in this fragment.
         fragment.moveBy(fragment.paginationOffset + offsetOfPaginationLayerFromRoot + subPixelAccumulationIfNeeded);
 
         // Intersect the fragment with our ancestor's background clip so that e.g., columns in an overflow:hidden block are
         // properly clipped by the overflow.
         fragment.intersect(ancestorClipRect.rect());
 
         // Now intersect with our pagination clip. This will typically mean we're just intersecting the dirty rect with the column
         // clip, so the column clip ends up being all we apply.
         fragment.intersect(fragment.paginationClip);
+
+        // TODO(mstensho): Don't add empty fragments. We've always done that in some cases, but
+        // there should be no reason to do so. Either filter them out here, or, even better: pass a
+        // better clip rectangle to the fragmentainer iterator, so that we won't end up with empty
+        // fragments here.
+        fragments.append(fragment);
     }
 }
 
 static inline LayoutRect frameVisibleRect(LayoutObject* layoutObject)
 {
     FrameView* frameView = layoutObject->document().view();
     if (!frameView)
         return LayoutRect();
 
     return LayoutRect(frameView->visibleContentRect());
@@ skipping 1372 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif