Get rid of continuations.

sky/engine/core/rendering/RenderInline.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 45 matching lines @@
 
 RenderInline* RenderInline::createAnonymous(Document* document)
 {
     RenderInline* renderer = new RenderInline(0);
     renderer->setDocumentForAnonymous(document);
     return renderer;
 }
 
 void RenderInline::willBeDestroyed()
 {
-#if ENABLE(ASSERT)
-    // Make sure we do not retain "this" in the continuation outline table map of our containing blocks.
-    if (parent() && style()->hasOutline()) {
-        bool containingBlockPaintsContinuationOutline = continuation() || isInlineElementContinuation();
-        if (containingBlockPaintsContinuationOutline) {
-            if (RenderBlock* cb = containingBlock()) {
-                if (RenderBlock* cbCb = cb->containingBlock())
-                    ASSERT(!cbCb->paintsContinuationOutline(this));
-            }
-        }
-    }
-#endif
-
     // Make sure to destroy anonymous children first while they are still connected to the rest of the tree, so that they will
     // properly dirty line boxes that they are removed from.  Effects that do :before/:after only on hover could crash otherwise.
     children()->destroyLeftoverChildren();
 
-    // Destroy our continuation before anything other than anonymous children.
-    // The reason we don't destroy it before anonymous children is that they may
-    // have continuations of their own that are anonymous children of our continuation.
-    RenderBoxModelObject* continuation = this->continuation();
-    if (continuation) {
-        continuation->destroy();
-        setContinuation(0);
-    }
-
     if (!documentBeingDestroyed()) {
         if (firstLineBox()) {
             // We can't wait for RenderBoxModelObject::destroy to clear the selection,
             // because by then we will have nuked the line boxes.
             // FIXME: The FrameSelection should be responsible for this when it
             // is notified of DOM mutations.
             if (isSelectionBorder())
                 view()->clearSelection();
 
             // If line boxes are contained inside a root, that means we're an inline.
             // In that case, we need to remove all the line boxes so that the parent
             // lines aren't pointing to deleted children. If the first line box does
             // not have a parent that means they are either already disconnected or
             // root lines that can just be destroyed without disconnecting.
             if (firstLineBox()->parent()) {
                 for (InlineFlowBox* box = firstLineBox(); box; box = box->nextLineBox())
                     box->remove();
             }
         } else if (parent())
             parent()->dirtyLinesFromChangedChild(this);
     }
 
     m_lineBoxes.deleteLineBoxes();
 
     RenderBoxModelObject::willBeDestroyed();
 }
 
-RenderInline* RenderInline::inlineElementContinuation() const
-{
-    RenderBoxModelObject* continuation = this->continuation();
-    if (!continuation || continuation->isInline())
-        return toRenderInline(continuation);
-    return toRenderBlock(continuation)->inlineElementContinuation();
-}
-
 void RenderInline::updateFromStyle()
 {
     RenderBoxModelObject::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.
     setHasTransform(false);
 }
 
-static RenderObject* inFlowPositionedInlineAncestor(RenderObject* p)
-{
-    while (p && p->isRenderInline()) {
-        if (p->isRelPositioned())
-            return p;
-        p = p->parent();
-    }
-    return 0;
-}
-
-static void updateStyleOfAnonymousBlockContinuations(RenderObject* block, const RenderStyle* newStyle, const RenderStyle* oldStyle)
-{
-    for (;block && block->isAnonymousBlock(); block = block->nextSibling()) {
-        if (!toRenderBlock(block)->isAnonymousBlockContinuation())
-            continue;
-
-        if (!block->style()->isOutlineEquivalent(newStyle)) {
-            RefPtr<RenderStyle> blockStyle = RenderStyle::clone(block->style());
-            blockStyle->setOutlineFromStyle(*newStyle);
-            block->setStyle(blockStyle);
-        }
-
-        if (block->style()->position() != newStyle->position()) {
-            // 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(toRenderBlock(block)->inlineElementContinuation()))
-                continue;
-            // FIXME: We should share blockStyle with the outline case, but it fails layout tests
-            // for dynamic position change of inlines containing block continuations. crbug.com/405222.
-            RefPtr<RenderStyle> blockStyle = RenderStyle::createAnonymousStyleWithDisplay(block->style(), BLOCK);
-            blockStyle->setPosition(newStyle->position());
-            block->setStyle(blockStyle);
-        }
-    }
-}
-
 void RenderInline::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 {
     RenderBoxModelObject::styleDidChange(diff, oldStyle);
 
-    // Ensure that all of the split inlines pick up the new style. We
-    // only do this if we're an inline, since we don't want to propagate
-    // a block's style to the other inlines.
-    // e.g., <font>foo <h4>goo</h4> moo</font>.  The <font> inlines before
-    // and after the block share the same style, but the block doesn't
-    // need to pass its style on to anyone else.
-    RenderStyle* newStyle = style();
-    RenderInline* continuation = inlineElementContinuation();
-    for (RenderInline* currCont = continuation; currCont; currCont = currCont->inlineElementContinuation()) {
-        RenderBoxModelObject* nextCont = currCont->continuation();
-        currCont->setContinuation(0);
-        currCont->setStyle(newStyle);
-        currCont->setContinuation(nextCont);
-    }
-
-    // If an inline's in-flow positioning has changed then any descendant blocks will need to change their in-flow positioning accordingly.
-    // Do this by updating the position of the descendant blocks' containing anonymous blocks - there may be more than one.
-    if (continuation && oldStyle
-        && (!newStyle->isOutlineEquivalent(oldStyle)
-            || (newStyle->position() != oldStyle->position() && (newStyle->hasInFlowPosition() || oldStyle->hasInFlowPosition())))) {
-        // If any descendant blocks exist then they will be in the next anonymous block and its siblings.
-        RenderObject* block = containingBlock()->nextSibling();
-        if (block && block->isAnonymousBlock())
-            updateStyleOfAnonymousBlockContinuations(block, newStyle, oldStyle);
-    }
-
     if (!alwaysCreateLineBoxes()) {
+        RenderStyle* newStyle = style();
         bool alwaysCreateLineBoxesNew = hasSelfPaintingLayer() || hasBoxDecorationBackground() || newStyle->hasPadding() || newStyle->hasMargin() || newStyle->hasOutline();
         if (oldStyle && alwaysCreateLineBoxesNew) {
             dirtyLineBoxes(false);
             setNeedsLayoutAndFullPaintInvalidation();
         }
         setAlwaysCreateLineBoxes(alwaysCreateLineBoxesNew);
     }
 }
 
-void RenderInline::setContinuation(RenderBoxModelObject* continuation)
-{
-    RenderBoxModelObject::setContinuation(continuation);
-    if (continuation && continuation->isAnonymousBlock() && !continuation->style()->isOutlineEquivalent(style())) {
-        // Push outline style to the block continuation.
-        RefPtr<RenderStyle> blockStyle = RenderStyle::clone(continuation->style());
-        blockStyle->setOutlineFromStyle(*style());
-        continuation->setStyle(blockStyle);
-    }
-    // FIXME: What if continuation is added when the inline has relative position? crbug.com/405222.
-}
-
 void RenderInline::updateAlwaysCreateLineBoxes(bool fullLayout)
 {
     // Once we have been tainted once, just assume it will happen again. This way effects like hover highlighting that change the
     // background color will only cause a layout on the first rollover.
     if (alwaysCreateLineBoxes())
         return;
 
     RenderStyle* parentStyle = parent()->style();
     RenderInline* parentRenderInline = parent()->isRenderInline() ? toRenderInline(parent()) : 0;
     bool alwaysCreateLineBoxesNew = (parentRenderInline && parentRenderInline->alwaysCreateLineBoxes())
@@ skipping 38 matching lines @@
     LayoutRect caretRect = localCaretRectForEmptyElement(borderAndPaddingWidth(), 0);
 
     if (InlineBox* firstBox = firstLineBox())
         caretRect.moveBy(roundedLayoutPoint(firstBox->topLeft()));
 
     return caretRect;
 }
 
 void RenderInline::addChild(RenderObject* newChild, RenderObject* beforeChild)
 {
-    if (continuation())
-        return addChildToContinuation(newChild, beforeChild);
-    return addChildIgnoringContinuation(newChild, beforeChild);
-}
-
-static RenderBoxModelObject* nextContinuation(RenderObject* renderer)
-{
-    if (renderer->isInline() && !renderer->isReplaced())
-        return toRenderInline(renderer)->continuation();
-    return toRenderBlock(renderer)->inlineElementContinuation();
-}
-
-RenderBoxModelObject* RenderInline::continuationBefore(RenderObject* beforeChild)
-{
-    if (beforeChild && beforeChild->parent() == this)
-        return this;
-
-    RenderBoxModelObject* curr = nextContinuation(this);
-    RenderBoxModelObject* nextToLast = this;
-    RenderBoxModelObject* last = this;
-    while (curr) {
-        if (beforeChild && beforeChild->parent() == curr) {
-            if (curr->slowFirstChild() == beforeChild)
-                return last;
-            return curr;
-        }
-
-        nextToLast = last;
-        last = curr;
-        curr = nextContinuation(curr);
-    }
-
-    if (!beforeChild && !last->slowFirstChild())
-        return nextToLast;
-    return last;
-}
-
-void RenderInline::addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild)
-{
-    if (!newChild->isInline() && !newChild->isFloatingOrOutOfFlowPositioned()) {
-        // We are placing a block inside an inline. We have to perform a split of this
-        // inline into continuations.  This involves creating an anonymous block box to hold
-        // |newChild|.  We then make that block box a continuation of this inline.  We take all of
-        // the children after |beforeChild| and put them in a clone of this object.
-        RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), BLOCK);
-
-        // If inside an inline affected by in-flow positioning the block needs to be affected by it too.
-        // Giving the block a layer like this allows it to collect the x/y offsets from inline parents later.
-        if (RenderObject* positionedAncestor = inFlowPositionedInlineAncestor(this))
-            newStyle->setPosition(positionedAncestor->style()->position());
-
-        RenderBlockFlow* newBox = RenderBlockFlow::createAnonymous(&document());
-        newBox->setStyle(newStyle.release());
-        RenderBoxModelObject* oldContinuation = continuation();
-        setContinuation(newBox);
-
-        splitFlow(beforeChild, newBox, newChild, oldContinuation);
-        return;
-    }
-
     RenderBoxModelObject::addChild(newChild, beforeChild);
-
     newChild->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
 }
 
-RenderInline* RenderInline::clone() const
-{
-    RenderInline* cloneInline = new RenderInline(node());
-    cloneInline->setStyle(style());
-    return cloneInline;
-}
-
-void RenderInline::splitInlines(RenderBlock* fromBlock, RenderBlock* toBlock,
-                                RenderBlock* middleBlock,
-                                RenderObject* beforeChild, RenderBoxModelObject* oldCont)
-{
-    // Create a clone of this inline.
-    RenderInline* cloneInline = clone();
-    cloneInline->setContinuation(oldCont);
-
-    // Now take all of the children from beforeChild to the end and remove
-    // them from |this| and place them in the clone.
-    RenderObject* o = beforeChild;
-    while (o) {
-        RenderObject* tmp = o;
-        o = tmp->nextSibling();
-        cloneInline->addChildIgnoringContinuation(children()->removeChildNode(this, tmp), 0);
-        tmp->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
-    }
-
-    // Hook |clone| up as the continuation of the middle block.
-    middleBlock->setContinuation(cloneInline);
-
-    // We have been reparented and are now under the fromBlock.  We need
-    // to walk up our inline parent chain until we hit the containing block.
-    // Once we hit the containing block we're done.
-    RenderBoxModelObject* curr = toRenderBoxModelObject(parent());
-    RenderBoxModelObject* currChild = this;
-
-    // FIXME: Because splitting is O(n^2) as tags nest pathologically, we cap the depth at which we're willing to clone.
-    // There will eventually be a better approach to this problem that will let us nest to a much
-    // greater depth (see bugzilla bug 13430) but for now we have a limit.  This *will* result in
-    // incorrect rendering, but the alternative is to hang forever.
-    unsigned splitDepth = 1;
-    const unsigned cMaxSplitDepth = 200;
-    while (curr && curr != fromBlock) {
-        ASSERT(curr->isRenderInline());
-        if (splitDepth < cMaxSplitDepth) {
-            // Create a new clone.
-            RenderInline* cloneChild = cloneInline;
-            cloneInline = toRenderInline(curr)->clone();
-
-            // Insert our child clone as the first child.
-            cloneInline->addChildIgnoringContinuation(cloneChild, 0);
-
-            // Hook the clone up as a continuation of |curr|.
-            RenderInline* inlineCurr = toRenderInline(curr);
-            oldCont = inlineCurr->continuation();
-            inlineCurr->setContinuation(cloneInline);
-            cloneInline->setContinuation(oldCont);
-
-            // Now we need to take all of the children starting from the first child
-            // *after* currChild and append them all to the clone.
-            o = currChild->nextSibling();
-            while (o) {
-                RenderObject* tmp = o;
-                o = tmp->nextSibling();
-                cloneInline->addChildIgnoringContinuation(inlineCurr->children()->removeChildNode(curr, tmp), 0);
-                tmp->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
-            }
-        }
-
-        // Keep walking up the chain.
-        currChild = curr;
-        curr = toRenderBoxModelObject(curr->parent());
-        splitDepth++;
-    }
-
-    // Now we are at the block level. We need to put the clone into the toBlock.
-    toBlock->children()->appendChildNode(toBlock, cloneInline);
-
-    // Now take all the children after currChild and remove them from the fromBlock
-    // and put them in the toBlock.
-    o = currChild->nextSibling();
-    while (o) {
-        RenderObject* tmp = o;
-        o = tmp->nextSibling();
-        toBlock->children()->appendChildNode(toBlock, fromBlock->children()->removeChildNode(fromBlock, tmp));
-    }
-}
-
-void RenderInline::splitFlow(RenderObject* beforeChild, RenderBlock* newBlockBox,
-                             RenderObject* newChild, RenderBoxModelObject* oldCont)
-{
-    RenderBlock* pre = 0;
-    RenderBlock* block = containingBlock();
-
-    // Delete our line boxes before we do the inline split into continuations.
-    block->deleteLineBoxTree();
-
-    bool madeNewBeforeBlock = false;
-    if (block->isAnonymousBlock()) {
-        // We can reuse this block and make it the preBlock of the next continuation.
-        pre = block;
-        pre->removePositionedObjects(0);
-        block = block->containingBlock();
-    } else {
-        // No anonymous block available for use.  Make one.
-        pre = block->createAnonymousBlock();
-        madeNewBeforeBlock = true;
-    }
-
-    RenderBlock* post = toRenderBlock(pre->createAnonymousBoxWithSameTypeAs(block));
-
-    RenderObject* boxFirst = madeNewBeforeBlock ? block->firstChild() : pre->nextSibling();
-    if (madeNewBeforeBlock)
-        block->children()->insertChildNode(block, pre, boxFirst);
-    block->children()->insertChildNode(block, newBlockBox, boxFirst);
-    block->children()->insertChildNode(block, post, boxFirst);
-    block->setChildrenInline(false);
-
-    if (madeNewBeforeBlock) {
-        RenderObject* o = boxFirst;
-        while (o) {
-            RenderObject* no = o;
-            o = no->nextSibling();
-            pre->children()->appendChildNode(pre, block->children()->removeChildNode(block, no));
-            no->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
-        }
-    }
-
-    splitInlines(pre, post, newBlockBox, beforeChild, oldCont);
-
-    // We already know the newBlockBox isn't going to contain inline kids, so avoid wasting
-    // time in makeChildrenNonInline by just setting this explicitly up front.
-    newBlockBox->setChildrenInline(false);
-
-    newBlockBox->addChild(newChild);
-
-    // Always just do a full layout in order to ensure that line boxes (especially wrappers for images)
-    // get deleted properly.  Because objects moves from the pre block into the post block, we want to
-    // make new line boxes instead of leaving the old line boxes around.
-    pre->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
-    block->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
-    post->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
-}
-
-void RenderInline::addChildToContinuation(RenderObject* newChild, RenderObject* beforeChild)
-{
-    RenderBoxModelObject* flow = continuationBefore(beforeChild);
-    ASSERT(!beforeChild || beforeChild->parent()->isRenderBlock() || beforeChild->parent()->isRenderInline());
-    RenderBoxModelObject* beforeChildParent = 0;
-    if (beforeChild)
-        beforeChildParent = toRenderBoxModelObject(beforeChild->parent());
-    else {
-        RenderBoxModelObject* cont = nextContinuation(flow);
-        if (cont)
-            beforeChildParent = cont;
-        else
-            beforeChildParent = flow;
-    }
-
-    if (newChild->isFloatingOrOutOfFlowPositioned())
-        return beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);
-
-    // A continuation always consists of two potential candidates: an inline or an anonymous
-    // block box holding block children.
-    bool childInline = newChild->isInline();
-    bool bcpInline = beforeChildParent->isInline();
-    bool flowInline = flow->isInline();
-
-    if (flow == beforeChildParent)
-        return flow->addChildIgnoringContinuation(newChild, beforeChild);
-    else {
-        // The goal here is to match up if we can, so that we can coalesce and create the
-        // minimal # of continuations needed for the inline.
-        if (childInline == bcpInline || (beforeChild && beforeChild->isInline()))
-            return beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);
-        if (flowInline == childInline)
-            return flow->addChildIgnoringContinuation(newChild, 0); // Just treat like an append.
-        return beforeChildParent->addChildIgnoringContinuation(newChild, beforeChild);
-    }
-}
-
 void RenderInline::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     ANNOTATE_GRAPHICS_CONTEXT(paintInfo, this);
     m_lineBoxes.paint(this, paintInfo, paintOffset);
 }
 
 template<typename GeneratorContext>
 void RenderInline::generateLineBoxRects(GeneratorContext& yield) const
 {
     if (!alwaysCreateLineBoxes())
@@ skipping 73 matching lines @@
     Vector<IntRect>& m_rects;
     const LayoutPoint& m_accumulatedOffset;
 };
 
 } // unnamed namespace
 
 void RenderInline::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
 {
     AbsoluteRectsGeneratorContext context(rects, accumulatedOffset);
     generateLineBoxRects(context);
-
-    if (continuation()) {
-        if (continuation()->isBox()) {
-            RenderBox* box = toRenderBox(continuation());
-            continuation()->absoluteRects(rects, toLayoutPoint(accumulatedOffset - containingBlock()->location() + box->locationOffset()));
-        } else
-            continuation()->absoluteRects(rects, toLayoutPoint(accumulatedOffset - containingBlock()->location()));
-    }
 }
 
 
 namespace {
 
 class AbsoluteQuadsGeneratorContext {
 public:
     AbsoluteQuadsGeneratorContext(const RenderInline* renderer, Vector<FloatQuad>& quads)
         : m_quads(quads)
         , m_geometryMap()
     {
         m_geometryMap.pushMappingsToAncestor(renderer, 0);
     }
 
     void operator()(const FloatRect& rect)
     {
         m_quads.append(m_geometryMap.absoluteRect(rect));
     }
 private:
     Vector<FloatQuad>& m_quads;
     RenderGeometryMap m_geometryMap;
 };
 
 } // unnamed namespace
 
 void RenderInline::absoluteQuads(Vector<FloatQuad>& quads) const
 {
     AbsoluteQuadsGeneratorContext context(this, quads);
     generateLineBoxRects(context);
-
-    if (continuation())
-        continuation()->absoluteQuads(quads);
 }
 
 LayoutUnit RenderInline::offsetLeft() const
 {
     LayoutPoint topLeft;
     if (InlineBox* firstBox = firstLineBoxIncludingCulling())
         topLeft = flooredLayoutPoint(firstBox->topLeft());
     return adjustedPositionRelativeToOffsetParent(topLeft).x();
 }
 
@@ skipping 107 matching lines @@
         // We can not use addNodeToRectBasedTestResult to determine if we fully enclose the hit-test area
         // because it can only handle rectangular targets.
         result.addNodeToRectBasedTestResult(node(), request, locationInContainer);
         return regionResult.contains(tmpLocation.boundingBox());
     }
     return false;
 }
 
 PositionWithAffinity RenderInline::positionForPoint(const LayoutPoint& point)
 {
+    // FIXME(sky): Now that we don't have continuations, can this whole function just be the following?
+    // return containingBlock()->positionForPoint(point);
+
     // FIXME: Does not deal with relative positioned inlines (should it?)
     RenderBlock* cb = containingBlock();
     if (firstLineBox()) {
         // This inline actually has a line box.  We must have clicked in the border/padding of one of these boxes.  We
         // should try to find a result by asking our containing block.
         return cb->positionForPoint(point);
     }
 
     // Translate the coords from the pre-anonymous block to the post-anonymous block.
-    LayoutPoint parentBlockPoint = cb->location() + point;
-    RenderBoxModelObject* c = continuation();
-    while (c) {
-        RenderBox* contBlock = c->isInline() ? c->containingBlock() : toRenderBlock(c);
-        if (c->isInline() || c->slowFirstChild())
-            return c->positionForPoint(parentBlockPoint - contBlock->locationOffset());
-        c = toRenderBlock(c)->inlineElementContinuation();
-    }
-
     return RenderBoxModelObject::positionForPoint(point);
 }
 
 namespace {
 
 class LinesBoundingBoxGeneratorContext {
 public:
     LinesBoundingBoxGeneratorContext(FloatRect& rect) : m_rect(rect) { }
     void operator()(const FloatRect& rect)
     {
@@ skipping 147 matching lines @@
     LayoutUnit logicalTop = firstLineBox()->logicalTopVisualOverflow(firstRootBox.lineTop());
     LayoutUnit logicalWidth = logicalRightSide - logicalLeftSide;
     LayoutUnit logicalHeight = lastLineBox()->logicalBottomVisualOverflow(lastRootBox.lineBottom()) - logicalTop;
 
     LayoutRect rect(logicalLeftSide, logicalTop, logicalWidth, logicalHeight);
     return rect;
 }
 
 LayoutRect RenderInline::clippedOverflowRectForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
 {
-    if (!firstLineBoxIncludingCulling() && !continuation())
+    if (!firstLineBoxIncludingCulling())
         return LayoutRect();
 
     LayoutRect paintInvalidationRect(linesVisualOverflowBoundingBox());
     bool hitPaintInvalidationContainer = false;
 
     // We need to add in the in-flow position offsets of any inlines (including us) up to our
     // containing block.
     RenderBlock* cb = containingBlock();
     for (const RenderObject* inlineFlow = this; inlineFlow && inlineFlow->isRenderInline() && inlineFlow != cb;
          inlineFlow = inlineFlow->parent()) {
@@ skipping 17 matching lines @@
     // FIXME: Passing paintInvalidationState directly to mapRectToPaintInvalidationBacking causes incorrect invalidations.
     // Should avoid slowRectMapping by properly adjusting paintInvalidationState. crbug.com/402994.
     ForceHorriblySlowRectMapping slowRectMapping(paintInvalidationState);
     cb->mapRectToPaintInvalidationBacking(paintInvalidationContainer, paintInvalidationRect, paintInvalidationState);
 
     if (outlineSize) {
         for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
             if (!curr->isText())
                 paintInvalidationRect.unite(curr->rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineSize));
         }
-
-        if (continuation() && !continuation()->isInline() && continuation()->parent())
-            paintInvalidationRect.unite(continuation()->rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineSize));
     }
 
     return paintInvalidationRect;
 }
 
 LayoutRect RenderInline::rectWithOutlineForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer, LayoutUnit outlineWidth, const PaintInvalidationState* paintInvalidationState) const
 {
     LayoutRect r(RenderBoxModelObject::rectWithOutlineForPaintInvalidation(paintInvalidationContainer, outlineWidth, paintInvalidationState));
     for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
         if (!curr->isText())
@@ skipping 105 matching lines @@
         // There can't be a transform between paintInvalidationContainer and o, because transforms create containers, so it should be safe
         // to just subtract the delta between the paintInvalidationContainer and o.
         LayoutSize containerOffset = paintInvalidationContainer->offsetFromAncestorContainer(o);
         transformState.move(-containerOffset.width(), -containerOffset.height(), preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
         return;
     }
 
     o->mapLocalToContainer(paintInvalidationContainer, transformState, mode, paintInvalidationState);
 }
 
-void RenderInline::childBecameNonInline(RenderObject* child)
-{
-    // We have to split the parent flow.
-    RenderBlock* newBox = containingBlock()->createAnonymousBlock();
-    RenderBoxModelObject* oldContinuation = continuation();
-    setContinuation(newBox);
-    RenderObject* beforeChild = child->nextSibling();
-    children()->removeChildNode(this, child);
-    splitFlow(beforeChild, newBox, child, oldContinuation);
-}
-
 void RenderInline::updateHitTestResult(HitTestResult& result, const LayoutPoint& point)
 {
     if (result.innerNode())
         return;
 
     Node* n = node();
     LayoutPoint localPoint(point);
     if (n) {
-        if (isInlineElementContinuation()) {
-            // We're in the continuation of a split inline.  Adjust our local point to be in the coordinate space
-            // of the principal renderer's containing block.  This will end up being the innerNonSharedNode.
-            RenderBlock* firstBlock = n->renderer()->containingBlock();
-
-            // Get our containing block.
-            RenderBox* block = containingBlock();
-            localPoint.moveBy(block->location() - firstBlock->locationOffset());
-        }
-
         result.setInnerNode(n);
         if (!result.innerNonSharedNode())
             result.setInnerNonSharedNode(n);
         result.setLocalPoint(localPoint);
     }
 }
 
 void RenderInline::dirtyLineBoxes(bool fullLayout)
 {
     if (fullLayout) {
@@ skipping 124 matching lines @@
 };
 
 } // unnamed namespace
 
 void RenderInline::addFocusRingRects(Vector<IntRect>& rects, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer) const
 {
     AbsoluteRectsIgnoringEmptyRectsGeneratorContext context(rects, additionalOffset);
     generateLineBoxRects(context);
 
     addChildFocusRingRects(rects, additionalOffset, paintContainer);
-
-    if (continuation()) {
-        // If the continuation doesn't paint into the same container, let its paint invalidation container handle it.
-        if (paintContainer != continuation()->containerForPaintInvalidation())
-            return;
-        if (continuation()->isInline())
-            continuation()->addFocusRingRects(rects, flooredLayoutPoint(additionalOffset + continuation()->containingBlock()->location() - containingBlock()->location()), paintContainer);
-        else
-            continuation()->addFocusRingRects(rects, flooredLayoutPoint(additionalOffset + toRenderBox(continuation())->location() - containingBlock()->location()), paintContainer);
-    }
 }
 
 namespace {
 
 class AbsoluteLayoutRectsGeneratorContext {
 public:
     AbsoluteLayoutRectsGeneratorContext(Vector<LayoutRect>& rects, const LayoutPoint& accumulatedOffset)
         : m_rects(rects)
         , m_accumulatedOffset(accumulatedOffset) { }
 
@@ skipping 154 matching lines @@
             pixelSnappedBox.maxY(),
             pixelSnappedBox.maxX() + outlineWidth,
             pixelSnappedBox.maxY() + outlineWidth,
             BSBottom, outlineColor, outlineStyle,
             outlineWidth,
             outlineWidth,
             antialias);
 }
 
 } // namespace blink