Cleanup: Remove LayoutRegion.

Source/core/layout/LayoutMultiColumnSet.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 16 matching lines @@
 #include "core/layout/LayoutMultiColumnSet.h"
 
 #include "core/editing/PositionWithAffinity.h"
 #include "core/layout/LayoutMultiColumnFlowThread.h"
 #include "core/layout/MultiColumnFragmentainerGroup.h"
 #include "core/paint/MultiColumnSetPainter.h"
 
 namespace blink {
 
 LayoutMultiColumnSet::LayoutMultiColumnSet(LayoutFlowThread* flowThread)
-    : LayoutRegion(0, flowThread)
+    : LayoutBlockFlow(0)
     , m_fragmentainerGroups(*this)
+    , m_flowThread(flowThread)
 {
 }
 
 LayoutMultiColumnSet* LayoutMultiColumnSet::createAnonymous(LayoutFlowThread& flowThread, const ComputedStyle& parentStyle)
 {
     Document& document = flowThread.document();
     LayoutMultiColumnSet* layoutObject = new LayoutMultiColumnSet(&flowThread);
     layoutObject->setDocumentForAnonymous(&document);
     layoutObject->setStyle(ComputedStyle::createAnonymousStyleWithDisplay(parentStyle, BLOCK));
     return layoutObject;
@@ skipping 45 matching lines @@
 LayoutUnit LayoutMultiColumnSet::logicalTopInFlowThread() const
 {
     return firstFragmentainerGroup().logicalTopInFlowThread();
 }
 
 LayoutUnit LayoutMultiColumnSet::logicalBottomInFlowThread() const
 {
     return lastFragmentainerGroup().logicalBottomInFlowThread();
 }
 
+LayoutRect LayoutMultiColumnSet::flowThreadPortionOverflowRect() const
+{
+    return overflowRectForFlowThreadPortion(flowThreadPortionRect(), !previousSiblingMultiColumnSet(), !nextSiblingMultiColumnSet());
+}
+
+LayoutRect LayoutMultiColumnSet::overflowRectForFlowThreadPortion(const LayoutRect& flowThreadPortionRect, bool isFirstPortion, bool isLastPortion) const
+{
+    if (hasOverflowClip())
+        return flowThreadPortionRect;
+
+    LayoutRect flowThreadOverflow = m_flowThread->visualOverflowRect();
+
+    // Only clip along the flow thread axis.
+    LayoutRect clipRect;
+    if (m_flowThread->isHorizontalWritingMode()) {
+        LayoutUnit minY = isFirstPortion ? flowThreadOverflow.y() : flowThreadPortionRect.y();
+        LayoutUnit maxY = isLastPortion ? std::max(flowThreadPortionRect.maxY(), flowThreadOverflow.maxY()) : flowThreadPortionRect.maxY();
+        LayoutUnit minX = std::min(flowThreadPortionRect.x(), flowThreadOverflow.x());
+        LayoutUnit maxX = std::max(flowThreadPortionRect.maxX(), flowThreadOverflow.maxX());
+        clipRect = LayoutRect(minX, minY, maxX - minX, maxY - minY);
+    } else {
+        LayoutUnit minX = isFirstPortion ? flowThreadOverflow.x() : flowThreadPortionRect.x();
+        LayoutUnit maxX = isLastPortion ? std::max(flowThreadPortionRect.maxX(), flowThreadOverflow.maxX()) : flowThreadPortionRect.maxX();
+        LayoutUnit minY = std::min(flowThreadPortionRect.y(), (flowThreadOverflow.y()));
+        LayoutUnit maxY = std::max(flowThreadPortionRect.y(), (flowThreadOverflow.maxY()));
+        clipRect = LayoutRect(minX, minY, maxX - minX, maxY - minY);
+    }
+
+    return clipRect;
+}
+
 bool LayoutMultiColumnSet::heightIsAuto() const
 {
     LayoutMultiColumnFlowThread* flowThread = multiColumnFlowThread();
     if (!flowThread->isLayoutPagedFlowThread()) {
         if (multiColumnBlockFlow()->style()->columnFill() == ColumnFillBalance)
             return true;
         if (LayoutBox* next = nextSiblingBox()) {
             if (next->isLayoutMultiColumnSpannerPlaceholder()) {
                 // If we're followed by a spanner, we need to balance.
                 return true;
@@ skipping 68 matching lines @@
 }
 
 void LayoutMultiColumnSet::expandToEncompassFlowThreadContentsIfNeeded()
 {
     ASSERT(multiColumnFlowThread()->lastMultiColumnSet() == this);
     // FIXME: this may result in the need for creating additional rows, since there may not be
     // enough space remaining in the currently last row.
     m_fragmentainerGroups.last().expandToEncompassFlowThreadOverflow();
 }
 
+void LayoutMultiColumnSet::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
+{
+    minLogicalWidth = m_flowThread->minPreferredLogicalWidth();
+    maxLogicalWidth = m_flowThread->maxPreferredLogicalWidth();
+}
+
 void LayoutMultiColumnSet::computeLogicalHeight(LayoutUnit, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
 {
     LayoutUnit logicalHeight;
     for (const auto& group : m_fragmentainerGroups)
         logicalHeight += group.logicalHeight();
     computedValues.m_extent = logicalHeight;
     computedValues.m_position = logicalTop;
 }
 
 PositionWithAffinity LayoutMultiColumnSet::positionForPoint(const LayoutPoint& point)
@@ skipping 39 matching lines @@
         rect.move(group.offsetFromColumnSet());
         overflowRect.unite(rect);
     }
     addLayoutOverflow(overflowRect);
     if (!hasOverflowClip())
         addVisualOverflow(overflowRect);
 }
 
 void LayoutMultiColumnSet::insertedIntoTree()
 {
-    LayoutRegion::insertedIntoTree();
-
-    attachRegion();
+    LayoutBlockFlow::insertedIntoTree();
+    attachToFlowThread();
 }
 
 void LayoutMultiColumnSet::willBeRemovedFromTree()
 {
-    LayoutRegion::willBeRemovedFromTree();
-
-    detachRegion();
+    LayoutBlockFlow::willBeRemovedFromTree();
+    detachFromFlowThread();
 }
 
-void LayoutMultiColumnSet::attachRegion()
+void LayoutMultiColumnSet::attachToFlowThread()
 {
     if (documentBeingDestroyed())
         return;
 
-    // A region starts off invalid.
-    setIsValid(false);
-
     if (!m_flowThread)
         return;
 
-    // Only after adding the region to the thread, the region is marked to be valid.
-    m_flowThread->addRegionToThread(this);
+    m_flowThread->addColumnSetToThread(this);
 }
 
-void LayoutMultiColumnSet::detachRegion()
+void LayoutMultiColumnSet::detachFromFlowThread()
 {
     if (m_flowThread) {
-        m_flowThread->removeRegionFromThread(this);
+        m_flowThread->removeColumnSetFromThread(this);
         m_flowThread = 0;
     }
 }
 
 LayoutRect LayoutMultiColumnSet::flowThreadPortionRect() const
 {
     LayoutRect portionRect(LayoutUnit(), logicalTopInFlowThread(), pageLogicalWidth(), logicalHeightInFlowThread());
     if (!isHorizontalWritingMode())
         return portionRect.transposedRect();
     return portionRect;
 }
 
 }