Changeset 154873 in webkit

Timestamp:

Aug 30, 2013, 5:33:15 AM (12 years ago)

Author:

Antti Koivisto

Message:

Remove AttachContext
​https://bugs.webkit.org/show_bug.cgi?id=120518

Reviewed by Andreas Kling.

This type is not useful anymore. Just pass the precomputed style to attachRenderTree and reattach-or-not flag to detachRenderTree.

• style/StyleResolveTree.cpp:

(WebCore::Style::createRendererIfNeeded):
(WebCore::Style::attachChildren):
(WebCore::Style::attachShadowRoot):
(WebCore::Style::attachRenderTree):
(WebCore::Style::detachChildren):
(WebCore::Style::detachShadowRoot):
(WebCore::Style::detachRenderTree):
(WebCore::Style::reattachRenderTree):
(WebCore::Style::resolveLocal):

• style/StyleResolveTree.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• dom/Element.cpp (modified) (1 diff)
• style/StyleResolveTree.cpp (modified) (15 diffs)
• style/StyleResolveTree.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog ¶

@@ +1 @@
+2013-08-30  Antti Koivisto  <antti@apple.com>
+
+        Remove AttachContext
+        https://bugs.webkit.org/show_bug.cgi?id=120518
+
+        Reviewed by Andreas Kling.
+
+        This type is not useful anymore. Just pass the precomputed style to attachRenderTree and reattach-or-not flag to detachRenderTree.
+
+        * style/StyleResolveTree.cpp:
+        (WebCore::Style::createRendererIfNeeded):
+        (WebCore::Style::attachChildren):
+        (WebCore::Style::attachShadowRoot):
+        (WebCore::Style::attachRenderTree):
+        (WebCore::Style::detachChildren):
+        (WebCore::Style::detachShadowRoot):
+        (WebCore::Style::detachRenderTree):
+        (WebCore::Style::reattachRenderTree):
+        (WebCore::Style::resolveLocal):
+        * style/StyleResolveTree.h:
+
 2013-08-30  Commit Queue  <commit-queue@webkit.org>
 

trunk/Source/WebCore/dom/Element.cpp ¶

@@ -1376 +1376 @@
 void Element::lazyReattach(ShouldSetAttached shouldSetAttached)
 {
-    Style::AttachContext context;
-    context.performingReattach = true;
-
     if (attached())
-        Style::detachRenderTree(this, context);
+        Style::detachRenderTreeInReattachMode(this);
     lazyAttach(shouldSetAttached);
 }

trunk/Source/WebCore/style/StyleResolveTree.cpp ¶

@@ -55 +55 @@
 namespace Style {
 
+enum DetachType { NormalDetach, ReattachDetach };
+
+static void attachRenderTree(Element*, RenderStyle* resolvedStyle);
+static void detachRenderTree(Element*, DetachType);
+
 Change determineChange(const RenderStyle* s1, const RenderStyle* s2, Settings* settings)
 {
@@ -189 +194 @@
 #endif
 
-static void createRendererIfNeeded(Element& element, const AttachContext& context)
+static void createRendererIfNeeded(Element& element, RenderStyle* resolvedStyle)
 {
     ASSERT(!element.renderer());
@@ -196 +201 @@
     ContainerNode* renderingParentNode = NodeRenderingTraversal::parent(&element);
 
-    RefPtr<RenderStyle> style = context.resolvedStyle;
+    RefPtr<RenderStyle> style = resolvedStyle;
 
     element.setIsInsideRegion(false);
@@ -432 +437 @@
 #endif
 
-static void attachChildren(ContainerNode& current, const AttachContext& context)
-{
-    AttachContext childrenContext(context);
-    childrenContext.resolvedStyle = 0;
-
+static void attachChildren(ContainerNode& current)
+{
     for (Node* child = current.firstChild(); child; child = child->nextSibling()) {
         ASSERT(!child->attached() || childAttachedAllowedWhenAttachingChildren(current));
@@ -446 +448 @@
         }
         if (child->isElementNode())
-            attachRenderTree(toElement(child), childrenContext);
-    }
-}
-
-static void attachShadowRoot(ShadowRoot& shadowRoot, const AttachContext& context)
+            attachRenderTree(toElement(child), nullptr);
+    }
+}
+
+static void attachShadowRoot(ShadowRoot& shadowRoot)
 {
     if (shadowRoot.attached())
@@ -457 +459 @@
     styleResolver.pushParentShadowRoot(&shadowRoot);
 
-    attachChildren(shadowRoot, context);
+    attachChildren(shadowRoot);
 
     styleResolver.popParentShadowRoot(&shadowRoot);
@@ -465 +467 @@
 }
 
-void attachRenderTree(Element* current, const AttachContext& context)
+static void attachRenderTree(Element* current, RenderStyle* resolvedStyle)
 {
     PostAttachCallbackDisabler callbackDisabler(current);
@@ -473 +475 @@
         current->willAttachRenderers();
 
-    createRendererIfNeeded(*current, context);
+    createRendererIfNeeded(*current, resolvedStyle);
 
     if (current->parentElement() && current->parentElement()->isInCanvasSubtree())
@@ -485 +487 @@
     if (ShadowRoot* shadowRoot = current->shadowRoot()) {
         parentPusher.push();
-        attachShadowRoot(*shadowRoot, context);
+        attachShadowRoot(*shadowRoot);
     } else if (current->firstChild())
         parentPusher.push();
 
-    attachChildren(*current, context);
+    attachChildren(*current);
 
     Node* sibling = current->nextSibling();
@@ -511 +513 @@
 }
 
-static void detachChildren(ContainerNode& current, const AttachContext& context)
-{
-    AttachContext childrenContext(context);
-    childrenContext.resolvedStyle = 0;
-
+static void detachChildren(ContainerNode& current, DetachType detachType)
+{
     for (Node* child = current.firstChild(); child; child = child->nextSibling()) {
         if (child->isTextNode()) {
@@ -522 +521 @@
         }
         if (child->isElementNode())
-            detachRenderTree(toElement(child), childrenContext);
+            detachRenderTree(toElement(child), detachType);
     }
     current.clearChildNeedsStyleRecalc();
 }
 
-static void detachShadowRoot(ShadowRoot& shadowRoot, const AttachContext& context)
+static void detachShadowRoot(ShadowRoot& shadowRoot, DetachType detachType)
 {
     if (!shadowRoot.attached())
         return;
-    detachChildren(shadowRoot, context);
+    detachChildren(shadowRoot, detachType);
 
     shadowRoot.setAttached(false);
 }
 
-void detachRenderTree(Element* current, const AttachContext& context)
+static void detachRenderTree(Element* current, DetachType detachType)
 {
     WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
@@ -547 +546 @@
     // Do not remove the element's hovered and active status
     // if performing a reattach.
-    if (!context.performingReattach)
+    if (detachType != ReattachDetach)
         current->clearHoverAndActiveStatusBeforeDetachingRenderer();
 
     if (ShadowRoot* shadowRoot = current->shadowRoot())
-        detachShadowRoot(*shadowRoot, context);
-
-    detachChildren(*current, context);
+        detachShadowRoot(*shadowRoot, detachType);
+
+    detachChildren(*current, detachType);
 
     if (current->renderer())
@@ -563 +562 @@
     if (current->hasCustomStyleResolveCallbacks())
         current->didDetachRenderers();
-}
-
-void reattachRenderTree(Element* current, const AttachContext& context)
-{
-    AttachContext reattachContext(context);
-    reattachContext.performingReattach = true;
-
-    if (current->attached())
-        detachRenderTree(current, reattachContext);
-
-    attachRenderTree(current, reattachContext);
 }
 
@@ -622 +610 @@
     }
     if (localChange == Detach) {
-        AttachContext reattachContext;
-        reattachContext.resolvedStyle = newStyle.get();
-        reattachRenderTree(current, reattachContext);
+        if (current->attached())
+            detachRenderTree(current, ReattachDetach);
+        attachRenderTree(current, newStyle.get());
         return Detach;
     }
@@ -845 +833 @@
 }
 
-}
-}
+void attachRenderTree(Element* element)
+{
+    attachRenderTree(element, nullptr);
+}
+
+void detachRenderTree(Element* element)
+{
+    detachRenderTree(element, NormalDetach);
+}
+
+void detachRenderTreeInReattachMode(Element* element)
+{
+    detachRenderTree(element, ReattachDetach);
+}
+
+void reattachRenderTree(Element* current)
+{
+    if (current->attached())
+        detachRenderTree(current, ReattachDetach);
+    attachRenderTree(current, nullptr);
+}
+
+}
+}

trunk/Source/WebCore/style/StyleResolveTree.h ¶

@@ -42 +42 @@
 void resolveTree(Document*, Change);
 
-struct AttachContext {
-    RenderStyle* resolvedStyle;
-    bool performingReattach;
-
-    AttachContext() : resolvedStyle(0), performingReattach(false) { }
-};
-void attachRenderTree(Element*, const AttachContext& = AttachContext());
-void detachRenderTree(Element*, const AttachContext& = AttachContext());
-void reattachRenderTree(Element*, const AttachContext& = AttachContext());
+void attachRenderTree(Element*);
+void detachRenderTree(Element*);
+void reattachRenderTree(Element*);
+// FIXME: This is only used for "lazy reattach" for shadow trees.
+void detachRenderTreeInReattachMode(Element*);
 
 void attachTextRenderer(Text&);