Merge 95924 - Source/WebCore: Issues with merging block children of a ruby

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 35 matching lines @@
 
 RenderRubyBase::~RenderRubyBase()
 {
 }
 
 bool RenderRubyBase::isChildAllowed(RenderObject* child, RenderStyle*) const
 {
     return child->isInline();
 }
 
-bool RenderRubyBase::hasOnlyWrappedInlineChildren(RenderObject* beforeChild) const
-{
-    // 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* beforeChild)
 {
     // This function removes all children that are before (!) beforeChild
     // and appends them to toBase.
-    ASSERT(toBase);
+    ASSERT_ARG(toBase, 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 (beforeChild && beforeChild->parent() != this)
         beforeChild = beforeChild->parent();
 
     if (childrenInline())
         moveInlineChildren(toBase, beforeChild);
     else
         moveBlockChildren(toBase, beforeChild);
 
     setNeedsLayoutAndPrefWidthsRecalc();
     toBase->setNeedsLayoutAndPrefWidthsRecalc();
 }
 
 void RenderRubyBase::moveInlineChildren(RenderRubyBase* toBase, RenderObject* beforeChild)
 {
+    ASSERT(childrenInline());
+    ASSERT_ARG(toBase, toBase);
+
+    if (!firstChild())
+        return;
+
     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(), beforeChild);
 }
 
 void RenderRubyBase::moveBlockChildren(RenderRubyBase* toBase, RenderObject* beforeChild)
 {
-    if (toBase->childrenInline()) {
-        // First check whether we move only wrapped inline objects.
-        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 != 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, beforeChild);
+    ASSERT(!childrenInline());
+    ASSERT_ARG(toBase, toBase);
 
-            // 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, beforeChild);
-}
-
-void RenderRubyBase::mergeBlockChildren(RenderRubyBase* toBase, RenderObject* beforeChild)
-{
-    // 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 (!firstChild())
         return;
 
+    if (toBase->childrenInline())
+        toBase->makeChildrenNonInline();
+
     // If an anonymous block would be put next to another such block, then merge those.
     RenderObject* firstChildHere = firstChild();
     RenderObject* lastChildThere = toBase->lastChild();
     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();
@@ skipping 22 matching lines @@
         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