Intersect with the dirty rect before deciding which columns to examine for collection.

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 196 matching lines @@
     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()) - 1;
 
-    // Figure out the start and end columns and only check within that range so that we don't walk the
-    // entire column row.
+    // 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 = columnIndexAtOffset(layerLogicalTop);
     unsigned endColumn = columnIndexAtOffset(layerLogicalBottom);
 
+    // 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);
+
     LayoutUnit colLogicalWidth = m_columnSet.pageLogicalWidth();
     LayoutUnit colGap = m_columnSet.columnGap();
     unsigned colCount = actualColumnCount();
 
     bool progressionIsInline = flowThread->progressionIsInline();
     bool leftToRight = m_columnSet.style()->isLeftToRightDirection();
 
     LayoutUnit initialBlockOffset = m_columnSet.logicalTop() + logicalTop() - flowThread->logicalTop();
 
     for (unsigned i = startColumn; i <= endColumn; i++) {
         // Get the portion of the flow thread that corresponds to this column.
         LayoutRect flowThreadPortion = flowThreadPortionRectAt(i);
 
         // Now get the overflow rect that corresponds to the column.
         LayoutRect flowThreadOverflowPortion = flowThreadPortionOverflowRect(flowThreadPortion, i, colCount, colGap);
 
-        // In order to create a fragment we must intersect the portion painted by this column.
-        LayoutRect clippedRect(layerBoundsInFlowThread);
-        clippedRect.intersect(flowThreadOverflowPortion);
-        if (clippedRect.isEmpty())
-            continue;
-
-        // We also need to intersect the dirty rect. We have to apply a translation and shift based off
-        // our column index.
         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();
 
-        // Shift the dirty rect to be in flow thread coordinates with this translation applied.
-        LayoutRect translatedDirtyRect(dirtyRect);
-        translatedDirtyRect.moveBy(-translationOffset);
-
-        // See if we intersect the dirty rect.
-        clippedRect = layerBoundingBox;
-        clippedRect.intersect(translatedDirtyRect);
-        if (clippedRect.isEmpty())
-            continue;
-
-        // Something does need to paint in this column. Make a fragment now and supply the physical translation
-        // offset and the clip rect for the column with that offset applied.
+        // 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);
     }
 }
@@ skipping 262 matching lines @@
     LayoutUnit columnGap = m_columnSet.columnGap();
     if (columnLengthInColumnProgressionDirection + columnGap <= 0)
         return 0;
     // Column boundaries are in the middle of the column gap.
     int index = (offsetInColumnProgressionDirection + columnGap / 2) / (columnLengthInColumnProgressionDirection + columnGap);
     if (index < 0)
         return 0;
     return std::min(unsigned(index), actualColumnCount() - 1);
 }
 
+void MultiColumnFragmentainerGroup::columnIntervalForVisualRect(const LayoutRect& rect, unsigned& firstColumn, unsigned& lastColumn) const
+{
+    bool isColumnProgressionInline = m_columnSet.multiColumnFlowThread()->progressionIsInline();
+    bool isFlippedColumnProgression = !m_columnSet.style()->isLeftToRightDirection() && isColumnProgressionInline;
+    if (m_columnSet.isHorizontalWritingMode() == isColumnProgressionInline) {
+        if (isFlippedColumnProgression) {
+            firstColumn = columnIndexAtVisualPoint(rect.maxXMinYCorner());
+            lastColumn = columnIndexAtVisualPoint(rect.minXMinYCorner());
+        } else {
+            firstColumn = columnIndexAtVisualPoint(rect.minXMinYCorner());
+            lastColumn = columnIndexAtVisualPoint(rect.maxXMinYCorner());
+        }
+    } else {
+        if (isFlippedColumnProgression) {
+            firstColumn = columnIndexAtVisualPoint(rect.minXMaxYCorner());
+            lastColumn = columnIndexAtVisualPoint(rect.minXMinYCorner());
+        } else {
+            firstColumn = columnIndexAtVisualPoint(rect.minXMinYCorner());
+            lastColumn = columnIndexAtVisualPoint(rect.minXMaxYCorner());
+        }
+    }
+    ASSERT(firstColumn <= lastColumn);
+}
+
 MultiColumnFragmentainerGroupList::MultiColumnFragmentainerGroupList(LayoutMultiColumnSet& columnSet)
     : m_columnSet(columnSet)
 {
     append(MultiColumnFragmentainerGroup(m_columnSet));
 }
 
 // An explicit empty destructor of MultiColumnFragmentainerGroupList should be in
 // MultiColumnFragmentainerGroup.cpp, because if an implicit destructor is used,
 // msvc 2015 tries to generate its destructor (because the class is dll-exported class)
 // and causes a compile error because of lack of MultiColumnFragmentainerGroup::operator=.
 // Since MultiColumnFragmentainerGroup is non-copyable, we cannot define the operator=.
 MultiColumnFragmentainerGroupList::~MultiColumnFragmentainerGroupList()
 {
 }
 
 MultiColumnFragmentainerGroup& MultiColumnFragmentainerGroupList::addExtraGroup()
 {
     append(MultiColumnFragmentainerGroup(m_columnSet));
     return last();
 }
 
 void MultiColumnFragmentainerGroupList::deleteExtraGroups()
 {
     shrink(1);
 }
 
 } // namespace blink