Changeset 153783 in webkit


Ignore:
Timestamp:
Aug 7, 2013, 5:02:04 AM (12 years ago)
Author:
Antti Koivisto
Message:

Move style recalculation out from Element
​https://bugs.webkit.org/show_bug.cgi?id=119497

Reviewed by Andreas Kling.

Element currently does too much. Element::recalcStyle() and the related functions can be turned into
standalone functions that operate on DOM tree. This will also give more freedom for future refactoring,
for example making style recalculation non-recursive.

  • WebCore.xcodeproj/project.pbxproj:
  • css/StyleResolveTree.cpp: Added.

(WebCore::Style::determineChange):

  • moved and renamed from Node::diff
  • factored to use early return style
  • simplifield the null input logic

(WebCore::Style::pseudoStyleCacheIsInvalid):

  • moved from Element::pseudoStyleCacheIsInvalid
  • narrowed to take RenderObject rather than operate on Element

(WebCore::Style::resolveLocal):

  • split from Element::recalcStyle
  • factored to use early return style

(WebCore::Style::resolveTree):

  • moved and renamed from Element::recalcStyle
  • css/StyleResolveTree.h: Added.


  • introcuduce Style namespace for style related classes and functions
  • move and rename Node::StyleChange -> Style::Change
  • css/StyleResolver.h:

(WebCore::StyleResolverParentPusher::StyleResolverParentPusher):
(WebCore::StyleResolverParentPusher::push):
(WebCore::StyleResolverParentPusher::~StyleResolverParentPusher):

Moved this stack helper to StyleResolver.h for now since it is needed by both
StyleRecalculation and Element.

  • dom/Document.cpp:

(WebCore::Document::recalcStyle):
(WebCore::Document::updateStyleIfNeeded):
(WebCore::Document::updateLayoutIgnorePendingStylesheets):
(WebCore::Document::attach):
(WebCore::Document::styleResolverChanged):
(WebCore::Document::webkitWillEnterFullScreenForElement):

  • dom/Document.h:
  • dom/Element.cpp:

(WebCore::shouldIgnoreAttributeCase):
(WebCore::Element::updatePseudoElement):
(WebCore::Element::resetComputedStyle):
(WebCore::Element::willRecalcStyle):
(WebCore::Element::didRecalcStyle):

  • dom/Element.h:


  • remove Element::recalcStyle
  • make a few private functions needed by StyleRecalculation public
  • dom/ElementShadow.cpp:

(WebCore::ElementShadow::recalcStyle):

  • dom/ElementShadow.h:
  • dom/Node.cpp:
  • dom/Node.h:
  • remove Node::StyleChange
  • remove Node::diff
  • dom/PseudoElement.cpp:

(WebCore::PseudoElement::didRecalcStyle):

  • dom/PseudoElement.h:
  • dom/ShadowRoot.cpp:

(WebCore::ShadowRoot::recalcStyle):
(WebCore::ShadowRoot::setResetStyleInheritance):

  • dom/ShadowRoot.h:
  • dom/Text.cpp:

(WebCore::Text::recalcTextStyle):

  • dom/Text.h:
  • html/HTMLFormControlElement.cpp:

(WebCore::HTMLFormControlElement::didRecalcStyle):

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

(WebCore::HTMLFrameSetElement::willRecalcStyle):

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

(WebCore::HTMLIFrameElement::didRecalcStyle):

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

(WebCore::HTMLMediaElement::didRecalcStyle):

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

(WebCore::HTMLOptionElement::didRecalcStyle):

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

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

  • html/HTMLPlugInImageElement.h:
  • inspector/InspectorOverlay.cpp:

(WebCore::InspectorOverlay::update):

  • loader/DocumentWriter.cpp:

(WebCore::DocumentWriter::reportDataReceived):

  • page/Frame.cpp:

(WebCore::Frame::setPageAndTextZoomFactors):

  • page/Page.cpp:

(WebCore::Page::setPageScaleFactor):

  • rendering/RenderBlock.cpp:

(WebCore::RenderBlock::updateFirstLetterStyle):

  • svg/SVGElement.cpp:

(WebCore::SVGElement::willRecalcStyle):

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

(WebCore::SVGUseElement::willRecalcStyle):

  • svg/SVGUseElement.h:
Location:
trunk/Source/WebCore
Files:
2 added
42 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/CMakeLists.txt

    r153772 r153783  
    10921092    css/StylePropertyShorthand.cpp
    10931093    css/StyleResolver.cpp
     1094    css/StyleResolveTree.cpp
    10941095    css/StyleRule.cpp
    10951096    css/StyleRuleImport.cpp

  • trunk/Source/WebCore/ChangeLog

    r153781 r153783  
     12013-08-07  Antti Koivisto  <antti@apple.com>
     2
     3        Move style recalculation out from Element
     4        https://bugs.webkit.org/show_bug.cgi?id=119497
     5
     6        Reviewed by Andreas Kling.
     7
     8        Element currently does too much. Element::recalcStyle() and the related functions can be turned into
     9        standalone functions that operate on DOM tree. This will also give more freedom for future refactoring,
     10        for example making style recalculation non-recursive.
     11
     12        * WebCore.xcodeproj/project.pbxproj:
     13        * css/StyleResolveTree.cpp: Added.
     14        (WebCore::Style::determineChange):
     15               
     16            - moved and renamed from Node::diff
     17            - factored to use early return style
     18            - simplifield the null input logic
     19
     20        (WebCore::Style::pseudoStyleCacheIsInvalid):
     21       
     22            - moved from Element::pseudoStyleCacheIsInvalid
     23            - narrowed to take RenderObject rather than operate on Element
     24
     25        (WebCore::Style::resolveLocal):
     26       
     27            - split from Element::recalcStyle
     28            - factored to use early return style
     29
     30        (WebCore::Style::resolveTree):
     31       
     32            - moved and renamed from Element::recalcStyle
     33
     34        * css/StyleResolveTree.h: Added.
     35       
     36            - introcuduce Style namespace for style related classes and functions
     37            - move and rename Node::StyleChange -> Style::Change
     38
     39        * css/StyleResolver.h:
     40        (WebCore::StyleResolverParentPusher::StyleResolverParentPusher):
     41        (WebCore::StyleResolverParentPusher::push):
     42        (WebCore::StyleResolverParentPusher::~StyleResolverParentPusher):
     43       
     44            Moved this stack helper to StyleResolver.h for now since it is needed by both
     45            StyleRecalculation and Element.
     46
     47        * dom/Document.cpp:
     48        (WebCore::Document::recalcStyle):
     49        (WebCore::Document::updateStyleIfNeeded):
     50        (WebCore::Document::updateLayoutIgnorePendingStylesheets):
     51        (WebCore::Document::attach):
     52        (WebCore::Document::styleResolverChanged):
     53        (WebCore::Document::webkitWillEnterFullScreenForElement):
     54        * dom/Document.h:
     55        * dom/Element.cpp:
     56        (WebCore::shouldIgnoreAttributeCase):
     57        (WebCore::Element::updatePseudoElement):
     58        (WebCore::Element::resetComputedStyle):
     59        (WebCore::Element::willRecalcStyle):
     60        (WebCore::Element::didRecalcStyle):
     61        * dom/Element.h:
     62       
     63            - remove Element::recalcStyle
     64            - make a few private functions needed by StyleRecalculation public
     65
     66        * dom/ElementShadow.cpp:
     67        (WebCore::ElementShadow::recalcStyle):
     68        * dom/ElementShadow.h:
     69        * dom/Node.cpp:
     70        * dom/Node.h:
     71
     72            - remove Node::StyleChange
     73            - remove Node::diff
     74
     75        * dom/PseudoElement.cpp:
     76        (WebCore::PseudoElement::didRecalcStyle):
     77        * dom/PseudoElement.h:
     78        * dom/ShadowRoot.cpp:
     79        (WebCore::ShadowRoot::recalcStyle):
     80        (WebCore::ShadowRoot::setResetStyleInheritance):
     81        * dom/ShadowRoot.h:
     82        * dom/Text.cpp:
     83        (WebCore::Text::recalcTextStyle):
     84        * dom/Text.h:
     85        * html/HTMLFormControlElement.cpp:
     86        (WebCore::HTMLFormControlElement::didRecalcStyle):
     87        * html/HTMLFormControlElement.h:
     88        * html/HTMLFrameSetElement.cpp:
     89        (WebCore::HTMLFrameSetElement::willRecalcStyle):
     90        * html/HTMLFrameSetElement.h:
     91        * html/HTMLIFrameElement.cpp:
     92        (WebCore::HTMLIFrameElement::didRecalcStyle):
     93        * html/HTMLIFrameElement.h:
     94        * html/HTMLMediaElement.cpp:
     95        (WebCore::HTMLMediaElement::didRecalcStyle):
     96        * html/HTMLMediaElement.h:
     97        * html/HTMLOptionElement.cpp:
     98        (WebCore::HTMLOptionElement::didRecalcStyle):
     99        * html/HTMLOptionElement.h:
     100        * html/HTMLPlugInImageElement.cpp:
     101        (WebCore::HTMLPlugInImageElement::willRecalcStyle):
     102        (WebCore::HTMLPlugInImageElement::documentWillSuspendForPageCache):
     103        (WebCore::HTMLPlugInImageElement::documentDidResumeFromPageCache):
     104        * html/HTMLPlugInImageElement.h:
     105        * inspector/InspectorOverlay.cpp:
     106        (WebCore::InspectorOverlay::update):
     107        * loader/DocumentWriter.cpp:
     108        (WebCore::DocumentWriter::reportDataReceived):
     109        * page/Frame.cpp:
     110        (WebCore::Frame::setPageAndTextZoomFactors):
     111        * page/Page.cpp:
     112        (WebCore::Page::setPageScaleFactor):
     113        * rendering/RenderBlock.cpp:
     114        (WebCore::RenderBlock::updateFirstLetterStyle):
     115        * svg/SVGElement.cpp:
     116        (WebCore::SVGElement::willRecalcStyle):
     117        * svg/SVGElement.h:
     118        * svg/SVGUseElement.cpp:
     119        (WebCore::SVGUseElement::willRecalcStyle):
     120        * svg/SVGUseElement.h:
     121
    11222013-08-07  Mihnea Ovidenie  <mihnea@adobe.com>
    2123

  • trunk/Source/WebCore/GNUmakefile.list.am

    r153772 r153783  
    27522752        Source/WebCore/css/StyleResolver.cpp \
    27532753        Source/WebCore/css/StyleResolver.h \
     2754        Source/WebCore/css/StyleResolveTree.cpp \
     2755        Source/WebCore/css/StyleResolveTree.h \
    27542756        Source/WebCore/css/StyleRule.cpp \
    27552757        Source/WebCore/css/StyleRule.h \

  • trunk/Source/WebCore/Target.pri

    r153772 r153783  
    334334    css/StylePropertyShorthand.cpp \
    335335    css/StyleResolver.cpp \
     336    css/StyleResolveTree.cpp \
    336337    css/StyleRule.cpp \
    337338    css/StyleRuleImport.cpp \
    … …  
    15431544    css/StylePropertyShorthand.h \
    15441545    css/StyleResolver.h \
     1546    css/StyleResolveTree.h \
    15451547    css/StyleRule.h \
    15461548    css/StyleRuleImport.h \

  • trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj

    r153772 r153783  
    93549354      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Production|x64'">true</ExcludedFromBuild>
    93559355    </ClCompile>
     9356    <ClCompile Include="..\css\StyleResolveTree.cpp" />
    93569357    <ClCompile Include="..\css\StyleRule.cpp" />
    93579358    <ClCompile Include="..\css\StyleRuleImport.cpp" />
    … …  
    1986719868    <ClInclude Include="..\css\StylePropertyShorthand.h" />
    1986819869    <ClInclude Include="..\css\StyleResolver.h" />
     19870    <ClInclude Include="..\css\StyleResolveTree.h" />
    1986919871    <ClInclude Include="..\css\StyleRule.h" />
    1987019872    <ClInclude Include="..\css\StyleRuleImport.h" />

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r153772 r153783  
    55475547                E4D687770ED7AE3D006EA978 /* PurgeableBufferMac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4D687760ED7AE3D006EA978 /* PurgeableBufferMac.cpp */; };
    55485548                E4D687790ED7AE4F006EA978 /* PurgeableBuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = E4D687780ED7AE4F006EA978 /* PurgeableBuffer.h */; };
     5549                E4DEAA1717A93DC3000E0430 /* StyleResolveTree.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4DEAA1517A93DC3000E0430 /* StyleResolveTree.cpp */; };
     5550                E4DEAA1817A93DC3000E0430 /* StyleResolveTree.h in Headers */ = {isa = PBXBuildFile; fileRef = E4DEAA1617A93DC3000E0430 /* StyleResolveTree.h */; settings = {ATTRIBUTES = (Private, ); }; };
    55495551                E4F9EEF2156D9FFA00D23E7E /* StyleSheetContents.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E4F9EEF0156D84C400D23E7E /* StyleSheetContents.cpp */; };
    55505552                E4F9EEF3156DA00700D23E7E /* StyleSheetContents.h in Headers */ = {isa = PBXBuildFile; fileRef = E4F9EEF1156D84C400D23E7E /* StyleSheetContents.h */; };
    … …  
    1236312365                E4D687760ED7AE3D006EA978 /* PurgeableBufferMac.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PurgeableBufferMac.cpp; sourceTree = "<group>"; };
    1236412366                E4D687780ED7AE4F006EA978 /* PurgeableBuffer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PurgeableBuffer.h; sourceTree = "<group>"; };
     12367                E4DEAA1517A93DC3000E0430 /* StyleResolveTree.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StyleResolveTree.cpp; sourceTree = "<group>"; };
     12368                E4DEAA1617A93DC3000E0430 /* StyleResolveTree.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StyleResolveTree.h; sourceTree = "<group>"; };
    1236512369                E4F9EEF0156D84C400D23E7E /* StyleSheetContents.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StyleSheetContents.cpp; sourceTree = "<group>"; };
    1236612370                E4F9EEF1156D84C400D23E7E /* StyleSheetContents.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StyleSheetContents.h; sourceTree = "<group>"; };
    … …  
    1984119845                                E139866115478474001E3F65 /* StyleResolver.cpp */,
    1984219846                                E139866215478474001E3F65 /* StyleResolver.h */,
     19847                                E4DEAA1517A93DC3000E0430 /* StyleResolveTree.cpp */,
     19848                                E4DEAA1617A93DC3000E0430 /* StyleResolveTree.h */,
    1984319849                                E4BBED4A14FCDBA1003F0B98 /* StyleRule.cpp */,
    1984419850                                E4BBED4B14FCDBA1003F0B98 /* StyleRule.h */,
    … …  
    2141721423                                52CCA9E815E3F64C0053C77F /* DOMDOMNamedFlowCollection.h in Headers */,
    2141821424                                52CCA9EA15E3F64C0053C77F /* DOMDOMNamedFlowCollectionInternal.h in Headers */,
     21425                                E4DEAA1817A93DC3000E0430 /* StyleResolveTree.h in Headers */,
    2141921426                                2D9A247415B9C2E300D34527 /* DOMDOMSecurityPolicy.h in Headers */,
    2142021427                                2D9A247515B9C2E300D34527 /* DOMDOMSecurityPolicyInternal.h in Headers */,
    … …  
    2453924546                                072CA86116CB4DC3008AE131 /* CaptionUserPreferences.cpp in Sources */,
    2454024547                                079D086C162F21F900DB8658 /* CaptionUserPreferencesMediaAF.cpp in Sources */,
     24548                                E4DEAA1717A93DC3000E0430 /* StyleResolveTree.cpp in Sources */,
    2454124549                                6550B69D099DF0270090D781 /* CDATASection.cpp in Sources */,
    2454224550                                CDA98E0B1603CD6000FEA3B1 /* CDM.cpp in Sources */,

  • trunk/Source/WebCore/css/StyleResolver.h

    r153748 r153783  
    678678}
    679679
     680class StyleResolverParentPusher {
     681public:
     682    StyleResolverParentPusher(Element* parent)
     683        : m_parent(parent)
     684        , m_pushedStyleResolver(0)
     685    { }
     686    void push()
     687    {
     688        if (m_pushedStyleResolver)
     689            return;
     690        m_pushedStyleResolver = m_parent->document()->ensureStyleResolver();
     691        m_pushedStyleResolver->pushParentElement(m_parent);
     692    }
     693    ~StyleResolverParentPusher()
     694    {
     695        if (!m_pushedStyleResolver)
     696            return;
     697        // This tells us that our pushed style selector is in a bad state,
     698        // so we should just bail out in that scenario.
     699        ASSERT(m_pushedStyleResolver == m_parent->document()->ensureStyleResolver());
     700        if (m_pushedStyleResolver != m_parent->document()->ensureStyleResolver())
     701            return;
     702        m_pushedStyleResolver->popParentElement(m_parent);
     703    }
     704   
     705private:
     706    Element* m_parent;
     707    StyleResolver* m_pushedStyleResolver;
     708};
     709
    680710} // namespace WebCore
    681711

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

    r153772 r153783  
    17431743}
    17441744
    1745 void Document::recalcStyle(StyleChange change)
     1745void Document::recalcStyle(Style::Change change)
    17461746{
    17471747    // we should not enter style recalc while painting
    … …  
    17841784
    17851785        if (m_pendingStyleRecalcShouldForce)
    1786             change = Force;
     1786            change = Style::Force;
    17871787
    17881788        // Recalculating the root style (on the document) is not needed in the common case.
    1789         if ((change == Force) || (shouldDisplaySeamlesslyWithParent() && (change >= Inherit))) {
     1789        if ((change == Style::Force) || (shouldDisplaySeamlesslyWithParent() && (change >= Style::Inherit))) {
    17901790            // style selector may set this again during recalc
    17911791            m_hasNodesWithPlaceholderStyle = false;
    17921792           
    17931793            RefPtr<RenderStyle> documentStyle = StyleResolver::styleForDocument(this, m_styleResolver ? m_styleResolver->fontSelector() : 0);
    1794             StyleChange ch = Node::diff(documentStyle.get(), renderer()->style(), this);
    1795             if (ch != NoChange)
     1794            Style::Change documentChange = Style::determineChange(documentStyle.get(), renderer()->style(), settings());
     1795            if (documentChange != Style::NoChange)
    17961796                renderer()->setStyle(documentStyle.release());
    17971797        }
    … …  
    18011801                continue;
    18021802            Element* element = toElement(n);
    1803             if (change >= Inherit || element->childNeedsStyleRecalc() || element->needsStyleRecalc())
    1804                 element->recalcStyle(change);
     1803            if (change >= Style::Inherit || element->childNeedsStyleRecalc() || element->needsStyleRecalc())
     1804                Style::resolveTree(element, change);
    18051805        }
    18061806
    … …  
    18511851
    18521852    AnimationUpdateBlock animationUpdateBlock(m_frame ? m_frame->animation() : 0);
    1853     recalcStyle(NoChange);
     1853    recalcStyle(Style::NoChange);
    18541854}
    18551855
    … …  
    19171917            // may not have had their real style calculated yet. Normally this gets cleaned when style sheets arrive
    19181918            // but here we need up-to-date style immediately.
    1919             recalcStyle(Force);
     1919            recalcStyle(Style::Force);
    19201920    }
    19211921
    … …  
    20252025#endif
    20262026
    2027     recalcStyle(Force);
     2027    recalcStyle(Style::Force);
    20282028
    20292029    RenderObject* render = renderer();
    … …  
    31803180    {
    31813181        AnimationUpdateBlock animationUpdateBlock(m_frame ? m_frame->animation() : 0);
    3182         recalcStyle(Force);
     3182        recalcStyle(Style::Force);
    31833183    }
    31843184
    … …  
    52105210    m_fullScreenElement->setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
    52115211   
    5212     recalcStyle(Force);
     5212    recalcStyle(Style::Force);
    52135213}
    52145214

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

    r153772 r153783  
    4545#include "ScriptExecutionContext.h"
    4646#include "StringWithDirection.h"
     47#include "StyleResolveTree.h"
    4748#include "Timer.h"
    4849#include "TreeScope.h"
    … …  
    506507    PassRefPtr<Text> createEditingTextNode(const String&);
    507508
    508     void recalcStyle(StyleChange = NoChange);
     509    void recalcStyle(Style::Change = Style::NoChange);
    509510    bool childNeedsAndNotInStyleRecalc();
    510511    void updateStyleIfNeeded();

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

    r153772 r153783  
    108108    return e && e->document()->isHTMLDocument() && e->isHTMLElement();
    109109}
    110    
    111 class StyleResolverParentPusher {
    112 public:
    113     StyleResolverParentPusher(Element* parent)
    114         : m_parent(parent)
    115         , m_pushedStyleResolver(0)
    116     {
    117     }
    118     void push()
    119     {
    120         if (m_pushedStyleResolver)
    121             return;
    122         m_pushedStyleResolver = m_parent->document()->ensureStyleResolver();
    123         m_pushedStyleResolver->pushParentElement(m_parent);
    124     }
    125     ~StyleResolverParentPusher()
    126     {
    127 
    128         if (!m_pushedStyleResolver)
    129             return;
    130 
    131         // This tells us that our pushed style selector is in a bad state,
    132         // so we should just bail out in that scenario.
    133         ASSERT(m_pushedStyleResolver == m_parent->document()->ensureStyleResolver());
    134         if (m_pushedStyleResolver != m_parent->document()->ensureStyleResolver())
    135             return;
    136 
    137         m_pushedStyleResolver->popParentElement(m_parent);
    138     }
    139 
    140 private:
    141     Element* m_parent;
    142     StyleResolver* m_pushedStyleResolver;
    143 };
    144110
    145111typedef Vector<RefPtr<Attr> > AttrNodeList;
    … …  
    14981464}
    14991465
    1500 bool Element::pseudoStyleCacheIsInvalid(const RenderStyle* currentStyle, RenderStyle* newStyle)
    1501 {
    1502     ASSERT(currentStyle == renderStyle());
    1503     ASSERT(renderer());
    1504 
    1505     if (!currentStyle)
    1506         return false;
    1507 
    1508     const PseudoStyleCache* pseudoStyleCache = currentStyle->cachedPseudoStyles();
    1509     if (!pseudoStyleCache)
    1510         return false;
    1511 
    1512     size_t cacheSize = pseudoStyleCache->size();
    1513     for (size_t i = 0; i < cacheSize; ++i) {
    1514         RefPtr<RenderStyle> newPseudoStyle;
    1515         PseudoId pseudoId = pseudoStyleCache->at(i)->styleType();
    1516         if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED)
    1517             newPseudoStyle = renderer()->uncachedFirstLineStyle(newStyle);
    1518         else
    1519             newPseudoStyle = renderer()->getUncachedPseudoStyle(PseudoStyleRequest(pseudoId), newStyle, newStyle);
    1520         if (!newPseudoStyle)
    1521             return true;
    1522         if (*newPseudoStyle != *pseudoStyleCache->at(i)) {
    1523             if (pseudoId < FIRST_INTERNAL_PSEUDOID)
    1524                 newStyle->setHasPseudoStyle(pseudoId);
    1525             newStyle->addCachedPseudoStyle(newPseudoStyle);
    1526             if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED) {
    1527                 // FIXME: We should do an actual diff to determine whether a repaint vs. layout
    1528                 // is needed, but for now just assume a layout will be required.  The diff code
    1529                 // in RenderObject::setStyle would need to be factored out so that it could be reused.
    1530                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
    1531             }
    1532             return true;
    1533         }
    1534     }
    1535     return false;
    1536 }
    1537 
    15381466PassRefPtr<RenderStyle> Element::styleForRenderer()
    15391467{
    … …  
    15441472
    15451473    return document()->ensureStyleResolver()->styleForElement(this);
    1546 }
    1547 
    1548 void Element::recalcStyle(StyleChange change)
    1549 {
    1550     if (hasCustomStyleCallbacks()) {
    1551         if (!willRecalcStyle(change))
    1552             return;
    1553     }
    1554 
    1555     // Ref currentStyle in case it would otherwise be deleted when setting the new style in the renderer.
    1556     RefPtr<RenderStyle> currentStyle(renderStyle());
    1557     bool hasParentStyle = parentNodeForRenderingAndStyle() ? static_cast<bool>(parentNodeForRenderingAndStyle()->renderStyle()) : false;
    1558     bool hasDirectAdjacentRules = childrenAffectedByDirectAdjacentRules();
    1559     bool hasIndirectAdjacentRules = childrenAffectedByForwardPositionalRules();
    1560 
    1561     if ((change > NoChange || needsStyleRecalc())) {
    1562         if (hasRareData())
    1563             elementRareData()->resetComputedStyle();
    1564     }
    1565     if (hasParentStyle && (change >= Inherit || needsStyleRecalc())) {
    1566         StyleChange localChange = Detach;
    1567         RefPtr<RenderStyle> newStyle;
    1568         if (currentStyle) {
    1569             newStyle = styleForRenderer();
    1570             localChange = Node::diff(currentStyle.get(), newStyle.get(), document());
    1571         }
    1572         if (localChange == Detach) {
    1573             AttachContext reattachContext;
    1574             reattachContext.resolvedStyle = newStyle.get();
    1575             reattach(reattachContext);
    1576 
    1577             // attach recalculates the style for all children. No need to do it twice.
    1578             clearNeedsStyleRecalc();
    1579             clearChildNeedsStyleRecalc();
    1580 
    1581             if (hasCustomStyleCallbacks())
    1582                 didRecalcStyle(change);
    1583             return;
    1584         }
    1585 
    1586         if (RenderObject* renderer = this->renderer()) {
    1587             if (localChange != NoChange || pseudoStyleCacheIsInvalid(currentStyle.get(), newStyle.get()) || (change == Force && renderer->requiresForcedStyleRecalcPropagation()) || styleChangeType() == SyntheticStyleChange)
    1588                 renderer->setAnimatableStyle(newStyle.get());
    1589             else if (needsStyleRecalc()) {
    1590                 // Although no change occurred, we use the new style so that the cousin style sharing code won't get
    1591                 // fooled into believing this style is the same.
    1592                 renderer->setStyleInternal(newStyle.get());
    1593             }
    1594         }
    1595 
    1596         // 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
    1597         // 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).
    1598         if (document()->styleSheetCollection()->usesRemUnits() && document()->documentElement() == this && localChange != NoChange && currentStyle && newStyle && currentStyle->fontSize() != newStyle->fontSize()) {
    1599             // Cached RenderStyles may depend on the re units.
    1600             if (StyleResolver* styleResolver = document()->styleResolverIfExists())
    1601                 styleResolver->invalidateMatchedPropertiesCache();
    1602             change = Force;
    1603         }
    1604 
    1605         if (change != Force) {
    1606             if (styleChangeType() >= FullStyleChange)
    1607                 change = Force;
    1608             else
    1609                 change = localChange;
    1610         }
    1611     }
    1612     StyleResolverParentPusher parentPusher(this);
    1613 
    1614     // FIXME: This does not care about sibling combinators. Will be necessary in XBL2 world.
    1615     if (ElementShadow* shadow = this->shadow()) {
    1616         if (change >= Inherit || shadow->childNeedsStyleRecalc() || shadow->needsStyleRecalc()) {
    1617             parentPusher.push();
    1618             shadow->recalcStyle(change);
    1619         }
    1620     }
    1621 
    1622     updatePseudoElement(BEFORE, change);
    1623 
    1624     // FIXME: This check is good enough for :hover + foo, but it is not good enough for :hover + foo + bar.
    1625     // For now we will just worry about the common case, since it's a lot trickier to get the second case right
    1626     // without doing way too much re-resolution.
    1627     bool forceCheckOfNextElementSibling = false;
    1628     bool forceCheckOfAnyElementSibling = false;
    1629     for (Node *n = firstChild(); n; n = n->nextSibling()) {
    1630         if (n->isTextNode()) {
    1631             toText(n)->recalcTextStyle(change);
    1632             continue;
    1633         }
    1634         if (!n->isElementNode())
    1635             continue;
    1636         Element* element = toElement(n);
    1637         bool childRulesChanged = element->needsStyleRecalc() && element->styleChangeType() == FullStyleChange;
    1638         if ((forceCheckOfNextElementSibling || forceCheckOfAnyElementSibling))
    1639             element->setNeedsStyleRecalc();
    1640         if (change >= Inherit || element->childNeedsStyleRecalc() || element->needsStyleRecalc()) {
    1641             parentPusher.push();
    1642             element->recalcStyle(change);
    1643         }
    1644         forceCheckOfNextElementSibling = childRulesChanged && hasDirectAdjacentRules;
    1645         forceCheckOfAnyElementSibling = forceCheckOfAnyElementSibling || (childRulesChanged && hasIndirectAdjacentRules);
    1646     }
    1647 
    1648     updatePseudoElement(AFTER, change);
    1649 
    1650     clearNeedsStyleRecalc();
    1651     clearChildNeedsStyleRecalc();
    1652    
    1653     if (hasCustomStyleCallbacks())
    1654         didRecalcStyle(change);
    16551474}
    16561475
    … …  
    24922311}
    24932312
    2494 void Element::updatePseudoElement(PseudoId pseudoId, StyleChange change)
     2313void Element::updatePseudoElement(PseudoId pseudoId, Style::Change change)
    24952314{
    24962315    PseudoElement* existing = pseudoElement(pseudoId);
    … …  
    24982317        // PseudoElement styles hang off their parent element's style so if we needed
    24992318        // a style recalc we should Force one on the pseudo.
    2500         existing->recalcStyle(needsStyleRecalc() ? Force : change);
     2319        Style::resolveTree(existing, needsStyleRecalc() ? Style::Force : change);
    25012320
    25022321        // Wait until our parent is not displayed or pseudoElementRendererIsNeeded
    … …  
    31282947}
    31292948
    3130 bool Element::willRecalcStyle(StyleChange)
     2949void Element::resetComputedStyle()
     2950{
     2951    if (!hasRareData())
     2952        return;
     2953    elementRareData()->resetComputedStyle();
     2954}
     2955
     2956bool Element::willRecalcStyle(Style::Change)
    31312957{
    31322958    ASSERT(hasCustomStyleCallbacks());
    … …  
    31342960}
    31352961
    3136 void Element::didRecalcStyle(StyleChange)
     2962void Element::didRecalcStyle(Style::Change)
    31372963{
    31382964    ASSERT(hasCustomStyleCallbacks());
    31392965}
    3140 
    31412966
    31422967PassRefPtr<RenderStyle> Element::customStyleForRenderer()

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

    r152345 r153783  
    3333#include "ScrollTypes.h"
    3434#include "SpaceSplitString.h"
     35#include "StyleResolveTree.h"
    3536
    3637namespace WebCore {
    … …  
    415416    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
    416417    virtual bool rendererIsNeeded(const NodeRenderingContext&);
    417     void recalcStyle(StyleChange = NoChange);
    418418    void didAffectSelector(AffectedSelectorMask);
    419419
    … …  
    658658    virtual void dispatchBlurEvent(PassRefPtr<Element> newFocusedElement);
    659659
     660    virtual bool willRecalcStyle(Style::Change);
     661    virtual void didRecalcStyle(Style::Change);
     662    void updatePseudoElement(PseudoId, Style::Change = Style::NoChange);
     663    void resetComputedStyle();
     664
    660665protected:
    661666    Element(const QualifiedName& tagName, Document* document, ConstructionType type)
    … …  
    670675    virtual void removeAllEventListeners() OVERRIDE FINAL;
    671676
    672     virtual bool willRecalcStyle(StyleChange);
    673     virtual void didRecalcStyle(StyleChange);
    674677    virtual PassRefPtr<RenderStyle> customStyleForRenderer();
    675678
    … …  
    693696    bool isUserActionElementHovered() const;
    694697
    695     void updatePseudoElement(PseudoId, StyleChange = NoChange);
    696698    PassRefPtr<PseudoElement> createPseudoElementIfNeeded(PseudoId);
    697699    void setPseudoElement(PseudoId, PassRefPtr<PseudoElement>);
    … …  
    737739    virtual void formatForDebugger(char* buffer, unsigned length) const;
    738740#endif
    739 
    740     bool pseudoStyleCacheIsInvalid(const RenderStyle* currentStyle, RenderStyle* newStyle);
    741741
    742742    void cancelFocusAppearanceUpdate();

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

    r151839 r153783  
    114114}
    115115
    116 void ElementShadow::recalcStyle(Node::StyleChange change)
     116void ElementShadow::recalcStyle(Style::Change change)
    117117{
    118118    if (ShadowRoot* root = shadowRoot())

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

    r151839 r153783  
    6262    bool childNeedsStyleRecalc() const;
    6363    bool needsStyleRecalc() const;
    64     void recalcStyle(Node::StyleChange);
     64    void recalcStyle(Style::Change);
    6565    void removeAllEventListeners();
    6666

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

    r153772 r153783  
    321321}
    322322
    323 Node::StyleChange Node::diff(const RenderStyle* s1, const RenderStyle* s2, Document* doc)
    324 {
    325     StyleChange ch = NoInherit;
    326     EDisplay display1 = s1 ? s1->display() : NONE;
    327     bool fl1 = s1 && s1->hasPseudoStyle(FIRST_LETTER);
    328     EDisplay display2 = s2 ? s2->display() : NONE;
    329     bool fl2 = s2 && s2->hasPseudoStyle(FIRST_LETTER);
    330    
    331     // We just detach if a renderer acquires or loses a column-span, since spanning elements
    332     // typically won't contain much content.
    333     bool colSpan1 = s1 && s1->columnSpan();
    334     bool colSpan2 = s2 && s2->columnSpan();
    335    
    336     bool specifiesColumns1 = s1 && (!s1->hasAutoColumnCount() || !s1->hasAutoColumnWidth());
    337     bool specifiesColumns2 = s2 && (!s2->hasAutoColumnCount() || !s2->hasAutoColumnWidth());
    338 
    339     if (display1 != display2 || fl1 != fl2 || colSpan1 != colSpan2
    340         || (specifiesColumns1 != specifiesColumns2 && doc->settings()->regionBasedColumnsEnabled())
    341         || (s1 && s2 && !s1->contentDataEquivalent(s2)))
    342         ch = Detach;
    343     else if (!s1 || !s2)
    344         ch = Inherit;
    345     else if (*s1 == *s2)
    346         ch = NoChange;
    347     else if (s1->inheritedNotEqual(s2))
    348         ch = Inherit;
    349     else if (s1->hasExplicitlyInheritedProperties() || s2->hasExplicitlyInheritedProperties())
    350         ch = Inherit;
    351 
    352     // If the pseudoStyles have changed, we want any StyleChange that is not NoChange
    353     // because setStyle will do the right thing with anything else.
    354     if (ch == NoChange && s1->hasAnyPublicPseudoStyles()) {
    355         for (PseudoId pseudoId = FIRST_PUBLIC_PSEUDOID; ch == NoChange && pseudoId < FIRST_INTERNAL_PSEUDOID; pseudoId = static_cast<PseudoId>(pseudoId + 1)) {
    356             if (s1->hasPseudoStyle(pseudoId)) {
    357                 RenderStyle* ps2 = s2->getCachedPseudoStyle(pseudoId);
    358                 if (!ps2)
    359                     ch = NoInherit;
    360                 else {
    361                     RenderStyle* ps1 = s1->getCachedPseudoStyle(pseudoId);
    362                     ch = ps1 && *ps1 == *ps2 ? NoChange : NoInherit;
    363                 }
    364             }
    365         }
    366     }
    367 
    368     // When text-combine property has been changed, we need to prepare a separate renderer object.
    369     // When text-combine is on, we use RenderCombineText, otherwise RenderText.
    370     // https://bugs.webkit.org/show_bug.cgi?id=55069
    371     if ((s1 && s2) && (s1->hasTextCombine() != s2->hasTextCombine()))
    372         ch = Detach;
    373 
    374     // We need to reattach the node, so that it is moved to the correct RenderFlowThread.
    375     if ((s1 && s2) && (s1->flowThread() != s2->flowThread()))
    376         ch = Detach;
    377 
    378     // When the region thread has changed, we need to prepare a separate render region object.
    379     if ((s1 && s2) && (s1->regionThread() != s2->regionThread()))
    380         ch = Detach;
    381 
    382     return ch;
    383 }
    384 
    385323void Node::trackForDebugging()
    386324{

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

    r153772 r153783  
    169169    static void dumpStatistics();
    170170
    171     enum StyleChange { NoChange, NoInherit, Inherit, Detach, Force };   
    172     static StyleChange diff(const RenderStyle*, const RenderStyle*, Document*);
    173 
    174171    virtual ~Node();
    175172    void willBeDeletedFrom(Document*);

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

    r151282 r153783  
    106106}
    107107
    108 void PseudoElement::didRecalcStyle(StyleChange)
     108void PseudoElement::didRecalcStyle(Style::Change)
    109109{
    110110    if (!renderer())

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

    r152347 r153783  
    6161    PseudoElement(Element*, PseudoId);
    6262
    63     virtual void didRecalcStyle(StyleChange) OVERRIDE;
     63    virtual void didRecalcStyle(Style::Change) OVERRIDE;
    6464    virtual PseudoId customPseudoId() const OVERRIDE { return m_pseudoId; }
    6565

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

    r151282 r153783  
    123123}
    124124
    125 void ShadowRoot::recalcStyle(StyleChange change)
     125void ShadowRoot::recalcStyle(Style::Change change)
    126126{
    127127    // ShadowRoot doesn't support custom callbacks.
    … …  
    133133    for (Node* child = firstChild(); child; child = child->nextSibling()) {
    134134        if (child->isElementNode())
    135             toElement(child)->recalcStyle(change);
     135            Style::resolveTree(toElement(child), change);
    136136        else if (child->isTextNode())
    137137            toText(child)->recalcTextStyle(change);
    … …  
    162162        m_resetStyleInheritance = value;
    163163        if (attached() && owner())
    164             owner()->recalcStyle(Force);
     164            owner()->recalcStyle(Style::Force);
    165165    }
    166166}

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

    r151282 r153783  
    5757    virtual ~ShadowRoot();
    5858
    59     void recalcStyle(StyleChange);
     59    void recalcStyle(Style::Change);
    6060
    6161    virtual bool applyAuthorStyles() const OVERRIDE { return m_applyAuthorStyles; }

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

    r153548 r153783  
    283283}
    284284
    285 void Text::recalcTextStyle(StyleChange change)
     285void Text::recalcTextStyle(Style::Change change)
    286286{
    287287    RenderText* renderer = toRenderText(this->renderer());
    288288
    289     if (change != NoChange && renderer)
     289    if (change != Style::NoChange && renderer)
    290290        renderer->setStyle(document()->ensureStyleResolver()->styleForText(this));
    291291

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

    r152320 r153783  
    2525
    2626#include "CharacterData.h"
     27#include "StyleResolveTree.h"
    2728
    2829namespace WebCore {
    … …  
    4546    PassRefPtr<Text> replaceWholeText(const String&, ExceptionCode&);
    4647   
    47     void recalcTextStyle(StyleChange);
     48    void recalcTextStyle(Style::Change);
    4849    void createTextRendererIfNeeded();
    4950    bool textRendererIsNeeded(const NodeRenderingContext&);

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

    r152218 r153783  
    301301}
    302302
    303 void HTMLFormControlElement::didRecalcStyle(StyleChange)
     303void HTMLFormControlElement::didRecalcStyle(Style::Change)
    304304{
    305305    // updateFromElement() can cause the selection to change, and in turn

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

    r151282 r153783  
    121121    virtual bool isMouseFocusable() const OVERRIDE;
    122122
    123     virtual void didRecalcStyle(StyleChange) OVERRIDE;
     123    virtual void didRecalcStyle(Style::Change) OVERRIDE;
    124124
    125125    virtual void dispatchBlurEvent(PassRefPtr<Element> newFocusedElement) OVERRIDE;

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

    r151282 r153783  
    201201}
    202202
    203 bool HTMLFrameSetElement::willRecalcStyle(StyleChange)
     203bool HTMLFrameSetElement::willRecalcStyle(Style::Change)
    204204{
    205205    if (needsStyleRecalc() && renderer()) {

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

    r151282 r153783  
    7878    virtual void defaultEventHandler(Event*);
    7979
    80     virtual bool willRecalcStyle(StyleChange);
     80    virtual bool willRecalcStyle(Style::Change) OVERRIDE;
    8181
    8282    virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;

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

    r153772 r153783  
    107107}
    108108
    109 void HTMLIFrameElement::didRecalcStyle(StyleChange styleChange)
     109void HTMLIFrameElement::didRecalcStyle(Style::Change styleChange)
    110110{
    111111    if (!shouldDisplaySeamlessly())
    112112        return;
    113113    Document* childDocument = contentDocument();
    114     if (styleChange >= Inherit || childDocument->childNeedsStyleRecalc() || childDocument->needsStyleRecalc())
     114    if (styleChange >= Style::Inherit || childDocument->childNeedsStyleRecalc() || childDocument->needsStyleRecalc())
    115115        contentDocument()->recalcStyle(styleChange);
    116116}

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

    r153772 r153783  
    4545    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
    4646
    47     virtual void didRecalcStyle(StyleChange) OVERRIDE;
     47    virtual void didRecalcStyle(Style::Change) OVERRIDE;
    4848};
    4949

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

    r153772 r153783  
    652652}
    653653
    654 void HTMLMediaElement::didRecalcStyle(StyleChange)
     654void HTMLMediaElement::didRecalcStyle(Style::Change)
    655655{
    656656    if (renderer())

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

    r153772 r153783  
    437437    virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
    438438    virtual void removedFrom(ContainerNode*) OVERRIDE;
    439     virtual void didRecalcStyle(StyleChange);
    440    
     439    virtual void didRecalcStyle(Style::Change);
     440
    441441    virtual void defaultEventHandler(Event*);
    442442

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

    r152211 r153783  
    324324}
    325325
    326 void HTMLOptionElement::didRecalcStyle(StyleChange)
     326void HTMLOptionElement::didRecalcStyle(Style::Change)
    327327{
    328328    // FIXME: This is nasty, we ask our owner select to repaint even if the new

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

    r152353 r153783  
    8787    virtual PassRefPtr<RenderStyle> customStyleForRenderer() OVERRIDE;
    8888
    89     void didRecalcStyle(StyleChange) OVERRIDE;
     89    void didRecalcStyle(Style::Change) OVERRIDE;
    9090
    9191    String collectOptionInnerText() const;

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

    r153145 r153783  
    225225}
    226226
    227 bool HTMLPlugInImageElement::willRecalcStyle(StyleChange)
     227bool HTMLPlugInImageElement::willRecalcStyle(Style::Change)
    228228{
    229229    // FIXME: Why is this necessary?  Manual re-attach is almost always wrong.
    … …  
    304304        m_customStyleForPageCache = RenderStyle::clone(renderStyle);
    305305        m_customStyleForPageCache->setDisplay(NONE);
    306         recalcStyle(Force);
     306        Style::resolveTree(this, Style::Force);
    307307    }
    308308
    … …  
    314314    if (m_customStyleForPageCache) {
    315315        m_customStyleForPageCache = 0;
    316         recalcStyle(Force);
     316        Style::resolveTree(this, Style::Force);
    317317    }
    318318

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

    r151947 r153783  
    127127private:
    128128    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*) OVERRIDE;
    129     virtual bool willRecalcStyle(StyleChange) OVERRIDE;
     129    virtual bool willRecalcStyle(Style::Change) OVERRIDE;
    130130
    131131    void didAddUserAgentShadowRoot(ShadowRoot*) OVERRIDE;

  • trunk/Source/WebCore/inspector/InspectorOverlay.cpp

    r151425 r153783  
    302302
    303303    // Position DOM elements.
    304     overlayPage()->mainFrame()->document()->recalcStyle(Node::Force);
     304    overlayPage()->mainFrame()->document()->recalcStyle(Style::Force);
    305305    if (overlayView->needsLayout())
    306306        overlayView->layout();

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

    r149830 r153783  
    209209    if (m_decoder->encoding().usesVisualOrdering())
    210210        m_frame->document()->setVisuallyOrdered();
    211     m_frame->document()->recalcStyle(Node::Force);
     211    m_frame->document()->recalcStyle(Style::Force);
    212212}
    213213

  • trunk/Source/WebCore/page/Frame.cpp

    r153431 r153783  
    930930    m_textZoomFactor = textZoomFactor;
    931931
    932     document->recalcStyle(Node::Force);
     932    document->recalcStyle(Style::Force);
    933933
    934934    for (RefPtr<Frame> child = tree()->firstChild(); child; child = child->tree()->nextSibling())

  • trunk/Source/WebCore/page/Page.cpp

    r153704 r153783  
    780780            document->renderer()->setNeedsLayout(true);
    781781
    782         document->recalcStyle(Node::Force);
     782        document->recalcStyle(Style::Force);
    783783
    784784        // Transform change on RenderView doesn't trigger repaint on non-composited contents.

  • trunk/Source/WebCore/rendering/RenderBlock.cpp

    r153781 r153783  
    67546754    ASSERT(firstLetter->isFloating() || firstLetter->isInline());
    67556755
    6756     if (Node::diff(firstLetter->style(), pseudoStyle, document()) == Node::Detach) {
     6756    if (Style::determineChange(firstLetter->style(), pseudoStyle, document()->settings()) == Style::Detach) {
    67576757        // The first-letter renderer needs to be replaced. Create a new renderer of the right type.
    67586758        RenderBoxModelObject* newFirstLetter;

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

    r152553 r153783  
    8989}
    9090
    91 bool SVGElement::willRecalcStyle(StyleChange change)
     91bool SVGElement::willRecalcStyle(Style::Change change)
    9292{
    9393    if (!hasSVGRareData() || styleChangeType() == SyntheticStyleChange)
    … …  
    9595    // If the style changes because of a regular property change (not induced by SMIL animations themselves)
    9696    // reset the "computed style without SMIL style properties", so the base value change gets reflected.
    97     if (change > NoChange || needsStyleRecalc())
     97    if (change > Style::NoChange || needsStyleRecalc())
    9898        svgRareData()->setNeedsOverrideComputedStyleUpdate();
    9999    return true;

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

    r152346 r153783  
    150150    RenderStyle* computedStyle(PseudoId = NOPSEUDO);
    151151    virtual RenderStyle* virtualComputedStyle(PseudoId pseudoElementSpecifier = NOPSEUDO) { return computedStyle(pseudoElementSpecifier); }
    152     virtual bool willRecalcStyle(StyleChange);
     152    virtual bool willRecalcStyle(Style::Change);
    153153
    154154    virtual bool rendererIsNeeded(const NodeRenderingContext&) { return false; }

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

    r152963 r153783  
    270270}
    271271
    272 bool SVGUseElement::willRecalcStyle(StyleChange)
     272bool SVGUseElement::willRecalcStyle(Style::Change)
    273273{
    274274    if (!m_wasInsertedByParser && m_needsShadowTreeRecreation && renderer() && needsStyleRecalc())

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

    r152963 r153783  
    3131#include "SVGNames.h"
    3232#include "SVGURIReference.h"
     33#include "StyleResolveTree.h"
    3334
    3435namespace WebCore {
    … …  
    6768    virtual void svgAttributeChanged(const QualifiedName&);
    6869
    69     virtual bool willRecalcStyle(StyleChange);
     70    virtual bool willRecalcStyle(Style::Change);
    7071
    7172    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
Note: See TracChangeset for help on using the changeset viewer.