Changeset 228400 in webkit


Ignore:
Timestamp:
Feb 12, 2018 3:28:51 PM (6 years ago)
Author:
Alan Bujtas
Message:

[RenderTreeBuilder] Introduce RenderTreebuilder::takeChild
https://bugs.webkit.org/show_bug.cgi?id=182707
<rdar://problem/37473433>

Reviewed by Antti Koivisto.

All takeChild calls should go through RenderTreeBuilder::takeChild from now on.
This patch also moves the Ruby related takeChild calls to RenderTreeBuilder.

No change in functionality.

  • rendering/RenderButton.cpp:

(WebCore::RenderButton::takeChild):

  • rendering/RenderElement.cpp:

(WebCore::RenderElement::removeAndDestroyChild):

  • rendering/RenderFullScreen.cpp:

(WebCore::RenderFullScreen::wrapExistingRenderer):
(WebCore::RenderFullScreen::unwrapRenderer):

  • rendering/RenderMenuList.cpp:

(RenderMenuList::takeChild):

  • rendering/RenderRuby.cpp:

(WebCore::RenderRubyAsInline::takeChild): Deleted.
(WebCore::RenderRubyAsBlock::takeChild): Deleted.

  • rendering/RenderRuby.h:
  • rendering/RenderRubyRun.cpp:

(WebCore::RenderRubyRun::takeChild): Deleted.

  • rendering/RenderRubyRun.h:
  • rendering/updating/RenderTreeBuilder.cpp:

(WebCore::RenderTreeBuilder::takeChild):
(WebCore::RenderTreeBuilder::takeChildFromRenderRubyAsInline): Deleted.
(WebCore::RenderTreeBuilder::takeChildFromRenderRubyAsBlock): Deleted.
(WebCore::RenderTreeBuilder::takeChildFromRenderRubyRun): Deleted.

  • rendering/updating/RenderTreeBuilder.h:
  • rendering/updating/RenderTreeBuilderFirstLetter.cpp:

(WebCore::RenderTreeBuilder::FirstLetter::updateStyle):

  • rendering/updating/RenderTreeBuilderList.cpp:

(WebCore::RenderTreeBuilder::List::updateItemMarker):

  • rendering/updating/RenderTreeBuilderMultiColumn.cpp:

(WebCore::RenderTreeBuilder::MultiColumn::createFragmentedFlow):
(WebCore::RenderTreeBuilder::MultiColumn::destroyFragmentedFlow):
(WebCore::RenderTreeBuilder::MultiColumn::processPossibleSpannerDescendant):

  • rendering/updating/RenderTreeBuilderRuby.cpp:

(WebCore::RenderTreeBuilder::Ruby::takeChild):

  • rendering/updating/RenderTreeBuilderTable.cpp:

(WebCore::RenderTreeBuilder::Table::collapseAndDestroyAnonymousSiblingRows):

Location:
trunk/Source/WebCore
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r228391 r228400  
     12018-02-12  Zalan Bujtas  <zalan@apple.com>
     2
     3        [RenderTreeBuilder] Introduce RenderTreebuilder::takeChild
     4        https://bugs.webkit.org/show_bug.cgi?id=182707
     5        <rdar://problem/37473433>
     6
     7        Reviewed by Antti Koivisto.
     8
     9        All takeChild calls should go through RenderTreeBuilder::takeChild from now on.
     10        This patch also moves the Ruby related takeChild calls to RenderTreeBuilder.
     11
     12        No change in functionality.
     13
     14        * rendering/RenderButton.cpp:
     15        (WebCore::RenderButton::takeChild):
     16        * rendering/RenderElement.cpp:
     17        (WebCore::RenderElement::removeAndDestroyChild):
     18        * rendering/RenderFullScreen.cpp:
     19        (WebCore::RenderFullScreen::wrapExistingRenderer):
     20        (WebCore::RenderFullScreen::unwrapRenderer):
     21        * rendering/RenderMenuList.cpp:
     22        (RenderMenuList::takeChild):
     23        * rendering/RenderRuby.cpp:
     24        (WebCore::RenderRubyAsInline::takeChild): Deleted.
     25        (WebCore::RenderRubyAsBlock::takeChild): Deleted.
     26        * rendering/RenderRuby.h:
     27        * rendering/RenderRubyRun.cpp:
     28        (WebCore::RenderRubyRun::takeChild): Deleted.
     29        * rendering/RenderRubyRun.h:
     30        * rendering/updating/RenderTreeBuilder.cpp:
     31        (WebCore::RenderTreeBuilder::takeChild):
     32        (WebCore::RenderTreeBuilder::takeChildFromRenderRubyAsInline): Deleted.
     33        (WebCore::RenderTreeBuilder::takeChildFromRenderRubyAsBlock): Deleted.
     34        (WebCore::RenderTreeBuilder::takeChildFromRenderRubyRun): Deleted.
     35        * rendering/updating/RenderTreeBuilder.h:
     36        * rendering/updating/RenderTreeBuilderFirstLetter.cpp:
     37        (WebCore::RenderTreeBuilder::FirstLetter::updateStyle):
     38        * rendering/updating/RenderTreeBuilderList.cpp:
     39        (WebCore::RenderTreeBuilder::List::updateItemMarker):
     40        * rendering/updating/RenderTreeBuilderMultiColumn.cpp:
     41        (WebCore::RenderTreeBuilder::MultiColumn::createFragmentedFlow):
     42        (WebCore::RenderTreeBuilder::MultiColumn::destroyFragmentedFlow):
     43        (WebCore::RenderTreeBuilder::MultiColumn::processPossibleSpannerDescendant):
     44        * rendering/updating/RenderTreeBuilderRuby.cpp:
     45        (WebCore::RenderTreeBuilder::Ruby::takeChild):
     46        * rendering/updating/RenderTreeBuilderTable.cpp:
     47        (WebCore::RenderTreeBuilder::Table::collapseAndDestroyAnonymousSiblingRows):
     48
    1492018-02-12  Zalan Bujtas  <zalan@apple.com>
    250
  • trunk/Source/WebCore/rendering/RenderButton.cpp

    r228337 r228400  
    8080        return RenderFlexibleBox::takeChild(builder, oldChild);
    8181    }
    82     return m_inner->takeChild(builder, oldChild);
     82    return builder.takeChild(*m_inner, oldChild);
    8383}
    8484   
  • trunk/Source/WebCore/rendering/RenderElement.cpp

    r228337 r228400  
    498498        }
    499499    }
    500     auto toDestroy = takeChild(builder, oldChild);
     500    auto toDestroy = builder.takeChild(*this, oldChild);
    501501}
    502502
  • trunk/Source/WebCore/rendering/RenderFullScreen.cpp

    r228337 r228400  
    133133    builder.insertChild(parent, WTFMove(newFullscreenRenderer), &renderer);
    134134
    135     auto toMove = parent.takeChild(builder, renderer);
     135    auto toMove = builder.takeChild(parent, renderer);
    136136
    137137    // Always just do a full layout to ensure that line boxes get deleted properly.
     
    179179            if (is<RenderBox>(*child))
    180180                downcast<RenderBox>(*child).clearOverrideSize();
    181             auto childToMove = child->parent()->takeChild(builder, *child);
     181            auto childToMove = builder.takeChild(*child->parent(), *child);
    182182            builder.insertChild(*parent(), WTFMove(childToMove), this);
    183183            parent()->setNeedsLayoutAndPrefWidthsRecalc();
  • trunk/Source/WebCore/rendering/RenderMenuList.cpp

    r228337 r228400  
    177177    if (!m_innerBlock || &oldChild == m_innerBlock)
    178178        return RenderFlexibleBox::takeChild(builder, oldChild);
    179     return m_innerBlock->takeChild(builder, oldChild);
     179    return builder.takeChild(*m_innerBlock, oldChild);
    180180}
    181181
  • trunk/Source/WebCore/rendering/RenderRuby.cpp

    r228339 r228400  
    6161}
    6262
    63 RenderPtr<RenderObject> RenderRubyAsInline::takeChild(RenderTreeBuilder& builder, RenderObject& child)
    64 {
    65     return builder.takeChildFromRenderRubyAsInline(*this, child);
    66 }
    67 
    6863//=== ruby as block object ===
    6964
     
    8176}
    8277
    83 RenderPtr<RenderObject> RenderRubyAsBlock::takeChild(RenderTreeBuilder& builder, RenderObject& child)
    84 {
    85     return builder.takeChildFromRenderRubyAsBlock(*this, child);
    86 }
    87 
    8878} // namespace WebCore
  • trunk/Source/WebCore/rendering/RenderRuby.h

    r228224 r228400  
    5757    virtual ~RenderRubyAsInline();
    5858
    59     RenderPtr<RenderObject> takeChild(RenderTreeBuilder&, RenderObject& child) override;
    60 
    6159protected:
    6260    void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;
     
    7775    Element& element() const { return downcast<Element>(nodeForNonAnonymous()); }
    7876
    79     RenderPtr<RenderObject> takeChild(RenderTreeBuilder&, RenderObject& child) override;
    80 
    8177protected:
    8278    void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;
  • trunk/Source/WebCore/rendering/RenderRubyRun.cpp

    r228345 r228400  
    9898}
    9999
    100 RenderPtr<RenderObject> RenderRubyRun::takeChild(RenderTreeBuilder& builder, RenderObject& child)
    101 {
    102     return builder.takeChildFromRenderRubyRun(*this, child);
    103 }
    104 
    105100RenderPtr<RenderRubyBase> RenderRubyRun::createRubyBase() const
    106101{
  • trunk/Source/WebCore/rendering/RenderRubyRun.h

    r228224 r228400  
    5757
    5858    bool isChildAllowed(const RenderObject&, const RenderStyle&) const override;
    59     RenderPtr<RenderObject> takeChild(RenderTreeBuilder&, RenderObject&) override;
    6059
    6160    RenderBlock* firstLineBlock() const override;
  • trunk/Source/WebCore/rendering/updating/RenderTreeBuilder.cpp

    r228391 r228400  
    188188}
    189189
     190RenderPtr<RenderObject> RenderTreeBuilder::takeChild(RenderElement& parent, RenderObject& child)
     191{
     192    if (is<RenderRubyAsInline>(parent))
     193        return rubyBuilder().takeChild(downcast<RenderRubyAsInline>(parent), child);
     194
     195    if (is<RenderRubyAsBlock>(parent))
     196        return rubyBuilder().takeChild(downcast<RenderRubyAsBlock>(parent), child);
     197
     198    if (is<RenderRubyRun>(parent))
     199        return rubyBuilder().takeChild(downcast<RenderRubyRun>(parent), child);
     200
     201    return parent.takeChild(*this, child);
     202}
     203
    190204void RenderTreeBuilder::insertChild(RenderTreePosition& position, RenderPtr<RenderObject> child)
    191205{
     
    477491}
    478492
    479 RenderPtr<RenderObject> RenderTreeBuilder::takeChildFromRenderRubyAsInline(RenderRubyAsInline& parent, RenderObject& child)
    480 {
    481     return rubyBuilder().takeChild(parent, child);
    482 }
    483 
    484 RenderPtr<RenderObject> RenderTreeBuilder::takeChildFromRenderRubyAsBlock(RenderRubyAsBlock& parent, RenderObject& child)
    485 {
    486     return rubyBuilder().takeChild(parent, child);
    487 }
    488 
    489 RenderPtr<RenderObject> RenderTreeBuilder::takeChildFromRenderRubyRun(RenderRubyRun& parent, RenderObject& child)
    490 {
    491     return rubyBuilder().takeChild(parent, child);
    492 }
    493 
    494493RenderPtr<RenderObject> RenderTreeBuilder::takeChildFromRenderBlock(RenderBlock& parent, RenderObject& oldChild)
    495494{
  • trunk/Source/WebCore/rendering/updating/RenderTreeBuilder.h

    r228391 r228400  
    5252    void insertChild(RenderTreePosition&, RenderPtr<RenderObject>);
    5353
     54    RenderPtr<RenderObject> takeChild(RenderElement&, RenderObject&) WARN_UNUSED_RETURN;
     55
    5456    void updateAfterDescendants(RenderElement&);
    5557
     
    7476    void insertChildToRenderMathMLFenced(RenderMathMLFenced& parent, RenderPtr<RenderObject> child, RenderObject* beforeChild = nullptr);
    7577
    76     RenderPtr<RenderObject> takeChildFromRenderRubyAsInline(RenderRubyAsInline& parent, RenderObject& child);
    77     RenderPtr<RenderObject> takeChildFromRenderRubyAsBlock(RenderRubyAsBlock& parent, RenderObject& child);
    78     RenderPtr<RenderObject> takeChildFromRenderRubyRun(RenderRubyRun& parent, RenderObject& child);
    7978    RenderPtr<RenderObject> takeChildFromRenderBlock(RenderBlock& parent, RenderObject& oldChild);
    8079
  • trunk/Source/WebCore/rendering/updating/RenderTreeBuilderFirstLetter.cpp

    r227977 r228400  
    175175            if (is<RenderText>(*child))
    176176                downcast<RenderText>(*child).removeAndDestroyTextBoxes();
    177             auto toMove = firstLetter->takeChild(m_builder, *child);
     177            auto toMove = m_builder.takeChild(*firstLetter, *child);
    178178            m_builder.insertChild(*newFirstLetter, WTFMove(toMove));
    179179        }
  • trunk/Source/WebCore/rendering/updating/RenderTreeBuilderList.cpp

    r228337 r228400  
    116116
    117117    if (currentParent)
    118         m_builder.insertChild(*newParent, currentParent->takeChild(m_builder, *markerRenderer), firstNonMarkerChild(*newParent));
     118        m_builder.insertChild(*newParent, m_builder.takeChild(*currentParent, *markerRenderer), firstNonMarkerChild(*newParent));
    119119    else
    120120        m_builder.insertChild(*newParent, WTFMove(newMarkerRenderer), firstNonMarkerChild(*newParent));
  • trunk/Source/WebCore/rendering/updating/RenderTreeBuilderMultiColumn.cpp

    r228337 r228400  
    161161            auto& spannerOriginalParent = *placeholder->parent();
    162162            // Detaching the spanner takes care of removing the placeholder (and merges the RenderMultiColumnSets).
    163             auto spannerToReInsert = spanner->parent()->takeChild(m_builder, *spanner);
     163            auto spannerToReInsert = m_builder.takeChild(*spanner->parent(), *spanner);
    164164            m_builder.insertChild(spannerOriginalParent, WTFMove(spannerToReInsert));
    165165        }
     
    209209        // Detaching the spanner takes care of removing the placeholder (and merges the RenderMultiColumnSets).
    210210        auto* spanner = placeholder->spanner();
    211         parentAndSpannerList.append(std::make_pair(spannerOriginalParent, spanner->parent()->takeChild(m_builder, *spanner)));
     211        parentAndSpannerList.append(std::make_pair(spannerOriginalParent, m_builder.takeChild(*spanner->parent(), *spanner)));
    212212    }
    213213    while (auto* columnSet = multiColumnFlow.firstMultiColumnSet())
     
    314314        auto& placeholder = *newPlaceholder;
    315315        m_builder.insertChild(*container, WTFMove(newPlaceholder), descendant.nextSibling());
    316         auto takenDescendant = container->takeChild(m_builder, descendant);
     316        auto takenDescendant = m_builder.takeChild(*container, descendant);
    317317
    318318        // This is a guard to stop an ancestor flow thread from processing the spanner.
  • trunk/Source/WebCore/rendering/updating/RenderTreeBuilderRuby.cpp

    r228345 r228400  
    388388        ASSERT(child.isBeforeContent() || child.isAfterContent());
    389389        auto& parent = *child.parent();
    390         auto takenChild = parent.takeChild(m_builder, child);
     390        auto takenChild = m_builder.takeChild(parent, child);
    391391        parent.removeFromParentAndDestroy(m_builder);
    392392        return takenChild;
     
    394394
    395395    // Otherwise find the containing run and remove it from there.
    396     return findRubyRunParent(child).takeChild(m_builder, child);
     396    return m_builder.takeChild(findRubyRunParent(child), child);
    397397}
    398398
     
    412412        ASSERT(child.isBeforeContent() || child.isAfterContent());
    413413        auto& parent = *child.parent();
    414         auto takenChild = parent.takeChild(m_builder, child);
     414        auto takenChild = m_builder.takeChild(parent, child);
    415415        parent.removeFromParentAndDestroy(m_builder);
    416416        return takenChild;
     
    418418
    419419    // Otherwise find the containing run and remove it from there.
    420     return findRubyRunParent(child).takeChild(m_builder, child);
     420    return m_builder.takeChild(findRubyRunParent(child), child);
    421421}
    422422
  • trunk/Source/WebCore/rendering/updating/RenderTreeBuilderTable.cpp

    r228284 r228400  
    237237        }
    238238        currentRow->moveAllChildrenTo(m_builder, rowToInsertInto, RenderBoxModelObject::NormalizeAfterInsertion::No);
    239         auto toDestroy = section->takeChild(m_builder, *currentRow);
     239        auto toDestroy = m_builder.takeChild(*section, *currentRow);
    240240        currentRow = currentRow->nextRow();
    241241    }
Note: See TracChangeset for help on using the changeset viewer.