Move rendering/RenderObject to layout/LayoutObject.

Source/core/rendering/RenderLineBoxList.cpp

 /*
  * Copyright (C) 2008 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
@@ skipping 210 matching lines @@
             if (inside) {
                 renderer->updateHitTestResult(result, locationInContainer.point() - toLayoutSize(accumulatedOffset));
                 return true;
             }
         }
     }
 
     return false;
 }
 
-void RenderLineBoxList::dirtyLinesFromChangedChild(RenderObject* container, RenderObject* child)
+void RenderLineBoxList::dirtyLinesFromChangedChild(LayoutObject* container, LayoutObject* child)
 {
     if (!container->parent() || (container->isRenderBlock() && (container->selfNeedsLayout() || !container->isRenderBlockFlow())))
         return;
 
     RenderInline* inlineContainer = container->isRenderInline() ? toRenderInline(container) : 0;
     InlineBox* firstBox = inlineContainer ? inlineContainer->firstLineBoxIncludingCulling() : firstLineBox();
 
     // If we have no first line box, then just bail early.
     if (!firstBox) {
         // For an empty inline, go ahead and propagate the check up to our parent, unless the parent
         // is already dirty.
         if (container->isInline() && !container->ancestorLineBoxDirty()) {
             container->parent()->dirtyLinesFromChangedChild(container);
             container->setAncestorLineBoxDirty(); // Mark the container to avoid dirtying the same lines again across multiple destroy() calls of the same subtree.
         }
         return;
     }
 
     // Try to figure out which line box we belong in.  First try to find a previous
     // line box by examining our siblings.  If we didn't find a line box, then use our
     // parent's first line box.
     RootInlineBox* box = 0;
-    RenderObject* curr = 0;
-    ListHashSet<RenderObject*, 16> potentialLineBreakObjects;
+    LayoutObject* curr = 0;
+    ListHashSet<LayoutObject*, 16> potentialLineBreakObjects;
     potentialLineBreakObjects.add(child);
     for (curr = child->previousSibling(); curr; curr = curr->previousSibling()) {
         potentialLineBreakObjects.add(curr);
 
         if (curr->isFloatingOrOutOfFlowPositioned())
             continue;
 
         if (curr->isReplaced()) {
             InlineBox* wrapper = toRenderBox(curr)->inlineBoxWrapper();
             if (wrapper)
@@ skipping 30 matching lines @@
     // If we found a line box, then dirty it.
     if (box) {
         RootInlineBox* adjacentBox;
         box->markDirty();
 
         // dirty the adjacent lines that might be affected
         // NOTE: we dirty the previous line because RootInlineBox objects cache
         // the address of the first object on the next line after a BR, which we may be
         // invalidating here.  For more info, see how RenderBlock::layoutInlineChildren
         // calls setLineBreakInfo with the result of findNextLineBreak.  findNextLineBreak,
-        // despite the name, actually returns the first RenderObject after the BR.
+        // despite the name, actually returns the first LayoutObject after the BR.
         // <rdar://problem/3849947> "Typing after pasting line does not appear until after window resize."
         adjacentBox = box->prevRootBox();
         if (adjacentBox)
             adjacentBox->markDirty();
         adjacentBox = box->nextRootBox();
         // If |child| or any of its immediately previous siblings with culled lineboxes is the object after a line-break in |box| or the linebox after it
         // then that means |child| actually sits on the linebox after |box| (or is its line-break object) and so we need to dirty it as well.
         if (adjacentBox && (potentialLineBreakObjects.contains(box->lineBreakObj()) || potentialLineBreakObjects.contains(adjacentBox->lineBreakObj()) || child->isBR() || isIsolated(container->style()->unicodeBidi())))
             adjacentBox->markDirty();
     }
 }
 
 #if ENABLE(ASSERT)
 
 void RenderLineBoxList::checkConsistency() const
 {
 #ifdef CHECK_CONSISTENCY
     const InlineFlowBox* prev = 0;
     for (const InlineFlowBox* child = m_firstLineBox; child != 0; child = child->nextLineBox()) {
         ASSERT(child->prevLineBox() == prev);
         prev = child;
     }
     ASSERT(prev == m_lastLineBox);
 #endif
 }
 
 #endif
 
 }