Move rendering/RenderObject to layout/LayoutObject.

Source/core/rendering/RenderMultiColumnFlowThread.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 39 matching lines @@
 RenderMultiColumnFlowThread* RenderMultiColumnFlowThread::createAnonymous(Document& document, RenderStyle* parentStyle)
 {
     RenderMultiColumnFlowThread* renderer = new RenderMultiColumnFlowThread();
     renderer->setDocumentForAnonymous(&document);
     renderer->setStyle(RenderStyle::createAnonymousStyleWithDisplay(parentStyle, BLOCK));
     return renderer;
 }
 
 RenderMultiColumnSet* RenderMultiColumnFlowThread::firstMultiColumnSet() const
 {
-    for (RenderObject* sibling = nextSibling(); sibling; sibling = sibling->nextSibling()) {
+    for (LayoutObject* sibling = nextSibling(); sibling; sibling = sibling->nextSibling()) {
         if (sibling->isRenderMultiColumnSet())
             return toRenderMultiColumnSet(sibling);
     }
     return 0;
 }
 
 RenderMultiColumnSet* RenderMultiColumnFlowThread::lastMultiColumnSet() const
 {
-    for (RenderObject* sibling = multiColumnBlockFlow()->lastChild(); sibling; sibling = sibling->previousSibling()) {
+    for (LayoutObject* sibling = multiColumnBlockFlow()->lastChild(); sibling; sibling = sibling->previousSibling()) {
         if (sibling->isRenderMultiColumnSet())
             return toRenderMultiColumnSet(sibling);
     }
     return 0;
 }
 
-static RenderObject* firstRendererInSet(RenderMultiColumnSet* multicolSet)
+static LayoutObject* firstRendererInSet(RenderMultiColumnSet* multicolSet)
 {
     RenderBox* 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->isRenderMultiColumnSpannerPlaceholder());
     return toRenderMultiColumnSpannerPlaceholder(sibling)->rendererInFlowThread()->nextInPreOrderAfterChildren(multicolSet->flowThread());
 }
 
-static RenderObject* lastRendererInSet(RenderMultiColumnSet* multicolSet)
+static LayoutObject* lastRendererInSet(RenderMultiColumnSet* multicolSet)
 {
     RenderBox* 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->isRenderMultiColumnSpannerPlaceholder());
     return toRenderMultiColumnSpannerPlaceholder(sibling)->rendererInFlowThread()->previousInPreOrder(multicolSet->flowThread());
 }
 
-RenderMultiColumnSet* RenderMultiColumnFlowThread::findSetRendering(RenderObject* renderer) const
+RenderMultiColumnSet* RenderMultiColumnFlowThread::findSetRendering(LayoutObject* renderer) const
 {
     ASSERT(!containingColumnSpannerPlaceholder(renderer)); // should not be used for spanners or content inside them.
     ASSERT(renderer != this);
     ASSERT(renderer->isDescendantOf(this));
     RenderMultiColumnSet* multicolSet = firstMultiColumnSet();
     if (!multicolSet)
         return 0;
     if (!multicolSet->nextSiblingMultiColumnSet())
         return multicolSet;
 
     // This is potentially SLOW! But luckily very uncommon. You would have to dynamically insert a
     // spanner into the middle of column contents to need this.
     for (; multicolSet; multicolSet = multicolSet->nextSiblingMultiColumnSet()) {
-        RenderObject* firstRenderer = firstRendererInSet(multicolSet);
-        RenderObject* lastRenderer = lastRendererInSet(multicolSet);
+        LayoutObject* firstRenderer = firstRendererInSet(multicolSet);
+        LayoutObject* lastRenderer = lastRendererInSet(multicolSet);
         ASSERT(firstRenderer);
 
-        for (RenderObject* walker = firstRenderer; walker; walker = walker->nextInPreOrder(this)) {
+        for (LayoutObject* walker = firstRenderer; walker; walker = walker->nextInPreOrder(this)) {
             if (walker == renderer)
                 return multicolSet;
             if (walker == lastRenderer)
                 break;
         }
     }
 
     return 0;
 }
 
-RenderMultiColumnSpannerPlaceholder* RenderMultiColumnFlowThread::containingColumnSpannerPlaceholder(const RenderObject* descendant) const
+RenderMultiColumnSpannerPlaceholder* RenderMultiColumnFlowThread::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();
     if (!firstBox || (firstBox == lastMultiColumnBox() && firstBox->isRenderMultiColumnSet()))
         return 0;
 
     // We have spanners. See if the renderer in question is one or inside of one then.
-    for (const RenderObject* ancestor = descendant; ancestor && ancestor != this; ancestor = ancestor->parent()) {
+    for (const LayoutObject* ancestor = descendant; ancestor && ancestor != this; ancestor = ancestor->parent()) {
         if (RenderMultiColumnSpannerPlaceholder* placeholder = ancestor->spannerPlaceholder())
             return placeholder;
     }
     return 0;
 }
 
 void RenderMultiColumnFlowThread::populate()
 {
     RenderBlockFlow* multicolContainer = multiColumnBlockFlow();
     ASSERT(!nextSibling());
@@ skipping 186 matching lines @@
 }
 
 void RenderMultiColumnFlowThread::createAndInsertSpannerPlaceholder(RenderBox* spanner, RenderBox* insertBefore)
 {
     RenderBlockFlow* multicolContainer = multiColumnBlockFlow();
     RenderMultiColumnSpannerPlaceholder* newPlaceholder = RenderMultiColumnSpannerPlaceholder::createAnonymous(multicolContainer->style(), spanner);
     multicolContainer->RenderBlock::addChild(newPlaceholder, insertBefore);
     spanner->setSpannerPlaceholder(*newPlaceholder);
 }
 
-bool RenderMultiColumnFlowThread::descendantIsValidColumnSpanner(RenderObject* descendant) const
+bool RenderMultiColumnFlowThread::descendantIsValidColumnSpanner(LayoutObject* descendant) const
 {
     // We assume that we're inside the flow thread. This function is not to be called otherwise.
     ASSERT(descendant->isDescendantOf(this));
 
     // We're evaluating if the descendant should be turned into a proper spanner. It shouldn't
     // already be one.
     ASSERT(!descendant->spannerPlaceholder());
 
     // The spec says that column-span only applies to in-flow block-level elements.
     if (descendant->style()->columnSpan() != ColumnSpanAll || !descendant->isBox() || descendant->isInline() || descendant->isFloatingOrOutOfFlowPositioned())
@@ skipping 75 matching lines @@
     }
     RenderBox* nextColumnBox = placeholder->nextSiblingMultiColumnBox();
     if (nextColumnBox && nextColumnBox->isRenderMultiColumnSet()) {
         RenderMultiColumnSet* nextSet = toRenderMultiColumnSet(nextColumnBox);
         m_lastSetWorkedOn = nextSet;
         nextSet->beginFlow(logicalTopInFlowThread);
     }
     return adjustment;
 }
 
-void RenderMultiColumnFlowThread::flowThreadDescendantWasInserted(RenderObject* descendant)
+void RenderMultiColumnFlowThread::flowThreadDescendantWasInserted(LayoutObject* descendant)
 {
     ASSERT(!m_isBeingEvacuated);
-    RenderObject* nextRenderer = descendant->nextInPreOrderAfterChildren(this);
+    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 (RenderObject* renderer = descendant; renderer; renderer = renderer->nextInPreOrder(descendant)) {
+    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;
             RenderMultiColumnSet* 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.
-                    RenderObject* previousRenderer = renderer->previousInPreOrder(this);
+                    LayoutObject* previousRenderer = renderer->previousInPreOrder(this);
                     if (!previousRenderer || previousRenderer == this) {
                         // The spanner is inserted as the first child of the multicol container,
                         // which means that we simply insert a new spanner placeholder at the
                         // beginning.
                         insertBefore = firstMultiColumnBox();
                     } else if (RenderMultiColumnSpannerPlaceholder* previousPlaceholder = containingColumnSpannerPlaceholder(previousRenderer)) {
                         // Before us is another spanner. We belong right after it then.
                         insertBefore = previousPlaceholder->nextSiblingMultiColumnBox();
                     } else {
                         // We're inside regular column content with both feet. Find out which column
@@ skipping 29 matching lines @@
             }
         } else {
             // Inserting at the end. Then we just need to make sure that there's a column set at the end.
             RenderBox* lastColumnBox = lastMultiColumnBox();
             if (!lastColumnBox || !lastColumnBox->isRenderMultiColumnSet())
                 createAndInsertMultiColumnSet();
         }
     }
 }
 
-void RenderMultiColumnFlowThread::flowThreadDescendantWillBeRemoved(RenderObject* descendant)
+void RenderMultiColumnFlowThread::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);
-    RenderObject* next;
+    LayoutObject* next;
     // Remove spanner placeholders that are no longer needed, and merge column sets around them.
-    for (RenderObject* renderer = descendant; renderer; renderer = next) {
+    for (LayoutObject* renderer = descendant; renderer; renderer = next) {
         RenderMultiColumnSpannerPlaceholder* 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 (nextColumnBox && nextColumnBox->isRenderMultiColumnSet()
                 && previousColumnBox && previousColumnBox->isRenderMultiColumnSet()) {
                 // Need to merge two column sets.
                 nextColumnBox->destroy();
                 previousColumnBox->setNeedsLayout();
                 invalidateRegions();
             }
         }
         placeholder->destroy();
     }
     if (hadContainingPlaceholder)
         return; // We're only removing a spanner (or something inside one), which means that no column content will be removed.
 
     // Column content will be removed. Does this mean that we should destroy a column set?
     RenderMultiColumnSpannerPlaceholder* adjacentPreviousSpannerPlaceholder = 0;
-    RenderObject* previousRenderer = descendant->previousInPreOrder(this);
+    LayoutObject* previousRenderer = descendant->previousInPreOrder(this);
     if (previousRenderer && previousRenderer != this) {
         adjacentPreviousSpannerPlaceholder = containingColumnSpannerPlaceholder(previousRenderer);
         if (!adjacentPreviousSpannerPlaceholder)
             return; // Preceded by column content. Set still needed.
     }
     RenderMultiColumnSpannerPlaceholder* adjacentNextSpannerPlaceholder = 0;
-    RenderObject* nextRenderer = descendant->nextInPreOrderAfterChildren(this);
+    LayoutObject* nextRenderer = descendant->nextInPreOrderAfterChildren(this);
     if (nextRenderer) {
         adjacentNextSpannerPlaceholder = containingColumnSpannerPlaceholder(nextRenderer);
         if (!adjacentNextSpannerPlaceholder)
             return; // Followed by column content. Set still needed.
     }
     // We have now determined that, with the removal of |descendant|, we should remove a column
     // set. Locate it and remove it. Do it without involving findSetRendering(), as that might be
     // very slow. Deduce the right set from the spanner placeholders that we've already found.
     RenderMultiColumnSet* columnSetToRemove;
     if (adjacentNextSpannerPlaceholder) {
@@ skipping 81 matching lines @@
     if (RenderMultiColumnSet* multicolSet = columnSetAtBlockOffset(offset))
         multicolSet->recordSpaceShortage(spaceShortage);
 }
 
 void RenderMultiColumnFlowThread::updateMinimumPageHeight(LayoutUnit offset, LayoutUnit minHeight)
 {
     if (RenderMultiColumnSet* multicolSet = columnSetAtBlockOffset(offset))
         multicolSet->updateMinimumColumnHeight(minHeight);
 }
 
-bool RenderMultiColumnFlowThread::addForcedRegionBreak(LayoutUnit offset, RenderObject* /*breakChild*/, bool /*isBefore*/, LayoutUnit* offsetBreakAdjustment)
+bool RenderMultiColumnFlowThread::addForcedRegionBreak(LayoutUnit offset, LayoutObject* /*breakChild*/, bool /*isBefore*/, LayoutUnit* offsetBreakAdjustment)
 {
     if (RenderMultiColumnSet* multicolSet = columnSetAtBlockOffset(offset)) {
         multicolSet->addContentRun(offset);
         if (offsetBreakAdjustment)
             *offsetBreakAdjustment = pageLogicalHeightForOffset(offset) ? pageRemainingLogicalHeightForOffset(offset, IncludePageBoundary) : LayoutUnit();
         return true;
     }
     return false;
 }
 
 bool RenderMultiColumnFlowThread::isPageLogicalHeightKnown() const
 {
     if (RenderMultiColumnSet* columnSet = lastMultiColumnSet())
         return columnSet->pageLogicalHeight();
     return false;
 }
 
 }