Move makeChildrenNonInline() and childBecameNonInline() to LayoutBlockFlow.

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 356 matching lines @@
             LayoutBlock* newBox = createAnonymousBlock();
             LayoutBox::addChild(newBox, beforeChild);
             newBox->addChild(newChild);
             return;
         }
     }
 
     LayoutBox::addChild(newChild, beforeChild);
 }
 
-static void getInlineRun(LayoutObject* start, LayoutObject* boundary,
-    LayoutObject*& inlineRunStart,
-    LayoutObject*& inlineRunEnd)
-{
-    // Beginning at |start| we find the largest contiguous run of inlines that
-    // we can.  We denote the run with start and end points, |inlineRunStart|
-    // and |inlineRunEnd|.  Note that these two values may be the same if
-    // we encounter only one inline.
-    //
-    // We skip any non-inlines we encounter as long as we haven't found any
-    // inlines yet.
-    //
-    // |boundary| indicates a non-inclusive boundary point.  Regardless of whether |boundary|
-    // is inline or not, we will not include it in a run with inlines before it.  It's as though we encountered
-    // a non-inline.
-
-    // Start by skipping as many non-inlines as we can.
-    LayoutObject * curr = start;
-    bool sawInline;
-    do {
-        while (curr && !(curr->isInline() || curr->isFloatingOrOutOfFlowPositioned()))
-            curr = curr->nextSibling();
-
-        inlineRunStart = inlineRunEnd = curr;
-
-        if (!curr)
-            return; // No more inline children to be found.
-
-        sawInline = curr->isInline();
-
-        curr = curr->nextSibling();
-        while (curr && (curr->isInline() || curr->isFloatingOrOutOfFlowPositioned()) && (curr != boundary)) {
-            inlineRunEnd = curr;
-            if (curr->isInline())
-                sawInline = true;
-            curr = curr->nextSibling();
-        }
-    } while (!sawInline);
-}
-
 void LayoutBlock::deleteLineBoxTree()
 {
     ASSERT(!m_lineBoxes.firstLineBox());
 }
 
-void LayoutBlock::makeChildrenNonInline(LayoutObject *insertionPoint)
-{
-    // makeChildrenNonInline takes a block whose children are *all* inline and it
-    // makes sure that inline children are coalesced under anonymous
-    // blocks.  If |insertionPoint| is defined, then it represents the insertion point for
-    // the new block child that is causing us to have to wrap all the inlines.  This
-    // means that we cannot coalesce inlines before |insertionPoint| with inlines following
-    // |insertionPoint|, because the new child is going to be inserted in between the inlines,
-    // splitting them.
-    ASSERT(isInlineBlockOrInlineTable() || !isInline());
-    ASSERT(!insertionPoint || insertionPoint->parent() == this);
-
-    setChildrenInline(false);
-
-    LayoutObject* child = firstChild();
-    if (!child)
-        return;
-
-    deleteLineBoxTree();
-
-    while (child) {
-        LayoutObject* inlineRunStart;
-        LayoutObject* inlineRunEnd;
-        getInlineRun(child, insertionPoint, inlineRunStart, inlineRunEnd);
-
-        if (!inlineRunStart)
-            break;
-
-        child = inlineRunEnd->nextSibling();
-
-        LayoutBlock* block = createAnonymousBlock();
-        children()->insertChildNode(this, block, inlineRunStart);
-        moveChildrenTo(block, inlineRunStart, child);
-    }
-
-#if ENABLE(ASSERT)
-    for (LayoutObject *c = firstChild(); c; c = c->nextSibling())
-        ASSERT(!c->isInline());
-#endif
-
-    setShouldDoFullPaintInvalidation();
-}
-
 void LayoutBlock::removeLeftoverAnonymousBlock(LayoutBlock* child)
 {
     ASSERT(child->isAnonymousBlock());
     ASSERT(!child->childrenInline());
     ASSERT(child->parent() == this);
 
     if (child->continuation())
         return;
 
     // Promote all the leftover anonymous block's children (to become children of this block
@@ skipping 1300 matching lines @@
 {
     if (childrenInline())
         return toLayoutBlockFlow(this);
     for (LayoutObject* child = firstChild(); child && !child->isFloatingOrOutOfFlowPositioned() && child->isLayoutBlockFlow(); child = toLayoutBlock(child)->firstChild()) {
         if (child->childrenInline())
             return toLayoutBlockFlow(child);
     }
     return nullptr;
 }
 
-void LayoutBlock::childBecameNonInline(LayoutObject*)
-{
-    makeChildrenNonInline();
-    if (isAnonymousBlock() && parent() && parent()->isLayoutBlock())
-        toLayoutBlock(parent())->removeLeftoverAnonymousBlock(this);
-    // |this| may be dead here
-}
-
 void LayoutBlock::updateHitTestResult(HitTestResult& result, const LayoutPoint& point)
 {
     if (result.innerNode())
         return;
 
     if (Node* n = nodeForHitTest())
         result.setNodeAndPosition(n, point);
 }
 
 // An inline-block uses its inlineBox as the inlineBoxWrapper,
@@ skipping 276 matching lines @@
         for (TrackedLayoutBoxListHashSet::const_iterator it = positionedDescendantSet->begin(); it != end; ++it) {
             LayoutBox* currBox = *it;
             ASSERT(!currBox->needsLayout());
         }
     }
 }
 
 #endif
 
 } // namespace blink