Cleanup: Remove LayoutRegion.

Source/core/layout/LayoutMultiColumnFlowThread.cpp

 /*
  * Copyright (C) 2012 Apple Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 165 matching lines @@
     // and instead leave you with dangling root line box pointers. But since this is how it is done
     // in other parts of the code that deal with reparenting layoutObjects, let's do the cleanup on our
     // own here as well.
     deleteLineBoxTree();
 
     destroy();
 }
 
 LayoutSize LayoutMultiColumnFlowThread::columnOffset(const LayoutPoint& point) const
 {
-    if (!hasValidRegionInfo())
+    if (!hasValidColumnSetInfo())
         return LayoutSize(0, 0);
 
     LayoutPoint flowThreadPoint = flipForWritingMode(point);
     LayoutUnit blockOffset = isHorizontalWritingMode() ? flowThreadPoint.y() : flowThreadPoint.x();
     LayoutMultiColumnSet* columnSet = columnSetAtBlockOffset(blockOffset);
     if (!columnSet)
         return LayoutSize(0, 0);
     return columnSet->flowThreadTranslationAtOffset(blockOffset);
 }
 
@@ skipping 18 matching lines @@
 }
 
 LayoutMultiColumnSet* LayoutMultiColumnFlowThread::columnSetAtBlockOffset(LayoutUnit offset) const
 {
     if (m_lastSetWorkedOn) {
         // Layout in progress. We are calculating the set heights as we speak, so the column set range
         // information is not up-to-date.
         return m_lastSetWorkedOn;
     }
 
-    ASSERT(!m_regionsInvalidated);
+    ASSERT(!m_columnSetsInvalidated);
     if (m_multiColumnSetList.isEmpty())
         return 0;
     if (offset <= 0)
         return m_multiColumnSetList.first();
 
     MultiColumnSetSearchAdapter adapter(offset);
     m_multiColumnSetIntervalTree.allOverlapsWithAdapter<MultiColumnSetSearchAdapter>(adapter);
 
     // If no set was found, the offset is in the flow thread overflow.
     if (!adapter.result() && !m_multiColumnSetList.isEmpty())
@@ skipping 26 matching lines @@
         LayoutMultiColumnSet* columnSet = toLayoutMultiColumnSet(columnBox);
         if (!m_inBalancingPass) {
             // This is the initial layout pass. We need to reset the column height, because contents
             // typically have changed.
             columnSet->resetColumnHeight();
         }
         if (!m_needsColumnHeightsRecalculation)
             m_needsColumnHeightsRecalculation = columnSet->heightIsAuto();
     }
 
-    invalidateRegions();
+    invalidateColumnSets();
     layout();
 }
 
 bool LayoutMultiColumnFlowThread::recalculateColumnHeights()
 {
     // All column sets that needed layout have now been laid out, so we can finally validate them.
-    validateRegions();
+    validateColumnSets();
 
     if (!m_needsColumnHeightsRecalculation)
         return false;
 
     // Column heights may change here because of balancing. We may have to do multiple layout
     // passes, depending on how the contents is fitted to the changed column heights. In most
     // cases, laying out again twice or even just once will suffice. Sometimes we need more
     // passes than that, though, but the number of retries should not exceed the number of
     // columns, unless we have a bug.
     bool needsRelayout = false;
@@ skipping 41 matching lines @@
         count = std::max<LayoutUnit>(std::min<LayoutUnit>(computedColumnCount, (availableWidth + columnGap) / (computedColumnWidth + columnGap)), 1);
         width = ((availableWidth + columnGap) / count) - columnGap;
     }
 }
 
 void LayoutMultiColumnFlowThread::createAndInsertMultiColumnSet(LayoutBox* insertBefore)
 {
     LayoutBlockFlow* multicolContainer = multiColumnBlockFlow();
     LayoutMultiColumnSet* newSet = LayoutMultiColumnSet::createAnonymous(*this, multicolContainer->styleRef());
     multicolContainer->LayoutBlock::addChild(newSet, insertBefore);
-    invalidateRegions();
+    invalidateColumnSets();
 
     // We cannot handle immediate column set siblings (and there's no need for it, either).
     // There has to be at least one spanner separating them.
     ASSERT(!newSet->previousSiblingMultiColumnBox() || !newSet->previousSiblingMultiColumnBox()->isLayoutMultiColumnSet());
     ASSERT(!newSet->nextSiblingMultiColumnBox() || !newSet->nextSiblingMultiColumnBox()->isLayoutMultiColumnSet());
 }
 
 void LayoutMultiColumnFlowThread::createAndInsertSpannerPlaceholder(LayoutBox* spanner, LayoutBox* insertBefore)
 {
     LayoutBlockFlow* multicolContainer = multiColumnBlockFlow();
@@ skipping 42 matching lines @@
             // after layout. Similarly for absolutely positioned boxes.
             return false;
         }
         if (ancestor->isUnsplittableForPagination())
             return false;
     }
     ASSERT_NOT_REACHED();
     return false;
 }
 
-void LayoutMultiColumnFlowThread::addRegionToThread(LayoutMultiColumnSet* columnSet)
+void LayoutMultiColumnFlowThread::addColumnSetToThread(LayoutMultiColumnSet* columnSet)
 {
     if (LayoutMultiColumnSet* nextSet = columnSet->nextSiblingMultiColumnSet()) {
         LayoutMultiColumnSetList::iterator it = m_multiColumnSetList.find(nextSet);
         ASSERT(it != m_multiColumnSetList.end());
         m_multiColumnSetList.insertBefore(it, columnSet);
     } else {
         m_multiColumnSetList.add(columnSet);
     }
-    columnSet->setIsValid(true);
 }
 
 void LayoutMultiColumnFlowThread::willBeRemovedFromTree()
 {
     // Detach all column sets from the flow thread. Cannot destroy them at this point, since they
     // are siblings of this object, and there may be pointers to this object's sibling somewhere
     // further up on the call stack.
     for (LayoutMultiColumnSet* columnSet = firstMultiColumnSet(); columnSet; columnSet = columnSet->nextSiblingMultiColumnSet())
-        columnSet->detachRegion();
+        columnSet->detachFromFlowThread();
     multiColumnBlockFlow()->resetMultiColumnFlowThread();
     LayoutFlowThread::willBeRemovedFromTree();
 }
 
 LayoutUnit LayoutMultiColumnFlowThread::skipColumnSpanner(LayoutBox* layoutObject, LayoutUnit logicalTopInFlowThread)
 {
     ASSERT(layoutObject->isColumnSpanAll());
     LayoutMultiColumnSpannerPlaceholder* placeholder = layoutObject->spannerPlaceholder();
     LayoutUnit adjustment;
     LayoutBox* previousColumnBox = placeholder->previousSiblingMultiColumnBox();
@@ skipping 159 matching lines @@
             continue;
         }
         next = layoutObject->nextInPreOrderAfterChildren(descendant); // It's a spanner. Its children are of no interest to us.
         if (LayoutBox* nextColumnBox = placeholder->nextSiblingMultiColumnBox()) {
             LayoutBox* previousColumnBox = placeholder->previousSiblingMultiColumnBox();
             if (nextColumnBox && nextColumnBox->isLayoutMultiColumnSet()
                 && previousColumnBox && previousColumnBox->isLayoutMultiColumnSet()) {
                 // Need to merge two column sets.
                 nextColumnBox->destroy();
                 previousColumnBox->setNeedsLayout(LayoutInvalidationReason::ColumnsChanged);
-                invalidateRegions();
+                invalidateColumnSets();
             }
         }
         placeholder->destroy();
     }
     if (hadContainingPlaceholder || !processedSomething)
         return; // No column content will be removed, so we can stop here.
 
     // Column content will be removed. Does this mean that we should destroy a column set?
     LayoutMultiColumnSpannerPlaceholder* adjacentPreviousSpannerPlaceholder = 0;
     LayoutObject* previousLayoutObject = descendant->previousInPreOrder(this);
@@ skipping 98 matching lines @@
     if (LayoutMultiColumnSet* multicolSet = columnSetAtBlockOffset(offset))
         multicolSet->recordSpaceShortage(offset, spaceShortage);
 }
 
 void LayoutMultiColumnFlowThread::updateMinimumPageHeight(LayoutUnit offset, LayoutUnit minHeight)
 {
     if (LayoutMultiColumnSet* multicolSet = columnSetAtBlockOffset(offset))
         multicolSet->updateMinimumColumnHeight(offset, minHeight);
 }
 
-bool LayoutMultiColumnFlowThread::addForcedRegionBreak(LayoutUnit offset, LayoutObject* /*breakChild*/, bool /*isBefore*/, LayoutUnit* offsetBreakAdjustment)
+bool LayoutMultiColumnFlowThread::addForcedColumnBreak(LayoutUnit offset, LayoutObject* /*breakChild*/, bool /*isBefore*/, LayoutUnit* offsetBreakAdjustment)
 {
     if (LayoutMultiColumnSet* multicolSet = columnSetAtBlockOffset(offset)) {
         multicolSet->addContentRun(offset);
         if (offsetBreakAdjustment)
             *offsetBreakAdjustment = pageLogicalHeightForOffset(offset) ? pageRemainingLogicalHeightForOffset(offset, IncludePageBoundary) : LayoutUnit();
         return true;
     }
     return false;
 }
 
 bool LayoutMultiColumnFlowThread::isPageLogicalHeightKnown() const
 {
     if (LayoutMultiColumnSet* columnSet = lastMultiColumnSet())
         return columnSet->pageLogicalHeight();
     return false;
 }
 
 }