Replace collectLayerFragments() with FragmentainerIterator.

third_party/WebKit/Source/core/layout/MultiColumnFragmentainerGroup.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/MultiColumnFragmentainerGroup.h"
 
 #include "core/layout/ColumnBalancer.h"
 #include "core/layout/FragmentationContext.h"
 #include "core/layout/LayoutMultiColumnSet.h"
 
@@ skipping 181 matching lines @@
         return startColumnRect; // It all takes place in one column. We're done.
 
     LayoutRect endColumnFlowThreadOverflowPortion = flowThreadPortionOverflowRectAt(endColumn);
     flowThread->flipForWritingMode(endColumnFlowThreadOverflowPortion);
     LayoutRect endColumnRect(boundingBoxInFlowThread);
     endColumnRect.intersect(endColumnFlowThreadOverflowPortion);
     endColumnRect.move(flowThreadTranslationAtOffset(logicalTopInFlowThreadAt(endColumn), CoordinateSpaceConversion::Containing));
     return unionRect(startColumnRect, endColumnRect);
 }
 
-void MultiColumnFragmentainerGroup::collectLayerFragments(PaintLayerFragments& fragments, const LayoutRect& layerBoundingBox, const LayoutRect& dirtyRect) const
-{
-    // |layerBoundingBox| is in the flow thread coordinate space, relative to the top/left edge of
-    // the flow thread, but note that it has been converted with respect to writing mode (so that
-    // it's visual/physical in that sense).
-    //
-    // |dirtyRect| is visual, relative to the multicol container.
-    //
-    // Then there's the output from this method - the stuff we put into the list of fragments. The
-    // fragment.paginationOffset point is the actual visual translation required to get from a
-    // location in the flow thread to a location in a given column. The fragment.paginationClip
-    // rectangle, on the other hand, is in flow thread coordinates, but otherwise completely
-    // physical in terms of writing mode.
-
-    LayoutMultiColumnFlowThread* flowThread = m_columnSet.multiColumnFlowThread();
-    bool isHorizontalWritingMode = m_columnSet.isHorizontalWritingMode();
-
-    // Put the layer bounds into flow thread-local coordinates by flipping it first. Since we're in
-    // a layoutObject, most rectangles are represented this way.
-    LayoutRect layerBoundsInFlowThread(layerBoundingBox);
-    flowThread->flipForWritingMode(layerBoundsInFlowThread);
-
-    // Now we can compare with the flow thread portions owned by each column. First let's
-    // see if the rect intersects our flow thread portion at all.
-    LayoutRect clippedRect(layerBoundsInFlowThread);
-    clippedRect.intersect(m_columnSet.flowThreadPortionOverflowRect());
-    if (clippedRect.isEmpty())
-        return;
-
-    // Now we know we intersect at least one column. Let's figure out the logical top and logical
-    // bottom of the area we're checking.
-    LayoutUnit layerLogicalTop = isHorizontalWritingMode ? layerBoundsInFlowThread.y() : layerBoundsInFlowThread.x();
-    LayoutUnit layerLogicalBottom = (isHorizontalWritingMode ? layerBoundsInFlowThread.maxY() : layerBoundsInFlowThread.maxX());
-
-    // Figure out the start and end columns for the layer and only check within that range so that
-    // we don't walk the entire column row.
-    unsigned startColumn;
-    unsigned endColumn;
-    columnIntervalForBlockRangeInFlowThread(layerLogicalTop, layerLogicalBottom, startColumn, endColumn);
-
-    // Now intersect with the columns actually occupied by the dirty rect, to narrow it down even further.
-    unsigned firstColumnInDirtyRect, lastColumnInDirtyRect;
-    columnIntervalForVisualRect(dirtyRect, firstColumnInDirtyRect, lastColumnInDirtyRect);
-    if (firstColumnInDirtyRect > endColumn || lastColumnInDirtyRect < startColumn)
-        return; // The two column intervals are disjoint. There's nothing to collect.
-    if (startColumn < firstColumnInDirtyRect)
-        startColumn = firstColumnInDirtyRect;
-    if (endColumn > lastColumnInDirtyRect)
-        endColumn = lastColumnInDirtyRect;
-    ASSERT(endColumn >= startColumn);
-
-    for (unsigned i = startColumn; i <= endColumn; i++) {
-        PaintLayerFragment fragment;
-
-        // Set the physical translation offset.
-        fragment.paginationOffset = toLayoutPoint(flowThreadTranslationAtOffset(logicalTopInFlowThreadAt(i), CoordinateSpaceConversion::Visual));
-
-        // Set the overflow clip rect that corresponds to the column.
-        fragment.paginationClip = flowThreadPortionOverflowRectAt(i);
-        // Flip it into more a physical (PaintLayer-style) rectangle.
-        flowThread->flipForWritingMode(fragment.paginationClip);
-
-        fragments.append(fragment);
-    }
-}
-
 LayoutRect MultiColumnFragmentainerGroup::calculateOverflow() const
 {
     // Note that we just return the bounding rectangle of the column boxes here. We currently don't
     // examine overflow caused by the actual content that ends up in each column.
     LayoutRect overflowRect;
     if (unsigned columnCount = actualColumnCount()) {
         overflowRect = columnRectAt(0);
         if (columnCount > 1)
             overflowRect.uniteEvenIfEmpty(columnRectAt(columnCount - 1));
     }
@@ skipping 262 matching lines @@
     append(MultiColumnFragmentainerGroup(m_columnSet));
     return last();
 }
 
 void MultiColumnFragmentainerGroupList::deleteExtraGroups()
 {
     shrink(1);
 }
 
 } // namespace blink