Changeset 206049 in webkit

Timestamp:

Sep 16, 2016 2:39:28 PM (8 years ago)

Author:

Antti Koivisto

Message:

Tighten region style map to use RenderElement instead of RenderObject
​https://bugs.webkit.org/show_bug.cgi?id=162064

Reviewed by Zalan Bujtas.

RenderTexts don't have styles of their own so the map can operate on RenderElements.

• rendering/RenderElement.cpp:

(WebCore::RenderElement::willBeRemovedFromTree):
(WebCore::RenderElement::removeFromRenderFlowThread):
(WebCore::RenderElement::removeFromRenderFlowThreadIncludingDescendants):
(WebCore::RenderElement::invalidateFlowThreadContainingBlockIncludingDescendants):

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

(WebCore::RenderFlowThread::removeFlowChildInfo):

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

(WebCore::RenderNamedFlowFragment::computeChildrenStyleInRegion):
(WebCore::RenderNamedFlowFragment::setRendererStyleInRegion):
(WebCore::RenderNamedFlowFragment::clearObjectStyleInRegion):
(WebCore::RenderNamedFlowFragment::setRegionObjectsRegionStyle):
(WebCore::RenderNamedFlowFragment::restoreRegionObjectsOriginalStyle):
(WebCore::RenderNamedFlowFragment::setObjectStyleInRegion): Deleted.

• rendering/RenderNamedFlowFragment.h:
• rendering/RenderNamedFlowThread.cpp:

(WebCore::RenderNamedFlowThread::clearRenderObjectCustomStyle):
(WebCore::RenderNamedFlowThread::removeFlowChildInfo):

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

(WebCore::RenderObject::willBeRemovedFromTree):
(WebCore::RenderObject::removeFromRenderFlowThread): Deleted.
(WebCore::RenderObject::removeFromRenderFlowThreadIncludingDescendants): Deleted.
(WebCore::RenderObject::invalidateFlowThreadContainingBlockIncludingDescendants): Deleted.

These can now move to RenderElement.

• rendering/RenderObject.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• rendering/RenderElement.cpp (modified) (2 diffs)
• rendering/RenderElement.h (modified) (2 diffs)
• rendering/RenderFlowThread.cpp (modified) (1 diff)
• rendering/RenderFlowThread.h (modified) (1 diff)
• rendering/RenderNamedFlowFragment.cpp (modified) (6 diffs)
• rendering/RenderNamedFlowFragment.h (modified) (3 diffs)
• rendering/RenderNamedFlowThread.cpp (modified) (2 diffs)
• rendering/RenderNamedFlowThread.h (modified) (1 diff)
• rendering/RenderObject.cpp (modified) (1 diff)
• rendering/RenderObject.h (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2016-09-16  Antti Koivisto  <antti@apple.com>
+
+        Tighten region style map to use RenderElement instead of RenderObject
+        https://bugs.webkit.org/show_bug.cgi?id=162064
+
+        Reviewed by Zalan Bujtas.
+
+        RenderTexts don't have styles of their own so the map can operate on RenderElements.
+
+        * rendering/RenderElement.cpp:
+        (WebCore::RenderElement::willBeRemovedFromTree):
+        (WebCore::RenderElement::removeFromRenderFlowThread):
+        (WebCore::RenderElement::removeFromRenderFlowThreadIncludingDescendants):
+        (WebCore::RenderElement::invalidateFlowThreadContainingBlockIncludingDescendants):
+        * rendering/RenderElement.h:
+        * rendering/RenderFlowThread.cpp:
+        (WebCore::RenderFlowThread::removeFlowChildInfo):
+        * rendering/RenderFlowThread.h:
+        * rendering/RenderNamedFlowFragment.cpp:
+        (WebCore::RenderNamedFlowFragment::computeChildrenStyleInRegion):
+        (WebCore::RenderNamedFlowFragment::setRendererStyleInRegion):
+        (WebCore::RenderNamedFlowFragment::clearObjectStyleInRegion):
+        (WebCore::RenderNamedFlowFragment::setRegionObjectsRegionStyle):
+        (WebCore::RenderNamedFlowFragment::restoreRegionObjectsOriginalStyle):
+        (WebCore::RenderNamedFlowFragment::setObjectStyleInRegion): Deleted.
+        * rendering/RenderNamedFlowFragment.h:
+        * rendering/RenderNamedFlowThread.cpp:
+        (WebCore::RenderNamedFlowThread::clearRenderObjectCustomStyle):
+        (WebCore::RenderNamedFlowThread::removeFlowChildInfo):
+        * rendering/RenderNamedFlowThread.h:
+        * rendering/RenderObject.cpp:
+        (WebCore::RenderObject::willBeRemovedFromTree):
+        (WebCore::RenderObject::removeFromRenderFlowThread): Deleted.
+        (WebCore::RenderObject::removeFromRenderFlowThreadIncludingDescendants): Deleted.
+        (WebCore::RenderObject::invalidateFlowThreadContainingBlockIncludingDescendants): Deleted.
+
+            These can now move to RenderElement.
+
+        * rendering/RenderObject.h:
+
 2016-09-16  Brent Fulgham  <bfulgham@apple.com>
 

trunk/Source/WebCore/rendering/RenderElement.cpp

@@ -1088 +1088 @@
         containerFlowThread->removeFlowChild(*this);
 
+    removeFromRenderFlowThread();
+
     RenderObject::willBeRemovedFromTree();
 }
@@ -2205 +2207 @@
 }
 
+void RenderElement::removeFromRenderFlowThread()
+{
+    if (flowThreadState() == NotInsideFlowThread)
+        return;
+
+    // Sometimes we remove the element from the flow, but it's not destroyed at that time.
+    // It's only until later when we actually destroy it and remove all the children from it.
+    // Currently, that happens for firstLetter elements and list markers.
+    // Pass in the flow thread so that we don't have to look it up for all the children.
+    removeFromRenderFlowThreadIncludingDescendants(true);
+}
+
+void RenderElement::removeFromRenderFlowThreadIncludingDescendants(bool shouldUpdateState)
+{
+    // Once we reach another flow thread we don't need to update the flow thread state
+    // but we have to continue cleanup the flow thread info.
+    if (isRenderFlowThread())
+        shouldUpdateState = false;
+
+    for (auto& child : childrenOfType<RenderObject>(*this)) {
+        if (is<RenderElement>(child)) {
+            downcast<RenderElement>(child).removeFromRenderFlowThreadIncludingDescendants(shouldUpdateState);
+            continue;
+        }
+        if (shouldUpdateState)
+            child.setFlowThreadState(NotInsideFlowThread);
+    }
+
+    // We have to ask for our containing flow thread as it may be above the removed sub-tree.
+    RenderFlowThread* flowThreadContainingBlock = this->flowThreadContainingBlock();
+    while (flowThreadContainingBlock) {
+        flowThreadContainingBlock->removeFlowChildInfo(this);
+
+        if (flowThreadContainingBlock->flowThreadState() == NotInsideFlowThread)
+            break;
+        auto* parent = flowThreadContainingBlock->parent();
+        if (!parent)
+            break;
+        flowThreadContainingBlock = parent->flowThreadContainingBlock();
+    }
+    if (is<RenderBlock>(*this))
+        downcast<RenderBlock>(*this).setCachedFlowThreadContainingBlockNeedsUpdate();
+
+    if (shouldUpdateState)
+        setFlowThreadState(NotInsideFlowThread);
+}
+
+void RenderElement::invalidateFlowThreadContainingBlockIncludingDescendants(RenderFlowThread* flowThread)
+{
+    if (flowThreadState() == NotInsideFlowThread)
+        return;
+
+    if (is<RenderBlock>(*this)) {
+        RenderBlock& block = downcast<RenderBlock>(*this);
+
+        if (block.cachedFlowThreadContainingBlockNeedsUpdate())
+            return;
+
+        flowThread = block.cachedFlowThreadContainingBlock();
+        block.setCachedFlowThreadContainingBlockNeedsUpdate();
+    }
+
+    if (flowThread)
+        flowThread->removeFlowChildInfo(this);
+
+    if (!is<RenderElement>(*this))
+        return;
+
+    for (auto& child : childrenOfType<RenderElement>(*this))
+        child.invalidateFlowThreadContainingBlockIncludingDescendants(flowThread);
+}
+
 #if ENABLE(IOS_TEXT_AUTOSIZING)
 static RenderObject::BlockContentHeightType includeNonFixedHeight(const RenderObject& renderer)

trunk/Source/WebCore/rendering/RenderElement.h

@@ -230 +230 @@
     RespectImageOrientationEnum shouldRespectImageOrientation() const;
 
+    void removeFromRenderFlowThread();
+    void invalidateFlowThreadContainingBlockIncludingDescendants(RenderFlowThread* = nullptr);
+
 protected:
     enum BaseTypeFlag {
@@ -285 +288 @@
     void updateOutlineAutoAncestor(bool hasOutlineAuto);
 
+    void removeFromRenderFlowThreadIncludingDescendants(bool shouldUpdateState);
+
 private:
     RenderElement(ContainerNode&, RenderStyle&&, BaseTypeFlags);

trunk/Source/WebCore/rendering/RenderFlowThread.cpp

@@ -93 +93 @@
 }
 
-void RenderFlowThread::removeFlowChildInfo(RenderObject* child)
+void RenderFlowThread::removeFlowChildInfo(RenderElement* child)
 {
     if (is<RenderBlockFlow>(*child))

trunk/Source/WebCore/rendering/RenderFlowThread.h

@@ -61 +61 @@
     virtual ~RenderFlowThread() { }
 
-    virtual void removeFlowChildInfo(RenderObject*);
+    virtual void removeFlowChildInfo(RenderElement*);
 #ifndef NDEBUG
     bool hasChildInfo(RenderObject* child) const { return is<RenderBox>(child) && m_regionRangeMap.contains(downcast<RenderBox>(child)); }

trunk/Source/WebCore/rendering/RenderNamedFlowFragment.cpp

@@ -360 +360 @@
 void RenderNamedFlowFragment::computeChildrenStyleInRegion(RenderElement& renderer)
 {
-    for (auto& child : childrenOfType<RenderObject>(renderer)) {
-
-        auto it = m_renderObjectRegionStyle.find(&child);
+    for (auto& child : childrenOfType<RenderElement>(renderer)) {
+        auto it = m_rendererRegionStyle.find(&child);
 
         std::unique_ptr<RenderStyle> childStyleInRegion;
         bool objectRegionStyleCached = false;
-        if (it != m_renderObjectRegionStyle.end()) {
+        if (it != m_rendererRegionStyle.end()) {
             childStyleInRegion = RenderStyle::clonePtr(*it->value.style);
             objectRegionStyleCached = true;
@@ -372 +371 @@
             if (child.isAnonymous() || child.isInFlowRenderFlowThread())
                 childStyleInRegion =  std::make_unique<RenderStyle>(RenderStyle::createAnonymousStyleWithDisplay(renderer.style(), child.style().display()));
-            else if (is<RenderText>(child))
-                childStyleInRegion = RenderStyle::clonePtr(renderer.style());
             else
-                childStyleInRegion = computeStyleInRegion(downcast<RenderElement>(child), renderer.style());
-        }
-
-        setObjectStyleInRegion(&child, WTFMove(childStyleInRegion), objectRegionStyleCached);
-
-        if (is<RenderElement>(child))
-            computeChildrenStyleInRegion(downcast<RenderElement>(child));
-    }
-}
-
-void RenderNamedFlowFragment::setObjectStyleInRegion(RenderObject* object, std::unique_ptr<RenderStyle> styleInRegion, bool objectRegionStyleCached)
-{
-    ASSERT(object->flowThreadContainingBlock());
-
-    std::unique_ptr<RenderStyle> objectOriginalStyle = RenderStyle::clonePtr(object->style());
-    if (is<RenderElement>(*object))
-        downcast<RenderElement>(*object).setStyleInternal(WTFMove(*styleInRegion));
-
-    if (is<RenderBoxModelObject>(*object) && !object->hasVisibleBoxDecorations()) {
-        bool hasVisibleBoxDecorations = is<RenderTableCell>(*object)
-        || object->style().hasBackground()
-        || object->style().hasVisibleBorder()
-        || object->style().hasAppearance()
-        || object->style().boxShadow();
-        object->setHasVisibleBoxDecorations(hasVisibleBoxDecorations);
+                childStyleInRegion = computeStyleInRegion(child, renderer.style());
+        }
+
+        setRendererStyleInRegion(child, WTFMove(childStyleInRegion), objectRegionStyleCached);
+        computeChildrenStyleInRegion(child);
+    }
+}
+
+void RenderNamedFlowFragment::setRendererStyleInRegion(RenderElement& renderer, std::unique_ptr<RenderStyle> styleInRegion, bool objectRegionStyleCached)
+{
+    ASSERT(renderer.flowThreadContainingBlock());
+
+    std::unique_ptr<RenderStyle> objectOriginalStyle = RenderStyle::clonePtr(renderer.style());
+    renderer.setStyleInternal(WTFMove(*styleInRegion));
+
+    if (is<RenderBoxModelObject>(renderer) && !renderer.hasVisibleBoxDecorations()) {
+        bool hasVisibleBoxDecorations = is<RenderTableCell>(renderer)
+        || renderer.style().hasBackground()
+        || renderer.style().hasVisibleBorder()
+        || renderer.style().hasAppearance()
+        || renderer.style().boxShadow();
+        renderer.setHasVisibleBoxDecorations(hasVisibleBoxDecorations);
     }
 
@@ -405 +399 @@
     styleInfo.style = WTFMove(objectOriginalStyle);
     styleInfo.cached = objectRegionStyleCached;
-    m_renderObjectRegionStyle.set(object, WTFMove(styleInfo));
-}
-
-void RenderNamedFlowFragment::clearObjectStyleInRegion(const RenderObject* object)
+    m_rendererRegionStyle.set(&renderer, WTFMove(styleInfo));
+}
+
+void RenderNamedFlowFragment::clearObjectStyleInRegion(const RenderElement* object)
 {
     ASSERT(object);
-    m_renderObjectRegionStyle.remove(object);
+    m_rendererRegionStyle.remove(object);
 
     // Clear the style for the children of this object.
-    for (RenderObject* child = object->firstChildSlow(); child; child = child->nextSibling())
-        clearObjectStyleInRegion(child);
+    for (auto& child : childrenOfType<RenderElement>(*object))
+        clearObjectStyleInRegion(&child);
 }
 
@@ -432 +426 @@
         if (!element->renderer())
             continue;
-
-        RenderElement* object = element->renderer();
+        auto& renderer = *element->renderer();
+
         // If the content node does not flow any of its children in this region,
         // we do not compute any style for them in this region.
-        if (!flowThread()->objectInFlowRegion(object, this))
+        if (!flowThread()->objectInFlowRegion(&renderer, this))
             continue;
 
         // If the object has style in region, use that instead of computing a new one.
-        auto it = m_renderObjectRegionStyle.find(object);
+        auto it = m_rendererRegionStyle.find(&renderer);
         std::unique_ptr<RenderStyle> objectStyleInRegion;
         bool objectRegionStyleCached = false;
-        if (it != m_renderObjectRegionStyle.end()) {
+        if (it != m_rendererRegionStyle.end()) {
             objectStyleInRegion = RenderStyle::clonePtr(*it->value.style);
             ASSERT(it->value.cached);
             objectRegionStyleCached = true;
         } else
-            objectStyleInRegion = computeStyleInRegion(*object, style());
-
-        setObjectStyleInRegion(object, WTFMove(objectStyleInRegion), objectRegionStyleCached);
-
-        computeChildrenStyleInRegion(*object);
+            objectStyleInRegion = computeStyleInRegion(renderer, style());
+
+        setRendererStyleInRegion(renderer, WTFMove(objectStyleInRegion), objectRegionStyleCached);
+
+        computeChildrenStyleInRegion(renderer);
     }
 }
@@ -461 +455 @@
         return;
 
-    RenderObjectRegionStyleMap temp;
-    for (auto& objectPair : m_renderObjectRegionStyle) {
-        RenderObject* object = const_cast<RenderObject*>(objectPair.key);
+    RendererRegionStyleMap temp;
+    for (auto& objectPair : m_rendererRegionStyle) {
+        auto* object = const_cast<RenderElement*>(objectPair.key);
         std::unique_ptr<RenderStyle> objectRegionStyle = RenderStyle::clonePtr(object->style());
         std::unique_ptr<RenderStyle> objectOriginalStyle = RenderStyle::clonePtr(*objectPair.value.style);
@@ -481 +475 @@
             temp.set(object, WTFMove(styleInfo));
         }
-        if (is<RenderElement>(*object))
-            downcast<RenderElement>(*object).setStyleInternal(WTFMove(*objectOriginalStyle));
-    }
-
-    m_renderObjectRegionStyle.swap(temp);
+        object->setStyleInternal(WTFMove(*objectOriginalStyle));
+    }
+
+    m_rendererRegionStyle.swap(temp);
 }
 

trunk/Source/WebCore/rendering/RenderNamedFlowFragment.h

@@ -80 +80 @@
 
     bool hasCustomRegionStyle() const { return m_hasCustomRegionStyle; }
-    void clearObjectStyleInRegion(const RenderObject*);
+    void clearObjectStyleInRegion(const RenderElement*);
 
     void setRegionObjectsRegionStyle();
@@ -126 +126 @@
     std::unique_ptr<RenderStyle> computeStyleInRegion(RenderElement&, const RenderStyle& parentStyle) const;
     void computeChildrenStyleInRegion(RenderElement&);
-    void setObjectStyleInRegion(RenderObject*, std::unique_ptr<RenderStyle>, bool objectRegionStyleCached);
+    void setRendererStyleInRegion(RenderElement&, std::unique_ptr<RenderStyle>, bool objectRegionStyleCached);
 
     void checkRegionStyle();
@@ -154 +154 @@
     };
 
-    typedef HashMap<const RenderObject*, ObjectRegionStyleInfo > RenderObjectRegionStyleMap;
-    RenderObjectRegionStyleMap m_renderObjectRegionStyle;
+    using RendererRegionStyleMap = HashMap<const RenderElement*, ObjectRegionStyleInfo>;
+    RendererRegionStyleMap m_rendererRegionStyle;
 
     bool m_hasCustomRegionStyle : 1;

trunk/Source/WebCore/rendering/RenderNamedFlowThread.cpp

@@ -813 +813 @@
 }
 
-void RenderNamedFlowThread::clearRenderObjectCustomStyle(const RenderObject* object)
+void RenderNamedFlowThread::clearRenderObjectCustomStyle(const RenderElement* object)
 {
     // Clear the styles for the object in the regions.
@@ -821 +821 @@
 }
 
-void RenderNamedFlowThread::removeFlowChildInfo(RenderObject* child)
+void RenderNamedFlowThread::removeFlowChildInfo(RenderElement* child)
 {
     RenderFlowThread::removeFlowChildInfo(child);

trunk/Source/WebCore/rendering/RenderNamedFlowThread.h

@@ -92 +92 @@
     void checkRegionsWithStyling();
 
-    void clearRenderObjectCustomStyle(const RenderObject*);
+    void clearRenderObjectCustomStyle(const RenderElement*);
 
-    void removeFlowChildInfo(RenderObject*) override;
+    void removeFlowChildInfo(RenderElement*) override;
 
     LayoutUnit flowContentBottom() const { return m_flowContentBottom; }

trunk/Source/WebCore/rendering/RenderObject.cpp

@@ -1427 +1427 @@
     // FIXME: We should ASSERT(isRooted()) but we have some out-of-order removals which would need to be fixed first.
 
-    removeFromRenderFlowThread();
+    setFlowThreadState(NotInsideFlowThread);
 
     // Update cached boundaries in SVG renderers, if a child is removed.
     parent()->setNeedsBoundariesUpdate();
-}
-
-void RenderObject::removeFromRenderFlowThread()
-{
-    if (flowThreadState() == NotInsideFlowThread)
-        return;
-
-    // Sometimes we remove the element from the flow, but it's not destroyed at that time.
-    // It's only until later when we actually destroy it and remove all the children from it.
-    // Currently, that happens for firstLetter elements and list markers.
-    // Pass in the flow thread so that we don't have to look it up for all the children.
-    removeFromRenderFlowThreadIncludingDescendants(true);
-}
-
-void RenderObject::removeFromRenderFlowThreadIncludingDescendants(bool shouldUpdateState)
-{
-    // Once we reach another flow thread we don't need to update the flow thread state
-    // but we have to continue cleanup the flow thread info.
-    if (isRenderFlowThread())
-        shouldUpdateState = false;
-
-    if (is<RenderElement>(*this)) {
-        for (auto& child : childrenOfType<RenderObject>(downcast<RenderElement>(*this)))
-            child.removeFromRenderFlowThreadIncludingDescendants(shouldUpdateState);
-    }
-
-    // We have to ask for our containing flow thread as it may be above the removed sub-tree.
-    RenderFlowThread* flowThreadContainingBlock = this->flowThreadContainingBlock();
-    while (flowThreadContainingBlock) {
-        flowThreadContainingBlock->removeFlowChildInfo(this);
-        if (flowThreadContainingBlock->flowThreadState() == NotInsideFlowThread)
-            break;
-        RenderObject* parent = flowThreadContainingBlock->parent();
-        if (!parent)
-            break;
-        flowThreadContainingBlock = parent->flowThreadContainingBlock();
-    }
-    if (is<RenderBlock>(*this))
-        downcast<RenderBlock>(*this).setCachedFlowThreadContainingBlockNeedsUpdate();
-
-    if (shouldUpdateState)
-        setFlowThreadState(NotInsideFlowThread);
-}
-
-void RenderObject::invalidateFlowThreadContainingBlockIncludingDescendants(RenderFlowThread* flowThread)
-{
-    if (flowThreadState() == NotInsideFlowThread)
-        return;
-
-    if (is<RenderBlock>(*this)) {
-        RenderBlock& block = downcast<RenderBlock>(*this);
-
-        if (block.cachedFlowThreadContainingBlockNeedsUpdate())
-            return;
-
-        flowThread = block.cachedFlowThreadContainingBlock();
-        block.setCachedFlowThreadContainingBlockNeedsUpdate();
-    }
-
-    if (flowThread)
-        flowThread->removeFlowChildInfo(this);
-
-    if (!is<RenderElement>(*this))
-        return;
-
-    for (auto& child : childrenOfType<RenderObject>(downcast<RenderElement>(*this)))
-        child.invalidateFlowThreadContainingBlockIncludingDescendants(flowThread);
 }
 

trunk/Source/WebCore/rendering/RenderObject.h

@@ -817 +817 @@
 
     virtual RenderFlowThread* locateFlowThreadContainingBlock() const;
-    void invalidateFlowThreadContainingBlockIncludingDescendants(RenderFlowThread* = nullptr);
     static void calculateBorderStyleColor(const EBorderStyle&, const BoxSide&, Color&);
 
@@ -830 +829 @@
     void setLayerNeedsFullRepaintForPositionedMovementLayout();
 
-    void removeFromRenderFlowThread();
-    void removeFromRenderFlowThreadIncludingDescendants(bool);
     Node* generatingPseudoHostElement() const;