Simplify MultiColumnFragmentainerGroup::collectLayerFragments().

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 "config.h"
 
 #include "core/layout/MultiColumnFragmentainerGroup.h"
 
 #include "core/layout/LayoutMultiColumnSet.h"
 
@@ skipping 170 matching lines @@
     // 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.
-    //
-    // All other rectangles in this method are sized physically, and the inline direction coordinate
-    // is physical too, but the block direction coordinate is "logical top". This is the same as
-    // e.g. LayoutBox::frameRect(). These rectangles also pretend that there's only one long column,
-    // i.e. they are for the flow thread.
 
     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
@@ skipping 17 matching lines @@
     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);
 
-    LayoutUnit colLogicalWidth = m_columnSet.pageLogicalWidth();
-    LayoutUnit colGap = m_columnSet.columnGap();
-    unsigned colCount = actualColumnCount();
+    for (unsigned i = startColumn; i <= endColumn; i++) {
+        DeprecatedPaintLayerFragment fragment;
 
-    bool progressionIsInline = flowThread->progressionIsInline();
-    bool leftToRight = m_columnSet.style()->isLeftToRightDirection();
+        // Set the physical translation offset.
+        fragment.paginationOffset = toLayoutPoint(flowThreadTranslationAtOffset(logicalTopInFlowThreadAt(i)));
 
-    LayoutUnit initialBlockOffset = m_columnSet.logicalTop() + logicalTop() - flowThread->logicalTop();
+        // Set the overflow clip rect that corresponds to the column.
+        fragment.paginationClip = flowThreadPortionOverflowRectAt(i);
+        // Flip it into more a physical (DeprecatedPaintLayer-style) rectangle.
+        flowThread->flipForWritingMode(fragment.paginationClip);
 
-    for (unsigned i = startColumn; i <= endColumn; i++) {
-        // Get the portion of the flow thread that corresponds to this column.

[leviw_travelin_and_unemployed, 2015/07/28 18:48:38]

Wow. That's a lot of code to remove.

-        LayoutRect flowThreadPortion = flowThreadPortionRectAt(i);
-
-        // Now get the overflow rect that corresponds to the column.
-        LayoutRect flowThreadOverflowPortion = flowThreadPortionOverflowRect(flowThreadPortion, i, colCount, colGap);
-
-        LayoutPoint translationOffset;
-        LayoutUnit inlineOffset = progressionIsInline ? i * (colLogicalWidth + colGap) : LayoutUnit();
-        if (!leftToRight)
-            inlineOffset = -inlineOffset;
-        translationOffset.setX(inlineOffset);
-        LayoutUnit blockOffset;
-        if (progressionIsInline) {
-            blockOffset = initialBlockOffset + (isHorizontalWritingMode ? -flowThreadPortion.y() : -flowThreadPortion.x());
-        } else {
-            // Column gap can apply in the block direction for page fragmentainers.
-            // There is currently no spec which calls for column-gap to apply
-            // for page fragmentainers at all, but it's applied here for compatibility
-            // with the old multicolumn implementation.
-            blockOffset = i * colGap;
-        }
-        if (isFlippedBlocksWritingMode(m_columnSet.style()->writingMode()))
-            blockOffset = -blockOffset;
-        translationOffset.setY(blockOffset);
-        if (!isHorizontalWritingMode)
-            translationOffset = translationOffset.transposedPoint();
-
-        // Make a fragment now and supply the physical translation offset and the clip rect for the
-        // column with that offset applied.
-        DeprecatedPaintLayerFragment fragment;
-        fragment.paginationOffset = translationOffset;
-
-        LayoutRect flippedFlowThreadOverflowPortion(flowThreadOverflowPortion);
-        // Flip it into more a physical (DeprecatedPaintLayer-style) rectangle.
-        flowThread->flipForWritingMode(flippedFlowThreadOverflowPortion);
-        fragment.paginationClip = flippedFlowThreadOverflowPortion;
         fragments.append(fragment);
     }
 }
 
 LayoutRect MultiColumnFragmentainerGroup::calculateOverflow() const
 {
     unsigned columnCount = actualColumnCount();
     if (!columnCount)
         return LayoutRect();
     return columnRectAt(columnCount - 1);
@@ skipping 183 matching lines @@
         ASSERT(columnIndex + 1 == actualColumnCount());
         logicalBottom = logicalBottomInFlowThread();
         ASSERT(logicalBottom >= logicalTop);
     }
     LayoutUnit portionLogicalHeight = logicalBottom - logicalTop;
     if (m_columnSet.isHorizontalWritingMode())
         return LayoutRect(LayoutUnit(), logicalTop, m_columnSet.pageLogicalWidth(), portionLogicalHeight);
     return LayoutRect(logicalTop, LayoutUnit(), portionLogicalHeight, m_columnSet.pageLogicalWidth());
 }
 
-LayoutRect MultiColumnFragmentainerGroup::flowThreadPortionOverflowRect(const LayoutRect& portionRect, unsigned columnIndex, unsigned columnCount, LayoutUnit columnGap) const
+LayoutRect MultiColumnFragmentainerGroup::flowThreadPortionOverflowRectAt(unsigned columnIndex) const

[leviw_travelin_and_unemployed, 2015/07/28 18:48:38]

That's way nicer :)

 {
     // This function determines the portion of the flow thread that paints for the column. Along the inline axis, columns are
     // unclipped at outside edges (i.e., the first and last column in the set), and they clip to half the column
     // gap along interior edges.
     //
     // In the block direction, we will not clip overflow out of the top of the first column, or out of the bottom of
     // the last column. This applies only to the true first column and last column across all column sets.
     //
     // FIXME: Eventually we will know overflow on a per-column basis, but we can't do this until we have a painting
     // mode that understands not to paint contents from a previous column in the overflow area of a following column.
     bool isFirstColumn = !columnIndex;
-    bool isLastColumn = columnIndex == columnCount - 1;
+    bool isLastColumn = columnIndex == actualColumnCount() - 1;
     bool isLTR = m_columnSet.style()->isLeftToRightDirection();
     bool isLeftmostColumn = isLTR ? isFirstColumn : isLastColumn;
     bool isRightmostColumn = isLTR ? isLastColumn : isFirstColumn;
 
+    LayoutRect portionRect = flowThreadPortionRectAt(columnIndex);
     // Calculate the overflow rectangle, based on the flow thread's, clipped at column logical
     // top/bottom unless it's the first/last column.
     LayoutRect overflowRect = m_columnSet.overflowRectForFlowThreadPortion(portionRect, isFirstColumn && !m_columnSet.previousSiblingMultiColumnSet(), isLastColumn && !m_columnSet.nextSiblingMultiColumnSet());
 
     // Avoid overflowing into neighboring columns, by clipping in the middle of adjacent column
     // gaps. Also make sure that we avoid rounding errors.
+    LayoutUnit columnGap = m_columnSet.columnGap();
     if (m_columnSet.isHorizontalWritingMode()) {
         if (!isLeftmostColumn)
             overflowRect.shiftXEdgeTo(portionRect.x() - columnGap / 2);
         if (!isRightmostColumn)
             overflowRect.shiftMaxXEdgeTo(portionRect.maxX() + columnGap - columnGap / 2);
     } else {
         if (!isLeftmostColumn)
             overflowRect.shiftYEdgeTo(portionRect.y() - columnGap / 2);
         if (!isRightmostColumn)
             overflowRect.shiftMaxYEdgeTo(portionRect.maxY() + columnGap - columnGap / 2);
@@ skipping 80 matching lines @@
     append(MultiColumnFragmentainerGroup(m_columnSet));
     return last();
 }
 
 void MultiColumnFragmentainerGroupList::deleteExtraGroups()
 {
     shrink(1);
 }
 
 } // namespace blink