Move inlineElementContinuation() 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 95 matching lines @@
     m_lineBoxes.deleteLineBoxes();
 
     LayoutBoxModelObject::willBeDestroyed();
 }
 
 LayoutInline* LayoutInline::inlineElementContinuation() const
 {
     LayoutBoxModelObject* continuation = this->continuation();
     if (!continuation || continuation->isInline())
         return toLayoutInline(continuation);
-    return toLayoutBlock(continuation)->inlineElementContinuation();
+    return toLayoutBlockFlow(continuation)->inlineElementContinuation();
 }
 
 void LayoutInline::updateFromStyle()
 {
     LayoutBoxModelObject::updateFromStyle();
 
     // FIXME: Is this still needed. Was needed for run-ins, since run-in is considered a block display type.
     setInline(true);
 
     // FIXME: Support transforms and reflections on inline flows someday.
     setHasTransformRelatedProperty(false);
     setHasReflection(false);
 }
 
 static LayoutObject* inFlowPositionedInlineAncestor(LayoutObject* p)
 {
     while (p && p->isLayoutInline()) {
         if (p->isInFlowPositioned())
             return p;
         p = p->parent();
     }
     return nullptr;
 }
 
 static void updateInFlowPositionOfAnonymousBlockContinuations(LayoutObject* block, const ComputedStyle& newStyle, const ComputedStyle& oldStyle, LayoutObject* containingBlockOfEndOfContinuation)

[szager1, 2016/05/13 22:08:48]

Similarly, this seems like it could be refactored into a method on
LayoutBlockFlow.  Not a big deal, but food for thought.

[mstensho (USE GERRIT), 2016/05/15 18:48:37]

Definitely food for thought, but maybe we can deal with it in a later CL, if we
think it's a good idea?

In a way, this is continuation weirdness that probably doesn't have a better
home than LayoutInline, but it sure operates on LayoutBlockFlow objects, on the
other hand. :) No strong opinions, really.

 {
     for (; block && block != containingBlockOfEndOfContinuation && block->isAnonymousBlock(); block = block->nextSibling()) {
-        if (!toLayoutBlock(block)->isAnonymousBlockContinuation())
+        LayoutBlockFlow* blockFlow = toLayoutBlockFlow(block);
+        if (!blockFlow->isAnonymousBlockContinuation())
             continue;
 
         // If we are no longer in-flow positioned but our descendant block(s) still have an in-flow positioned ancestor then
         // their containing anonymous block should keep its in-flow positioning.
-        if (oldStyle.hasInFlowPosition() && inFlowPositionedInlineAncestor(toLayoutBlock(block)->inlineElementContinuation()))
+        if (oldStyle.hasInFlowPosition() && inFlowPositionedInlineAncestor(blockFlow->inlineElementContinuation()))
             continue;
 
         RefPtr<ComputedStyle> newBlockStyle = ComputedStyle::clone(block->styleRef());
         newBlockStyle->setPosition(newStyle.position());
         block->setStyle(newBlockStyle);
     }
 }
 
 void LayoutInline::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
 {
@@ skipping 107 matching lines @@
         beforeChild = beforeChild->parent();
     if (continuation())
         return addChildToContinuation(newChild, beforeChild);
     return addChildIgnoringContinuation(newChild, beforeChild);
 }
 
 static LayoutBoxModelObject* nextContinuation(LayoutObject* layoutObject)
 {
     if (layoutObject->isInline() && !layoutObject->isAtomicInlineLevel())
         return toLayoutInline(layoutObject)->continuation();
-    return toLayoutBlock(layoutObject)->inlineElementContinuation();
+    return toLayoutBlockFlow(layoutObject)->inlineElementContinuation();
 }
 
 LayoutBoxModelObject* LayoutInline::continuationBefore(LayoutObject* beforeChild)
 {
     if (beforeChild && beforeChild->parent() == this)
         return this;
 
     LayoutBoxModelObject* curr = nextContinuation(this);
     LayoutBoxModelObject* nextToLast = this;
     LayoutBoxModelObject* last = this;
@@ skipping 544 matching lines @@
         return cb->positionForPoint(point);
     }
 
     // Translate the coords from the pre-anonymous block to the post-anonymous block.
     LayoutPoint parentBlockPoint = cb->location() + point;
     LayoutBoxModelObject* c = continuation();
     while (c) {
         LayoutBox* contBlock = c->isInline() ? c->containingBlock() : toLayoutBlock(c);
         if (c->isInline() || c->slowFirstChild())
             return c->positionForPoint(parentBlockPoint - contBlock->locationOffset());
-        c = toLayoutBlock(c)->inlineElementContinuation();
+        c = toLayoutBlockFlow(c)->inlineElementContinuation();
     }
 
     return LayoutBoxModelObject::positionForPoint(point);
 }
 
 namespace {
 
 class LinesBoundingBoxGeneratorContext {
 public:
     LinesBoundingBoxGeneratorContext(FloatRect& rect) : m_rect(rect) { }
@@ skipping 506 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