Changeset 208005 in webkit

Timestamp:

Oct 27, 2016 2:19:34 PM (8 years ago)

Author:

Alan Bujtas

Message:

RenderMultiColumnFlowThread::processPossibleSpannerDescendant should take RenderObject& instead of RenderObject*
​https://bugs.webkit.org/show_bug.cgi?id=164072

Reviewed by Simon Fraser.

No change in functionality.

• rendering/RenderFlowThread.h:
• rendering/RenderMultiColumnFlowThread.cpp:

(WebCore::findSetRendering):
(WebCore::isValidColumnSpanner):
(WebCore::RenderMultiColumnFlowThread::processPossibleSpannerDescendant):
(WebCore::RenderMultiColumnFlowThread::flowThreadDescendantInserted):
(WebCore::RenderMultiColumnFlowThread::findSetRendering): Deleted.

• rendering/RenderMultiColumnFlowThread.h:
• rendering/RenderMultiColumnSet.cpp:

(WebCore::precedesRenderer):
(WebCore::RenderMultiColumnSet::containsRendererInFlowThread):

• rendering/RenderMultiColumnSet.h:
• rendering/RenderMultiColumnSpannerPlaceholder.cpp:

(WebCore::RenderMultiColumnSpannerPlaceholder::createAnonymous):
(WebCore::RenderMultiColumnSpannerPlaceholder::RenderMultiColumnSpannerPlaceholder):

• rendering/RenderMultiColumnSpannerPlaceholder.h:
• rendering/RenderObject.cpp:

(WebCore::RenderObject::insertedIntoTree):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• rendering/RenderFlowThread.h (modified) (1 diff)
• rendering/RenderMultiColumnFlowThread.cpp (modified) (10 diffs)
• rendering/RenderMultiColumnFlowThread.h (modified) (3 diffs)
• rendering/RenderMultiColumnSet.cpp (modified) (3 diffs)
• rendering/RenderMultiColumnSet.h (modified) (1 diff)
• rendering/RenderMultiColumnSpannerPlaceholder.cpp (modified) (2 diffs)
• rendering/RenderMultiColumnSpannerPlaceholder.h (modified) (2 diffs)
• rendering/RenderObject.cpp (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2016-10-27  Zalan Bujtas  <zalan@apple.com>
+
+        RenderMultiColumnFlowThread::processPossibleSpannerDescendant should take RenderObject& instead of RenderObject*
+        https://bugs.webkit.org/show_bug.cgi?id=164072
+
+        Reviewed by Simon Fraser.
+
+        No change in functionality.
+
+        * rendering/RenderFlowThread.h:
+        * rendering/RenderMultiColumnFlowThread.cpp:
+        (WebCore::findSetRendering):
+        (WebCore::isValidColumnSpanner):
+        (WebCore::RenderMultiColumnFlowThread::processPossibleSpannerDescendant):
+        (WebCore::RenderMultiColumnFlowThread::flowThreadDescendantInserted):
+        (WebCore::RenderMultiColumnFlowThread::findSetRendering): Deleted.
+        * rendering/RenderMultiColumnFlowThread.h:
+        * rendering/RenderMultiColumnSet.cpp:
+        (WebCore::precedesRenderer):
+        (WebCore::RenderMultiColumnSet::containsRendererInFlowThread):
+        * rendering/RenderMultiColumnSet.h:
+        * rendering/RenderMultiColumnSpannerPlaceholder.cpp:
+        (WebCore::RenderMultiColumnSpannerPlaceholder::createAnonymous):
+        (WebCore::RenderMultiColumnSpannerPlaceholder::RenderMultiColumnSpannerPlaceholder):
+        * rendering/RenderMultiColumnSpannerPlaceholder.h:
+        * rendering/RenderObject.cpp:
+        (WebCore::RenderObject::insertedIntoTree):
+
 2016-10-27  Brent Fulgham  <bfulgham@apple.com>
 

trunk/Source/WebCore/rendering/RenderFlowThread.h

@@ -93 +93 @@
     virtual RenderObject* resolveMovedChild(RenderObject* child) const { return child; }
     // Called when a descendant of the flow thread has been inserted.
-    virtual void flowThreadDescendantInserted(RenderObject*) { }
+    virtual void flowThreadDescendantInserted(RenderObject&) { }
     // Called when a sibling or descendant of the flow thread is about to be removed.
     virtual void flowThreadRelativeWillBeRemoved(RenderObject*) { }

trunk/Source/WebCore/rendering/RenderMultiColumnFlowThread.cpp

@@ -134 +134 @@
 }
 
-RenderMultiColumnSet* RenderMultiColumnFlowThread::findSetRendering(RenderObject* renderer) const
-{
-    for (RenderMultiColumnSet* multicolSet = firstMultiColumnSet(); multicolSet; multicolSet = multicolSet->nextSiblingMultiColumnSet()) {
+static RenderMultiColumnSet* findSetRendering(const RenderMultiColumnFlowThread& flowThread, const RenderObject& renderer)
+{
+    // Find the set inside which the specified renderer would be rendered.
+    for (auto* multicolSet = flowThread.firstMultiColumnSet(); multicolSet; multicolSet = multicolSet->nextSiblingMultiColumnSet()) {
         if (multicolSet->containsRendererInFlowThread(renderer))
             return multicolSet;
@@ -234 +235 @@
 }
 
-static bool isValidColumnSpanner(RenderMultiColumnFlowThread* flowThread, RenderObject* descendant)
+static bool isValidColumnSpanner(const RenderMultiColumnFlowThread& flowThread, const RenderObject& descendant)
 {
     // We assume that we're inside the flow thread. This function is not to be called otherwise.
-    ASSERT(descendant->isDescendantOf(flowThread));
+    ASSERT(descendant.isDescendantOf(&flowThread));
 
     // First make sure that the renderer itself has the right properties for becoming a spanner.
-    auto& style = descendant->style();
-    if (style.columnSpan() != ColumnSpanAll || !is<RenderBox>(*descendant) || descendant->isFloatingOrOutOfFlowPositioned())
+    auto& style = descendant.style();
+    if (style.columnSpan() != ColumnSpanAll || !is<RenderBox>(descendant) || descendant.isFloatingOrOutOfFlowPositioned())
         return false;
 
-    RenderElement* container = descendant->parent();
+    RenderElement* container = descendant.parent();
     if (!is<RenderBlockFlow>(*container) || container->childrenInline()) {
         // Needs to be block-level.
@@ -251 +252 @@
     
     // We need to have the flow thread as the containing block. A spanner cannot break out of the flow thread.
-    RenderFlowThread* enclosingFlowThread = descendant->flowThreadContainingBlock();
-    if (enclosingFlowThread != flowThread)
+    RenderFlowThread* enclosingFlowThread = descendant.flowThreadContainingBlock();
+    if (enclosingFlowThread != &flowThread)
         return false;
 
     // This looks like a spanner, but if we're inside something unbreakable, it's not to be treated as one.
-    for (RenderBox* ancestor = downcast<RenderBox>(*descendant).containingBlock(); ancestor && !is<RenderView>(*ancestor); ancestor = ancestor->containingBlock()) {
+    for (auto* ancestor = downcast<RenderBox>(descendant).containingBlock(); ancestor && !is<RenderView>(*ancestor); ancestor = ancestor->containingBlock()) {
         if (ancestor->isRenderFlowThread()) {
             // Don't allow any intervening non-multicol fragmentation contexts. The spec doesn't say
             // anything about disallowing this, but it's just going to be too complicated to
             // implement (not to mention specify behavior).
-            return ancestor == flowThread;
-        }
-        ASSERT(ancestor->style().columnSpan() != ColumnSpanAll || !isValidColumnSpanner(flowThread, ancestor));
+            return ancestor == &flowThread;
+        }
+        ASSERT(ancestor->style().columnSpan() != ColumnSpanAll || !isValidColumnSpanner(flowThread, *ancestor));
         if (ancestor->isUnsplittableForPagination())
             return false;
@@ -295 +296 @@
 }
 
-RenderObject* RenderMultiColumnFlowThread::processPossibleSpannerDescendant(RenderObject*& subtreeRoot, RenderObject* descendant)
+RenderObject* RenderMultiColumnFlowThread::processPossibleSpannerDescendant(RenderObject*& subtreeRoot, RenderObject& descendant)
 {
     RenderBlockFlow* multicolContainer = multiColumnBlockFlow();
-    RenderObject* nextRendererInFlowThread = spannerPlacehoderCandidate(*descendant, *this);
+    RenderObject* nextRendererInFlowThread = spannerPlacehoderCandidate(descendant, *this);
     RenderObject* insertBeforeMulticolChild = nullptr;
-    RenderObject* nextDescendant = descendant;
-
-    if (isValidColumnSpanner(this, descendant)) {
+    RenderObject* nextDescendant = &descendant;
+
+    if (isValidColumnSpanner(*this, descendant)) {
         // This is a spanner (column-span:all). Such renderers are moved from where they would
         // otherwise occur in the render tree to becoming a direct child of the multicol container,
@@ -308 +309 @@
         // basically just relies on regular block layout done by the RenderBlockFlow that
         // establishes the multicol container.
-        RenderBlockFlow* container = downcast<RenderBlockFlow>(descendant->parent());
+        RenderBlockFlow* container = downcast<RenderBlockFlow>(descendant.parent());
         RenderMultiColumnSet* setToSplit = nullptr;
         if (nextRendererInFlowThread) {
-            setToSplit = findSetRendering(descendant);
+            setToSplit = findSetRendering(*this, descendant);
             if (setToSplit) {
                 setToSplit->setNeedsLayout();
@@ -323 +324 @@
         // this placeholder serves as a break point for column sets, so that, when encountered, we
         // end flowing one column set and move to the next one.
-        RenderMultiColumnSpannerPlaceholder* placeholder = RenderMultiColumnSpannerPlaceholder::createAnonymous(this, downcast<RenderBox>(descendant), &container->style());
-        container->addChild(placeholder, descendant->nextSibling());
-        container->removeChild(*descendant);
+        RenderMultiColumnSpannerPlaceholder* placeholder = RenderMultiColumnSpannerPlaceholder::createAnonymous(this,
+            downcast<RenderBox>(descendant), &container->style());
+        container->addChild(placeholder, descendant.nextSibling());
+        container->removeChild(descendant);
         
         // This is a guard to stop an ancestor flow thread from processing the spanner.
         gShiftingSpanner = true;
-        multicolContainer->RenderBlock::addChild(descendant, insertBeforeMulticolChild);
+        multicolContainer->RenderBlock::addChild(&descendant, insertBeforeMulticolChild);
         gShiftingSpanner = false;
         
@@ -336 +338 @@
         // creation of column sets or anything like that. Continue at its original position in
         // the tree, i.e. where the placeholder was just put.
-        if (subtreeRoot == descendant)
+        if (subtreeRoot == &descendant)
             subtreeRoot = placeholder;
         nextDescendant = placeholder;
@@ -376 +378 @@
 }
 
-void RenderMultiColumnFlowThread::flowThreadDescendantInserted(RenderObject* descendant)
-{
-    if (gShiftingSpanner || m_beingEvacuated || descendant->isInFlowRenderFlowThread())
+void RenderMultiColumnFlowThread::flowThreadDescendantInserted(RenderObject& newDescendant)
+{
+    if (gShiftingSpanner || m_beingEvacuated || newDescendant.isInFlowRenderFlowThread())
         return;
-    RenderObject* subtreeRoot = descendant;
-    for (; descendant; descendant = (descendant ? descendant->nextInPreOrder(subtreeRoot) : nullptr)) {
+    RenderObject* subtreeRoot = &newDescendant;
+    for (auto* descendant = &newDescendant; descendant; descendant = (descendant ? descendant->nextInPreOrder(subtreeRoot) : nullptr)) {
         if (is<RenderMultiColumnSpannerPlaceholder>(*descendant)) {
             // A spanner's placeholder has been inserted. The actual spanner renderer is moved from
@@ -407 +409 @@
                     subtreeRoot = spanner;
                 // Now we process the spanner.
-                descendant = processPossibleSpannerDescendant(subtreeRoot, spanner);
+                descendant = processPossibleSpannerDescendant(subtreeRoot, *spanner);
                 continue;
             }
@@ -416 +418 @@
             continue;
         }
-        
-        descendant = processPossibleSpannerDescendant(subtreeRoot, descendant);
+        descendant = processPossibleSpannerDescendant(subtreeRoot, *descendant);
     }
 }

trunk/Source/WebCore/rendering/RenderMultiColumnFlowThread.h

@@ -53 +53 @@
 
     void layout() override;
-
-    // Find the set inside which the specified renderer would be rendered.
-    RenderMultiColumnSet* findSetRendering(RenderObject*) const;
 
     // Populate the flow thread with what's currently its siblings. Called when a regular block
@@ -117 +114 @@
     void willBeRemovedFromTree() override;
     RenderObject* resolveMovedChild(RenderObject* child) const override;
-    void flowThreadDescendantInserted(RenderObject*) override;
+    void flowThreadDescendantInserted(RenderObject&) override;
     void flowThreadRelativeWillBeRemoved(RenderObject*) override;
     void flowThreadDescendantBoxLaidOut(RenderBox*) override;
@@ -130 +127 @@
 
     void handleSpannerRemoval(RenderObject* spanner);
-    RenderObject* processPossibleSpannerDescendant(RenderObject*& subtreeRoot, RenderObject* descendant);
+    RenderObject* processPossibleSpannerDescendant(RenderObject*& subtreeRoot, RenderObject& descendant);
     
 private:

trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp

@@ -92 +92 @@
 }
 
-static bool precedesRenderer(RenderObject* renderer, RenderObject* boundary)
+static bool precedesRenderer(const RenderObject* renderer, const RenderObject* boundary)
 {
     for (; renderer; renderer = renderer->nextInPreOrder()) {
@@ -101 +101 @@
 }
 
-bool RenderMultiColumnSet::containsRendererInFlowThread(RenderObject* renderer) const
+bool RenderMultiColumnSet::containsRendererInFlowThread(const RenderObject& renderer) const
 {
     if (!previousSiblingMultiColumnSet() && !nextSiblingMultiColumnSet()) {
         // There is only one set. This is easy, then.
-        return renderer->isDescendantOf(m_flowThread);
+        return renderer.isDescendantOf(m_flowThread);
     }
 
@@ -114 +114 @@
 
     // This is SLOW! But luckily very uncommon.
-    return precedesRenderer(firstRenderer, renderer) && precedesRenderer(renderer, lastRenderer);
+    return precedesRenderer(firstRenderer, &renderer) && precedesRenderer(&renderer, lastRenderer);
 }
 

trunk/Source/WebCore/rendering/RenderMultiColumnSet.h

@@ -61 +61 @@
 
     // Return true if the specified renderer (descendant of the flow thread) is inside this column set.
-    bool containsRendererInFlowThread(RenderObject*) const;
+    bool containsRendererInFlowThread(const RenderObject&) const;
 
     void setLogicalTopInFlowThread(LayoutUnit);

trunk/Source/WebCore/rendering/RenderMultiColumnSpannerPlaceholder.cpp

@@ -35 +35 @@
 namespace WebCore {
 
-RenderMultiColumnSpannerPlaceholder* RenderMultiColumnSpannerPlaceholder::createAnonymous(RenderMultiColumnFlowThread* flowThread, RenderBox* spanner, const RenderStyle* parentStyle)
+RenderMultiColumnSpannerPlaceholder* RenderMultiColumnSpannerPlaceholder::createAnonymous(RenderMultiColumnFlowThread* flowThread, RenderBox& spanner, const RenderStyle* parentStyle)
 {
     auto newStyle = RenderStyle::createAnonymousStyleWithDisplay(*parentStyle, BLOCK);
@@ -44 +44 @@
 }
 
-RenderMultiColumnSpannerPlaceholder::RenderMultiColumnSpannerPlaceholder(RenderMultiColumnFlowThread* flowThread, RenderBox* spanner, RenderStyle&& style)
+RenderMultiColumnSpannerPlaceholder::RenderMultiColumnSpannerPlaceholder(RenderMultiColumnFlowThread* flowThread, RenderBox& spanner, RenderStyle&& style)
     : RenderBox(flowThread->document(), WTFMove(style), RenderBoxModelObjectFlag)
-    , m_spanner(spanner)
+    , m_spanner(&spanner)
     , m_flowThread(flowThread)
 {

trunk/Source/WebCore/rendering/RenderMultiColumnSpannerPlaceholder.h

@@ -39 +39 @@
 class RenderMultiColumnSpannerPlaceholder final : public RenderBox {
 public:
-    static RenderMultiColumnSpannerPlaceholder* createAnonymous(RenderMultiColumnFlowThread*, RenderBox* spanner, const RenderStyle* parentStyle);
+    static RenderMultiColumnSpannerPlaceholder* createAnonymous(RenderMultiColumnFlowThread*, RenderBox& spanner, const RenderStyle* parentStyle);
 
     RenderBox* spanner() const { return m_spanner; }
@@ -45 +45 @@
 
 private:
-    RenderMultiColumnSpannerPlaceholder(RenderMultiColumnFlowThread*, RenderBox* spanner, RenderStyle&&);
+    RenderMultiColumnSpannerPlaceholder(RenderMultiColumnFlowThread*, RenderBox& spanner, RenderStyle&&);
     bool isRenderMultiColumnSpannerPlaceholder() const override { return true; }
 

trunk/Source/WebCore/rendering/RenderObject.cpp

@@ -1422 +1422 @@
 
     if (RenderFlowThread* flowThread = flowThreadContainingBlock())
-        flowThread->flowThreadDescendantInserted(this);
+        flowThread->flowThreadDescendantInserted(*this);
 }