Changeset 154903 in webkit


Ignore:
Timestamp:
Aug 30, 2013 11:43:29 AM (11 years ago)
Author:
Antti Koivisto
Message:

Use Element& in StyleResolveTree
​https://bugs.webkit.org/show_bug.cgi?id=120540

Reviewed by Andreas Kling.

  • dom/ContainerNode.cpp:

(WebCore::attachChild):
(WebCore::detachChild):

  • dom/Document.cpp:

(WebCore::Document::recalcStyle):
(WebCore::Document::createRenderTree):
(WebCore::Document::detach):

  • dom/Element.cpp:

(WebCore::Element::lazyReattach):
(WebCore::Element::updateExistingPseudoElement):
(WebCore::Element::createPseudoElementIfNeeded):
(WebCore::disconnectPseudoElement):

  • dom/ShadowRoot.cpp:

(WebCore::ShadowRoot::setResetStyleInheritance):

  • html/HTMLDetailsElement.cpp:

(WebCore::HTMLDetailsElement::parseAttribute):

  • html/HTMLInputElement.cpp:

(WebCore::HTMLInputElement::updateType):
(WebCore::HTMLInputElement::parseAttribute):

  • html/HTMLObjectElement.cpp:

(WebCore::HTMLObjectElement::renderFallbackContent):

  • html/HTMLPlugInImageElement.cpp:

(WebCore::HTMLPlugInImageElement::willRecalcStyle):
(WebCore::HTMLPlugInImageElement::documentWillSuspendForPageCache):
(WebCore::HTMLPlugInImageElement::documentDidResumeFromPageCache):
(WebCore::HTMLPlugInImageElement::restartSnapshottedPlugIn):

  • html/HTMLSelectElement.cpp:

(WebCore::HTMLSelectElement::parseAttribute):
(WebCore::HTMLSelectElement::parseMultipleAttribute):

  • html/HTMLViewSourceDocument.cpp:

(WebCore::HTMLViewSourceDocument::createContainingTable):
(WebCore::HTMLViewSourceDocument::addSpanWithClassName):
(WebCore::HTMLViewSourceDocument::addLine):
(WebCore::HTMLViewSourceDocument::finishLine):
(WebCore::HTMLViewSourceDocument::addBase):
(WebCore::HTMLViewSourceDocument::addLink):

  • html/parser/HTMLConstructionSite.cpp:

(WebCore::executeTask):

  • html/parser/HTMLTreeBuilder.cpp:

(WebCore::HTMLTreeBuilder::callTheAdoptionAgency):

  • html/shadow/InsertionPoint.cpp:

(WebCore::InsertionPoint::willAttachRenderers):
(WebCore::InsertionPoint::willDetachRenderers):

  • loader/PlaceholderDocument.cpp:

(WebCore::PlaceholderDocument::createRenderTree):

  • style/StyleResolveTree.cpp:

(WebCore::Style::attachChildren):
(WebCore::Style::attachRenderTree):
(WebCore::Style::detachChildren):
(WebCore::Style::detachRenderTree):
(WebCore::Style::resolveLocal):
(WebCore::Style::updateTextStyle):
(WebCore::Style::resolveShadowTree):
(WebCore::Style::resolveTree):

Documents only ever have one child element. Remove the loop.

(WebCore::Style::detachRenderTreeInReattachMode):
(WebCore::Style::reattachRenderTree):

  • style/StyleResolveTree.h:
  • svg/SVGTests.cpp:

(WebCore::SVGTests::handleAttributeChange):

  • xml/XMLErrors.cpp:

(WebCore::XMLErrors::insertErrorMessageBlock):

  • xml/parser/XMLDocumentParserLibxml2.cpp:

(WebCore::XMLDocumentParser::startElementNs):

Location:
trunk/Source/WebCore
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r154901 r154903  
     12013-08-30  Antti Koivisto  <antti@apple.com>
     2
     3        Use Element& in StyleResolveTree
     4        https://bugs.webkit.org/show_bug.cgi?id=120540
     5
     6        Reviewed by Andreas Kling.
     7
     8        * dom/ContainerNode.cpp:
     9        (WebCore::attachChild):
     10        (WebCore::detachChild):
     11        * dom/Document.cpp:
     12        (WebCore::Document::recalcStyle):
     13        (WebCore::Document::createRenderTree):
     14        (WebCore::Document::detach):
     15        * dom/Element.cpp:
     16        (WebCore::Element::lazyReattach):
     17        (WebCore::Element::updateExistingPseudoElement):
     18        (WebCore::Element::createPseudoElementIfNeeded):
     19        (WebCore::disconnectPseudoElement):
     20        * dom/ShadowRoot.cpp:
     21        (WebCore::ShadowRoot::setResetStyleInheritance):
     22        * html/HTMLDetailsElement.cpp:
     23        (WebCore::HTMLDetailsElement::parseAttribute):
     24        * html/HTMLInputElement.cpp:
     25        (WebCore::HTMLInputElement::updateType):
     26        (WebCore::HTMLInputElement::parseAttribute):
     27        * html/HTMLObjectElement.cpp:
     28        (WebCore::HTMLObjectElement::renderFallbackContent):
     29        * html/HTMLPlugInImageElement.cpp:
     30        (WebCore::HTMLPlugInImageElement::willRecalcStyle):
     31        (WebCore::HTMLPlugInImageElement::documentWillSuspendForPageCache):
     32        (WebCore::HTMLPlugInImageElement::documentDidResumeFromPageCache):
     33        (WebCore::HTMLPlugInImageElement::restartSnapshottedPlugIn):
     34        * html/HTMLSelectElement.cpp:
     35        (WebCore::HTMLSelectElement::parseAttribute):
     36        (WebCore::HTMLSelectElement::parseMultipleAttribute):
     37        * html/HTMLViewSourceDocument.cpp:
     38        (WebCore::HTMLViewSourceDocument::createContainingTable):
     39        (WebCore::HTMLViewSourceDocument::addSpanWithClassName):
     40        (WebCore::HTMLViewSourceDocument::addLine):
     41        (WebCore::HTMLViewSourceDocument::finishLine):
     42        (WebCore::HTMLViewSourceDocument::addBase):
     43        (WebCore::HTMLViewSourceDocument::addLink):
     44        * html/parser/HTMLConstructionSite.cpp:
     45        (WebCore::executeTask):
     46        * html/parser/HTMLTreeBuilder.cpp:
     47        (WebCore::HTMLTreeBuilder::callTheAdoptionAgency):
     48        * html/shadow/InsertionPoint.cpp:
     49        (WebCore::InsertionPoint::willAttachRenderers):
     50        (WebCore::InsertionPoint::willDetachRenderers):
     51        * loader/PlaceholderDocument.cpp:
     52        (WebCore::PlaceholderDocument::createRenderTree):
     53        * style/StyleResolveTree.cpp:
     54        (WebCore::Style::attachChildren):
     55        (WebCore::Style::attachRenderTree):
     56        (WebCore::Style::detachChildren):
     57        (WebCore::Style::detachRenderTree):
     58        (WebCore::Style::resolveLocal):
     59        (WebCore::Style::updateTextStyle):
     60        (WebCore::Style::resolveShadowTree):
     61        (WebCore::Style::resolveTree):
     62       
     63            Documents only ever have one child element. Remove the loop.
     64
     65        (WebCore::Style::detachRenderTreeInReattachMode):
     66        (WebCore::Style::reattachRenderTree):
     67        * style/StyleResolveTree.h:
     68        * svg/SVGTests.cpp:
     69        (WebCore::SVGTests::handleAttributeChange):
     70        * xml/XMLErrors.cpp:
     71        (WebCore::XMLErrors::insertErrorMessageBlock):
     72        * xml/parser/XMLDocumentParserLibxml2.cpp:
     73        (WebCore::XMLDocumentParser::startElementNs):
     74
    1752013-08-30  Andreas Kling  <akling@apple.com>
    276

  • trunk/Source/WebCore/dom/ContainerNode.cpp

    r154877 r154903  
    109109{
    110110    if (child->isElementNode())
    111         Style::attachRenderTree(toElement(child));
     111        Style::attachRenderTree(*toElement(child));
    112112    else if (child->isTextNode())
    113113        Style::attachTextRenderer(*toText(child));
    … …  
    117117{
    118118    if (child->isElementNode())
    119         Style::detachRenderTree(toElement(child));
     119        Style::detachRenderTree(*toElement(child));
    120120    else if (child->isTextNode())
    121121        Style::detachTextRenderer(*toText(child));

  • trunk/Source/WebCore/dom/Document.cpp

    r154901 r154903  
    19921992
    19931993    if (m_documentElement)
    1994         Style::attachRenderTree(m_documentElement.get());
     1994        Style::attachRenderTree(*m_documentElement);
    19951995
    19961996    setAttached(true);
    … …  
    20922092
    20932093    if (m_documentElement)
    2094         Style::detachRenderTree(m_documentElement.get());
     2094        Style::detachRenderTree(*m_documentElement);
    20952095
    20962096    clearChildNeedsStyleRecalc();

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

    r154881 r154903  
    13701370{
    13711371    if (attached())
    1372         Style::detachRenderTreeInReattachMode(this);
     1372        Style::detachRenderTreeInReattachMode(*this);
    13731373    lazyAttach(shouldSetAttached);
    13741374}
    … …  
    23012301    // PseudoElement styles hang off their parent element's style so if we needed
    23022302    // a style recalc we should Force one on the pseudo.
    2303     Style::resolveTree(existingPseudoElement, needsStyleRecalc() ? Style::Force : change);
     2303    Style::resolveTree(*existingPseudoElement, needsStyleRecalc() ? Style::Force : change);
    23042304
    23052305    // FIXME: This is silly.
    … …  
    23222322        return 0;
    23232323    RefPtr<PseudoElement> pseudoElement = PseudoElement::create(this, pseudoId);
    2324     Style::attachRenderTree(pseudoElement.get());
     2324    Style::attachRenderTree(*pseudoElement);
    23252325    return pseudoElement.release();
    23262326}
    … …  
    23752375        return;
    23762376    if (pseudoElement->attached())
    2377         Style::detachRenderTree(pseudoElement);
     2377        Style::detachRenderTree(*pseudoElement);
    23782378    ASSERT(pseudoElement->hostElement());
    23792379    pseudoElement->clearHostElement();

  • trunk/Source/WebCore/dom/ShadowRoot.cpp

    r154257 r154903  
    145145        m_resetStyleInheritance = value;
    146146        if (attached() && hostElement())
    147             Style::resolveTree(hostElement(), Style::Force);
     147            Style::resolveTree(*hostElement(), Style::Force);
    148148    }
    149149}

  • trunk/Source/WebCore/html/HTMLDetailsElement.cpp

    r154877 r154903  
    139139        m_isOpen = !value.isNull();
    140140        if (oldValue != m_isOpen && attached())
    141             Style::reattachRenderTree(this);
     141            Style::reattachRenderTree(*this);
    142142    } else
    143143        HTMLElement::parseAttribute(name, value);

  • trunk/Source/WebCore/html/HTMLInputElement.cpp

    r154877 r154903  
    480480    bool wasAttached = attached();
    481481    if (wasAttached)
    482         Style::detachRenderTree(this);
     482        Style::detachRenderTree(*this);
    483483
    484484    m_inputType = newType.release();
    … …  
    531531
    532532    if (wasAttached) {
    533         Style::attachRenderTree(this);
     533        Style::attachRenderTree(*this);
    534534        if (document().focusedElement() == this)
    535535            updateFocusAppearance(true);
    … …  
    696696        // time to relayout for this change.
    697697        if (m_maxResults != oldResults && (m_maxResults <= 0 || oldResults <= 0) && attached())
    698             Style::reattachRenderTree(this);
     698            Style::reattachRenderTree(*this);
    699699        setNeedsStyleRecalc();
    700700        FeatureObserver::observe(&document(), FeatureObserver::ResultsAttribute);

  • trunk/Source/WebCore/html/HTMLObjectElement.cpp

    r154877 r154903  
    379379            // If we don't think we have an image type anymore, then clear the image from the loader.
    380380            m_imageLoader->setImage(0);
    381             Style::reattachRenderTree(this);
     381            Style::reattachRenderTree(*this);
    382382            return;
    383383        }
    … …  
    387387
    388388    // FIXME: Style gets recalculated which is suboptimal.
    389     Style::reattachRenderTree(this);
     389    Style::reattachRenderTree(*this);
    390390}
    391391

  • trunk/Source/WebCore/html/HTMLPlugInImageElement.cpp

    r154877 r154903  
    227227    // FIXME: Why is this necessary?  Manual re-attach is almost always wrong.
    228228    if (!useFallbackContent() && needsWidgetUpdate() && renderer() && !isImageType() && (displayState() != DisplayingSnapshot))
    229         Style::reattachRenderTree(this);
     229        Style::reattachRenderTree(*this);
    230230    return true;
    231231}
    … …  
    298298        m_customStyleForPageCache = RenderStyle::clone(renderStyle);
    299299        m_customStyleForPageCache->setDisplay(NONE);
    300         Style::resolveTree(this, Style::Force);
     300        Style::resolveTree(*this, Style::Force);
    301301    }
    302302
    … …  
    308308    if (m_customStyleForPageCache) {
    309309        m_customStyleForPageCache = 0;
    310         Style::resolveTree(this, Style::Force);
     310        Style::resolveTree(*this, Style::Force);
    311311    }
    312312
    … …  
    516516
    517517    setDisplayState(Restarting);
    518     Style::reattachRenderTree(this);
     518    Style::reattachRenderTree(*this);
    519519}
    520520

  • trunk/Source/WebCore/html/HTMLSelectElement.cpp

    r154877 r154903  
    307307        setNeedsValidityCheck();
    308308        if (m_size != oldSize && attached()) {
    309             Style::reattachRenderTree(this);
     309            Style::reattachRenderTree(*this);
    310310            setRecalcListItems();
    311311        }
    … …  
    10121012    setNeedsValidityCheck();
    10131013    if (oldUsesMenuList != usesMenuList() && attached())
    1014         Style::reattachRenderTree(this);
     1014        Style::reattachRenderTree(*this);
    10151015}
    10161016

  • trunk/Source/WebCore/html/HTMLViewSourceDocument.cpp

    r154738 r154903  
    8787    m_current = m_tbody;
    8888
    89     Style::attachRenderTree(html.get());
     89    Style::attachRenderTree(*html);
    9090}
    9191
    … …  
    185185    span->setAttribute(classAttr, className);
    186186    m_current->parserAppendChild(span);
    187     Style::attachRenderTree(span.get());
     187    Style::attachRenderTree(*span);
    188188    return span.release();
    189189}
    … …  
    194194    RefPtr<HTMLTableRowElement> trow = HTMLTableRowElement::create(this);
    195195    m_tbody->parserAppendChild(trow);
    196     Style::reattachRenderTree(trow.get());
     196    Style::reattachRenderTree(*trow);
    197197
    198198    // Create a cell that will hold the line number (it is generated in the stylesheet using counters).
    … …  
    200200    td->setAttribute(classAttr, "webkit-line-number");
    201201    trow->parserAppendChild(td);
    202     Style::attachRenderTree(td.get());
     202    Style::attachRenderTree(*td);
    203203
    204204    // Create a second cell for the line contents
    … …  
    206206    td->setAttribute(classAttr, "webkit-line-content");
    207207    trow->parserAppendChild(td);
    208     Style::attachRenderTree(td.get());
     208    Style::attachRenderTree(*td);
    209209    m_current = m_td = td;
    210210
    … …  
    228228        RefPtr<HTMLBRElement> br = HTMLBRElement::create(this);
    229229        m_current->parserAppendChild(br);
    230         Style::attachRenderTree(br.get());
     230        Style::attachRenderTree(*br);
    231231    }
    232232    m_current = m_tbody;
    … …  
    284284    base->setAttribute(hrefAttr, href);
    285285    m_current->parserAppendChild(base);
    286     Style::attachRenderTree(base.get());
     286    Style::attachRenderTree(*base);
    287287    return base.release();
    288288}
    … …  
    304304    anchor->setAttribute(hrefAttr, url);
    305305    m_current->parserAppendChild(anchor);
    306     Style::attachRenderTree(anchor.get());
     306    Style::attachRenderTree(*anchor);
    307307    return anchor.release();
    308308}

  • trunk/Source/WebCore/html/parser/HTMLConstructionSite.cpp

    r154877 r154903  
    102102    if (task.child->parentNode() && task.parent->attached() && !task.child->attached()) {
    103103        if (task.child->isElementNode())
    104             Style::attachRenderTree(toElement(task.child.get()));
     104            Style::attachRenderTree(*toElement(task.child.get()));
    105105        else if (task.child->isTextNode())
    106106            Style::attachTextRenderer(*toText(task.child.get()));

  • trunk/Source/WebCore/html/parser/HTMLTreeBuilder.cpp

    r154801 r154903  
    16261626            // Notice that newItem->element() might already be attached if, for example, one of the reparented
    16271627            // children is a style element, which attaches itself automatically.
    1628             Style::attachRenderTree(newItem->element());
     1628            Style::attachRenderTree(*newItem->element());
    16291629        }
    16301630        // 14.

  • trunk/Source/WebCore/html/shadow/InsertionPoint.cpp

    r154738 r154903  
    6565        }
    6666        if (current->isElementNode())
    67             Style::attachRenderTree(toElement(current));
     67            Style::attachRenderTree(*toElement(current));
    6868    }
    6969}
    … …  
    8080        }
    8181        if (current->isElementNode())
    82             Style::detachRenderTree(toElement(current));
     82            Style::detachRenderTree(*toElement(current));
    8383    }
    8484}

  • trunk/Source/WebCore/loader/PlaceholderDocument.cpp

    r154573 r154903  
    2727#include "PlaceholderDocument.h"
    2828
    29 #include "ElementTraversal.h"
     29#include "ChildIterator.h"
    3030
    3131namespace WebCore {
    … …  
    3535    ASSERT(!attached());
    3636
    37     for (Element* child = ElementTraversal::firstWithin(this); child; child = ElementTraversal::nextSibling(child))
    38         Style::attachRenderTree(child);
     37    auto children = elementChildren(this);
     38    for (auto child = children.begin(), end = children.end(); child != end; ++child)
     39        Style::attachRenderTree(*child);
    3940
    4041    setAttached(true);

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

    r154901 r154903  
    2828
    2929#include "AXObjectCache.h"
     30#include "ChildIterator.h"
    3031#include "Element.h"
    3132#include "ElementRareData.h"
    … …  
    5758enum DetachType { NormalDetach, ReattachDetach };
    5859
    59 static void attachRenderTree(Element*, RenderStyle* resolvedStyle);
    60 static void detachRenderTree(Element*, DetachType);
     60static void attachRenderTree(Element&, RenderStyle* resolvedStyle);
     61static void detachRenderTree(Element&, DetachType);
    6162
    6263Change determineChange(const RenderStyle* s1, const RenderStyle* s2, Settings* settings)
    … …  
    448449        }
    449450        if (child->isElementNode())
    450             attachRenderTree(toElement(child), nullptr);
     451            attachRenderTree(*toElement(child), nullptr);
    451452    }
    452453}
    … …  
    467468}
    468469
    469 static void attachRenderTree(Element* current, RenderStyle* resolvedStyle)
    470 {
    471     PostAttachCallbackDisabler callbackDisabler(current);
     470static void attachRenderTree(Element& current, RenderStyle* resolvedStyle)
     471{
     472    PostAttachCallbackDisabler callbackDisabler(&current);
    472473    WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
    473474
    474     if (current->hasCustomStyleResolveCallbacks())
    475         current->willAttachRenderers();
    476 
    477     createRendererIfNeeded(*current, resolvedStyle);
    478 
    479     if (current->parentElement() && current->parentElement()->isInCanvasSubtree())
    480         current->setIsInCanvasSubtree(true);
    481 
    482     current->updateBeforePseudoElement(NoChange);
    483 
    484     StyleResolverParentPusher parentPusher(current);
     475    if (current.hasCustomStyleResolveCallbacks())
     476        current.willAttachRenderers();
     477
     478    createRendererIfNeeded(current, resolvedStyle);
     479
     480    if (current.parentElement() && current.parentElement()->isInCanvasSubtree())
     481        current.setIsInCanvasSubtree(true);
     482
     483    current.updateBeforePseudoElement(NoChange);
     484
     485    StyleResolverParentPusher parentPusher(&current);
    485486
    486487    // When a shadow root exists, it does the work of attaching the children.
    487     if (ShadowRoot* shadowRoot = current->shadowRoot()) {
     488    if (ShadowRoot* shadowRoot = current.shadowRoot()) {
    488489        parentPusher.push();
    489490        attachShadowRoot(*shadowRoot);
    490     } else if (current->firstChild())
     491    } else if (current.firstChild())
    491492        parentPusher.push();
    492493
    493     attachChildren(*current);
    494 
    495     Node* sibling = current->nextSibling();
    496     if (current->renderer() && sibling && !sibling->renderer() && sibling->attached())
     494    attachChildren(current);
     495
     496    Node* sibling = current.nextSibling();
     497    if (current.renderer() && sibling && !sibling->renderer() && sibling->attached())
    497498        createTextRenderersForSiblingsAfterAttachIfNeeded(sibling);
    498499
    499     current->setAttached(true);
    500     current->clearNeedsStyleRecalc();
    501 
    502     if (AXObjectCache* cache = current->document().axObjectCache())
    503         cache->updateCacheAfterNodeIsAttached(current);
    504 
    505     current->updateAfterPseudoElement(NoChange);
    506 
    507     current->updateFocusAppearanceAfterAttachIfNeeded();
     500    current.setAttached(true);
     501    current.clearNeedsStyleRecalc();
     502
     503    if (AXObjectCache* cache = current.document().axObjectCache())
     504        cache->updateCacheAfterNodeIsAttached(&current);
     505
     506    current.updateAfterPseudoElement(NoChange);
     507
     508    current.updateFocusAppearanceAfterAttachIfNeeded();
    508509   
    509     if (current->hasCustomStyleResolveCallbacks())
    510         current->didAttachRenderers();
     510    if (current.hasCustomStyleResolveCallbacks())
     511        current.didAttachRenderers();
    511512}
    512513
    … …  
    519520        }
    520521        if (child->isElementNode())
    521             detachRenderTree(toElement(child), detachType);
     522            detachRenderTree(*toElement(child), detachType);
    522523    }
    523524    current.clearChildNeedsStyleRecalc();
    … …  
    533534}
    534535
    535 static void detachRenderTree(Element* current, DetachType detachType)
     536static void detachRenderTree(Element& current, DetachType detachType)
    536537{
    537538    WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
    538539
    539     if (current->hasCustomStyleResolveCallbacks())
    540         current->willDetachRenderers();
    541 
    542     current->clearStyleDerivedDataBeforeDetachingRenderer();
     540    if (current.hasCustomStyleResolveCallbacks())
     541        current.willDetachRenderers();
     542
     543    current.clearStyleDerivedDataBeforeDetachingRenderer();
    543544
    544545    // Do not remove the element's hovered and active status
    545546    // if performing a reattach.
    546547    if (detachType != ReattachDetach)
    547         current->clearHoverAndActiveStatusBeforeDetachingRenderer();
    548 
    549     if (ShadowRoot* shadowRoot = current->shadowRoot())
     548        current.clearHoverAndActiveStatusBeforeDetachingRenderer();
     549
     550    if (ShadowRoot* shadowRoot = current.shadowRoot())
    550551        detachShadowRoot(*shadowRoot, detachType);
    551552
    552     detachChildren(*current, detachType);
    553 
    554     if (current->renderer())
    555         current->renderer()->destroyAndCleanupAnonymousWrappers();
    556     current->setRenderer(0);
    557 
    558     current->setAttached(false);
    559 
    560     if (current->hasCustomStyleResolveCallbacks())
    561         current->didDetachRenderers();
     553    detachChildren(current, detachType);
     554
     555    if (current.renderer())
     556        current.renderer()->destroyAndCleanupAnonymousWrappers();
     557    current.setRenderer(0);
     558
     559    current.setAttached(false);
     560
     561    if (current.hasCustomStyleResolveCallbacks())
     562        current.didDetachRenderers();
    562563}
    563564
    … …  
    596597}
    597598
    598 static Change resolveLocal(Element* current, Change inheritedChange)
     599static Change resolveLocal(Element& current, Change inheritedChange)
    599600{
    600601    Change localChange = Detach;
    601602    RefPtr<RenderStyle> newStyle;
    602     RefPtr<RenderStyle> currentStyle = current->renderStyle();
    603 
    604     Document& document = current->document();
     603    RefPtr<RenderStyle> currentStyle = current.renderStyle();
     604
     605    Document& document = current.document();
    605606    if (currentStyle) {
    606         newStyle = current->styleForRenderer();
     607        newStyle = current.styleForRenderer();
    607608        localChange = determineChange(currentStyle.get(), newStyle.get(), document.settings());
    608609    }
    609610    if (localChange == Detach) {
    610         if (current->attached())
     611        if (current.attached())
    611612            detachRenderTree(current, ReattachDetach);
    612613        attachRenderTree(current, newStyle.get());
    … …  
    614615    }
    615616
    616     if (RenderObject* renderer = current->renderer()) {
    617         if (localChange != NoChange || pseudoStyleCacheIsInvalid(renderer, newStyle.get()) || (inheritedChange == Force && renderer->requiresForcedStyleRecalcPropagation()) || current->styleChangeType() == SyntheticStyleChange)
     617    if (RenderObject* renderer = current.renderer()) {
     618        if (localChange != NoChange || pseudoStyleCacheIsInvalid(renderer, newStyle.get()) || (inheritedChange == Force && renderer->requiresForcedStyleRecalcPropagation()) || current.styleChangeType() == SyntheticStyleChange)
    618619            renderer->setAnimatableStyle(newStyle.get());
    619         else if (current->needsStyleRecalc()) {
     620        else if (current.needsStyleRecalc()) {
    620621            // Although no change occurred, we use the new style so that the cousin style sharing code won't get
    621622            // fooled into believing this style is the same.
    … …  
    626627    // If "rem" units are used anywhere in the document, and if the document element's font size changes, then go ahead and force font updating
    627628    // all the way down the tree. This is simpler than having to maintain a cache of objects (and such font size changes should be rare anyway).
    628     if (document.styleSheetCollection()->usesRemUnits() && document.documentElement() == current && localChange != NoChange && currentStyle && newStyle && currentStyle->fontSize() != newStyle->fontSize()) {
     629    if (document.styleSheetCollection()->usesRemUnits() && document.documentElement() == &current && localChange != NoChange && currentStyle && newStyle && currentStyle->fontSize() != newStyle->fontSize()) {
    629630        // Cached RenderStyles may depend on the re units.
    630631        if (StyleResolver* styleResolver = document.styleResolverIfExists())
    … …  
    634635    if (inheritedChange == Force)
    635636        return Force;
    636     if (current->styleChangeType() >= FullStyleChange)
     637    if (current.styleChangeType() >= FullStyleChange)
    637638        return Force;
    638639
    … …  
    640641}
    641642
    642 static void updateTextStyle(Text* text, RenderStyle* parentElementStyle, Style::Change change)
    643 {
    644     RenderText* renderer = toRenderText(text->renderer());
     643static void updateTextStyle(Text& text, RenderStyle* parentElementStyle, Style::Change change)
     644{
     645    RenderText* renderer = toRenderText(text.renderer());
    645646
    646647    if (change != Style::NoChange && renderer)
    647648        renderer->setStyle(parentElementStyle);
    648649
    649     if (!text->needsStyleRecalc())
     650    if (!text.needsStyleRecalc())
    650651        return;
    651652    if (renderer)
    652         renderer->setText(text->dataImpl());
     653        renderer->setText(text.dataImpl());
    653654    else
    654         attachTextRenderer(*text);
    655     text->clearNeedsStyleRecalc();
     655        attachTextRenderer(text);
     656    text.clearNeedsStyleRecalc();
    656657}
    657658
    … …  
    666667        if (child->isTextNode()) {
    667668            // Current user agent ShadowRoots don't have immediate text children so this branch is never actually taken.
    668             updateTextStyle(toText(child), parentElementStyle, change);
     669            updateTextStyle(*toText(child), parentElementStyle, change);
    669670            continue;
    670671        }
    671         resolveTree(toElement(child), change);
     672        resolveTree(*toElement(child), change);
    672673    }
    673674
    … …  
    731732#endif // PLATFORM(IOS)
    732733
    733 void resolveTree(Element* current, Change change)
     734void resolveTree(Element& current, Change change)
    734735{
    735736    ASSERT(change != Detach);
    736737
    737     if (current->hasCustomStyleResolveCallbacks()) {
    738         if (!current->willRecalcStyle(change))
     738    if (current.hasCustomStyleResolveCallbacks()) {
     739        if (!current.willRecalcStyle(change))
    739740            return;
    740741    }
    741742
    742     ContainerNode* renderingParentNode = NodeRenderingTraversal::parent(current);
     743    ContainerNode* renderingParentNode = NodeRenderingTraversal::parent(&current);
    743744    bool hasParentStyle = renderingParentNode && renderingParentNode->renderStyle();
    744     bool hasDirectAdjacentRules = current->childrenAffectedByDirectAdjacentRules();
    745     bool hasIndirectAdjacentRules = current->childrenAffectedByForwardPositionalRules();
     745    bool hasDirectAdjacentRules = current.childrenAffectedByDirectAdjacentRules();
     746    bool hasIndirectAdjacentRules = current.childrenAffectedByForwardPositionalRules();
    746747
    747748#if PLATFORM(IOS)
    … …  
    749750#endif
    750751
    751     if (change > NoChange || current->needsStyleRecalc())
    752         current->resetComputedStyle();
    753 
    754     if (hasParentStyle && (change >= Inherit || current->needsStyleRecalc()))
     752    if (change > NoChange || current.needsStyleRecalc())
     753        current.resetComputedStyle();
     754
     755    if (hasParentStyle && (change >= Inherit || current.needsStyleRecalc()))
    755756        change = resolveLocal(current, change);
    756757
    757758    if (change != Detach) {
    758         StyleResolverParentPusher parentPusher(current);
    759 
    760         RenderStyle* currentStyle = current->renderStyle();
    761 
    762         if (ShadowRoot* shadowRoot = current->shadowRoot()) {
     759        StyleResolverParentPusher parentPusher(&current);
     760
     761        RenderStyle* currentStyle = current.renderStyle();
     762
     763        if (ShadowRoot* shadowRoot = current.shadowRoot()) {
    763764            if (change >= Inherit || shadowRoot->childNeedsStyleRecalc() || shadowRoot->needsStyleRecalc()) {
    764765                parentPusher.push();
    … …  
    767768        }
    768769
    769         current->updateBeforePseudoElement(change);
     770        current.updateBeforePseudoElement(change);
    770771
    771772        // FIXME: This check is good enough for :hover + foo, but it is not good enough for :hover + foo + bar.
    … …  
    774775        bool forceCheckOfNextElementSibling = false;
    775776        bool forceCheckOfAnyElementSibling = false;
    776         for (Node* child = current->firstChild(); child; child = child->nextSibling()) {
     777        for (Node* child = current.firstChild(); child; child = child->nextSibling()) {
    777778            if (child->isTextNode()) {
    778                 updateTextStyle(toText(child), currentStyle, change);
     779                updateTextStyle(*toText(child), currentStyle, change);
    779780                continue;
    780781            }
    … …  
    787788            if (change >= Inherit || childElement->childNeedsStyleRecalc() || childElement->needsStyleRecalc()) {
    788789                parentPusher.push();
    789                 resolveTree(childElement, change);
     790                resolveTree(*childElement, change);
    790791            }
    791792            forceCheckOfNextElementSibling = childRulesChanged && hasDirectAdjacentRules;
    … …  
    793794        }
    794795
    795         current->updateAfterPseudoElement(change);
    796     }
    797 
    798     current->clearNeedsStyleRecalc();
    799     current->clearChildNeedsStyleRecalc();
     796        current.updateAfterPseudoElement(change);
     797    }
     798
     799    current.clearNeedsStyleRecalc();
     800    current.clearChildNeedsStyleRecalc();
    800801   
    801     if (current->hasCustomStyleResolveCallbacks())
    802         current->didRecalcStyle(change);
     802    if (current.hasCustomStyleResolveCallbacks())
     803        current.didRecalcStyle(change);
    803804}
    804805
    … …  
    824825    }
    825826
    826     for (Element* child = ElementTraversal::firstWithin(&document); child; child = ElementTraversal::nextSibling(child)) {
    827         if (change < Inherit && !child->childNeedsStyleRecalc() && !child->needsStyleRecalc())
    828             continue;
    829         resolveTree(child, change);
    830     }
    831 }
    832 
    833 void attachRenderTree(Element* element)
     827    Element* documentElement = document.documentElement();
     828    if (!documentElement)
     829        return;
     830    if (change < Inherit && !documentElement->childNeedsStyleRecalc() && !documentElement->needsStyleRecalc())
     831        return;
     832    resolveTree(*documentElement, change);
     833}
     834
     835void attachRenderTree(Element& element)
    834836{
    835837    attachRenderTree(element, nullptr);
    836838}
    837839
    838 void detachRenderTree(Element* element)
     840void detachRenderTree(Element& element)
    839841{
    840842    detachRenderTree(element, NormalDetach);
    841843}
    842844
    843 void detachRenderTreeInReattachMode(Element* element)
     845void detachRenderTreeInReattachMode(Element& element)
    844846{
    845847    detachRenderTree(element, ReattachDetach);
    846848}
    847849
    848 void reattachRenderTree(Element* current)
    849 {
    850     if (current->attached())
     850void reattachRenderTree(Element& current)
     851{
     852    if (current.attached())
    851853        detachRenderTree(current, ReattachDetach);
    852854    attachRenderTree(current, nullptr);

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

    r154901 r154903  
    3939enum Change { NoChange, NoInherit, Inherit, Detach, Force };
    4040
    41 void resolveTree(Element*, Change);
     41void resolveTree(Element&, Change);
    4242void resolveTree(Document&, Change);
    4343
    44 void attachRenderTree(Element*);
    45 void detachRenderTree(Element*);
    46 void reattachRenderTree(Element*);
     44void attachRenderTree(Element&);
     45void detachRenderTree(Element&);
     46void reattachRenderTree(Element&);
    4747// FIXME: This is only used for "lazy reattach" for shadow trees.
    48 void detachRenderTreeInReattachMode(Element*);
     48void detachRenderTreeInReattachMode(Element&);
    4949
    5050void attachTextRenderer(Text&);

  • trunk/Source/WebCore/svg/SVGTests.cpp

    r154257 r154903  
    160160    bool attached = targetElement->attached();
    161161    if (valid && !attached && targetElement->parentNode()->attached())
    162         Style::attachRenderTree(targetElement);
     162        Style::attachRenderTree(*targetElement);
    163163    else if (!valid && attached)
    164         Style::detachRenderTree(targetElement);
     164        Style::detachRenderTree(*targetElement);
    165165
    166166    return true;

  • trunk/Source/WebCore/xml/XMLErrors.cpp

    r154323 r154903  
    129129        m_document->parserAppendChild(rootElement);
    130130        if (m_document->attached() && !rootElement->attached())
    131             Style::attachRenderTree(rootElement.get());
     131            Style::attachRenderTree(*rootElement);
    132132        documentElement = body.get();
    133133    }
    … …  
    140140        documentElement->parentNode()->parserRemoveChild(documentElement.get());
    141141        if (documentElement->attached())
    142             Style::detachRenderTree(documentElement.get());
     142            Style::detachRenderTree(*documentElement);
    143143
    144144        body->parserAppendChild(documentElement);
    … …  
    148148            // In general, rootElement shouldn't be attached right now, but it will be if there is a style element
    149149            // in the SVG content.
    150             Style::reattachRenderTree(rootElement.get());
     150            Style::reattachRenderTree(*rootElement);
    151151
    152152        documentElement = body.get();
    … …  
    175175
    176176    if (documentElement->attached() && !reportElement->attached())
    177         Style::attachRenderTree(reportElement.get());
     177        Style::attachRenderTree(*reportElement);
    178178
    179179    m_document->updateStyleIfNeeded();

  • trunk/Source/WebCore/xml/parser/XMLDocumentParserLibxml2.cpp

    r154877 r154903  
    863863
    864864    if (m_view && currentNode->attached() && !newElement->attached())
    865         Style::attachRenderTree(newElement.get());
     865        Style::attachRenderTree(*newElement);
    866866
    867867    if (newElement->hasTagName(HTMLNames::htmlTag))
Note: See TracChangeset for help on using the changeset viewer.