Rename attach and detach to createRenderTree/destroyRenderTree

Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 1293 matching lines @@
             document().accessSVGExtensions()->removeElementFromPendingResources(this);
 
         if (isUpgradedCustomElement())
             CustomElement::didLeaveDocument(this, insertionPoint->document());
     }
 
     if (hasRareData())
         elementRareData()->setIsInCanvasSubtree(false);
 }
 
-void Element::attach(const AttachContext& context)
+void Element::createRenderTree(const AttachContext& context)
 {
     ASSERT(document().inStyleRecalc());
 
     StyleResolverParentPusher parentPusher(this);
 
-    // We've already been through detach when doing a lazyAttach, but we might
+    // We've already been through detach when doing a scheduleRenderTreeCreation, but we might
     // need to clear any state that's been added since then.
-    if (hasRareData() && styleChangeType() == LazyAttachStyleChange) {
+    if (hasRareData() && styleChangeType() == DeferredRenderTreeCreationStyleChange) {
         ElementRareData* data = elementRareData();
         data->clearComputedStyle();
         data->resetDynamicRestyleObservations();
         if (!context.resolvedStyle)
             data->resetStyleState();
     }
 
     NodeRenderingContext(this, context.resolvedStyle).createRendererForElementIfNeeded();
 
     createPseudoElementIfNeeded(BEFORE);
 
     // When a shadow root exists, it does the work of attaching the children.
     if (ElementShadow* shadow = this->shadow()) {
         parentPusher.push();
-        shadow->attach(context);
+        shadow->createRenderTree(context);
     } else if (firstChild())
         parentPusher.push();
 
-    ContainerNode::attach(context);
+    ContainerNode::createRenderTree(context);
 
     createPseudoElementIfNeeded(AFTER);
     createPseudoElementIfNeeded(BACKDROP);
 
     if (hasRareData()) {
         ElementRareData* data = elementRareData();
         if (data->needsFocusAppearanceUpdateSoonAfterAttach()) {
             if (isFocusable() && document().focusedElement() == this)
                 document().updateFocusAppearanceSoon(false /* don't restore selection */);
             data->setNeedsFocusAppearanceUpdateSoonAfterAttach(false);
         }
     }
 
     InspectorInstrumentation::didRecalculateStyleForElement(this);
 }
 
 void Element::unregisterNamedFlowContentNode()
 {
     if (RuntimeEnabledFeatures::cssRegionsEnabled() && inNamedFlow() && document().renderView())
         document().renderView()->flowThreadController()->unregisterNamedFlowContentNode(this);
 }
 
-void Element::detach(const AttachContext& context)
+void Element::destroyRenderTree(const AttachContext& context)
 {
     WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
     unregisterNamedFlowContentNode();
     cancelFocusAppearanceUpdate();
     if (hasRareData()) {
         ElementRareData* data = elementRareData();
         data->setPseudoElement(BEFORE, 0);
         data->setPseudoElement(AFTER, 0);
         data->setPseudoElement(BACKDROP, 0);
         data->clearComputedStyle();
         data->resetDynamicRestyleObservations();
         data->setIsInsideRegion(false);
 
         // Only clear the style state if we're not going to reuse the style from recalcStyle.
         if (!context.resolvedStyle)
             data->resetStyleState();
 
-        if (RuntimeEnabledFeatures::webAnimationsCSSEnabled() && !context.performingReattach) {
+        if (RuntimeEnabledFeatures::webAnimationsCSSEnabled() && !context.reconstructingRenderTree) {
             if (ActiveAnimations* activeAnimations = data->activeAnimations())
                 activeAnimations->cssAnimations()->cancel();
         }
     }
     if (ElementShadow* shadow = this->shadow())
-        shadow->detach(context);
-    ContainerNode::detach(context);
+        shadow->destroyRenderTree(context);
+    ContainerNode::destroyRenderTree(context);
 }
 
 bool Element::pseudoStyleCacheIsInvalid(const RenderStyle* currentStyle, RenderStyle* newStyle)
 {
     ASSERT(currentStyle == renderStyle());
     ASSERT(renderer());
 
     if (!currentStyle)
         return false;
 
@@ skipping 77 matching lines @@
     ASSERT(document().inStyleRecalc());
 
     CSSAnimationUpdateScope cssAnimationUpdateScope(this);
     RefPtr<RenderStyle> oldStyle = renderStyle();
     RefPtr<RenderStyle> newStyle = styleForRenderer();
     StyleRecalcChange localChange = RenderStyle::compare(oldStyle.get(), newStyle.get());
 
     if (localChange == Reattach) {
         AttachContext reattachContext;
         reattachContext.resolvedStyle = newStyle.get();
-        reattach(reattachContext);
+        recreateRenderTree(reattachContext);
         return Reattach;
     }
 
     InspectorInstrumentation::didRecalculateStyleForElement(this);
 
     if (RenderObject* renderer = this->renderer()) {
         if (localChange != NoChange || pseudoStyleCacheIsInvalid(oldStyle.get(), newStyle.get()) || (change == Force && renderer->requiresForcedStyleRecalcPropagation()) || shouldNotifyRendererWithIdenticalStyles()) {
             renderer->setAnimatableStyle(newStyle.get());
         } else if (needsStyleRecalc()) {
             // Although no change occurred, we use the new style so that the cousin style sharing code won't get
@@ skipping 41 matching lines @@
     bool forceCheckOfAnyElementSibling = false;
     bool forceReattachOfAnyWhitespaceSibling = false;
     for (Node* child = firstChild(); child; child = child->nextSibling()) {
         bool didReattach = false;
 
         if (child->renderer())
             forceReattachOfAnyWhitespaceSibling = false;
 
         if (child->isTextNode()) {
             if (forceReattachOfAnyWhitespaceSibling && toText(child)->containsOnlyWhitespace())
-                child->reattach();
+                child->recreateRenderTree();
             else
                 didReattach = toText(child)->recalcTextStyle(change);
         } else if (child->isElementNode()) {
             Element* element = toElement(child);
 
             bool childRulesChanged = element->needsStyleRecalc() && element->styleChangeType() >= SubtreeStyleChange;
 
             if (forceCheckOfNextElementSibling || forceCheckOfAnyElementSibling)
                 element->setNeedsStyleRecalc();
 
@@ skipping 919 matching lines @@
     return true;
 }
 
 void Element::createPseudoElement(PseudoId pseudoId)
 {
     ASSERT(needsPseudoElement(pseudoId));
     ASSERT(!isPseudoElement());
     RefPtr<PseudoElement> element = PseudoElement::create(this, pseudoId);
     if (pseudoId == BACKDROP)
         document().addToTopLayer(element.get(), this);
-    element->attach();
+    element->createRenderTree();
 
     ensureElementRareData()->setPseudoElement(pseudoId, element.release());
 }
 
 PseudoElement* Element::pseudoElement(PseudoId pseudoId) const
 {
     return hasRareData() ? elementRareData()->pseudoElement(pseudoId) : 0;
 }
 
 RenderObject* Element::pseudoElementRenderer(PseudoId pseudoId) const
@@ skipping 128 matching lines @@
 }
 
 void Element::setIsInTopLayer(bool inTopLayer)
 {
     if (isInTopLayer() == inTopLayer)
         return;
     ensureElementRareData()->setIsInTopLayer(inTopLayer);
 
     // We must ensure a reattach occurs so the renderer is inserted in the correct sibling order under RenderView according to its
     // top layer position, or in its usual place if not in the top layer.
-    lazyReattachIfAttached();
+    scheduleRenderTreeRecreationIfAttached();
 }
 
 void Element::webkitRequestPointerLock()
 {
     if (document().page())
         document().page()->pointerLockController().requestPointerLock(this);
 }
 
 SpellcheckAttributeState Element::spellcheckAttributeState() const
 {
@@ skipping 993 matching lines @@
     return 0;
 }
 
 Attribute* UniqueElementData::attributeItem(unsigned index)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(index < length());
     return &m_attributeVector.at(index);
 }
 
 } // namespace WebCore