Move rendering/RenderObject to layout/LayoutObject.

Source/core/layout/LayoutRubyRun.cpp

 /*
  * Copyright (C) 2009 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 47 matching lines @@
 
 bool LayoutRubyRun::hasRubyBase() const
 {
     // The only place where a ruby base can be is in the last position
     // Note: As anonymous blocks, ruby runs do not have ':before' or ':after' content themselves.
     return lastChild() && lastChild()->isRubyBase();
 }
 
 LayoutRubyText* LayoutRubyRun::rubyText() const
 {
-    RenderObject* child = firstChild();
+    LayoutObject* child = firstChild();
     // If in future it becomes necessary to support floating or positioned ruby text,
     // layout will have to be changed to handle them properly.
     ASSERT(!child || !child->isRubyText() || !child->isFloatingOrOutOfFlowPositioned());
     return child && child->isRubyText() ? static_cast<LayoutRubyText*>(child) : 0;
 }
 
 LayoutRubyBase* LayoutRubyRun::rubyBase() const
 {
-    RenderObject* child = lastChild();
+    LayoutObject* child = lastChild();
     return child && child->isRubyBase() ? static_cast<LayoutRubyBase*>(child) : 0;
 }
 
 LayoutRubyBase* LayoutRubyRun::rubyBaseSafe()
 {
     LayoutRubyBase* base = rubyBase();
     if (!base) {
         base = createRubyBase();
         RenderBlockFlow::addChild(base);
     }
     return base;
 }
 
-bool LayoutRubyRun::isChildAllowed(RenderObject* child, const RenderStyle&) const
+bool LayoutRubyRun::isChildAllowed(LayoutObject* child, const RenderStyle&) const
 {
     return child->isRubyText() || child->isInline();
 }
 
-void LayoutRubyRun::addChild(RenderObject* child, RenderObject* beforeChild)
+void LayoutRubyRun::addChild(LayoutObject* child, LayoutObject* beforeChild)
 {
     ASSERT(child);
 
     if (child->isRubyText()) {
         if (!beforeChild) {
             // LayoutRuby has already ascertained that we can add the child here.
             ASSERT(!hasRubyText());
             // prepend ruby texts as first child
             RenderBlockFlow::addChild(child, firstChild());
         }  else if (beforeChild->isRubyText()) {
             // New text is inserted just before another.
             // In this case the new text takes the place of the old one, and
             // the old text goes into a new run that is inserted as next sibling.
             ASSERT(beforeChild->parent() == this);
-            RenderObject* ruby = parent();
+            LayoutObject* ruby = parent();
             ASSERT(ruby->isRuby());
             RenderBlock* newRun = staticCreateRubyRun(ruby);
             ruby->addChild(newRun, nextSibling());
             // Add the new ruby text and move the old one to the new run
             // Note: Doing it in this order and not using LayoutRubyRun's methods,
             // in order to avoid automatic removal of the ruby run in case there is no
             // other child besides the old ruby text.
             RenderBlockFlow::addChild(child, beforeChild);
             RenderBlockFlow::removeChild(beforeChild);
             newRun->addChild(beforeChild);
         } else if (hasRubyBase()) {
             // Insertion before a ruby base object.
             // In this case we need insert a new run before the current one and split the base.
-            RenderObject* ruby = parent();
+            LayoutObject* ruby = parent();
             LayoutRubyRun* newRun = staticCreateRubyRun(ruby);
             ruby->addChild(newRun, this);
             newRun->addChild(child);
             rubyBaseSafe()->moveChildren(newRun->rubyBaseSafe(), beforeChild);
         }
     } else {
         // child is not a text -> insert it into the base
         // (append it instead if beforeChild is the ruby text)
         LayoutRubyBase* base = rubyBaseSafe();
         if (beforeChild == base)
             beforeChild = base->firstChild();
         if (beforeChild && beforeChild->isRubyText())
             beforeChild = 0;
         ASSERT(!beforeChild || beforeChild->isDescendantOf(base));
         base->addChild(child, beforeChild);
     }
 }
 
-void LayoutRubyRun::removeChild(RenderObject* child)
+void LayoutRubyRun::removeChild(LayoutObject* child)
 {
     // If the child is a ruby text, then merge the ruby base with the base of
     // the right sibling run, if possible.
     if (!beingDestroyed() && !documentBeingDestroyed() && child->isRubyText()) {
         LayoutRubyBase* base = rubyBase();
-        RenderObject* rightNeighbour = nextSibling();
+        LayoutObject* rightNeighbour = nextSibling();
         if (base && rightNeighbour && rightNeighbour->isRubyRun()) {
             // Ruby run without a base can happen only at the first run.
             LayoutRubyRun* rightRun = toLayoutRubyRun(rightNeighbour);
             if (rightRun->hasRubyBase()) {
                 LayoutRubyBase* rightBase = rightRun->rubyBaseSafe();
                 // Collect all children in a single base, then swap the bases.
                 rightBase->moveChildren(base);
                 moveChildTo(rightRun, base);
                 rightRun->moveChildTo(this, rightBase);
                 // The now empty ruby base will be removed below.
@@ skipping 23 matching lines @@
 
 LayoutRubyBase* LayoutRubyRun::createRubyBase() const
 {
     LayoutRubyBase* layoutObject = LayoutRubyBase::createAnonymous(&document());
     RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), BLOCK);
     newStyle->setTextAlign(CENTER); // FIXME: use WEBKIT_CENTER?
     layoutObject->setStyle(newStyle.release());
     return layoutObject;
 }
 
-LayoutRubyRun* LayoutRubyRun::staticCreateRubyRun(const RenderObject* parentRuby)
+LayoutRubyRun* LayoutRubyRun::staticCreateRubyRun(const LayoutObject* parentRuby)
 {
     ASSERT(parentRuby && parentRuby->isRuby());
     LayoutRubyRun* rr = new LayoutRubyRun();
     rr->setDocumentForAnonymous(&parentRuby->document());
     RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(parentRuby->style(), INLINE_BLOCK);
     rr->setStyle(newStyle.release());
     return rr;
 }
 
-RenderObject* LayoutRubyRun::layoutSpecialExcludedChild(bool relayoutChildren, SubtreeLayoutScope& layoutScope)
+LayoutObject* LayoutRubyRun::layoutSpecialExcludedChild(bool relayoutChildren, SubtreeLayoutScope& layoutScope)
 {
     // Don't bother positioning the LayoutRubyRun yet.
     LayoutRubyText* rt = rubyText();
     if (!rt)
         return 0;
     if (relayoutChildren)
         layoutScope.setChildNeedsLayout(rt);
     rt->layoutIfNeeded();
     return rt;
 }
@@ skipping 37 matching lines @@
             lastLineBottom += rb->logicalTop();
         }
 
         rt->setLogicalTop(-firstLineRubyTextTop + lastLineBottom);
     }
 
     // Update our overflow to account for the new LayoutRubyText position.
     computeOverflow(clientLogicalBottom());
 }
 
-void LayoutRubyRun::getOverhang(bool firstLine, RenderObject* startRenderer, RenderObject* endRenderer, int& startOverhang, int& endOverhang) const
+void LayoutRubyRun::getOverhang(bool firstLine, LayoutObject* startRenderer, LayoutObject* endRenderer, int& startOverhang, int& endOverhang) const
 {
     ASSERT(!needsLayout());
 
     startOverhang = 0;
     endOverhang = 0;
 
     LayoutRubyBase* rubyBase = this->rubyBase();
     LayoutRubyText* rubyText = this->rubyText();
 
     if (!rubyBase || !rubyText)
@@ skipping 23 matching lines @@
     // We can overhang the ruby by no more than half the width of the neighboring text
     // and no more than half the font size.
     int halfWidthOfFontSize = rubyText->style(firstLine)->fontSize() / 2;
     if (startOverhang)
         startOverhang = std::min<int>(startOverhang, std::min<int>(toRenderText(startRenderer)->minLogicalWidth(), halfWidthOfFontSize));
     if (endOverhang)
         endOverhang = std::min<int>(endOverhang, std::min<int>(toRenderText(endRenderer)->minLogicalWidth(), halfWidthOfFontSize));
 }
 
 } // namespace blink