Merge 95462 - Source/WebCore: Issues with merging ruby bases.

Source/WebCore/rendering/RenderRubyBase.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 @@
     // Tests whether all children in the base before beforeChild are either floated/positioned,
     // or inline objects wrapped in anonymous blocks.
     // Note that beforeChild may be 0, in which case all children are looked at.
     for (RenderObject* child = firstChild(); child != beforeChild; child = child->nextSibling()) {
         if (!child->isFloatingOrPositioned() && !(child->isAnonymousBlock() && child->childrenInline()))
             return false;
     }
     return true;
 }
 
-void RenderRubyBase::moveChildren(RenderRubyBase* toBase, RenderObject* fromBeforeChild)
+void RenderRubyBase::moveChildren(RenderRubyBase* toBase, RenderObject* beforeChild)
 {
     // This function removes all children that are before (!) beforeChild
     // and appends them to toBase.
     ASSERT(toBase);
     
     // First make sure that beforeChild (if set) is indeed a direct child of this.
     // Inline children might be wrapped in an anonymous block if there's a continuation.
     // Theoretically, in ruby bases, this can happen with only the first such a child,
     // so it should be OK to just climb the tree.
-    while (fromBeforeChild && fromBeforeChild->parent() != this)
-        fromBeforeChild = fromBeforeChild->parent();
+    while (beforeChild && beforeChild->parent() != this)
+        beforeChild = beforeChild->parent();
 
     if (childrenInline())
-        moveInlineChildren(toBase, fromBeforeChild);
+        moveInlineChildren(toBase, beforeChild);
     else
-        moveBlockChildren(toBase, fromBeforeChild);
+        moveBlockChildren(toBase, beforeChild);
 
     setNeedsLayoutAndPrefWidthsRecalc();
     toBase->setNeedsLayoutAndPrefWidthsRecalc();
 }
 
-void RenderRubyBase::moveInlineChildren(RenderRubyBase* toBase, RenderObject* fromBeforeChild)
+void RenderRubyBase::moveInlineChildren(RenderRubyBase* toBase, RenderObject* beforeChild)
 {
     RenderBlock* toBlock;
 
     if (toBase->childrenInline()) {
         // The standard and easy case: move the children into the target base
         toBlock = toBase;
     } else {
         // We need to wrap the inline objects into an anonymous block.
         // If toBase has a suitable block, we re-use it, otherwise create a new one.
         RenderObject* lastChild = toBase->lastChild();
         if (lastChild && lastChild->isAnonymousBlock() && lastChild->childrenInline())
             toBlock = toRenderBlock(lastChild);
         else {
             toBlock = toBase->createAnonymousBlock();
             toBase->children()->appendChildNode(toBase, toBlock);
         }
     }
     // Move our inline children into the target block we determined above.
-    moveChildrenTo(toBlock, firstChild(), fromBeforeChild);
+    moveChildrenTo(toBlock, firstChild(), beforeChild);
 }
 
-void RenderRubyBase::moveBlockChildren(RenderRubyBase* toBase, RenderObject* fromBeforeChild)
+void RenderRubyBase::moveBlockChildren(RenderRubyBase* toBase, RenderObject* beforeChild)
 {
     if (toBase->childrenInline()) {
         // First check whether we move only wrapped inline objects.
-        if (hasOnlyWrappedInlineChildren(fromBeforeChild)) {
+        if (hasOnlyWrappedInlineChildren(beforeChild)) {
             // The reason why the base is in block flow must be after beforeChild.
             // We therefore can extract the inline objects and move them to toBase.
-            for (RenderObject* child = firstChild(); child != fromBeforeChild; child = firstChild()) {
+            for (RenderObject* child = firstChild(); child != beforeChild; child = firstChild()) {
                 if (child->isAnonymousBlock()) {
                     RenderBlock* anonBlock = toRenderBlock(child);
                     ASSERT(anonBlock->childrenInline());
                     ASSERT(!anonBlock->inlineElementContinuation());
                     anonBlock->moveAllChildrenTo(toBase, toBase->children());
                     anonBlock->deleteLineBoxTree();
                     anonBlock->destroy();
                 } else {
                     ASSERT(child->isFloatingOrPositioned());
                     moveChildTo(toBase, child);
                 }
             }
         } else {
             // Moving block children -> have to set toBase as block flow
             toBase->makeChildrenNonInline();
             // Move children, potentially collapsing anonymous block wrappers.
-            mergeBlockChildren(toBase, fromBeforeChild);
+            mergeBlockChildren(toBase, beforeChild);
 
             // Now we need to check if the leftover children are all inline.
             // If so, make this base inline again.
             if (hasOnlyWrappedInlineChildren()) {
                 RenderObject* next = 0;
                 for (RenderObject* child = firstChild(); child; child = next) {
                     next = child->nextSibling();
                     if (child->isFloatingOrPositioned())
                         continue;
                     ASSERT(child->isAnonymousBlock());
 
                     RenderBlock* anonBlock = toRenderBlock(child);
                     ASSERT(anonBlock->childrenInline());
                     ASSERT(!anonBlock->inlineElementContinuation());
                     // Move inline children out of anonymous block.
                     anonBlock->moveAllChildrenTo(this, anonBlock);
                     anonBlock->deleteLineBoxTree();
                     anonBlock->destroy();
                 }
                 setChildrenInline(true);
             }
         }
     } else
-        mergeBlockChildren(toBase, fromBeforeChild);
+        mergeBlockChildren(toBase, beforeChild);
 }
 
-void RenderRubyBase::mergeBlockChildren(RenderRubyBase* toBase, RenderObject* fromBeforeChild)
+void RenderRubyBase::mergeBlockChildren(RenderRubyBase* toBase, RenderObject* beforeChild)
 {
-    // This function removes all children that are before fromBeforeChild and appends them to toBase.
+    // This function removes all children that are before beforeChild and appends them to toBase.
     ASSERT(!childrenInline());
     ASSERT(toBase);
     ASSERT(!toBase->childrenInline());
 
     // Quick check whether we have anything to do, to simplify the following code.
-    if (fromBeforeChild != firstChild())
+    if (!firstChild())
         return;
 
     // If an anonymous block would be put next to another such block, then merge those.
     RenderObject* firstChildHere = firstChild();
     RenderObject* lastChildThere = toBase->lastChild();
-    if (firstChildHere && firstChildHere->isAnonymousBlock() && firstChildHere->childrenInline() 
+    if (firstChildHere->isAnonymousBlock() && firstChildHere->childrenInline() 
             && lastChildThere && lastChildThere->isAnonymousBlock() && lastChildThere->childrenInline()) {            
         RenderBlock* anonBlockHere = toRenderBlock(firstChildHere);
         RenderBlock* anonBlockThere = toRenderBlock(lastChildThere);
         anonBlockHere->moveAllChildrenTo(anonBlockThere, anonBlockThere->children());
         anonBlockHere->deleteLineBoxTree();
         anonBlockHere->destroy();
     }
     // Move all remaining children normally.
-    moveChildrenTo(toBase, firstChild(), fromBeforeChild);
+    moveChildrenTo(toBase, firstChild(), beforeChild);
 }
 
 RenderRubyRun* RenderRubyBase::rubyRun() const
 {
     ASSERT(parent());
     ASSERT(parent()->isRubyRun());
 
     return toRenderRubyRun(parent());
 }
 
 ETextAlign RenderRubyBase::textAlignmentForLine(bool /* endsWithSoftBreak */) const
 {
     return JUSTIFY;
 }
 
 void RenderRubyBase::adjustInlineDirectionLineBounds(int expansionOpportunityCount, float& logicalLeft, float& logicalWidth) const
 {
     int maxPreferredLogicalWidth = this->maxPreferredLogicalWidth();
     if (maxPreferredLogicalWidth >= logicalWidth)
         return;
 
     // Inset the ruby base by half the inter-ideograph expansion amount.
     float inset = (logicalWidth - maxPreferredLogicalWidth) / (expansionOpportunityCount + 1);
 
     logicalLeft += inset / 2;
     logicalWidth -= inset;
 }
 
 } // namespace WebCore