Changeset 154254 in webkit


Ignore:
Timestamp:
Aug 18, 2013 1:01:20 PM (11 years ago)
Author:
Antti Koivisto
Message:

<​https://webkit.org/b/119982> Make Element::attach non-virtual

Reviewed by Andreas Kling.

This will give us more future refactoring options.

  • dom/Element.cpp:

(WebCore::Element::attach):
(WebCore::Element::detach):

Make non-virtual. Call element type specific custom functions as needed.

(WebCore::Element::styleForRenderer):
(WebCore::Element::willRecalcStyle):
(WebCore::Element::didRecalcStyle):
(WebCore::Element::willAttachRenderers):
(WebCore::Element::didAttachRenderers):
(WebCore::Element::willDetachRenderers):
(WebCore::Element::didDetachRenderers):

Add virtual custom callbacks.

(WebCore::Element::customStyleForRenderer):

  • dom/Element.h:
  • dom/Node.h:

(WebCore::Node::pseudoId):
(WebCore::Node::hasCustomStyleResolveCallbacks):
(WebCore::Node::setHasCustomStyleResolveCallbacks):

Use the existing bit as it largely overlaps. Rename for clarity.

(WebCore::Node::customPseudoId):

  • dom/PseudoElement.cpp:

(WebCore::PseudoElement::PseudoElement):
(WebCore::PseudoElement::didAttachRenderers):

  • dom/PseudoElement.h:
  • html/HTMLCanvasElement.cpp:

(WebCore::HTMLCanvasElement::HTMLCanvasElement):
(WebCore::HTMLCanvasElement::willAttachRenderers):

  • html/HTMLCanvasElement.h:
  • html/HTMLFormControlElement.cpp:

(WebCore::HTMLFormControlElement::HTMLFormControlElement):
(WebCore::HTMLFormControlElement::didAttachRenderers):

  • html/HTMLFormControlElement.h:
  • html/HTMLFrameElement.cpp:

(WebCore::HTMLFrameElement::HTMLFrameElement):
(WebCore::HTMLFrameElement::didAttachRenderers):

  • html/HTMLFrameElement.h:
  • html/HTMLFrameElementBase.cpp:

(WebCore::HTMLFrameElementBase::HTMLFrameElementBase):
(WebCore::HTMLFrameElementBase::didAttachRenderers):

  • html/HTMLFrameElementBase.h:
  • html/HTMLFrameSetElement.cpp:

(WebCore::HTMLFrameSetElement::HTMLFrameSetElement):
(WebCore::HTMLFrameSetElement::willAttachRenderers):

  • html/HTMLFrameSetElement.h:
  • html/HTMLIFrameElement.cpp:

(WebCore::HTMLIFrameElement::HTMLIFrameElement):

  • html/HTMLImageElement.cpp:

(WebCore::HTMLImageElement::HTMLImageElement):
(WebCore::HTMLImageElement::didAttachRenderers):

  • html/HTMLImageElement.h:
  • html/HTMLInputElement.cpp:

(WebCore::HTMLInputElement::HTMLInputElement):
(WebCore::HTMLInputElement::willAttachRenderers):
(WebCore::HTMLInputElement::didAttachRenderers):
(WebCore::HTMLInputElement::didDetachRenderers):

  • html/HTMLInputElement.h:
  • html/HTMLLIElement.cpp:

(WebCore::HTMLLIElement::HTMLLIElement):
(WebCore::HTMLLIElement::didAttachRenderers):

  • html/HTMLLIElement.h:
  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::HTMLMediaElement):
(WebCore::HTMLMediaElement::willAttachRenderers):
(WebCore::HTMLMediaElement::didAttachRenderers):

  • html/HTMLMediaElement.h:
  • html/HTMLOptGroupElement.cpp:

(WebCore::HTMLOptGroupElement::HTMLOptGroupElement):
(WebCore::HTMLOptGroupElement::didAttachRenderers):
(WebCore::HTMLOptGroupElement::willDetachRenderers):

  • html/HTMLOptGroupElement.h:
  • html/HTMLOptionElement.cpp:

(WebCore::HTMLOptionElement::HTMLOptionElement):
(WebCore::HTMLOptionElement::didAttachRenderers):
(WebCore::HTMLOptionElement::willDetachRenderers):

  • html/HTMLOptionElement.h:
  • html/HTMLPlugInElement.cpp:

(WebCore::HTMLPlugInElement::HTMLPlugInElement):
(WebCore::HTMLPlugInElement::willDetachRenderers):

  • html/HTMLPlugInElement.h:
  • html/HTMLPlugInImageElement.cpp:

(WebCore::HTMLPlugInImageElement::HTMLPlugInImageElement):
(WebCore::HTMLPlugInImageElement::didAttachRenderers):
(WebCore::HTMLPlugInImageElement::willDetachRenderers):

  • html/HTMLPlugInImageElement.h:
  • html/HTMLProgressElement.cpp:

(WebCore::HTMLProgressElement::HTMLProgressElement):
(WebCore::HTMLProgressElement::didAttachRenderers):

  • html/HTMLProgressElement.h:
  • html/HTMLTextAreaElement.cpp:

(WebCore::HTMLTextAreaElement::HTMLTextAreaElement):
(WebCore::HTMLTextAreaElement::didAttachRenderers):

  • html/HTMLTextAreaElement.h:
  • html/HTMLVideoElement.cpp:

(WebCore::HTMLVideoElement::HTMLVideoElement):
(WebCore::HTMLVideoElement::didAttachRenderers):

  • html/HTMLVideoElement.h:
  • html/shadow/InsertionPoint.cpp:

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

  • html/shadow/InsertionPoint.h:
  • html/shadow/SliderThumbElement.cpp:

(WebCore::SliderThumbElement::SliderThumbElement):
(WebCore::SliderThumbElement::willDetachRenderers):

  • html/shadow/SliderThumbElement.h:
  • html/shadow/SpinButtonElement.cpp:

(WebCore::SpinButtonElement::SpinButtonElement):
(WebCore::SpinButtonElement::willDetachRenderers):

  • html/shadow/SpinButtonElement.h:
  • html/shadow/TextControlInnerElements.cpp:

(WebCore::TextControlInnerElement::TextControlInnerElement):
(WebCore::TextControlInnerTextElement::TextControlInnerTextElement):
(WebCore::SearchFieldCancelButtonElement::SearchFieldCancelButtonElement):
(WebCore::SearchFieldCancelButtonElement::willDetachRenderers):
(WebCore::InputFieldSpeechButtonElement::InputFieldSpeechButtonElement):
(WebCore::InputFieldSpeechButtonElement::willAttachRenderers):
(WebCore::InputFieldSpeechButtonElement::willDetachRenderers):

  • html/shadow/TextControlInnerElements.h:
  • style/StyleResolveTree.cpp:

(WebCore::Style::resolveTree):

  • svg/SVGElement.cpp:

(WebCore::SVGElement::SVGElement):

  • svg/SVGImageElement.cpp:

(WebCore::SVGImageElement::SVGImageElement):
(WebCore::SVGImageElement::didAttachRenderers):

  • svg/SVGImageElement.h:
  • svg/SVGUseElement.cpp:

(WebCore::SVGUseElement::SVGUseElement):

Location:
trunk/Source/WebCore
Files:
52 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r154253 r154254  
     12013-08-18  Antti Koivisto  <antti@apple.com>
     2
     3        <https://webkit.org/b/119982> Make Element::attach non-virtual
     4
     5        Reviewed by Andreas Kling.
     6
     7        This will give us more future refactoring options.
     8
     9        * dom/Element.cpp:
     10        (WebCore::Element::attach):
     11        (WebCore::Element::detach):
     12       
     13            Make non-virtual. Call element type specific custom functions as needed.
     14
     15        (WebCore::Element::styleForRenderer):
     16        (WebCore::Element::willRecalcStyle):
     17        (WebCore::Element::didRecalcStyle):
     18        (WebCore::Element::willAttachRenderers):
     19        (WebCore::Element::didAttachRenderers):
     20        (WebCore::Element::willDetachRenderers):
     21        (WebCore::Element::didDetachRenderers):
     22       
     23            Add virtual custom callbacks.
     24
     25        (WebCore::Element::customStyleForRenderer):
     26        * dom/Element.h:
     27        * dom/Node.h:
     28        (WebCore::Node::pseudoId):
     29        (WebCore::Node::hasCustomStyleResolveCallbacks):
     30        (WebCore::Node::setHasCustomStyleResolveCallbacks):
     31       
     32            Use the existing bit as it largely overlaps. Rename for clarity.
     33
     34        (WebCore::Node::customPseudoId):
     35        * dom/PseudoElement.cpp:
     36        (WebCore::PseudoElement::PseudoElement):
     37        (WebCore::PseudoElement::didAttachRenderers):
     38        * dom/PseudoElement.h:
     39        * html/HTMLCanvasElement.cpp:
     40        (WebCore::HTMLCanvasElement::HTMLCanvasElement):
     41        (WebCore::HTMLCanvasElement::willAttachRenderers):
     42        * html/HTMLCanvasElement.h:
     43        * html/HTMLFormControlElement.cpp:
     44        (WebCore::HTMLFormControlElement::HTMLFormControlElement):
     45        (WebCore::HTMLFormControlElement::didAttachRenderers):
     46        * html/HTMLFormControlElement.h:
     47        * html/HTMLFrameElement.cpp:
     48        (WebCore::HTMLFrameElement::HTMLFrameElement):
     49        (WebCore::HTMLFrameElement::didAttachRenderers):
     50        * html/HTMLFrameElement.h:
     51        * html/HTMLFrameElementBase.cpp:
     52        (WebCore::HTMLFrameElementBase::HTMLFrameElementBase):
     53        (WebCore::HTMLFrameElementBase::didAttachRenderers):
     54        * html/HTMLFrameElementBase.h:
     55        * html/HTMLFrameSetElement.cpp:
     56        (WebCore::HTMLFrameSetElement::HTMLFrameSetElement):
     57        (WebCore::HTMLFrameSetElement::willAttachRenderers):
     58        * html/HTMLFrameSetElement.h:
     59        * html/HTMLIFrameElement.cpp:
     60        (WebCore::HTMLIFrameElement::HTMLIFrameElement):
     61        * html/HTMLImageElement.cpp:
     62        (WebCore::HTMLImageElement::HTMLImageElement):
     63        (WebCore::HTMLImageElement::didAttachRenderers):
     64        * html/HTMLImageElement.h:
     65        * html/HTMLInputElement.cpp:
     66        (WebCore::HTMLInputElement::HTMLInputElement):
     67        (WebCore::HTMLInputElement::willAttachRenderers):
     68        (WebCore::HTMLInputElement::didAttachRenderers):
     69        (WebCore::HTMLInputElement::didDetachRenderers):
     70        * html/HTMLInputElement.h:
     71        * html/HTMLLIElement.cpp:
     72        (WebCore::HTMLLIElement::HTMLLIElement):
     73        (WebCore::HTMLLIElement::didAttachRenderers):
     74        * html/HTMLLIElement.h:
     75        * html/HTMLMediaElement.cpp:
     76        (WebCore::HTMLMediaElement::HTMLMediaElement):
     77        (WebCore::HTMLMediaElement::willAttachRenderers):
     78        (WebCore::HTMLMediaElement::didAttachRenderers):
     79        * html/HTMLMediaElement.h:
     80        * html/HTMLOptGroupElement.cpp:
     81        (WebCore::HTMLOptGroupElement::HTMLOptGroupElement):
     82        (WebCore::HTMLOptGroupElement::didAttachRenderers):
     83        (WebCore::HTMLOptGroupElement::willDetachRenderers):
     84        * html/HTMLOptGroupElement.h:
     85        * html/HTMLOptionElement.cpp:
     86        (WebCore::HTMLOptionElement::HTMLOptionElement):
     87        (WebCore::HTMLOptionElement::didAttachRenderers):
     88        (WebCore::HTMLOptionElement::willDetachRenderers):
     89        * html/HTMLOptionElement.h:
     90        * html/HTMLPlugInElement.cpp:
     91        (WebCore::HTMLPlugInElement::HTMLPlugInElement):
     92        (WebCore::HTMLPlugInElement::willDetachRenderers):
     93        * html/HTMLPlugInElement.h:
     94        * html/HTMLPlugInImageElement.cpp:
     95        (WebCore::HTMLPlugInImageElement::HTMLPlugInImageElement):
     96        (WebCore::HTMLPlugInImageElement::didAttachRenderers):
     97        (WebCore::HTMLPlugInImageElement::willDetachRenderers):
     98        * html/HTMLPlugInImageElement.h:
     99        * html/HTMLProgressElement.cpp:
     100        (WebCore::HTMLProgressElement::HTMLProgressElement):
     101        (WebCore::HTMLProgressElement::didAttachRenderers):
     102        * html/HTMLProgressElement.h:
     103        * html/HTMLTextAreaElement.cpp:
     104        (WebCore::HTMLTextAreaElement::HTMLTextAreaElement):
     105        (WebCore::HTMLTextAreaElement::didAttachRenderers):
     106        * html/HTMLTextAreaElement.h:
     107        * html/HTMLVideoElement.cpp:
     108        (WebCore::HTMLVideoElement::HTMLVideoElement):
     109        (WebCore::HTMLVideoElement::didAttachRenderers):
     110        * html/HTMLVideoElement.h:
     111        * html/shadow/InsertionPoint.cpp:
     112        (WebCore::InsertionPoint::InsertionPoint):
     113        (WebCore::InsertionPoint::willAttachRenderers):
     114        (WebCore::InsertionPoint::willDetachRenderers):
     115        * html/shadow/InsertionPoint.h:
     116        * html/shadow/SliderThumbElement.cpp:
     117        (WebCore::SliderThumbElement::SliderThumbElement):
     118        (WebCore::SliderThumbElement::willDetachRenderers):
     119        * html/shadow/SliderThumbElement.h:
     120        * html/shadow/SpinButtonElement.cpp:
     121        (WebCore::SpinButtonElement::SpinButtonElement):
     122        (WebCore::SpinButtonElement::willDetachRenderers):
     123        * html/shadow/SpinButtonElement.h:
     124        * html/shadow/TextControlInnerElements.cpp:
     125        (WebCore::TextControlInnerElement::TextControlInnerElement):
     126        (WebCore::TextControlInnerTextElement::TextControlInnerTextElement):
     127        (WebCore::SearchFieldCancelButtonElement::SearchFieldCancelButtonElement):
     128        (WebCore::SearchFieldCancelButtonElement::willDetachRenderers):
     129        (WebCore::InputFieldSpeechButtonElement::InputFieldSpeechButtonElement):
     130        (WebCore::InputFieldSpeechButtonElement::willAttachRenderers):
     131        (WebCore::InputFieldSpeechButtonElement::willDetachRenderers):
     132        * html/shadow/TextControlInnerElements.h:
     133        * style/StyleResolveTree.cpp:
     134        (WebCore::Style::resolveTree):
     135        * svg/SVGElement.cpp:
     136        (WebCore::SVGElement::SVGElement):
     137        * svg/SVGImageElement.cpp:
     138        (WebCore::SVGImageElement::SVGImageElement):
     139        (WebCore::SVGImageElement::didAttachRenderers):
     140        * svg/SVGImageElement.h:
     141        * svg/SVGUseElement.cpp:
     142        (WebCore::SVGUseElement::SVGUseElement):
     143
    11442013-08-18  Gavin Barraclough  <barraclough@apple.com>
    2145

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

    r154249 r154254  
    14171417{
    14181418    PostAttachCallbackDisabler callbackDisabler(this);
    1419     StyleResolverParentPusher parentPusher(this);
    14201419    WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
     1420
     1421    if (hasCustomStyleResolveCallbacks())
     1422        willAttachRenderers();
    14211423
    14221424    createRendererIfNeeded(context);
    … …  
    14261428
    14271429    updatePseudoElement(BEFORE);
     1430
     1431    StyleResolverParentPusher parentPusher(this);
    14281432
    14291433    // When a shadow root exists, it does the work of attaching the children.
    … …  
    14581462        }
    14591463    }
     1464
     1465    if (hasCustomStyleResolveCallbacks())
     1466        didAttachRenderers();
    14601467}
    14611468
    … …  
    14851492{
    14861493    WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
     1494
     1495    if (hasCustomStyleResolveCallbacks())
     1496        willDetachRenderers();
     1497
    14871498    unregisterNamedFlowContentNode();
    14881499    cancelFocusAppearanceUpdate();
    … …  
    15191530
    15201531    setAttached(false);
     1532
     1533    if (hasCustomStyleResolveCallbacks())
     1534        didDetachRenderers();
    15211535}
    15221536
    … …  
    15641578PassRefPtr<RenderStyle> Element::styleForRenderer()
    15651579{
    1566     if (hasCustomStyleCallbacks()) {
     1580    if (hasCustomStyleResolveCallbacks()) {
    15671581        if (RefPtr<RenderStyle> style = customStyleForRenderer())
    15681582            return style.release();
    … …  
    31013115bool Element::willRecalcStyle(Style::Change)
    31023116{
    3103     ASSERT(hasCustomStyleCallbacks());
     3117    ASSERT(hasCustomStyleResolveCallbacks());
    31043118    return true;
    31053119}
    … …  
    31073121void Element::didRecalcStyle(Style::Change)
    31083122{
    3109     ASSERT(hasCustomStyleCallbacks());
     3123    ASSERT(hasCustomStyleResolveCallbacks());
     3124}
     3125
     3126void Element::willAttachRenderers()
     3127{
     3128    ASSERT(hasCustomStyleResolveCallbacks());
     3129}
     3130
     3131void Element::didAttachRenderers()
     3132{
     3133    ASSERT(hasCustomStyleResolveCallbacks());
     3134}
     3135
     3136void Element::willDetachRenderers()
     3137{
     3138    ASSERT(hasCustomStyleResolveCallbacks());
     3139}
     3140
     3141void Element::didDetachRenderers()
     3142{
     3143    ASSERT(hasCustomStyleResolveCallbacks());
    31103144}
    31113145
    31123146PassRefPtr<RenderStyle> Element::customStyleForRenderer()
    31133147{
    3114     ASSERT(hasCustomStyleCallbacks());
     3148    ASSERT(hasCustomStyleResolveCallbacks());
    31153149    return 0;
    31163150}

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

    r154249 r154254  
    300300        AttachContext() : resolvedStyle(0), performingReattach(false) { }
    301301    };
    302     virtual void attach(const AttachContext& = AttachContext());
    303     virtual void detach(const AttachContext& = AttachContext());
     302    void attach(const AttachContext& = AttachContext());
     303    void detach(const AttachContext& = AttachContext());
    304304    void reattach(const AttachContext& = AttachContext());
    305305    void reattachIfAttached(const AttachContext& = AttachContext());
    … …  
    556556    virtual bool willRecalcStyle(Style::Change);
    557557    virtual void didRecalcStyle(Style::Change);
     558
    558559    void updatePseudoElement(PseudoId, Style::Change = Style::NoChange);
    559560    void resetComputedStyle();
    … …  
    674675    void detachChildren(const AttachContext&);
    675676
     677    virtual void willAttachRenderers();
     678    virtual void didAttachRenderers();
     679    virtual void willDetachRenderers();
     680    virtual void didDetachRenderers();
     681
    676682    void createRendererIfNeeded(const AttachContext&);
    677683

  • trunk/Source/WebCore/dom/Node.h

    r154165 r154254  
    239239    bool isBeforePseudoElement() const { return pseudoId() == BEFORE; }
    240240    bool isAfterPseudoElement() const { return pseudoId() == AFTER; }
    241     PseudoId pseudoId() const { return (isElementNode() && hasCustomStyleCallbacks()) ? customPseudoId() : NOPSEUDO; }
     241    PseudoId pseudoId() const { return (isElementNode() && hasCustomStyleResolveCallbacks()) ? customPseudoId() : NOPSEUDO; }
    242242
    243243    virtual bool isMediaControlElement() const { return false; }
    … …  
    267267
    268268    bool inNamedFlow() const { return getFlag(InNamedFlowFlag); }
    269     bool hasCustomStyleCallbacks() const { return getFlag(HasCustomStyleCallbacksFlag); }
     269    bool hasCustomStyleResolveCallbacks() const { return getFlag(HasCustomStyleResolveCallbacksFlag); }
    270270
    271271    bool isRegisteredWithNamedFlow() const;
    … …  
    636636        InNamedFlowFlag = 1 << 19,
    637637        HasSyntheticAttrChildNodesFlag = 1 << 20,
    638         HasCustomStyleCallbacksFlag = 1 << 21,
     638        HasCustomStyleResolveCallbacksFlag = 1 << 21,
    639639        HasScopedHTMLStyleChildFlag = 1 << 22,
    640640        HasEventTargetDataFlag = 1 << 23,
    … …  
    682682    void clearEventTargetData();
    683683
    684     void setHasCustomStyleCallbacks() { setFlag(true, HasCustomStyleCallbacksFlag); }
     684    void setHasCustomStyleResolveCallbacks() { setFlag(true, HasCustomStyleResolveCallbacksFlag); }
    685685
    686686    Document* documentInternal() const { return treeScope()->documentScope(); }
    … …  
    694694    virtual PseudoId customPseudoId() const
    695695    {
    696         ASSERT(hasCustomStyleCallbacks());
     696        ASSERT(hasCustomStyleResolveCallbacks());
    697697        return NOPSEUDO;
    698698    }

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

    r154232 r154254  
    6262{
    6363    ASSERT(pseudoId == BEFORE || pseudoId == AFTER);
    64     setHasCustomStyleCallbacks();
     64    setHasCustomStyleResolveCallbacks();
    6565}
    6666
    … …  
    7878}
    7979
    80 void PseudoElement::attach(const AttachContext& context)
     80void PseudoElement::didAttachRenderers()
    8181{
    82     ASSERT(!renderer());
    83 
    84     Element::attach(context);
    85 
    8682    RenderObject* renderer = this->renderer();
    8783    if (!renderer || !renderer->style()->regionThread().isEmpty())

  • trunk/Source/WebCore/dom/PseudoElement.h

    r154232 r154254  
    4747
    4848    virtual PassRefPtr<RenderStyle> customStyleForRenderer() OVERRIDE;
    49     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
     49    virtual void didAttachRenderers() OVERRIDE;
    5050    virtual bool rendererIsNeeded(const NodeRenderingContext&) OVERRIDE;
    5151

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

    r154192 r154254  
    8181{
    8282    ASSERT(hasTagName(canvasTag));
     83    setHasCustomStyleResolveCallbacks();
    8384}
    8485
    … …  
    121122}
    122123
    123 void HTMLCanvasElement::attach(const AttachContext& context)
     124void HTMLCanvasElement::willAttachRenderers()
    124125{
    125126    setIsInCanvasSubtree(true);
    126     HTMLElement::attach(context);
    127127}
    128128

  • trunk/Source/WebCore/html/HTMLCanvasElement.h

    r154033 r154254  
    148148    virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
    149149    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
    150     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
     150    virtual void willAttachRenderers() OVERRIDE;
    151151    virtual bool areAuthorShadowsAllowed() const OVERRIDE;
    152152

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

    r154178 r154254  
    6464{
    6565    setForm(form ? form : findFormAncestor());
    66     setHasCustomStyleCallbacks();
     66    setHasCustomStyleResolveCallbacks();
    6767}
    6868
    … …  
    209209}
    210210
    211 void HTMLFormControlElement::attach(const AttachContext& context)
    212 {
    213     PostAttachCallbackDisabler disabler(this);
    214 
    215     HTMLElement::attach(context);
    216 
     211void HTMLFormControlElement::didAttachRenderers()
     212{
    217213    // The call to updateFromElement() needs to go after the call through
    218214    // to the base class's attach() because that can sometimes do a close

  • trunk/Source/WebCore/html/HTMLFormControlElement.h

    r153783 r154254  
    112112    virtual void requiredAttributeChanged();
    113113    virtual void disabledAttributeChanged();
    114     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
     114    virtual void didAttachRenderers() OVERRIDE;
    115115    virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
    116116    virtual void removedFrom(ContainerNode*) OVERRIDE;

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

    r151282 r154254  
    4141{
    4242    ASSERT(hasTagName(frameTag));
     43    setHasCustomStyleResolveCallbacks();
    4344}
    4445
    … …  
    7374}
    7475
    75 void HTMLFrameElement::attach(const AttachContext& context)
     76void HTMLFrameElement::didAttachRenderers()
    7677{
    77     HTMLFrameElementBase::attach(context);
    78    
     78    HTMLFrameElementBase::didAttachRenderers();
    7979    if (HTMLFrameSetElement* frameSetElement = containingFrameSetElement(this)) {
    8080        if (!m_frameBorderSet)

  • trunk/Source/WebCore/html/HTMLFrameElement.h

    r151282 r154254  
    4040    HTMLFrameElement(const QualifiedName&, Document*);
    4141
    42     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
     42    virtual void didAttachRenderers() OVERRIDE;
    4343
    4444    virtual bool rendererIsNeeded(const NodeRenderingContext&);

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

    r154142 r154254  
    5252    , m_viewSource(false)
    5353{
     54    setHasCustomStyleResolveCallbacks();
    5455}
    5556
    … …  
    173174}
    174175
    175 void HTMLFrameElementBase::attach(const AttachContext& context)
    176 {
    177     HTMLFrameOwnerElement::attach(context);
    178 
     176void HTMLFrameElementBase::didAttachRenderers()
     177{
    179178    if (RenderPart* part = renderPart()) {
    180179        if (Frame* frame = contentFrame())

  • trunk/Source/WebCore/html/HTMLFrameElementBase.h

    r152889 r154254  
    5353    virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
    5454    virtual void didNotifySubtreeInsertions(ContainerNode*) OVERRIDE;
    55     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
     55    virtual void didAttachRenderers() OVERRIDE;
    5656
    5757private:

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

    r154142 r154254  
    5757{
    5858    ASSERT(hasTagName(framesetTag));
    59    
    60     setHasCustomStyleCallbacks();
     59    setHasCustomStyleResolveCallbacks();
    6160}
    6261
    … …  
    166165}
    167166
    168 void HTMLFrameSetElement::attach(const AttachContext& context)
     167void HTMLFrameSetElement::willAttachRenderers()
    169168{
    170169    // Inherit default settings from parent frameset
    171170    // FIXME: This is not dynamic.
    172171    for (ContainerNode* node = parentNode(); node; node = node->parentNode()) {
    173         if (node->hasTagName(framesetTag)) {
    174             HTMLFrameSetElement* frameset = static_cast<HTMLFrameSetElement*>(node);
    175             if (!m_frameborderSet)
    176                 m_frameborder = frameset->hasFrameBorder();
    177             if (m_frameborder) {
    178                 if (!m_borderSet)
    179                     m_border = frameset->border();
    180                 if (!m_borderColorSet)
    181                     m_borderColorSet = frameset->hasBorderColor();
    182             }
    183             if (!m_noresize)
    184                 m_noresize = frameset->noResize();
    185             break;
    186         }
    187     }
    188 
    189     HTMLElement::attach(context);
     172        if (!node->hasTagName(framesetTag))
     173            continue;
     174        HTMLFrameSetElement* frameset = static_cast<HTMLFrameSetElement*>(node);
     175        if (!m_frameborderSet)
     176            m_frameborder = frameset->hasFrameBorder();
     177        if (m_frameborder) {
     178            if (!m_borderSet)
     179                m_border = frameset->border();
     180            if (!m_borderColorSet)
     181                m_borderColorSet = frameset->hasBorderColor();
     182        }
     183        if (!m_noresize)
     184            m_noresize = frameset->noResize();
     185    }
    190186}
    191187

  • trunk/Source/WebCore/html/HTMLFrameSetElement.h

    r153783 r154254  
    7272    virtual void collectStyleForPresentationAttribute(const QualifiedName&, const AtomicString&, MutableStylePropertySet*) OVERRIDE;
    7373
    74     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
     74    virtual void willAttachRenderers() OVERRIDE;
    7575    virtual bool rendererIsNeeded(const NodeRenderingContext&);
    7676    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);

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

    r153796 r154254  
    4343{
    4444    ASSERT(hasTagName(iframeTag));
    45     setHasCustomStyleCallbacks();
     45    setHasCustomStyleResolveCallbacks();
    4646}
    4747

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

    r154106 r154254  
    5353{
    5454    ASSERT(hasTagName(imgTag));
     55    setHasCustomStyleResolveCallbacks();
    5556    if (form)
    5657        form->registerImgElement(this);
    … …  
    185186}
    186187
    187 void HTMLImageElement::attach(const AttachContext& context)
    188 {
    189     HTMLElement::attach(context);
    190 
    191     if (renderer() && renderer()->isImage() && !m_imageLoader.hasPendingBeforeLoadEvent()) {
    192         RenderImage* renderImage = toRenderImage(renderer());
    193         RenderImageResource* renderImageResource = renderImage->imageResource();
    194         if (renderImageResource->hasImage())
    195             return;
    196         renderImageResource->setCachedImage(m_imageLoader.image());
    197 
    198         // If we have no image at all because we have no src attribute, set
    199         // image height and width for the alt text instead.
    200         if (!m_imageLoader.image() && !renderImageResource->cachedImage())
    201             renderImage->setImageSizeForAltText();
    202     }
     188void HTMLImageElement::didAttachRenderers()
     189{
     190    if (!renderer() || !renderer()->isImage())
     191        return;
     192    if (m_imageLoader.hasPendingBeforeLoadEvent())
     193        return;
     194    RenderImage* renderImage = toRenderImage(renderer());
     195    RenderImageResource* renderImageResource = renderImage->imageResource();
     196    if (renderImageResource->hasImage())
     197        return;
     198    renderImageResource->setCachedImage(m_imageLoader.image());
     199
     200    // If we have no image at all because we have no src attribute, set
     201    // image height and width for the alt text instead.
     202    if (!m_imageLoader.image() && !renderImageResource->cachedImage())
     203        renderImage->setImageSizeForAltText();
    203204}
    204205

  • trunk/Source/WebCore/html/HTMLImageElement.h

    r153772 r154254  
    9191    virtual void collectStyleForPresentationAttribute(const QualifiedName&, const AtomicString&, MutableStylePropertySet*) OVERRIDE;
    9292
    93     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
     93    virtual void didAttachRenderers() OVERRIDE;
    9494    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
    9595

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

    r154106 r154254  
    136136{
    137137    ASSERT(hasTagName(inputTag) || hasTagName(isindexTag));
     138    setHasCustomStyleResolveCallbacks();
    138139}
    139140
    … …  
    796797}
    797798
    798 void HTMLInputElement::attach(const AttachContext& context)
    799 {
    800     PostAttachCallbackDisabler disabler(this);
    801 
     799void HTMLInputElement::willAttachRenderers()
     800{
    802801    if (!m_hasType)
    803802        updateType();
    804 
    805     HTMLTextFormControlElement::attach(context);
     803}
     804
     805void HTMLInputElement::didAttachRenderers()
     806{
     807    HTMLTextFormControlElement::didAttachRenderers();
    806808
    807809    m_inputType->attach();
    … …  
    811813}
    812814
    813 void HTMLInputElement::detach(const AttachContext& context)
    814 {
    815     HTMLTextFormControlElement::detach(context);
     815void HTMLInputElement::didDetachRenderers()
     816{
    816817    setFormControlValueMatchesRenderer(false);
    817818    m_inputType->detach();

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

    r153647 r154254  
    190190    virtual bool rendererIsNeeded(const NodeRenderingContext&);
    191191    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
    192     virtual void detach(const AttachContext& = AttachContext()) OVERRIDE;
     192    virtual void willAttachRenderers() OVERRIDE;
     193    virtual void didAttachRenderers() OVERRIDE;
     194    virtual void didDetachRenderers() OVERRIDE;
    193195
    194196    // FIXME: For isActivatedSubmit and setActivatedSubmit, we should use the NVI-idiom here by making
    … …  
    352354
    353355    virtual void copyNonAttributePropertiesFromElement(const Element&);
    354 
    355     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
    356356
    357357    virtual bool appendFormData(FormDataList&, bool);

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

    r151282 r154254  
    3939{
    4040    ASSERT(hasTagName(liTag));
     41    setHasCustomStyleResolveCallbacks();
    4142}
    4243
    … …  
    8687}
    8788
    88 void HTMLLIElement::attach(const AttachContext& context)
     89void HTMLLIElement::didAttachRenderers()
    8990{
    90     ASSERT(!attached());
     91    if (!renderer() || !renderer()->isListItem())
     92        return;
     93    RenderListItem* listItemRenderer = toRenderListItem(renderer());
    9194
    92     HTMLElement::attach(context);
     95    // Find the enclosing list node.
     96    Element* listNode = 0;
     97    Element* current = this;
     98    while (!listNode) {
     99        current = current->parentElement();
     100        if (!current)
     101            break;
     102        if (current->hasTagName(ulTag) || current->hasTagName(olTag))
     103            listNode = current;
     104    }
    93105
    94     if (renderer() && renderer()->isListItem()) {
    95         RenderListItem* listItemRenderer = toRenderListItem(renderer());
     106    // If we are not in a list, tell the renderer so it can position us inside.
     107    // We don't want to change our style to say "inside" since that would affect nested nodes.
     108    if (!listNode)
     109        listItemRenderer->setNotInList(true);
    96110
    97         // Find the enclosing list node.
    98         Element* listNode = 0;
    99         Element* current = this;
    100         while (!listNode) {
    101             current = current->parentElement();
    102             if (!current)
    103                 break;
    104             if (current->hasTagName(ulTag) || current->hasTagName(olTag))
    105                 listNode = current;
    106         }
    107 
    108         // If we are not in a list, tell the renderer so it can position us inside.
    109         // We don't want to change our style to say "inside" since that would affect nested nodes.
    110         if (!listNode)
    111             listItemRenderer->setNotInList(true);
    112 
    113         parseValue(fastGetAttribute(valueAttr));
    114     }
     111    parseValue(fastGetAttribute(valueAttr));
    115112}
    116113

  • trunk/Source/WebCore/html/HTMLLIElement.h

    r151282 r154254  
    4040    virtual void collectStyleForPresentationAttribute(const QualifiedName&, const AtomicString&, MutableStylePropertySet*) OVERRIDE;
    4141
    42     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
     42    virtual void didAttachRenderers() OVERRIDE;
    4343
    4444    void parseValue(const AtomicString&);

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

    r154225 r154254  
    328328{
    329329    LOG(Media, "HTMLMediaElement::HTMLMediaElement");
     330    setHasCustomStyleResolveCallbacks();
     331
    330332    document->registerForMediaVolumeCallbacks(this);
    331333    document->registerForPrivateBrowsingStateChangedCallbacks(this);
    … …  
    336338    }
    337339
    338     setHasCustomStyleCallbacks();
    339340    addElementToDocumentMap(this, document);
    340341
    … …  
    632633}
    633634
    634 void HTMLMediaElement::attach(const AttachContext& context)
     635void HTMLMediaElement::willAttachRenderers()
    635636{
    636637    ASSERT(!attached());
    … …  
    639640    m_needWidgetUpdate = true;
    640641#endif
    641 
    642     HTMLElement::attach(context);
    643 
     642}
     643
     644void HTMLMediaElement::didAttachRenderers()
     645{
    644646    if (renderer())
    645647        renderer()->updateFromElement();

  • trunk/Source/WebCore/html/HTMLMediaElement.h

    r154201 r154254  
    387387    virtual void finishParsingChildren();
    388388    virtual bool isURLAttribute(const Attribute&) const OVERRIDE;
    389     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
     389    virtual void willAttachRenderers() OVERRIDE;
     390    virtual void didAttachRenderers() OVERRIDE;
    390391
    391392    virtual void didMoveToNewDocument(Document* oldDocument) OVERRIDE;

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

    r153926 r154254  
    4343{
    4444    ASSERT(hasTagName(optgroupTag));
    45     setHasCustomStyleCallbacks();
     45    setHasCustomStyleResolveCallbacks();
    4646}
    4747
    … …  
    9292}
    9393
    94 void HTMLOptGroupElement::attach(const AttachContext& context)
     94void HTMLOptGroupElement::didAttachRenderers()
    9595{
    96     HTMLElement::attach(context);
    9796    // If after attaching nothing called styleForRenderer() on this node we
    9897    // manually cache the value. This happens if our parent doesn't have a
    … …  
    102101}
    103102
    104 void HTMLOptGroupElement::detach(const AttachContext& context)
     103void HTMLOptGroupElement::willDetachRenderers()
    105104{
    106105    m_style.clear();
    107     HTMLElement::detach(context);
    108106}
    109107

  • trunk/Source/WebCore/html/HTMLOptGroupElement.h

    r152353 r154254  
    4747    virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
    4848    virtual bool rendererIsNeeded(const NodeRenderingContext&) { return false; }
    49     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
    50     virtual void detach(const AttachContext& = AttachContext()) OVERRIDE;
     49    virtual void didAttachRenderers() OVERRIDE;
     50    virtual void willDetachRenderers() OVERRIDE;
    5151
    5252    virtual void childrenChanged(bool changedByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);

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

    r153926 r154254  
    5757{
    5858    ASSERT(hasTagName(optionTag));
    59     setHasCustomStyleCallbacks();
     59    setHasCustomStyleResolveCallbacks();
    6060}
    6161
    … …  
    9191}
    9292
    93 void HTMLOptionElement::attach(const AttachContext& context)
    94 {
    95     HTMLElement::attach(context);
     93void HTMLOptionElement::didAttachRenderers()
     94{
    9695    // If after attaching nothing called styleForRenderer() on this node we
    9796    // manually cache the value. This happens if our parent doesn't have a
    … …  
    101100}
    102101
    103 void HTMLOptionElement::detach(const AttachContext& context)
     102void HTMLOptionElement::willDetachRenderers()
    104103{
    105104    m_style.clear();
    106     HTMLElement::detach(context);
    107105}
    108106

  • trunk/Source/WebCore/html/HTMLOptionElement.h

    r153783 r154254  
    7272    virtual bool isFocusable() const OVERRIDE;
    7373    virtual bool rendererIsNeeded(const NodeRenderingContext&) { return false; }
    74     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
    75     virtual void detach(const AttachContext& = AttachContext()) OVERRIDE;
     74    virtual void didAttachRenderers() OVERRIDE;
     75    virtual void willDetachRenderers() OVERRIDE;
    7676
    7777    virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;

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

    r154192 r154254  
    6262    , m_displayState(Playing)
    6363{
     64    setHasCustomStyleResolveCallbacks();
    6465}
    6566
    … …  
    9495}
    9596
    96 void HTMLPlugInElement::detach(const AttachContext& context)
     97void HTMLPlugInElement::willDetachRenderers()
    9798{
    9899    m_instance.clear();
    … …  
    110111    }
    111112#endif
    112 
    113     HTMLFrameOwnerElement::detach(context);
    114113}
    115114

  • trunk/Source/WebCore/html/HTMLPlugInElement.h

    r151599 r154254  
    8484    HTMLPlugInElement(const QualifiedName& tagName, Document*);
    8585
    86     virtual void detach(const AttachContext& = AttachContext()) OVERRIDE;
     86    virtual void willDetachRenderers() OVERRIDE;
    8787    virtual bool isPresentationAttribute(const QualifiedName&) const OVERRIDE;
    8888    virtual void collectStyleForPresentationAttribute(const QualifiedName&, const AtomicString&, MutableStylePropertySet*) OVERRIDE;

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

    r154201 r154254  
    116116    , m_snapshotDecision(SnapshotNotYetDecided)
    117117{
    118     setHasCustomStyleCallbacks();
     118    setHasCustomStyleResolveCallbacks();
    119119}
    120120
    … …  
    232232}
    233233
    234 void HTMLPlugInImageElement::attach(const AttachContext& context)
    235 {
    236     PostAttachCallbackDisabler disabler(this);
    237 
    238     bool isImage = isImageType();
    239 
    240     if (!isImage)
     234void HTMLPlugInImageElement::didAttachRenderers()
     235{
     236    if (!isImageType()) {
    241237        queuePostAttachCallback(&HTMLPlugInImageElement::updateWidgetCallback, this);
    242 
    243     HTMLPlugInElement::attach(context);
    244 
    245     if (isImage && renderer() && !useFallbackContent()) {
    246         if (!m_imageLoader)
    247             m_imageLoader = adoptPtr(new HTMLImageLoader(this));
    248         m_imageLoader->updateFromElement();
    249     }
    250 }
    251 
    252 void HTMLPlugInImageElement::detach(const AttachContext& context)
    253 {
    254     // FIXME: Because of the insanity that is HTMLPlugInImageElement::recalcStyle,
     238        return;
     239    }
     240    if (!renderer() || useFallbackContent())
     241        return;
     242    if (!m_imageLoader)
     243        m_imageLoader = adoptPtr(new HTMLImageLoader(this));
     244    m_imageLoader->updateFromElement();
     245}
     246
     247void HTMLPlugInImageElement::willDetachRenderers()
     248{
     249    // FIXME: Because of the insanity that is HTMLPlugInImageElement::willRecalcStyle,
    255250    // we can end up detaching during an attach() call, before we even have a
    256251    // renderer.  In that case, don't mark the widget for update.
    257     if (attached() && renderer() && !useFallbackContent())
    258         // Update the widget the next time we attach (detaching destroys the plugin).
    259         setNeedsWidgetUpdate(true);
    260     HTMLPlugInElement::detach(context);
     252    if (!attached() || !renderer())
     253        return;
     254    if (useFallbackContent())
     255        return;
     256    // Update the widget the next time we attach (detaching destroys the plugin).
     257    setNeedsWidgetUpdate(true);
     258
     259    HTMLPlugInElement::willDetachRenderers();
    261260}
    262261

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

    r153783 r154254  
    110110
    111111    static void updateWidgetCallback(Node*, unsigned = 0);
    112     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
    113     virtual void detach(const AttachContext& = AttachContext()) OVERRIDE;
     112    virtual void didAttachRenderers() OVERRIDE;
     113    virtual void willDetachRenderers() OVERRIDE;
    114114
    115115    bool allowedToLoadFrameURL(const String& url);

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

    r151947 r154254  
    4646{
    4747    ASSERT(hasTagName(progressTag));
     48    setHasCustomStyleResolveCallbacks();
    4849}
    4950
    … …  
    9293}
    9394
    94 void HTMLProgressElement::attach(const AttachContext& context)
     95void HTMLProgressElement::didAttachRenderers()
    9596{
    96     LabelableElement::attach(context);
    9797    if (RenderProgress* render = renderProgress())
    9898        render->updateFromElement();

  • trunk/Source/WebCore/html/HTMLProgressElement.h

    r151282 r154254  
    6161    virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
    6262
    63     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
     63    virtual void didAttachRenderers() OVERRIDE;
    6464
    6565    void didElementStateChange();

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

    r154240 r154254  
    9898    ASSERT(hasTagName(textareaTag));
    9999    setFormControlValueMatchesRenderer(true);
     100    setHasCustomStyleResolveCallbacks();
    100101}
    101102
    … …  
    516517}
    517518
    518 void HTMLTextAreaElement::attach(const AttachContext& context)
    519 {
    520     HTMLTextFormControlElement::attach(context);
     519void HTMLTextAreaElement::didAttachRenderers()
     520{
     521    HTMLTextFormControlElement::didAttachRenderers();
    521522    fixPlaceholderRenderer(m_placeholder, innerTextElement());
    522523}

  • trunk/Source/WebCore/html/HTMLTextAreaElement.h

    r152353 r154254  
    112112
    113113    virtual bool shouldUseInputMethod() OVERRIDE;
    114     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
     114    virtual void didAttachRenderers() OVERRIDE;
    115115    virtual bool matchesReadOnlyPseudoClass() const OVERRIDE;
    116116    virtual bool matchesReadWritePseudoClass() const OVERRIDE;

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

    r154142 r154254  
    5252{
    5353    ASSERT(hasTagName(videoTag));
     54    setHasCustomStyleResolveCallbacks();
    5455    if (document->settings())
    5556        m_defaultPosterURL = document->settings()->defaultVideoPosterURL();
    … …  
    7576#endif
    7677
    77 void HTMLVideoElement::attach(const AttachContext& context)
    78 {
    79     HTMLMediaElement::attach(context);
     78void HTMLVideoElement::didAttachRenderers()
     79{
     80    HTMLMediaElement::didAttachRenderers();
    8081
    8182#if !ENABLE(PLUGIN_PROXY_FOR_VIDEO)

  • trunk/Source/WebCore/html/HTMLVideoElement.h

    r152614 r154254  
    7979    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
    8080#endif
    81     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
     81    virtual void didAttachRenderers() OVERRIDE;
    8282    virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
    8383    virtual bool isPresentationAttribute(const QualifiedName&) const OVERRIDE;

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

    r154165 r154254  
    4646    , m_hasDistribution(false)
    4747{
     48    setHasCustomStyleResolveCallbacks();
    4849}
    4950
    … …  
    5253}
    5354
    54 void InsertionPoint::attach(const AttachContext& context)
     55void InsertionPoint::willAttachRenderers()
    5556{
    5657    if (ShadowRoot* shadowRoot = containingShadowRoot())
    … …  
    6465        }
    6566        if (current->isElementNode())
    66             toElement(current)->attach(context);
    67     }
    68     HTMLElement::attach(context);
    69 }
    70 
    71 void InsertionPoint::detach(const AttachContext& context)
     67            toElement(current)->attach();
     68    }
     69}
     70
     71void InsertionPoint::willDetachRenderers()
    7272{
    7373    if (ShadowRoot* shadowRoot = containingShadowRoot())
    … …  
    8080        }
    8181        if (current->isElementNode())
    82             toElement(current)->detach(context);
    83     }
    84     HTMLElement::detach(context);
     82            toElement(current)->detach();
     83    }
    8584}
    8685

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

    r154106 r154254  
    6666    void setResetStyleInheritance(bool);
    6767
    68     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
    69     virtual void detach(const AttachContext& = AttachContext()) OVERRIDE;
     68    virtual void willAttachRenderers() OVERRIDE;
     69    virtual void willDetachRenderers() OVERRIDE;
    7070
    7171    bool shouldUseFallbackElements() const;

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

    r154178 r154254  
    207207// --------------------------------
    208208
     209SliderThumbElement::SliderThumbElement(Document* document)
     210    : HTMLDivElement(HTMLNames::divTag, document)
     211    , m_inDragMode(false)
     212{
     213    setHasCustomStyleResolveCallbacks();
     214}
     215
    209216void SliderThumbElement::setPositionFromValue()
    210217{
    … …  
    386393}
    387394
    388 void SliderThumbElement::detach(const AttachContext& context)
     395void SliderThumbElement::willDetachRenderers()
    389396{
    390397    if (m_inDragMode) {
    … …  
    392399            frame->eventHandler().setCapturingMouseEventsNode(0);
    393400    }
    394     HTMLDivElement::detach(context);
    395401}
    396402

  • trunk/Source/WebCore/html/shadow/SliderThumbElement.h

    r151947 r154254  
    5555    virtual bool willRespondToMouseMoveEvents() OVERRIDE;
    5656    virtual bool willRespondToMouseClickEvents() OVERRIDE;
    57     virtual void detach(const AttachContext& = AttachContext()) OVERRIDE;
     57    virtual void willDetachRenderers() OVERRIDE;
    5858    virtual const AtomicString& shadowPseudoId() const;
    5959    HTMLInputElement* hostInput() const;
    … …  
    7373    bool m_inDragMode;
    7474};
    75 
    76 inline SliderThumbElement::SliderThumbElement(Document* document)
    77     : HTMLDivElement(HTMLNames::divTag, document)
    78     , m_inDragMode(false)
    79 {
    80 }
    8175
    8276inline PassRefPtr<SliderThumbElement> SliderThumbElement::create(Document* document)

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

    r154178 r154254  
    5151    , m_repeatingTimer(this, &SpinButtonElement::repeatingTimerFired)
    5252{
     53    setHasCustomStyleResolveCallbacks();
    5354}
    5455
    … …  
    6465}
    6566
    66 void SpinButtonElement::detach(const AttachContext& context)
     67void SpinButtonElement::willDetachRenderers()
    6768{
    6869    releaseCapture();
    69     HTMLDivElement::detach(context);
    7070}
    7171

  • trunk/Source/WebCore/html/shadow/SpinButtonElement.h

    r151282 r154254  
    7171
    7272    virtual const AtomicString& shadowPseudoId() const;
    73     virtual void detach(const AttachContext& = AttachContext()) OVERRIDE;
     73    virtual void willDetachRenderers() OVERRIDE;
    7474    virtual bool isSpinButtonElement() const { return true; }
    7575    virtual bool isDisabledFormControl() const OVERRIDE { return shadowHost() && shadowHost()->isDisabledFormControl(); }

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

    r154178 r154254  
    6666    : HTMLDivElement(divTag, document)
    6767{
    68     setHasCustomStyleCallbacks();
     68    setHasCustomStyleResolveCallbacks();
    6969}
    7070
    … …  
    8585    : HTMLDivElement(divTag, document)
    8686{
    87     setHasCustomStyleCallbacks();
     87    setHasCustomStyleResolveCallbacks();
    8888}
    8989
    … …  
    183183    , m_capturing(false)
    184184{
     185    setHasCustomStyleResolveCallbacks();
    185186}
    186187
    … …  
    196197}
    197198
    198 void SearchFieldCancelButtonElement::detach(const AttachContext& context)
     199void SearchFieldCancelButtonElement::willDetachRenderers()
    199200{
    200201    if (m_capturing) {
    … …  
    202203            frame->eventHandler().setCapturingMouseEventsNode(0);
    203204    }
    204     HTMLDivElement::detach(context);
    205 }
    206 
     205}
    207206
    208207void SearchFieldCancelButtonElement::defaultEventHandler(Event* event)
    … …  
    265264    , m_listenerId(0)
    266265{
     266    setHasCustomStyleResolveCallbacks();
    267267}
    268268
    … …  
    405405}
    406406
    407 void InputFieldSpeechButtonElement::attach(const AttachContext& context)
     407void InputFieldSpeechButtonElement::willAttachRenderers()
    408408{
    409409    ASSERT(!m_listenerId);
    410410    if (SpeechInput* input = SpeechInput::from(document()->page()))
    411411        m_listenerId = input->registerListener(this);
    412     HTMLDivElement::attach(context);
    413 }
    414 
    415 void InputFieldSpeechButtonElement::detach(const AttachContext& context)
     412}
     413
     414void InputFieldSpeechButtonElement::willDetachRenderers()
    416415{
    417416    if (m_capturing) {
    … …  
    426425        m_listenerId = 0;
    427426    }
    428 
    429     HTMLDivElement::detach(context);
    430427}
    431428

  • trunk/Source/WebCore/html/shadow/TextControlInnerElements.h

    r151282 r154254  
    9292    SearchFieldCancelButtonElement(Document*);
    9393    virtual const AtomicString& shadowPseudoId() const;
    94     virtual void detach(const AttachContext& = AttachContext()) OVERRIDE;
     94    virtual void willDetachRenderers() OVERRIDE;
    9595    virtual bool isMouseFocusable() const OVERRIDE { return false; }
    9696
    … …  
    113113    virtual ~InputFieldSpeechButtonElement();
    114114
    115     virtual void detach();
    116115    virtual void defaultEventHandler(Event*);
    117116    virtual bool willRespondToMouseClickEvents();
    … …  
    132131    virtual const AtomicString& shadowPseudoId() const;
    133132    virtual bool isMouseFocusable() const OVERRIDE { return false; }
    134     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
     133    virtual void willAttachRenderers() OVERRIDE;
     134    virtual void willDetachRenderera) OVERRIDE;
     135
    135136
    136137    bool m_capturing;

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

    r154106 r154254  
    221221    ASSERT(change != Detach);
    222222
    223     if (current->hasCustomStyleCallbacks()) {
     223    if (current->hasCustomStyleResolveCallbacks()) {
    224224        if (!current->willRecalcStyle(change))
    225225            return;
    … …  
    280280    current->clearChildNeedsStyleRecalc();
    281281   
    282     if (current->hasCustomStyleCallbacks())
     282    if (current->hasCustomStyleResolveCallbacks())
    283283        current->didRecalcStyle(change);
    284284}

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

    r154165 r154254  
    5454    : StyledElement(tagName, document, constructionType)
    5555{
    56     setHasCustomStyleCallbacks();
     56    setHasCustomStyleResolveCallbacks();
    5757}
    5858

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

    r152526 r154254  
    6767    ASSERT(isSVGImageElement(this));
    6868    registerAnimatedPropertiesForSVGImageElement();
     69    setHasCustomStyleResolveCallbacks();
    6970}
    7071
    … …  
    194195}
    195196
    196 void SVGImageElement::attach(const AttachContext& context)
    197 {
    198     SVGGraphicsElement::attach(context);
    199 
     197void SVGImageElement::didAttachRenderers()
     198{
    200199    if (RenderSVGImage* imageObj = toRenderSVGImage(renderer())) {
    201200        if (imageObj->imageResource()->hasImage())

  • trunk/Source/WebCore/svg/SVGImageElement.h

    r152524 r154254  
    5252    virtual void svgAttributeChanged(const QualifiedName&);
    5353
    54     virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
     54    virtual void didAttachRenderers() OVERRIDE;
    5555    virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
    5656

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

    r154106 r154254  
    9393    , m_svgLoadEventTimer(this, &SVGElement::svgLoadEventTimerFired)
    9494{
    95     ASSERT(hasCustomStyleCallbacks());
     95    ASSERT(hasCustomStyleResolveCallbacks());
    9696    ASSERT(hasTagName(SVGNames::useTag));
    9797    registerAnimatedPropertiesForSVGUseElement();
Note: See TracChangeset for help on using the changeset viewer.