Move rendering/RenderBox to layout/LayoutBox.

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 57 matching lines @@
 {
     for (LayoutObject* sibling = multiColumnBlockFlow()->lastChild(); sibling; sibling = sibling->previousSibling()) {
         if (sibling->isLayoutMultiColumnSet())
             return toLayoutMultiColumnSet(sibling);
     }
     return 0;
 }
 
 static LayoutObject* firstRendererInSet(LayoutMultiColumnSet* multicolSet)
 {
-    RenderBox* sibling = multicolSet->previousSiblingMultiColumnBox();
+    LayoutBox* sibling = multicolSet->previousSiblingMultiColumnBox();
     if (!sibling)
         return multicolSet->flowThread()->firstChild();
     // Adjacent column content sets should not occur. We would have no way of figuring out what each
     // of them contains then.
     ASSERT(sibling->isLayoutMultiColumnSpannerPlaceholder());
     return toLayoutMultiColumnSpannerPlaceholder(sibling)->rendererInFlowThread()->nextInPreOrderAfterChildren(multicolSet->flowThread());
 }
 
 static LayoutObject* lastRendererInSet(LayoutMultiColumnSet* multicolSet)
 {
-    RenderBox* sibling = multicolSet->nextSiblingMultiColumnBox();
+    LayoutBox* sibling = multicolSet->nextSiblingMultiColumnBox();
     if (!sibling)
         return 0; // By right we should return lastLeafChild() here, but the caller doesn't care, so just return 0.
     // Adjacent column content sets should not occur. We would have no way of figuring out what each
     // of them contains then.
     ASSERT(sibling->isLayoutMultiColumnSpannerPlaceholder());
     return toLayoutMultiColumnSpannerPlaceholder(sibling)->rendererInFlowThread()->previousInPreOrder(multicolSet->flowThread());
 }
 
 LayoutMultiColumnSet* LayoutMultiColumnFlowThread::findSetRendering(LayoutObject* renderer) const
 {
@@ skipping 23 matching lines @@
 
     return 0;
 }
 
 LayoutMultiColumnSpannerPlaceholder* LayoutMultiColumnFlowThread::containingColumnSpannerPlaceholder(const LayoutObject* descendant) const
 {
     ASSERT(descendant->isDescendantOf(this));
 
     // Before we spend time on searching the ancestry, see if there's a quick way to determine
     // whether there might be any spanners at all.
-    RenderBox* firstBox = firstMultiColumnBox();
+    LayoutBox* firstBox = firstMultiColumnBox();
     if (!firstBox || (firstBox == lastMultiColumnBox() && firstBox->isLayoutMultiColumnSet()))
         return 0;
 
     // We have spanners. See if the renderer in question is one or inside of one then.
     for (const LayoutObject* ancestor = descendant; ancestor && ancestor != this; ancestor = ancestor->parent()) {
         if (LayoutMultiColumnSpannerPlaceholder* placeholder = ancestor->spannerPlaceholder())
             return placeholder;
     }
     return 0;
 }
 
 void LayoutMultiColumnFlowThread::populate()
 {
     RenderBlockFlow* multicolContainer = multiColumnBlockFlow();
     ASSERT(!nextSibling());
     // Reparent children preceding the flow thread into the flow thread. It's multicol content
     // now. At this point there's obviously nothing after the flow thread, but renderers (column
     // sets and spanners) will be inserted there as we insert elements into the flow thread.
     multicolContainer->moveChildrenTo(this, multicolContainer->firstChild(), this, true);
 }
 
 void LayoutMultiColumnFlowThread::evacuateAndDestroy()
 {
     RenderBlockFlow* multicolContainer = multiColumnBlockFlow();
     m_isBeingEvacuated = true;
 
     // Remove all sets and spanners.
-    while (RenderBox* columnBox = firstMultiColumnBox()) {
+    while (LayoutBox* columnBox = firstMultiColumnBox()) {
         ASSERT(columnBox->isAnonymous());
         columnBox->destroy();
     }
 
     ASSERT(!previousSibling());
     ASSERT(!nextSibling());
 
     // Finally we can promote all flow thread's children. Before we move them to the flow thread's
     // container, we need to unregister the flow thread, so that they aren't just re-added again to
     // the flow thread that we're trying to empty.
@@ skipping 62 matching lines @@
     if (!needsLayout()) {
         // Just before the multicol container (our parent RenderBlockFlow) finishes laying out, it
         // will call recalculateColumnHeights() on us unconditionally, but we only want that method
         // to do any work if we actually laid out the flow thread. Otherwise, the balancing
         // machinery would kick in needlessly, and trigger additional layout passes. Furthermore, we
         // actually depend on a proper flowthread layout pass in order to do balancing, since it's
         // flowthread layout that sets up content runs.
         return;
     }
 
-    for (RenderBox* columnBox = firstMultiColumnBox(); columnBox; columnBox = columnBox->nextSiblingMultiColumnBox()) {
+    for (LayoutBox* columnBox = firstMultiColumnBox(); columnBox; columnBox = columnBox->nextSiblingMultiColumnBox()) {
         if (!columnBox->isLayoutMultiColumnSet()) {
             ASSERT(columnBox->isLayoutMultiColumnSpannerPlaceholder()); // no other type is expected.
             m_needsColumnHeightsRecalculation = true;
             continue;
         }
         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();
@@ skipping 59 matching lines @@
         width = std::max<LayoutUnit>(0, (availableWidth - ((count - 1) * columnGap)) / count);
     } else if (!columnStyle->hasAutoColumnWidth() && columnStyle->hasAutoColumnCount()) {
         count = std::max<LayoutUnit>(1, (availableWidth + columnGap) / (computedColumnWidth + columnGap));
         width = ((availableWidth + columnGap) / count) - columnGap;
     } else {
         count = std::max<LayoutUnit>(std::min<LayoutUnit>(computedColumnCount, (availableWidth + columnGap) / (computedColumnWidth + columnGap)), 1);
         width = ((availableWidth + columnGap) / count) - columnGap;
     }
 }
 
-void LayoutMultiColumnFlowThread::createAndInsertMultiColumnSet(RenderBox* insertBefore)
+void LayoutMultiColumnFlowThread::createAndInsertMultiColumnSet(LayoutBox* insertBefore)
 {
     RenderBlockFlow* multicolContainer = multiColumnBlockFlow();
     LayoutMultiColumnSet* newSet = LayoutMultiColumnSet::createAnonymous(*this, multicolContainer->styleRef());
     multicolContainer->RenderBlock::addChild(newSet, insertBefore);
     invalidateRegions();
 
     // 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(RenderBox* spanner, RenderBox* insertBefore)
+void LayoutMultiColumnFlowThread::createAndInsertSpannerPlaceholder(LayoutBox* spanner, LayoutBox* insertBefore)
 {
     RenderBlockFlow* multicolContainer = multiColumnBlockFlow();
     LayoutMultiColumnSpannerPlaceholder* newPlaceholder = LayoutMultiColumnSpannerPlaceholder::createAnonymous(multicolContainer->styleRef(), *spanner);
     multicolContainer->RenderBlock::addChild(newPlaceholder, insertBefore);
     spanner->setSpannerPlaceholder(*newPlaceholder);
 }
 
 bool LayoutMultiColumnFlowThread::descendantIsValidColumnSpanner(LayoutObject* descendant) const
 {
     // We assume that we're inside the flow thread. This function is not to be called otherwise.
@@ skipping 55 matching lines @@
 {
     // 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();
     multiColumnBlockFlow()->resetMultiColumnFlowThread();
     LayoutFlowThread::willBeRemovedFromTree();
 }
 
-LayoutUnit LayoutMultiColumnFlowThread::skipColumnSpanner(RenderBox* renderer, LayoutUnit logicalTopInFlowThread)
+LayoutUnit LayoutMultiColumnFlowThread::skipColumnSpanner(LayoutBox* renderer, LayoutUnit logicalTopInFlowThread)
 {
     ASSERT(renderer->isColumnSpanAll());
     LayoutMultiColumnSpannerPlaceholder* placeholder = renderer->spannerPlaceholder();
     LayoutUnit adjustment;
-    RenderBox* previousColumnBox = placeholder->previousSiblingMultiColumnBox();
+    LayoutBox* previousColumnBox = placeholder->previousSiblingMultiColumnBox();
     if (previousColumnBox && previousColumnBox->isLayoutMultiColumnSet()) {
         // Pad flow thread offset to a column boundary, so that any column content that's supposed
         // to come after the spanner doesn't bleed into the column row preceding the spanner.
         LayoutMultiColumnSet* previousSet = toLayoutMultiColumnSet(previousColumnBox);
         if (previousSet->pageLogicalHeight()) {
             LayoutUnit columnLogicalTopInFlowThread = previousSet->pageLogicalTopForOffset(logicalTopInFlowThread);
             if (columnLogicalTopInFlowThread != logicalTopInFlowThread) {
                 adjustment = columnLogicalTopInFlowThread + previousSet->pageLogicalHeight() - logicalTopInFlowThread;
                 logicalTopInFlowThread += adjustment;
             }
         }
         previousSet->endFlow(logicalTopInFlowThread);
     }
-    RenderBox* nextColumnBox = placeholder->nextSiblingMultiColumnBox();
+    LayoutBox* nextColumnBox = placeholder->nextSiblingMultiColumnBox();
     if (nextColumnBox && nextColumnBox->isLayoutMultiColumnSet()) {
         LayoutMultiColumnSet* nextSet = toLayoutMultiColumnSet(nextColumnBox);
         m_lastSetWorkedOn = nextSet;
         nextSet->beginFlow(logicalTopInFlowThread);
     }
     return adjustment;
 }
 
 void LayoutMultiColumnFlowThread::flowThreadDescendantWasInserted(LayoutObject* descendant)
 {
     ASSERT(!m_isBeingEvacuated);
     LayoutObject* nextRenderer = descendant->nextInPreOrderAfterChildren(this);
     // This method ensures that the list of column sets and spanner placeholders reflects the
     // multicol content after having inserted a descendant (or descendant subtree). See the header
     // file for more information. Go through the subtree that was just inserted and create column
     // sets (needed by regular column content) and spanner placeholders (one needed by each spanner)
     // where needed.
     for (LayoutObject* renderer = descendant; renderer; renderer = renderer->nextInPreOrder(descendant)) {
         if (containingColumnSpannerPlaceholder(renderer))
             continue; // Inside a column spanner. Nothing to do, then.
         if (descendantIsValidColumnSpanner(renderer)) {
             // This renderer is a spanner, so it needs to establish a spanner placeholder.
-            RenderBox* insertBefore = 0;
+            LayoutBox* insertBefore = 0;
             LayoutMultiColumnSet* setToSplit = 0;
             if (nextRenderer) {
                 // The spanner is inserted before something. Figure out what this entails. If the
                 // next renderer is a spanner too, it means that we can simply insert a new spanner
                 // placeholder in front of its placeholder.
                 insertBefore = nextRenderer->spannerPlaceholder();
                 if (!insertBefore) {
                     // The next renderer isn't a spanner; it's regular column content. Examine what
                     // comes right before us in the flow thread, then.
                     LayoutObject* previousRenderer = renderer->previousInPreOrder(this);
@@ skipping 12 matching lines @@
                         setToSplit = findSetRendering(previousRenderer);
                         ASSERT(setToSplit == findSetRendering(nextRenderer));
                         setToSplit->setNeedsLayoutAndFullPaintInvalidation();
                         insertBefore = setToSplit->nextSiblingMultiColumnBox();
                         // We've found out which set that needs to be split. Now proceed to
                         // inserting the spanner placeholder, and then insert a second column set.
                     }
                 }
                 ASSERT(setToSplit || insertBefore);
             }
-            createAndInsertSpannerPlaceholder(toRenderBox(renderer), insertBefore);
+            createAndInsertSpannerPlaceholder(toLayoutBox(renderer), insertBefore);
             if (setToSplit)
                 createAndInsertMultiColumnSet(insertBefore);
             continue;
         }
         // This renderer is regular column content (i.e. not a spanner). Create a set if necessary.
         if (nextRenderer) {
             if (LayoutMultiColumnSpannerPlaceholder* placeholder = nextRenderer->spannerPlaceholder()) {
                 // If inserted right before a spanner, we need to make sure that there's a set for us there.
-                RenderBox* previous = placeholder->previousSiblingMultiColumnBox();
+                LayoutBox* previous = placeholder->previousSiblingMultiColumnBox();
                 if (!previous || !previous->isLayoutMultiColumnSet())
                     createAndInsertMultiColumnSet(placeholder);
             } else {
                 // Otherwise, since |nextRenderer| isn't a spanner, it has to mean that there's
                 // already a set for that content. We can use it for this renderer too.
                 ASSERT(findSetRendering(nextRenderer));
                 ASSERT(findSetRendering(renderer) == findSetRendering(nextRenderer));
             }
         } else {
             // Inserting at the end. Then we just need to make sure that there's a column set at the end.
-            RenderBox* lastColumnBox = lastMultiColumnBox();
+            LayoutBox* lastColumnBox = lastMultiColumnBox();
             if (!lastColumnBox || !lastColumnBox->isLayoutMultiColumnSet())
                 createAndInsertMultiColumnSet();
         }
     }
 }
 
 void LayoutMultiColumnFlowThread::flowThreadDescendantWillBeRemoved(LayoutObject* descendant)
 {
     // This method ensures that the list of column sets and spanner placeholders reflects the
     // multicol content that we'll be left with after removal of a descendant (or descendant
     // subtree). See the header file for more information. Removing content may mean that we need to
     // remove column sets and/or spanner placeholders.
     if (m_isBeingEvacuated)
         return;
     bool hadContainingPlaceholder = containingColumnSpannerPlaceholder(descendant);
     LayoutObject* next;
     // Remove spanner placeholders that are no longer needed, and merge column sets around them.
     for (LayoutObject* renderer = descendant; renderer; renderer = next) {
         LayoutMultiColumnSpannerPlaceholder* placeholder = renderer->spannerPlaceholder();
         if (!placeholder) {
             next = renderer->nextInPreOrder(descendant);
             continue;
         }
         next = renderer->nextInPreOrderAfterChildren(descendant); // It's a spanner. Its children are of no interest to us.
-        if (RenderBox* nextColumnBox = placeholder->nextSiblingMultiColumnBox()) {
-            RenderBox* previousColumnBox = placeholder->previousSiblingMultiColumnBox();
+        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();
                 invalidateRegions();
             }
         }
         placeholder->destroy();
     }
@@ skipping 123 matching lines @@
 }
 
 bool LayoutMultiColumnFlowThread::isPageLogicalHeightKnown() const
 {
     if (LayoutMultiColumnSet* columnSet = lastMultiColumnSet())
         return columnSet->pageLogicalHeight();
     return false;
 }
 
 }