Cleanup: Remove LayoutRegion.

Source/core/layout/LayoutFlowThread.cpp

 /*
  * Copyright (C) 2011 Adobe Systems Incorporated. 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.
@@ skipping 20 matching lines @@
 
 #include "core/layout/LayoutFlowThread.h"
 
 #include "core/layout/LayoutMultiColumnSet.h"
 #include "core/layout/LayoutView.h"
 
 namespace blink {
 
 LayoutFlowThread::LayoutFlowThread()
     : LayoutBlockFlow(0)
-    , m_regionsInvalidated(false)
-    , m_regionsHaveUniformLogicalHeight(true)
+    , m_columnSetsInvalidated(false)
+    , m_columnSetsHaveUniformLogicalHeight(true)
     , m_pageLogicalSizeChanged(false)
 {
 }
 
-void LayoutFlowThread::removeRegionFromThread(LayoutMultiColumnSet* columnSet)
+void LayoutFlowThread::removeColumnSetFromThread(LayoutMultiColumnSet* columnSet)
 {
     ASSERT(columnSet);
     m_multiColumnSetList.remove(columnSet);
 }
 
-void LayoutFlowThread::invalidateRegions()
+void LayoutFlowThread::invalidateColumnSets()
 {
-    if (m_regionsInvalidated) {
+    if (m_columnSetsInvalidated) {
         ASSERT(selfNeedsLayout());
         return;
     }
 
     setNeedsLayoutAndFullPaintInvalidation(LayoutInvalidationReason::ColumnsChanged);
 
-    m_regionsInvalidated = true;
+    m_columnSetsInvalidated = true;
 }
 
-void LayoutFlowThread::validateRegions()
+void LayoutFlowThread::validateColumnSets()
 {
-    if (m_regionsInvalidated) {
-        m_regionsInvalidated = false;
-        m_regionsHaveUniformLogicalHeight = true;
+    if (m_columnSetsInvalidated) {
+        m_columnSetsInvalidated = false;
+        m_columnSetsHaveUniformLogicalHeight = true;
 
-        if (hasRegions()) {
-            LayoutUnit previousRegionLogicalHeight = 0;
-            bool firstRegionVisited = false;
+        if (hasColumnSets()) {
+            LayoutUnit previousLogicalHeight = 0;
+            bool firstVisited = false;
 
             for (auto* columnSet : m_multiColumnSetList) {
-                LayoutUnit regionLogicalHeight = columnSet->pageLogicalHeight();
+                LayoutUnit currentLogicalHeight = columnSet->pageLogicalHeight();
 
-                if (!firstRegionVisited) {
-                    firstRegionVisited = true;
+                if (!firstVisited) {
+                    firstVisited = true;
                 } else {
-                    if (m_regionsHaveUniformLogicalHeight && previousRegionLogicalHeight != regionLogicalHeight)
-                        m_regionsHaveUniformLogicalHeight = false;
+                    if (m_columnSetsHaveUniformLogicalHeight && previousLogicalHeight != currentLogicalHeight)
+                        m_columnSetsHaveUniformLogicalHeight = false;
                 }
 
-                previousRegionLogicalHeight = regionLogicalHeight;
+                previousLogicalHeight = currentLogicalHeight;
             }
         }
     }
 
     updateLogicalWidth(); // Called to get the maximum logical width for the columnSet.
     generateColumnSetIntervalTree();
 }
 
 void LayoutFlowThread::mapRectToPaintInvalidationBacking(const LayoutBoxModelObject* paintInvalidationContainer, LayoutRect& rect, const PaintInvalidationState* paintInvalidationState) const
 {
     ASSERT(paintInvalidationContainer != this); // A flow thread should never be an invalidation container.
     // |rect| is a layout rectangle, where the block direction coordinate is flipped for writing
     // mode. fragmentsBoundingBox(), on the other hand, works on physical rectangles, so we need to
     // flip the rectangle before and after calling it.
     flipForWritingMode(rect);
     rect = fragmentsBoundingBox(rect);
     flipForWritingMode(rect);
     LayoutBlockFlow::mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
 }
 
 void LayoutFlowThread::layout()
 {
-    m_pageLogicalSizeChanged = m_regionsInvalidated && everHadLayout();
+    m_pageLogicalSizeChanged = m_columnSetsInvalidated && everHadLayout();
     LayoutBlockFlow::layout();
     m_pageLogicalSizeChanged = false;
 }
 
 void LayoutFlowThread::computeLogicalHeight(LayoutUnit, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
 {
     computedValues.m_position = logicalTop;
     computedValues.m_extent = 0;
 
     for (LayoutMultiColumnSetList::const_iterator iter = m_multiColumnSetList.begin(); iter != m_multiColumnSetList.end(); ++iter) {
@@ skipping 29 matching lines @@
     LayoutUnit pageLogicalBottom = pageLogicalTop + pageLogicalHeight;
     LayoutUnit remainingHeight = pageLogicalBottom - offset;
     if (pageBoundaryRule == IncludePageBoundary) {
         // If IncludePageBoundary is set, the line exactly on the top edge of a
         // columnSet will act as being part of the previous columnSet.
         remainingHeight = intMod(remainingHeight, pageLogicalHeight);
     }
     return remainingHeight;
 }
 
-LayoutRegion* LayoutFlowThread::firstRegion() const
-{
-    if (!hasValidRegionInfo())
-        return 0;
-    return m_multiColumnSetList.first();
-}
-
-LayoutRegion* LayoutFlowThread::lastRegion() const
-{
-    if (!hasValidRegionInfo())
-        return 0;
-    return m_multiColumnSetList.last();
-}
-
 void LayoutFlowThread::generateColumnSetIntervalTree()
 {
     // FIXME: Optimize not to clear the interval all the time. This implies manually managing the tree nodes lifecycle.
     m_multiColumnSetIntervalTree.clear();
     m_multiColumnSetIntervalTree.initIfNeeded();
     for (auto columnSet : m_multiColumnSetList)
         m_multiColumnSetIntervalTree.add(MultiColumnSetIntervalTree::createInterval(columnSet->logicalTopInFlowThread(), columnSet->logicalBottomInFlowThread(), columnSet));
 }
 
 void LayoutFlowThread::collectLayerFragments(DeprecatedPaintLayerFragments& layerFragments, const LayoutRect& layerBoundingBox, const LayoutRect& dirtyRect)
 {
-    ASSERT(!m_regionsInvalidated);
+    ASSERT(!m_columnSetsInvalidated);
 
     for (LayoutMultiColumnSetList::const_iterator iter = m_multiColumnSetList.begin(); iter != m_multiColumnSetList.end(); ++iter) {
         LayoutMultiColumnSet* columnSet = *iter;
         columnSet->collectLayerFragments(layerFragments, layerBoundingBox, dirtyRect);
     }
 }
 
 LayoutRect LayoutFlowThread::fragmentsBoundingBox(const LayoutRect& layerBoundingBox) const
 {
-    ASSERT(!m_regionsInvalidated);
+    ASSERT(!m_columnSetsInvalidated);
 
     LayoutRect result;
     for (auto* columnSet : m_multiColumnSetList) {
         DeprecatedPaintLayerFragments fragments;
         columnSet->collectLayerFragments(fragments, layerBoundingBox, LayoutRect(LayoutRect::infiniteIntRect()));
         for (const auto& fragment : fragments) {
             LayoutRect fragmentRect(layerBoundingBox);
             fragmentRect.intersect(fragment.paginationClip);
             fragmentRect.moveBy(fragment.paginationOffset);
             result.unite(fragmentRect);
         }
     }
 
     return result;
 }
 
 void LayoutFlowThread::MultiColumnSetSearchAdapter::collectIfNeeded(const MultiColumnSetInterval& interval)
 {
     if (m_result)
         return;
     if (interval.low() <= m_offset && interval.high() > m_offset)
         m_result = interval.data();
 }
 
 } // namespace blink