Move continuation getter and setter down to LayoutBlockFlow.

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. 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
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 327 matching lines @@
 void LayoutInline::moveChildrenToIgnoringContinuation(LayoutInline* to, LayoutObject* startChild)
 {
     LayoutObject* child = startChild;
     while (child) {
         LayoutObject* currentChild = child;
         child = currentChild->nextSibling();
         to->addChildIgnoringContinuation(children()->removeChildNode(this, currentChild), nullptr);
     }
 }
 
-void LayoutInline::splitInlines(LayoutBlock* fromBlock, LayoutBlock* toBlock,
-    LayoutBlock* middleBlock, LayoutObject* beforeChild, LayoutBoxModelObject* oldCont)
+void LayoutInline::splitInlines(LayoutBlockFlow* fromBlock, LayoutBlockFlow* toBlock,
+    LayoutBlockFlow* middleBlock, LayoutObject* beforeChild, LayoutBoxModelObject* oldCont)
 {
     ASSERT(isDescendantOf(fromBlock));
 
     // If we're splitting the inline containing the fullscreened element,
     // |beforeChild| may be the layoutObject for the fullscreened element. However,
     // that layoutObject is wrapped in a LayoutFullScreen, so |this| is not its
     // parent. Since the splitting logic expects |this| to be the parent, set
     // |beforeChild| to be the LayoutFullScreen.
     if (Fullscreen* fullscreen = Fullscreen::fromIfExists(document())) {
         const Element* fullScreenElement = fullscreen->webkitCurrentFullScreenElement();
@@ skipping 59 matching lines @@
 
     // Hook |cloneInline| up as the continuation of the middle block.
     cloneInline->setContinuation(oldCont);
     middleBlock->setContinuation(cloneInline);
 
     // Now take all of the children from |beforeChild| to the end and remove
     // them from |this| and place them in the clone.
     moveChildrenToIgnoringContinuation(cloneInline, beforeChild);
 }
 
-void LayoutInline::splitFlow(LayoutObject* beforeChild, LayoutBlock* newBlockBox,
+void LayoutInline::splitFlow(LayoutObject* beforeChild, LayoutBlockFlow* newBlockBox,
     LayoutObject* newChild, LayoutBoxModelObject* oldCont)
 {
-    LayoutBlockFlow* containingBlockFlow = toLayoutBlockFlow(containingBlock());
-    LayoutBlock* pre = nullptr;
-    LayoutBlock* block = containingBlockFlow;
+    LayoutBlockFlow* block = toLayoutBlockFlow(containingBlock());
+    LayoutBlockFlow* pre = nullptr;
 
     // Delete our line boxes before we do the inline split into continuations.
-    containingBlockFlow->deleteLineBoxTree();
+    block->deleteLineBoxTree();
 
     bool reusedAnonymousBlock = false;
     if (block->isAnonymousBlock()) {
         LayoutBlock* outerContainingBlock = block->containingBlock();
         if (outerContainingBlock
             && outerContainingBlock->isLayoutBlockFlow()
             && !outerContainingBlock->createsAnonymousWrapper()) {
             // We can reuse this block and make it the preBlock of the next continuation.
-            containingBlockFlow->removePositionedObjects(nullptr);
-            containingBlockFlow->removeFloatingObjects();
-            pre = containingBlockFlow;
-            block = outerContainingBlock;
+            block->removePositionedObjects(nullptr);
+            block->removeFloatingObjects();
+            pre = block;
+            block = toLayoutBlockFlow(outerContainingBlock);
             reusedAnonymousBlock = true;
         }
     }
     if (!reusedAnonymousBlock)
-        pre = block->createAnonymousBlock(); // No anonymous block available for use. Make one.
+        pre = toLayoutBlockFlow(block->createAnonymousBlock()); // No anonymous block available for use. Make one.
 
-    LayoutBlock* post = toLayoutBlock(pre->createAnonymousBoxWithSameTypeAs(block));
+    LayoutBlockFlow* post = toLayoutBlockFlow(pre->createAnonymousBlock());
 
     LayoutObject* boxFirst = !reusedAnonymousBlock ? block->firstChild() : pre->nextSibling();
     if (!reusedAnonymousBlock)
         block->children()->insertChildNode(block, pre, boxFirst);
     block->children()->insertChildNode(block, newBlockBox, boxFirst);
     block->children()->insertChildNode(block, post, boxFirst);
     block->setChildrenInline(false);
 
     if (!reusedAnonymousBlock) {
         LayoutObject* o = boxFirst;
@@ skipping 661 matching lines @@
 void LayoutInline::updateDragState(bool dragOn)
 {
     LayoutBoxModelObject::updateDragState(dragOn);
     if (LayoutBoxModelObject* continuation = this->continuation())
         continuation->updateDragState(dragOn);
 }
 
 void LayoutInline::childBecameNonInline(LayoutObject* child)
 {
     // We have to split the parent flow.
-    LayoutBlock* newBox = containingBlock()->createAnonymousBlock();
+    LayoutBlockFlow* newBox = toLayoutBlockFlow(containingBlock()->createAnonymousBlock());
     LayoutBoxModelObject* oldContinuation = continuation();
     setContinuation(newBox);
     LayoutObject* beforeChild = child->nextSibling();
     children()->removeChildNode(this, child);
     splitFlow(beforeChild, newBox, child, oldContinuation);
 }
 
 void LayoutInline::updateHitTestResult(HitTestResult& result, const LayoutPoint& point)
 {
     if (result.innerNode())
@@ skipping 207 matching lines @@
 
 void LayoutInline::invalidateDisplayItemClients(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason) const
 {
     LayoutBoxModelObject::invalidateDisplayItemClients(paintInvalidationContainer, invalidationReason);
 
     for (InlineFlowBox* box = firstLineBox(); box; box = box->nextLineBox())
         paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box, invalidationReason);
 }
 
 } // namespace blink