Changeset 224279 in webkit


Ignore:
Timestamp:
Nov 1, 2017 9:28:17 AM (6 years ago)
Author:
commit-queue@webkit.org
Message:

Unreviewed, rolling out r224273 and r224278.
​https://bugs.webkit.org/show_bug.cgi?id=179120

Some crashes under guard malloc (Requested by anttik on
#webkit).

Reverted changesets:

"Remove empty continuations in
RenderObject::removeFromParentAndDestroyCleaningUpAnonymousWrappers"
​https://bugs.webkit.org/show_bug.cgi?id=179014
​https://trac.webkit.org/changeset/224273

"Fix ContinuationChainNode::insertAfter assertion."
​https://bugs.webkit.org/show_bug.cgi?id=179115
​https://trac.webkit.org/changeset/224278

Location:
trunk
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r224273 r224279  
     12017-11-01  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r224273 and r224278.
     4        https://bugs.webkit.org/show_bug.cgi?id=179120
     5
     6        Some crashes under guard malloc (Requested by anttik on
     7        #webkit).
     8
     9        Reverted changesets:
     10
     11        "Remove empty continuations in
     12        RenderObject::removeFromParentAndDestroyCleaningUpAnonymousWrappers"
     13        https://bugs.webkit.org/show_bug.cgi?id=179014
     14        https://trac.webkit.org/changeset/224273
     15
     16        "Fix ContinuationChainNode::insertAfter assertion."
     17        https://bugs.webkit.org/show_bug.cgi?id=179115
     18        https://trac.webkit.org/changeset/224278
     19
    1202017-11-01  Antti Koivisto  <antti@apple.com>
    221

  • trunk/LayoutTests/fast/ruby/float-overhang-from-ruby-text-expected.txt

    r224273 r224279  
    1818        RenderRuby (inline) {RUBY} at (0,0) size 100x50
    1919          RenderRubyRun (anonymous) at (0,0) size 100x50
    20             RenderText {#text} at (0,0) size 100x50
    21               text run at (0,0) width 100: "aa"
     20            RenderRubyBase (anonymous) at (0,0) size 100x50
     21              RenderText {#text} at (0,0) size 100x50
     22                text run at (0,0) width 100: "aa"
    2223        RenderText {#text} at (0,0) size 0x0

  • trunk/LayoutTests/platform/mac/fast/ruby/rubyDOM-remove-rt1-expected.txt

    r224273 r224279  
    2525                text run at (30,0) width 47: "HTML"
    2626          RenderRubyRun (anonymous) at (259,10) size 9x18
    27             RenderText {#text} at (0,0) size 8x18
    28               text run at (0,0) width 8: "5"
     27            RenderRubyBase (anonymous) at (0,0) size 8x18
     28              RenderText {#text} at (0,0) size 8x18
     29                text run at (0,0) width 8: "5"
    2930        RenderText {#text} at (267,10) size 38x18
    3031          text run at (267,10) width 38: " spec."

  • trunk/Source/WebCore/ChangeLog

    r224278 r224279  
     12017-11-01  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r224273 and r224278.
     4        https://bugs.webkit.org/show_bug.cgi?id=179120
     5
     6        Some crashes under guard malloc (Requested by anttik on
     7        #webkit).
     8
     9        Reverted changesets:
     10
     11        "Remove empty continuations in
     12        RenderObject::removeFromParentAndDestroyCleaningUpAnonymousWrappers"
     13        https://bugs.webkit.org/show_bug.cgi?id=179014
     14        https://trac.webkit.org/changeset/224273
     15
     16        "Fix ContinuationChainNode::insertAfter assertion."
     17        https://bugs.webkit.org/show_bug.cgi?id=179115
     18        https://trac.webkit.org/changeset/224278
     19
    1202017-11-01  Emilio Cobos Álvarez  <emilio@crisal.io>
    221

  • trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

    r224273 r224279  
    164164static inline RenderObject* firstChildInContinuation(RenderInline& renderer)
    165165{
    166     auto* continuation = renderer.continuation();
     166    auto continuation = renderer.continuation();
    167167
    168168    while (continuation) {

  • trunk/Source/WebCore/rendering/RenderBlock.cpp

    r224273 r224279  
    436436
    437437    auto& newStyle = style();
    438     if (!isAnonymousBlock() && !isContinuation()) {
     438    if (!isAnonymousBlock()) {
    439439        // Ensure that all of our continuation blocks pick up the new style.
    440         for (RenderBlock* currCont = blockElementContinuation(); currCont; currCont = currCont->blockElementContinuation())
     440        for (RenderBlock* currCont = blockElementContinuation(); currCont; currCont = currCont->blockElementContinuation()) {
     441            RenderBoxModelObject* nextCont = currCont->continuation();
     442            currCont->setContinuation(0);
    441443            currCont->setStyle(RenderStyle::clone(newStyle));
     444            currCont->setContinuation(nextCont);
     445        }
    442446    }
    443447
    … …  
    815819}
    816820
    817 void RenderBlock::dropAnonymousBoxChild(RenderBlock& child)
    818 {
    819     setNeedsLayoutAndPrefWidthsRecalc();
    820     setChildrenInline(child.childrenInline());
     821void RenderBlock::dropAnonymousBoxChild(RenderBlock& parent, RenderBlock& child)
     822{
     823    parent.setNeedsLayoutAndPrefWidthsRecalc();
     824    parent.setChildrenInline(child.childrenInline());
    821825    RenderObject* nextSibling = child.nextSibling();
    822826
    823     auto toBeDeleted = takeChildInternal(child, child.hasLayer() ? NotifyChildren : DontNotifyChildren);
    824     child.moveAllChildrenTo(this, nextSibling, child.hasLayer());
     827    auto toBeDeleted = parent.takeChildInternal(child, child.hasLayer() ? NotifyChildren : DontNotifyChildren);
     828    child.moveAllChildrenTo(&parent, nextSibling, child.hasLayer());
    825829    // Delete the now-empty block's lines and nuke it.
    826830    child.deleteLines();
    … …  
    890894        // The removal has knocked us down to containing only a single anonymous
    891895        // box. We can pull the content right back up into our box.
    892         dropAnonymousBoxChild(downcast<RenderBlock>(*child));
     896        dropAnonymousBoxChild(*this, downcast<RenderBlock>(*child));
    893897    } else if (((prev && prev->isAnonymousBlock()) || (next && next->isAnonymousBlock())) && canDropAnonymousBlockChild()) {
    894898        // It's possible that the removal has knocked us down to a single anonymous
    … …  
    906910            }
    907911            if (dropAnonymousBlock)
    908                 dropAnonymousBoxChild(anonBlock);
     912                dropAnonymousBoxChild(*this, anonBlock);
    909913        }
    910914    }
    … …  
    914918        if (childrenInline())
    915919            deleteLines();
     920
     921        // If we are an empty anonymous block in the continuation chain,
     922        // we need to remove ourself and fix the continuation chain.
     923        if (!beingDestroyed() && isAnonymousBlockContinuation() && !oldChild.isListMarker()) {
     924            auto containingBlockIgnoringAnonymous = containingBlock();
     925            while (containingBlockIgnoringAnonymous && containingBlockIgnoringAnonymous->isAnonymousBlock())
     926                containingBlockIgnoringAnonymous = containingBlockIgnoringAnonymous->containingBlock();
     927            for (RenderObject* current = this; current; current = current->previousInPreOrder(containingBlockIgnoringAnonymous)) {
     928                if (!is<RenderBoxModelObject>(current) || downcast<RenderBoxModelObject>(*current).continuation() != this)
     929                    continue;
     930                // Found our previous continuation. We just need to point it to
     931                // |this|'s next continuation.
     932                auto* nextContinuation = continuation();
     933                if (is<RenderInline>(*current))
     934                    downcast<RenderInline>(*current).setContinuation(nextContinuation);
     935                else if (is<RenderBlock>(*current))
     936                    downcast<RenderBlock>(*current).setContinuation(nextContinuation);
     937                else
     938                    ASSERT_NOT_REACHED();
     939                break;
     940            }
     941            setContinuation(nullptr);
     942            // FIXME: This is dangerous.
     943            removeFromParentAndDestroy();
     944        }
    916945    }
    917946    return takenChild;

  • trunk/Source/WebCore/rendering/RenderBlock.h

    r224273 r224279  
    193193    RenderBlock* blockElementContinuation() const;
    194194
     195    using RenderBoxModelObject::continuation;
     196    using RenderBoxModelObject::setContinuation;
     197
    195198    static RenderPtr<RenderBlock> createAnonymousWithParentRendererAndDisplay(const RenderBox& parent, EDisplay = BLOCK);
    196199    RenderPtr<RenderBlock> createAnonymousBlock(EDisplay = BLOCK) const;
    197     void dropAnonymousBoxChild(RenderBlock& child);
     200    static void dropAnonymousBoxChild(RenderBlock& parent, RenderBlock& child);
    198201
    199202    RenderPtr<RenderBox> createAnonymousBoxWithSameTypeAs(const RenderBox&) const override;

  • trunk/Source/WebCore/rendering/RenderBoxModelObject.cpp

    r224278 r224279  
    7878// <b><i><p>Hello</p></i></b>. In this example the <i> will have a block as
    7979// its continuation but the <b> will just have an inline as its continuation.
    80 
    81 struct RenderBoxModelObject::ContinuationChainNode {
    82     WeakPtr<RenderBoxModelObject> renderer;
    83     ContinuationChainNode* previous { nullptr };
    84     ContinuationChainNode* next { nullptr };
    85 
    86     ContinuationChainNode(RenderBoxModelObject&);
    87     ~ContinuationChainNode();
    88 
    89     void insertAfter(ContinuationChainNode&);
    90 
    91     WTF_MAKE_FAST_ALLOCATED;
    92 };
    93 
    94 RenderBoxModelObject::ContinuationChainNode::ContinuationChainNode(RenderBoxModelObject& renderer)
    95     : renderer(makeWeakPtr(renderer))
    96 {
    97 }
    98 
    99 RenderBoxModelObject::ContinuationChainNode::~ContinuationChainNode()
    100 {
    101     if (next) {
    102         ASSERT(previous);
    103         ASSERT(next->previous == this);
    104         next->previous = previous;
    105     }
    106     if (previous) {
    107         ASSERT(previous->next == this);
    108         previous->next = next;
    109     }
    110 }
    111 
    112 void RenderBoxModelObject::ContinuationChainNode::insertAfter(ContinuationChainNode& after)
    113 {
    114     ASSERT(!previous);
    115     ASSERT(!next);
    116     if ((next = after.next)) {
    117         ASSERT(next->previous == &after);
    118         next->previous = this;
    119     }
    120     previous = &after;
    121     after.next = this;
    122 }
    123 
    124 typedef HashMap<const RenderBoxModelObject*, std::unique_ptr<RenderBoxModelObject::ContinuationChainNode>> ContinuationChainNodeMap;
    125 static ContinuationChainNodeMap& continuationChainNodeMap()
    126 {
    127     static NeverDestroyed<ContinuationChainNodeMap> map;
     80typedef HashMap<const RenderBoxModelObject*, WeakPtr<RenderBoxModelObject>> ContinuationMap;
     81static ContinuationMap& continuationMap()
     82{
     83    static NeverDestroyed<ContinuationMap> map;
    12884    return map;
    12985}
    … …  
    232188void RenderBoxModelObject::willBeDestroyed()
    233189{
    234     if (continuation() && !isContinuation()) {
    235         removeAndDestroyAllContinuations();
    236         ASSERT(!continuation());
    237     }
    238     if (hasContinuationChainNode())
    239         removeFromContinuationChain();
     190    if (hasContinuation()) {
     191        continuation()->removeFromParentAndDestroy();
     192        setContinuation(nullptr);
     193    }
    240194
    241195    // If this is a first-letter object with a remaining text fragment then the
    … …  
    24942448RenderBoxModelObject* RenderBoxModelObject::continuation() const
    24952449{
    2496     if (!hasContinuationChainNode())
     2450    if (!hasContinuation())
    24972451        return nullptr;
    2498 
    2499     auto& continuationChainNode = *continuationChainNodeMap().get(this);
    2500     if (!continuationChainNode.next)
    2501         return nullptr;
    2502     return continuationChainNode.next->renderer.get();
    2503 }
    2504 
    2505 void RenderBoxModelObject::insertIntoContinuationChainAfter(RenderBoxModelObject& afterRenderer)
    2506 {
    2507     ASSERT(isContinuation());
    2508     ASSERT(!continuationChainNodeMap().contains(this));
    2509 
    2510     auto& after = afterRenderer.ensureContinuationChainNode();
    2511     ensureContinuationChainNode().insertAfter(after);
    2512 }
    2513 
    2514 void RenderBoxModelObject::removeFromContinuationChain()
    2515 {
    2516     ASSERT(hasContinuationChainNode());
    2517     ASSERT(continuationChainNodeMap().contains(this));
    2518     setHasContinuationChainNode(false);
    2519     continuationChainNodeMap().remove(this);
    2520 }
    2521 
    2522 auto RenderBoxModelObject::ensureContinuationChainNode() -> ContinuationChainNode&
    2523 {
    2524     setHasContinuationChainNode(true);
    2525     return *continuationChainNodeMap().ensure(this, [&] {
    2526         return std::make_unique<ContinuationChainNode>(*this);
    2527     }).iterator->value;
    2528 }
    2529 
    2530 void RenderBoxModelObject::removeAndDestroyAllContinuations()
    2531 {
    2532     ASSERT(!isContinuation());
    2533     ASSERT(hasContinuationChainNode());
    2534     ASSERT(continuationChainNodeMap().contains(this));
    2535     auto& continuationChainNode = *continuationChainNodeMap().get(this);
    2536     while (continuationChainNode.next)
    2537         continuationChainNode.next->renderer->removeFromParentAndDestroy();
    2538     removeFromContinuationChain();
     2452    return continuationMap().get(this).get();
     2453}
     2454
     2455void RenderBoxModelObject::setContinuation(RenderBoxModelObject* continuation)
     2456{
     2457    ASSERT(!continuation || continuation->isContinuation());
     2458    if (continuation)
     2459        continuationMap().set(this, makeWeakPtr(continuation));
     2460    else if (hasContinuation())
     2461        continuationMap().remove(this);
     2462    setHasContinuation(!!continuation);
    25392463}
    25402464

  • trunk/Source/WebCore/rendering/RenderBoxModelObject.h

    r224273 r224279  
    236236
    237237    RenderBoxModelObject* continuation() const;
    238    
    239     void insertIntoContinuationChainAfter(RenderBoxModelObject&);
    240     void removeFromContinuationChain();
    241238
    242239    virtual LayoutRect paintRectToClipOutFromBorder(const LayoutRect&) { return LayoutRect(); };
    … …  
    260257    InterpolationQuality chooseInterpolationQuality(GraphicsContext&, Image&, const void*, const LayoutSize&);
    261258
     259    void setContinuation(RenderBoxModelObject*);
     260
    262261    LayoutRect localCaretRectForEmptyElement(LayoutUnit width, LayoutUnit textIndentOffset);
    263262
    … …  
    303302    RenderBlock* containingBlockForAutoHeightDetection(Length logicalHeight) const;
    304303
    305     struct ContinuationChainNode;
    306 
    307304private:
    308     ContinuationChainNode& ensureContinuationChainNode();
    309     void removeAndDestroyAllContinuations();
    310 
    311305    LayoutUnit computedCSSPadding(const Length&) const;
    312306   

  • trunk/Source/WebCore/rendering/RenderElement.cpp

    r224273 r224279  
    102102    , m_hasPausedImageAnimations(false)
    103103    , m_hasCounterNodeMap(false)
    104     , m_hasContinuationChainNode(false)
     104    , m_hasContinuation(false)
    105105    , m_isContinuation(false)
    106106    , m_hasValidCachedFirstLineStyle(false)
    … …  
    962962void RenderElement::removeAnonymousWrappersForInlinesIfNecessary()
    963963{
    964     // FIXME: Move to RenderBlock.
    965     if (!is<RenderBlock>(*this))
    966         return;
    967     RenderBlock& thisBlock = downcast<RenderBlock>(*this);
    968     if (!thisBlock.canDropAnonymousBlockChild())
     964    RenderBlock& parentBlock = downcast<RenderBlock>(*parent());
     965    if (!parentBlock.canDropAnonymousBlockChild())
    969966        return;
    970967
    … …  
    974971    // FIXME: We should also handle split inlines here - we exclude them at the moment by returning
    975972    // if we find a continuation.
    976     RenderObject* current = firstChild();
    977     while (current && ((current->isAnonymousBlock() && !downcast<RenderBlock>(*current).isContinuation()) || current->style().isFloating() || current->style().hasOutOfFlowPosition()))
     973    RenderObject* current = parent()->firstChild();
     974    while (current && ((current->isAnonymousBlock() && !downcast<RenderBlock>(*current).isAnonymousBlockContinuation()) || current->style().isFloating() || current->style().hasOutOfFlowPosition()))
    978975        current = current->nextSibling();
    979976
    … …  
    982979
    983980    RenderObject* next;
    984     for (current = firstChild(); current; current = next) {
     981    for (current = parent()->firstChild(); current; current = next) {
    985982        next = current->nextSibling();
    986983        if (current->isAnonymousBlock())
    987             thisBlock.dropAnonymousBoxChild(downcast<RenderBlock>(*current));
     984            parentBlock.dropAnonymousBoxChild(parentBlock, downcast<RenderBlock>(*current));
    988985    }
    989986}
    … …  
    10141011
    10151012    if (s_noLongerAffectsParentBlock)
    1016         parent()->removeAnonymousWrappersForInlinesIfNecessary();
     1013        removeAnonymousWrappersForInlinesIfNecessary();
    10171014
    10181015    SVGRenderSupport::styleChanged(*this, oldStyle);
    … …  
    21562153        downcast<RenderElement>(child).updateOutlineAutoAncestor(hasOutlineAuto);
    21572154    }
    2158     if (is<RenderBoxModelObject>(*this)) {
    2159         if (auto* continuation = downcast<RenderBoxModelObject>(*this).continuation())
    2160             continuation->updateOutlineAutoAncestor(hasOutlineAuto);
    2161     }
     2155    if (hasContinuation())
     2156        downcast<RenderBoxModelObject>(*this).continuation()->updateOutlineAutoAncestor(hasOutlineAuto);
    21622157}
    21632158

  • trunk/Source/WebCore/rendering/RenderElement.h

    r224273 r224279  
    222222    virtual void updateAnonymousChildStyle(const RenderObject&, RenderStyle&) const { };
    223223
    224     void removeAnonymousWrappersForInlinesIfNecessary();
    225 
    226     bool hasContinuationChainNode() const { return m_hasContinuationChainNode; }
     224    bool hasContinuation() const { return m_hasContinuation; }
    227225    bool isContinuation() const { return m_isContinuation; }
    228226    void setIsContinuation() { m_isContinuation = true; }
    … …  
    267265    bool renderInlineAlwaysCreatesLineBoxes() const { return m_renderInlineAlwaysCreatesLineBoxes; }
    268266
    269     void setHasContinuationChainNode(bool b) { m_hasContinuationChainNode = b; }
     267    void setHasContinuation(bool b) { m_hasContinuation = b; }
    270268
    271269    void setRenderBlockHasMarginBeforeQuirk(bool b) { m_renderBlockHasMarginBeforeQuirk = b; }
    … …  
    306304    // normal flow object.
    307305    void handleDynamicFloatPositionChange();
     306    void removeAnonymousWrappersForInlinesIfNecessary();
    308307
    309308    bool shouldRepaintForStyleDifference(StyleDifference) const;
    … …  
    338337    unsigned m_hasPausedImageAnimations : 1;
    339338    unsigned m_hasCounterNodeMap : 1;
    340     unsigned m_hasContinuationChainNode : 1;
     339    unsigned m_hasContinuation : 1;
    341340    unsigned m_isContinuation : 1;
    342341    mutable unsigned m_hasValidCachedFirstLineStyle : 1;

  • trunk/Source/WebCore/rendering/RenderInline.cpp

    r224273 r224279  
    190190    auto& newStyle = style();
    191191    RenderInline* continuation = inlineElementContinuation();
    192     if (continuation && !isContinuation()) {
    193         for (RenderInline* currCont = continuation; currCont; currCont = currCont->inlineElementContinuation())
     192    if (continuation) {
     193        for (RenderInline* currCont = continuation; currCont; currCont = currCont->inlineElementContinuation()) {
     194            RenderBoxModelObject* nextCont = currCont->continuation();
     195            currCont->setContinuation(nullptr);
    194196            currCont->setStyle(RenderStyle::clone(newStyle));
     197            currCont->setContinuation(nextCont);
     198        }
    195199        // If an inline's in-flow positioning has changed and it is part of an active continuation as a descendant of an anonymous containing block,
    196200        // then any descendant blocks will need to change their in-flow positioning accordingly.
    … …  
    341345        newBox->setIsContinuation();
    342346        RenderBoxModelObject* oldContinuation = continuation();
    343         if (oldContinuation)
    344             oldContinuation->removeFromContinuationChain();
    345         newBox->insertIntoContinuationChainAfter(*this);
     347        setContinuation(newBox.get());
    346348
    347349        splitFlow(beforeChild, WTFMove(newBox), WTFMove(newChild), oldContinuation);
    … …  
    416418        rendererToMove = nextSibling;
    417419    }
     420    cloneInline->setContinuation(oldCont);
    418421    // Hook |clone| up as the continuation of the middle block.
    419     cloneInline->insertIntoContinuationChainAfter(*middleBlock);
    420     if (oldCont)
    421         oldCont->insertIntoContinuationChainAfter(*cloneInline);
     422    middleBlock->setContinuation(cloneInline.get());
    422423
    423424    // We have been reparented and are now under the fromBlock.  We need
    … …  
    443444
    444445            // Hook the clone up as a continuation of |curr|.
    445             cloneInline->insertIntoContinuationChainAfter(*current);
     446            RenderInline& currentInline = downcast<RenderInline>(*current);
     447            oldCont = currentInline.continuation();
     448            currentInline.setContinuation(cloneInline.get());
     449            cloneInline->setContinuation(oldCont);
    446450
    447451            // Now we need to take all of the children starting from the first child
    448452            // *after* currentChild and append them all to the clone.
    449             for (auto* sibling = currentChild->nextSibling(); sibling;) {
    450                 auto* next = sibling->nextSibling();
    451                 auto childToMove = current->takeChildInternal(*sibling, NotifyChildren);
     453            for (auto* current = currentChild->nextSibling(); current;) {
     454                auto* next = current->nextSibling();
     455                auto childToMove = currentInline.takeChildInternal(*current, NotifyChildren);
    452456                cloneInline->addChildIgnoringContinuation(WTFMove(childToMove));
    453                 sibling->setNeedsLayoutAndPrefWidthsRecalc();
    454                 sibling = next;
     457                current->setNeedsLayoutAndPrefWidthsRecalc();
     458                current = next;
    455459            }
    456460        }
    … …  
    573577        while (parent && parent->parent() && parent->parent()->isAnonymous()) {
    574578            // The ancestor candidate needs to be inside the continuation.
    575             if (parent->isContinuation())
     579            if (parent->hasContinuation())
    576580                break;
    577581            parent = parent->parent();
    … …  
    13761380    newBox->setIsContinuation();
    13771381    RenderBoxModelObject* oldContinuation = continuation();
    1378     if (oldContinuation)
    1379         oldContinuation->removeFromContinuationChain();
    1380     newBox->insertIntoContinuationChainAfter(*this);
     1382    setContinuation(newBox.get());
    13811383    RenderObject* beforeChild = child.nextSibling();
    13821384    auto removedChild = takeChildInternal(child, NotifyChildren);

  • trunk/Source/WebCore/rendering/RenderInline.h

    r224273 r224279  
    8787    void addFocusRingRects(Vector<LayoutRect>&, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer = 0) final;
    8888    void paintOutline(PaintInfo&, const LayoutPoint&);
     89
     90    using RenderBoxModelObject::continuation;
     91    using RenderBoxModelObject::setContinuation;
    8992
    9093    bool alwaysCreateLineBoxes() const { return renderInlineAlwaysCreatesLineBoxes(); }

  • trunk/Source/WebCore/rendering/RenderObject.cpp

    r224273 r224279  
    825825        ASSERT(rendererHasOutlineAutoAncestor
    826826            || renderer->outlineStyleForRepaint().outlineStyleIsAuto()
    827             || (is<RenderBoxModelObject>(*renderer) && downcast<RenderBoxModelObject>(*renderer).isContinuation()));
     827            || (is<RenderElement>(*renderer) && downcast<RenderElement>(*renderer).hasContinuation()));
    828828        if (renderer == &repaintContainer && rendererHasOutlineAutoAncestor)
    829829            repaintRectNeedsConverting = true;
    … …  
    11761176    if (is<RenderBoxModelObject>(*this)) {
    11771177        auto& renderer = downcast<RenderBoxModelObject>(*this);
    1178         if (renderer.continuation())
     1178        if (renderer.hasContinuation())
    11791179            stream << " continuation->(" << renderer.continuation() << ")";
    11801180    }
    … …  
    14671467        if (destroyRootParent->isRenderFragmentedFlow())
    14681468            break;
     1469        // FIXME: Destroy continuations here too.
     1470        if (destroyRootParent->isContinuation())
     1471            break;
    14691472        bool destroyingOnlyChild = destroyRootParent->firstChild() == destroyRoot && destroyRootParent->lastChild() == destroyRoot;
    14701473        if (!destroyingOnlyChild)
    … …  
    14881491        downcast<RenderTableRow>(destroyRoot).collapseAndDestroyAnonymousSiblingRows();
    14891492
    1490     auto& destroyRootParent = *destroyRoot.parent();
    1491     destroyRootParent.removeAndDestroyChild(destroyRoot);
    1492     destroyRootParent.removeAnonymousWrappersForInlinesIfNecessary();
     1493    destroyRoot.removeFromParentAndDestroy();
    14931494    // WARNING: |this| is deleted here.
    14941495}
Note: See TracChangeset for help on using the changeset viewer.