Rename attach and detach to createRenderTree/destroyRenderTree

Source/core/dom/Node.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 72 matching lines @@
 class ShadowRoot;
 class TagNodeList;
 class TouchEvent;
 
 const int nodeStyleChangeShift = 14;
 
 enum StyleChangeType {
     NoStyleChange = 0,
     LocalStyleChange = 1 << nodeStyleChangeShift,
     SubtreeStyleChange = 2 << nodeStyleChangeShift,
-    LazyAttachStyleChange = 3 << nodeStyleChangeShift,
+    DeferredRenderTreeCreationStyleChange = 3 << nodeStyleChangeShift,
 };
 
 // If the style change is from the renderer then we'll call setStyle on the
 // renderer even if the style computed from CSS is identical.
 enum StyleChangeSource {
     StyleChangeFromCSS,
     StyleChangeFromRenderer
 };
 
 class NodeRareDataBase {
@@ skipping 296 matching lines @@
 
     bool hasScopedHTMLStyleChild() const { return getFlag(HasScopedHTMLStyleChildFlag); }
     void setHasScopedHTMLStyleChild(bool flag) { setFlag(flag, HasScopedHTMLStyleChildFlag); }
 
     bool hasEventTargetData() const { return getFlag(HasEventTargetDataFlag); }
     void setHasEventTargetData(bool flag) { setFlag(flag, HasEventTargetDataFlag); }
 
     bool isV8CollectableDuringMinorGC() const { return getFlag(V8CollectableDuringMinorGCFlag); }
     void setV8CollectableDuringMinorGC(bool flag) { setFlag(flag, V8CollectableDuringMinorGCFlag); }
 
-    void lazyAttach();
-    void lazyReattach();
+    void scheduleRenderTreeCreation();
+    void scheduleRenderTreeReconstruction();

[ojan, 2013/09/24 22:41:24]

How about scheduleRenderTreeRecreation?

 
     virtual void setFocus(bool flag);
     virtual void setActive(bool flag = true, bool pause = false);
     virtual void setHovered(bool flag = true);
 
     virtual short tabIndex() const;
 
     virtual Node* focusDelegate();
     // This is called only when the node is focused.
     virtual bool shouldHaveFocusAppearance() const;
@@ skipping 109 matching lines @@
         else
             m_data.m_renderer = renderer;
     }
 
     // Use these two methods with caution.
     RenderBox* renderBox() const;
     RenderBoxModelObject* renderBoxModelObject() const;
 
     struct AttachContext {
         RenderStyle* resolvedStyle;
-        bool performingReattach;
+        bool reconstructingRenderTree;

[ojan, 2013/09/24 22:41:24]

Ditto...recreatingRenderTree.

 
-        AttachContext() : resolvedStyle(0), performingReattach(false) { }
+        AttachContext() : resolvedStyle(0), reconstructingRenderTree(false) { }
     };
 
     // Attaches this node to the rendering tree. This calculates the style to be applied to the node and creates an
     // appropriate RenderObject which will be inserted into the tree (except when the style has display: none). This
     // makes the node visible in the FrameView.
-    virtual void attach(const AttachContext& = AttachContext());
+    virtual void createRenderTree(const AttachContext& = AttachContext());
 
     // Detaches the node from the rendering tree, making it invisible in the rendered view. This method will remove
     // the node's rendering object from the rendering tree and delete it.
-    virtual void detach(const AttachContext& = AttachContext());
+    virtual void destroyRenderTree(const AttachContext& = AttachContext());
 
 #ifndef NDEBUG
     bool inDetach() const;
 #endif
 
-    void reattach(const AttachContext& = AttachContext());
-    void lazyReattachIfAttached();
+    void recreateRenderTree(const AttachContext& = AttachContext());
+    void scheduleRenderTreeRecreationIfAttached();
 
     // Wrapper for nodes that don't have a renderer, but still cache the style (like HTMLOptionElement).
     RenderStyle* renderStyle() const;
     RenderStyle* parentRenderStyle() const;
 
     RenderStyle* computedStyle(PseudoId pseudoElementSpecifier = NOPSEUDO) { return virtualComputedStyle(pseudoElementSpecifier); }
 
     // -----------------------------------------------------------------------------
     // Notification of document structure changes (see ContainerNode.h for more notification methods)
     //
@@ skipping 253 matching lines @@
     bool rendererIsEditable(EditableLevel, UserSelectAllTreatment = UserSelectAllIsAlwaysNonEditable) const;
     bool isEditableToAccessibility(EditableLevel) const;
 
     bool isUserActionElementActive() const;
     bool isUserActionElementInActiveChain() const;
     bool isUserActionElementHovered() const;
     bool isUserActionElementFocused() const;
 
     void setStyleChange(StyleChangeType);
 
-    void detachNode(Node*, const AttachContext&);
+    void destroyRenderTreeForNode(Node*, const AttachContext&);
     void clearAttached() { clearFlag(IsAttachedFlag); }
 
-    // Used to share code between lazyAttach and setNeedsStyleRecalc.
+    // Used to share code between scheduleRenderTreeCreation and setNeedsStyleRecalc.
     void markAncestorsWithChildNeedsStyleRecalc();
 
     virtual void refEventTarget();
     virtual void derefEventTarget();
 
     virtual RenderStyle* nonRendererStyle() const { return 0; }
 
     virtual RenderStyle* virtualComputedStyle(PseudoId = NOPSEUDO);
 
     Element* ancestorElement() const;
@@ skipping 48 matching lines @@
 {
     return isShadowRoot() ? 0 : parentOrShadowHostNode();
 }
 
 inline ContainerNode* Node::parentNodeGuaranteedHostFree() const
 {
     ASSERT(!isShadowRoot());
     return parentOrShadowHostNode();
 }
 
-inline void Node::lazyReattachIfAttached()
+inline void Node::scheduleRenderTreeRecreationIfAttached()
 {
     if (attached())
-        lazyReattach();
+        scheduleRenderTreeReconstruction();
 }
 
-inline void Node::lazyReattach()
+inline void Node::scheduleRenderTreeReconstruction()
 {
-    if (styleChangeType() == LazyAttachStyleChange)
+    if (styleChangeType() == DeferredRenderTreeCreationStyleChange)
         return;
 
     AttachContext context;
-    context.performingReattach = true;
+    context.reconstructingRenderTree = true;
 
     if (attached())
-        detach(context);
-    lazyAttach();
+        destroyRenderTree(context);
+    scheduleRenderTreeCreation();
 }
 
 inline bool shouldRecalcStyle(StyleRecalcChange change, const Node* node)
 {
     return change >= Inherit || node->childNeedsStyleRecalc() || node->needsStyleRecalc();
 }
 
 } //namespace
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showTree(const WebCore::Node*);
 void showNodePath(const WebCore::Node*);
 #endif
 
 #endif