Remove anonymous block wrapper when all children become inline

third_party/WebKit/Source/core/layout/LayoutBlock.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 589 matching lines @@
     if ((prev && (prev->isRubyRun() || prev->isRubyBase()))
         || (next && (next->isRubyRun() || next->isRubyBase())))
         return false;
 
     return true;
 }
 
 void LayoutBlock::removeAnonymousWrappersIfRequired()
 {
     ASSERT(isLayoutBlockFlow());
-    Vector<LayoutBox*, 16> blocksToRemove;
+    Vector<LayoutBox*, 3> blocksToRemove;
     for (LayoutBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
         if (child->isFloatingOrOutOfFlowPositioned())
             continue;
 
         // There are still block children in the container, so any anonymous wrappers are still needed.
         if (!child->isAnonymousBlock())
             return;
         // We can't remove anonymous wrappers if they contain continuations as this means there are block children present.
         if (child->isLayoutBlock() && toLayoutBlock(child)->continuation())
             return;
@@ skipping 18 matching lines @@
         return;
     parent->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(LayoutInvalidationReason::ChildAnonymousBlockChanged);
 
     child->moveAllChildrenTo(parent, child->nextSibling(), child->hasLayer());
     parent->setChildrenInline(child->childrenInline());
 
     parent->children()->removeChildNode(parent, child, child->hasLayer());
     child->destroy();
 }
 
-static inline bool shouldMakeChildrenInline(const LayoutBlock* block)
+void LayoutBlock::makeChildrenInlineIfPossible()

[mstensho (USE GERRIT), 2015/10/26 13:42:46]

Before doing anything (object type checks and establishing the Vector), how
about first checking if we have children at all? I.e. move the |child|
definition a few lines up and bail early if it's nullptr.

 {
-    if (!block->isLayoutBlockFlow())
-        return false;
-    LayoutObject* child = block->firstChild();
+    if (!isLayoutBlockFlow() || isRubyRun())

[mstensho (USE GERRIT), 2015/10/26 13:42:46]

I'm wondering if we need more checks here. What about continuations and
LayoutRubyBase? I'm looking at canMergeContiguousAnonymousBlocks()... Not sure
if it's possible to end up with anonymous ruby base siblings or anything, but...

+        return;
+    Vector<LayoutBlock*, 3> blocksToRemove;
+    LayoutObject* child = firstChild();
     while (child) {
-        // TODO(rhogan): If we encounter anonymous blocks with inline children we should fold them in here.
-        if (!child->isFloatingOrOutOfFlowPositioned())
-            return false;
+        if (child->isAnonymousBlock() && child->childrenInline())
+            blocksToRemove.append(toLayoutBlock(child));
+        else if (!child->isFloatingOrOutOfFlowPositioned())
+            return;
         child = child->nextSibling();
     }
-    return true;
+    for (size_t i = 0; i < blocksToRemove.size(); i++)
+        collapseAnonymousBlockChild(this, blocksToRemove[i]);
+    setChildrenInline(true);
 }
 
 void LayoutBlock::removeChild(LayoutObject* oldChild)
 {
     // No need to waste time in merging or removing empty anonymous blocks.
     // We can just bail out if our document is getting destroyed.
     if (documentBeingDestroyed()) {
         LayoutBox::removeChild(oldChild);
         return;
     }
@@ skipping 84 matching lines @@
                 else if (curr->isLayoutBlock())
                     toLayoutBlock(curr)->setContinuation(nextContinuation);
                 else
                     ASSERT_NOT_REACHED();
 
                 break;
             }
             setContinuation(nullptr);
             destroy();
         }
-    } else if (!beingDestroyed() && !oldChild->isFloatingOrOutOfFlowPositioned() && shouldMakeChildrenInline(this)) {
+    } else if (!beingDestroyed() && !oldChild->isFloatingOrOutOfFlowPositioned()) {
         // If the child we're removing means that we can now treat all children as inline without the need for anonymous blocks, then do that.
-        setChildrenInline(true);
+        makeChildrenInlineIfPossible();
     }
 }
 
 bool LayoutBlock::isSelfCollapsingBlock() const
 {
     // We are not self-collapsing if we
     // (a) have a non-zero height according to layout (an optimization to avoid wasting time)
     // (b) are a table,
     // (c) have border/padding,
     // (d) have a min-height
@@ skipping 2102 matching lines @@
 void LayoutBlock::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const LayoutObject* obj) const
 {
     showLayoutObject();
     for (const RootInlineBox* root = firstRootBox(); root; root = root->nextRootBox())
         root->showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, 1);
 }
 
 #endif
 
 } // namespace blink