Move rendering/RenderObject to layout/LayoutObject.

Source/core/layout/LayoutObjectChildList.cpp

 /*
  * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. 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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
-#include "core/rendering/RenderObjectChildList.h"
+#include "core/layout/LayoutObjectChildList.h"
 
 #include "core/dom/AXObjectCache.h"
 #include "core/layout/Layer.h"
 #include "core/layout/LayoutCounter.h"
-#include "core/rendering/RenderObject.h"
+#include "core/layout/LayoutObject.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/style/RenderStyle.h"
 
 namespace blink {
 
-void RenderObjectChildList::destroyLeftoverChildren()
+void LayoutObjectChildList::destroyLeftoverChildren()
 {
     while (firstChild()) {
         // List markers are owned by their enclosing list and so don't get destroyed by this container.
         if (firstChild()->isListMarker()) {
             firstChild()->remove();
             continue;
         }
 
         // Destroy any anonymous children remaining in the render tree, as well as implicit (shadow) DOM elements like those used in the engine-based text fields.
         if (firstChild()->node())
             firstChild()->node()->setRenderer(0);
         firstChild()->destroy();
     }
 }
 
-RenderObject* RenderObjectChildList::removeChildNode(RenderObject* owner, RenderObject* oldChild, bool notifyRenderer)
+LayoutObject* LayoutObjectChildList::removeChildNode(LayoutObject* owner, LayoutObject* oldChild, bool notifyRenderer)
 {
     ASSERT(oldChild->parent() == owner);
     ASSERT(this == owner->virtualChildren());
 
     if (oldChild->isFloatingOrOutOfFlowPositioned())
         toRenderBox(oldChild)->removeFloatingOrPositionedChildFromBlockLists();
 
     {
         // FIXME: We should not be allowing paint invalidation during layout. crbug.com/336250
         AllowPaintInvalidationScope scoper(owner->frameView());
@@ skipping 43 matching lines @@
     // by skipping this step when destroying the entire tree.
     if (!owner->documentBeingDestroyed())
         LayoutCounter::rendererRemovedFromTree(oldChild);
 
     if (AXObjectCache* cache = owner->document().existingAXObjectCache())
         cache->childrenChanged(owner);
 
     return oldChild;
 }
 
-void RenderObjectChildList::insertChildNode(RenderObject* owner, RenderObject* newChild, RenderObject* beforeChild, bool notifyRenderer)
+void LayoutObjectChildList::insertChildNode(LayoutObject* owner, LayoutObject* newChild, LayoutObject* beforeChild, bool notifyRenderer)
 {
     ASSERT(!newChild->parent());
     ASSERT(this == owner->virtualChildren());
     ASSERT(!owner->isRenderBlockFlow() || (!newChild->isTableSection() && !newChild->isTableRow() && !newChild->isTableCell()));
 
     while (beforeChild && beforeChild->parent() && beforeChild->parent() != owner)
         beforeChild = beforeChild->parent();
 
     // This should never happen, but if it does prevent render tree corruption
     // where child->parent() ends up being owner but child->nextSibling()->parent()
     // is not owner.
     if (beforeChild && beforeChild->parent() != owner) {
         ASSERT_NOT_REACHED();
         return;
     }
 
     newChild->setParent(owner);
 
     if (firstChild() == beforeChild)
         setFirstChild(newChild);
 
     if (beforeChild) {
-        RenderObject* previousSibling = beforeChild->previousSibling();
+        LayoutObject* previousSibling = beforeChild->previousSibling();
         if (previousSibling)
             previousSibling->setNextSibling(newChild);
         newChild->setPreviousSibling(previousSibling);
         newChild->setNextSibling(beforeChild);
         beforeChild->setPreviousSibling(newChild);
     } else {
         if (lastChild())
             lastChild()->setNextSibling(newChild);
         newChild->setPreviousSibling(lastChild());
         setLastChild(newChild);
     }
 
     if (!owner->documentBeingDestroyed() && notifyRenderer)
         newChild->insertedIntoTree();
 
     if (!owner->documentBeingDestroyed()) {
         LayoutCounter::rendererSubtreeAttached(newChild);
     }
 
     newChild->setNeedsLayoutAndPrefWidthsRecalc();
     newChild->setShouldDoFullPaintInvalidation(PaintInvalidationRendererInsertion);
     if (!owner->normalChildNeedsLayout())
         owner->setChildNeedsLayout(); // We may supply the static position for an absolute positioned child.
 
     if (AXObjectCache* cache = owner->document().axObjectCache())
         cache->childrenChanged(owner);
 }
 
-void RenderObjectChildList::invalidatePaintOnRemoval(const RenderObject& oldChild)
+void LayoutObjectChildList::invalidatePaintOnRemoval(const LayoutObject& oldChild)
 {
     if (!oldChild.isRooted())
         return;
     if (oldChild.isBody()) {
         oldChild.view()->setShouldDoFullPaintInvalidation();
         return;
     }
     DisableCompositingQueryAsserts disabler;
     oldChild.invalidatePaintUsingContainer(oldChild.containerForPaintInvalidation(), oldChild.previousPaintInvalidationRect(), PaintInvalidationRendererRemoval);
 }
 
 } // namespace blink