Changeset 140530 in webkit


Ignore:
Timestamp:
Jan 23, 2013 2:26:04 AM (11 years ago)
Author:
akling@apple.com
Message:

Pass CSSSelector pointers around as const after parsing stage.
<​http://webkit.org/b/107645>

Reviewed by Antti Koivisto.

Have CSSSelectorList vend const CSSSelector* and make the style resolution code
operate on const pointers instead.

This gives us some compile-time confidence that nobody is changing the selectors
after we've parsed them.

  • css/CSSSelector.cpp:

(WebCore::CSSSelector::operator==):
(WebCore::CSSSelector::selectorText):
(WebCore::CSSSelector::parseNth):
(WebCore::CSSSelector::matchNth):

  • css/CSSSelector.h:

(CSSSelector):
(WebCore::CSSSelector::tagHistory):
(WebCore::CSSSelector::selectorList):

  • css/CSSSelectorList.cpp:

(WebCore::CSSSelectorList::selectorsText):
(WebCore::forEachTagSelector):
(WebCore::forEachSelector):
(WebCore::SelectorNeedsNamespaceResolutionFunctor::operator()):
(WebCore::SelectorHasInvalidSelectorFunctor::operator()):

  • css/CSSSelectorList.h:

(WebCore::CSSSelectorList::first):
(CSSSelectorList):
(WebCore::CSSSelectorList::selectorAt):
(WebCore::CSSSelectorList::indexOfNextSelectorAfter):
(WebCore::CSSSelectorList::next):

  • css/CSSStyleRule.cpp:

(WebCore::CSSStyleRule::generateSelectorText):

  • css/RuleSet.cpp:

(WebCore::selectorListContainsUncommonAttributeSelector):
(WebCore::collectFeaturesFromRuleData):

  • css/RuleSet.h:

(WebCore::RuleData::selector):
(WebCore::RuleSet::RuleSetSelectorPair::RuleSetSelectorPair):
(RuleSetSelectorPair):

  • css/SelectorChecker.cpp:

(WebCore::SelectorChecker::matches):
(WebCore::SelectorChecker::match):
(WebCore::SelectorChecker::checkOne):
(WebCore::SelectorChecker::checkScrollbarPseudoClass):
(WebCore::SelectorChecker::determineLinkMatchType):

  • css/SelectorChecker.h:

(WebCore::SelectorChecker::SelectorCheckingContext::SelectorCheckingContext):
(SelectorCheckingContext):
(SelectorChecker):

  • css/StyleInvalidationAnalysis.cpp:

(WebCore::determineSelectorScopes):

  • css/StyleResolver.cpp:

(WebCore::StyleResolver::collectMatchingRulesForRegion):
(WebCore::StyleResolver::checkRegionSelector):

  • css/StyleResolver.h:

(StyleResolver):

  • dom/SelectorQuery.cpp:

(WebCore::SelectorDataList::initialize):
(WebCore::SelectorDataList::execute):

  • dom/SelectorQuery.h:

(WebCore::SelectorDataList::SelectorData::SelectorData):
(SelectorData):

  • html/shadow/ContentDistributor.cpp:

(WebCore::ContentDistributor::collectSelectFeatureSetFrom):

  • html/shadow/ContentSelectorQuery.cpp:

(WebCore::ContentSelectorChecker::checkContentSelector):
(WebCore::ContentSelectorDataList::initialize):

  • html/shadow/ContentSelectorQuery.h:

(ContentSelectorChecker):
(ContentSelectorDataList):

  • html/shadow/HTMLContentElement.cpp:

(WebCore::validateSubSelector):
(WebCore::validateSelector):
(WebCore::HTMLContentElement::validateSelect):

  • inspector/InspectorCSSAgent.cpp:

(WebCore::InspectorCSSAgent::buildArrayForMatchedRuleList):

  • inspector/InspectorStyleSheet.cpp:

(WebCore::InspectorStyleSheet::buildObjectForSelectorList):

Location:
trunk/Source/WebCore
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r140529 r140530  
     12013-01-23  Andreas Kling  <akling@apple.com>
     2
     3        Pass CSSSelector pointers around as const after parsing stage.
     4        <http://webkit.org/b/107645>
     5
     6        Reviewed by Antti Koivisto.
     7
     8        Have CSSSelectorList vend const CSSSelector* and make the style resolution code
     9        operate on const pointers instead.
     10
     11        This gives us some compile-time confidence that nobody is changing the selectors
     12        after we've parsed them.
     13
     14        * css/CSSSelector.cpp:
     15        (WebCore::CSSSelector::operator==):
     16        (WebCore::CSSSelector::selectorText):
     17        (WebCore::CSSSelector::parseNth):
     18        (WebCore::CSSSelector::matchNth):
     19        * css/CSSSelector.h:
     20        (CSSSelector):
     21        (WebCore::CSSSelector::tagHistory):
     22        (WebCore::CSSSelector::selectorList):
     23        * css/CSSSelectorList.cpp:
     24        (WebCore::CSSSelectorList::selectorsText):
     25        (WebCore::forEachTagSelector):
     26        (WebCore::forEachSelector):
     27        (WebCore::SelectorNeedsNamespaceResolutionFunctor::operator()):
     28        (WebCore::SelectorHasInvalidSelectorFunctor::operator()):
     29        * css/CSSSelectorList.h:
     30        (WebCore::CSSSelectorList::first):
     31        (CSSSelectorList):
     32        (WebCore::CSSSelectorList::selectorAt):
     33        (WebCore::CSSSelectorList::indexOfNextSelectorAfter):
     34        (WebCore::CSSSelectorList::next):
     35        * css/CSSStyleRule.cpp:
     36        (WebCore::CSSStyleRule::generateSelectorText):
     37        * css/RuleSet.cpp:
     38        (WebCore::selectorListContainsUncommonAttributeSelector):
     39        (WebCore::collectFeaturesFromRuleData):
     40        * css/RuleSet.h:
     41        (WebCore::RuleData::selector):
     42        (WebCore::RuleSet::RuleSetSelectorPair::RuleSetSelectorPair):
     43        (RuleSetSelectorPair):
     44        * css/SelectorChecker.cpp:
     45        (WebCore::SelectorChecker::matches):
     46        (WebCore::SelectorChecker::match):
     47        (WebCore::SelectorChecker::checkOne):
     48        (WebCore::SelectorChecker::checkScrollbarPseudoClass):
     49        (WebCore::SelectorChecker::determineLinkMatchType):
     50        * css/SelectorChecker.h:
     51        (WebCore::SelectorChecker::SelectorCheckingContext::SelectorCheckingContext):
     52        (SelectorCheckingContext):
     53        (SelectorChecker):
     54        * css/StyleInvalidationAnalysis.cpp:
     55        (WebCore::determineSelectorScopes):
     56        * css/StyleResolver.cpp:
     57        (WebCore::StyleResolver::collectMatchingRulesForRegion):
     58        (WebCore::StyleResolver::checkRegionSelector):
     59        * css/StyleResolver.h:
     60        (StyleResolver):
     61        * dom/SelectorQuery.cpp:
     62        (WebCore::SelectorDataList::initialize):
     63        (WebCore::SelectorDataList::execute):
     64        * dom/SelectorQuery.h:
     65        (WebCore::SelectorDataList::SelectorData::SelectorData):
     66        (SelectorData):
     67        * html/shadow/ContentDistributor.cpp:
     68        (WebCore::ContentDistributor::collectSelectFeatureSetFrom):
     69        * html/shadow/ContentSelectorQuery.cpp:
     70        (WebCore::ContentSelectorChecker::checkContentSelector):
     71        (WebCore::ContentSelectorDataList::initialize):
     72        * html/shadow/ContentSelectorQuery.h:
     73        (ContentSelectorChecker):
     74        (ContentSelectorDataList):
     75        * html/shadow/HTMLContentElement.cpp:
     76        (WebCore::validateSubSelector):
     77        (WebCore::validateSelector):
     78        (WebCore::HTMLContentElement::validateSelect):
     79        * inspector/InspectorCSSAgent.cpp:
     80        (WebCore::InspectorCSSAgent::buildArrayForMatchedRuleList):
     81        * inspector/InspectorStyleSheet.cpp:
     82        (WebCore::InspectorStyleSheet::buildObjectForSelectorList):
     83
    1842013-01-23  Sergio Villar Senin  <svillar@igalia.com>
    285

  • trunk/Source/WebCore/css/CSSSelector.cpp

    r140371 r140530  
    561561}
    562562
    563 bool CSSSelector::operator==(const CSSSelector& other)
     563bool CSSSelector::operator==(const CSSSelector& other) const
    564564{
    565565    const CSSSelector* sel1 = this;
    … …  
    617617            switch (cs->pseudoType()) {
    618618            case PseudoNot:
    619                 if (CSSSelectorList* selectorList = cs->selectorList())
     619                if (const CSSSelectorList* selectorList = cs->selectorList())
    620620                    str.append(selectorList->first()->selectorText());
    621621                str.append(')');
    … …  
    630630                break;
    631631            case PseudoAny: {
    632                 CSSSelector* firstSubSelector = cs->selectorList()->first();
    633                 for (CSSSelector* subSelector = firstSubSelector; subSelector; subSelector = CSSSelectorList::next(subSelector)) {
     632                const CSSSelector* firstSubSelector = cs->selectorList()->first();
     633                for (const CSSSelector* subSelector = firstSubSelector; subSelector; subSelector = CSSSelectorList::next(subSelector)) {
    634634                    if (subSelector != firstSubSelector)
    635635                        str.append(',');
    … …  
    689689    }
    690690
    691     if (CSSSelector* tagHistory = cs->tagHistory()) {
     691    if (const CSSSelector* tagHistory = cs->tagHistory()) {
    692692        String tagHistoryText = tagHistory->selectorText();
    693693        switch (cs->relation()) {
    … …  
    728728}
    729729
    730 bool CSSSelector::parseNth()
     730bool CSSSelector::parseNth() const
    731731{
    732732    if (!m_hasRareData)
    … …  
    738738}
    739739
    740 bool CSSSelector::matchNth(int count)
     740bool CSSSelector::matchNth(int count) const
    741741{
    742742    ASSERT(m_hasRareData);

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

    r140383 r140530  
    4848
    4949        // checks if the 2 selectors (including sub selectors) agree.
    50         bool operator==(const CSSSelector&);
     50        bool operator==(const CSSSelector&) const;
    5151
    5252        // tag == -1 means apply to all elements (Selector = *)
    … …  
    199199        // Selectors are kept in an array by CSSSelectorList. The next component of the selector is
    200200        // the next item in the array.
    201         CSSSelector* tagHistory() const { return m_isLastInTagHistory ? 0 : const_cast<CSSSelector*>(this + 1); }
     201        const CSSSelector* tagHistory() const { return m_isLastInTagHistory ? 0 : const_cast<CSSSelector*>(this + 1); }
    202202
    203203        const QualifiedName& tagQName() const;
    … …  
    205205        const QualifiedName& attribute() const;
    206206        const AtomicString& argument() const { return m_hasRareData ? m_data.m_rareData->m_argument : nullAtom; }
    207         CSSSelectorList* selectorList() const { return m_hasRareData ? m_data.m_rareData->m_selectorList.get() : 0; }
     207        const CSSSelectorList* selectorList() const { return m_hasRareData ? m_data.m_rareData->m_selectorList.get() : 0; }
    208208
    209209        void setValue(const AtomicString&);
    … …  
    212212        void setSelectorList(PassOwnPtr<CSSSelectorList>);
    213213
    214         bool parseNth();
    215         bool matchNth(int count);
     214        bool parseNth() const;
     215        bool matchNth(int count) const;
    216216
    217217        bool matchesPseudoElement() const;
    … …  
    238238
    239239    private:
    240         bool m_parsedNth              : 1; // Used for :nth-*
     240        mutable bool m_parsedNth      : 1; // Used for :nth-*
    241241        bool m_isLastInSelectorList   : 1;
    242242        bool m_isLastInTagHistory     : 1;

  • trunk/Source/WebCore/css/CSSSelectorList.cpp

    r140371 r140530  
    135135    StringBuilder result;
    136136
    137     for (CSSSelector* s = first(); s; s = next(s)) {
     137    for (const CSSSelector* s = first(); s; s = next(s)) {
    138138        if (s != first())
    139139            result.append(", ");
    … …  
    151151
    152152template <typename Functor>
    153 static bool forEachTagSelector(Functor& functor, CSSSelector* selector)
     153static bool forEachTagSelector(Functor& functor, const CSSSelector* selector)
    154154{
    155155    ASSERT(selector);
    … …  
    158158        if (functor(selector))
    159159            return true;
    160         if (CSSSelectorList* selectorList = selector->selectorList()) {
    161             for (CSSSelector* subSelector = selectorList->first(); subSelector; subSelector = CSSSelectorList::next(subSelector)) {
     160        if (const CSSSelectorList* selectorList = selector->selectorList()) {
     161            for (const CSSSelector* subSelector = selectorList->first(); subSelector; subSelector = CSSSelectorList::next(subSelector)) {
    162162                if (forEachTagSelector(functor, subSelector))
    163163                    return true;
    … …  
    172172static bool forEachSelector(Functor& functor, const CSSSelectorList* selectorList)
    173173{
    174     for (CSSSelector* selector = selectorList->first(); selector; selector = CSSSelectorList::next(selector)) {
     174    for (const CSSSelector* selector = selectorList->first(); selector; selector = CSSSelectorList::next(selector)) {
    175175        if (forEachTagSelector(functor, selector))
    176176            return true;
    … …  
    182182class SelectorNeedsNamespaceResolutionFunctor {
    183183public:
    184     bool operator()(CSSSelector* selector)
     184    bool operator()(const CSSSelector* selector)
    185185    {
    186186        if (selector->m_match == CSSSelector::Tag && selector->tagQName().prefix() != nullAtom && selector->tagQName().prefix() != starAtom)
    … …  
    200200class SelectorHasInvalidSelectorFunctor {
    201201public:
    202     bool operator()(CSSSelector* selector)
     202    bool operator()(const CSSSelector* selector)
    203203    {
    204204        return selector->isUnknownPseudoElement() || selector->isCustomPseudoElement();

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

    r134693 r140530  
    4444    void adoptSelectorVector(Vector<OwnPtr<CSSParserSelector> >& selectorVector);
    4545
    46     CSSSelector* first() const { return m_selectorArray ? m_selectorArray : 0; }
    47     static CSSSelector* next(CSSSelector*);
     46    const CSSSelector* first() const { return m_selectorArray ? m_selectorArray : 0; }
     47    static const CSSSelector* next(const CSSSelector*);
    4848    bool hasOneSelector() const { return m_selectorArray && !next(m_selectorArray); }
    49     CSSSelector* selectorAt(size_t index) const { return &m_selectorArray[index]; }
     49    const CSSSelector* selectorAt(size_t index) const { return &m_selectorArray[index]; }
    5050
    5151    size_t indexOfNextSelectorAfter(size_t index) const
    5252    {
    53         CSSSelector* current = selectorAt(index);
     53        const CSSSelector* current = selectorAt(index);
    5454        current = next(current);
    5555        if (!current)
    … …  
    7474};
    7575
    76 inline CSSSelector* CSSSelectorList::next(CSSSelector* current)
     76inline const CSSSelector* CSSSelectorList::next(const CSSSelector* current)
    7777{
    7878    // Skip subparts of compound selectors.

  • trunk/Source/WebCore/css/CSSStyleRule.cpp

    r135465 r140530  
    7070{
    7171    StringBuilder builder;
    72     for (CSSSelector* s = m_styleRule->selectorList().first(); s; s = CSSSelectorList::next(s)) {
    73         if (s != m_styleRule->selectorList().first())
     72    for (const CSSSelector* selector = m_styleRule->selectorList().first(); selector; selector = CSSSelectorList::next(selector)) {
     73        if (selector != m_styleRule->selectorList().first())
    7474            builder.append(", ");
    75         builder.append(s->selectorText());
     75        builder.append(selector->selectorText());
    7676    }
    7777    return builder.toString();

  • trunk/Source/WebCore/css/RuleSet.cpp

    r140505 r140530  
    7676static inline bool selectorListContainsUncommonAttributeSelector(const CSSSelector* selector)
    7777{
    78     CSSSelectorList* selectorList = selector->selectorList();
     78    const CSSSelectorList* selectorList = selector->selectorList();
    7979    if (!selectorList)
    8080        return false;
    81     for (CSSSelector* selector = selectorList->first(); selector; selector = CSSSelectorList::next(selector)) {
    82         for (CSSSelector* component = selector; component; component = component->tagHistory()) {
     81    for (const CSSSelector* selector = selectorList->first(); selector; selector = CSSSelectorList::next(selector)) {
     82        for (const CSSSelector* component = selector; component; component = component->tagHistory()) {
    8383            if (component->isAttributeSelector())
    8484                return true;
    … …  
    191191{
    192192    bool foundSiblingSelector = false;
    193     for (CSSSelector* selector = ruleData.selector(); selector; selector = selector->tagHistory()) {
     193    for (const CSSSelector* selector = ruleData.selector(); selector; selector = selector->tagHistory()) {
    194194        features.collectFeaturesFromSelector(selector);
    195195       
    196         if (CSSSelectorList* selectorList = selector->selectorList()) {
    197             for (CSSSelector* subSelector = selectorList->first(); subSelector; subSelector = CSSSelectorList::next(subSelector)) {
     196        if (const CSSSelectorList* selectorList = selector->selectorList()) {
     197            for (const CSSSelector* subSelector = selectorList->first(); subSelector; subSelector = CSSSelectorList::next(subSelector)) {
    198198                if (!foundSiblingSelector && selector->isSiblingSelector())
    199199                    foundSiblingSelector = true;

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

    r140371 r140530  
    6060    unsigned position() const { return m_position; }
    6161    StyleRule* rule() const { return m_rule; }
    62     CSSSelector* selector() const { return m_rule->selectorList().selectorAt(m_selectorIndex); }
     62    const CSSSelector* selector() const { return m_rule->selectorList().selectorAt(m_selectorIndex); }
    6363    unsigned selectorIndex() const { return m_selectorIndex; }
    6464
    … …  
    160160
    161161    struct RuleSetSelectorPair {
    162         RuleSetSelectorPair(CSSSelector* selector, PassOwnPtr<RuleSet> ruleSet) : selector(selector), ruleSet(ruleSet) { }
     162        RuleSetSelectorPair(const CSSSelector* selector, PassOwnPtr<RuleSet> ruleSet) : selector(selector), ruleSet(ruleSet) { }
    163163        RuleSetSelectorPair(const RuleSetSelectorPair& rs) : selector(rs.selector), ruleSet(const_cast<RuleSetSelectorPair*>(&rs)->ruleSet.release()) { }
    164164        void reportMemoryUsage(MemoryObjectInfo*) const;
    165165
    166         CSSSelector* selector;
     166        const CSSSelector* selector;
    167167        OwnPtr<RuleSet> ruleSet;
    168168    };

  • trunk/Source/WebCore/css/SelectorChecker.cpp

    r140382 r140530  
    7070}
    7171
    72 bool SelectorChecker::matches(CSSSelector* sel, Element* element, bool isFastCheckableSelector) const
     72bool SelectorChecker::matches(const CSSSelector* selector, Element* element, bool isFastCheckableSelector) const
    7373{
    7474    if (isFastCheckableSelector && !element->isSVGElement()) {
    75         if (!fastCheckRightmostSelector(sel, element, VisitedMatchDisabled))
    76             return false;
    77         return fastCheck(sel, element);
     75        if (!fastCheckRightmostSelector(selector, element, VisitedMatchDisabled))
     76            return false;
     77        return fastCheck(selector, element);
    7878    }
    7979
    8080    PseudoId ignoreDynamicPseudo = NOPSEUDO;
    81     return match(SelectorCheckingContext(sel, element, SelectorChecker::VisitedMatchDisabled), ignoreDynamicPseudo, DOMSiblingTraversalStrategy()) == SelectorMatches;
     81    return match(SelectorCheckingContext(selector, element, SelectorChecker::VisitedMatchDisabled), ignoreDynamicPseudo, DOMSiblingTraversalStrategy()) == SelectorMatches;
    8282}
    8383
    … …  
    281281
    282282    // Prepare next selector
    283     CSSSelector* historySelector = context.selector->tagHistory();
     283    const CSSSelector* historySelector = context.selector->tagHistory();
    284284    if (!historySelector)
    285285        return SelectorMatches;
    … …  
    474474{
    475475    Element* const & element = context.element;
    476     CSSSelector* const & selector = context.selector;
     476    const CSSSelector* const & selector = context.selector;
    477477    ASSERT(element);
    478478    ASSERT(selector);
    … …  
    502502        // Handle :not up front.
    503503        if (selector->pseudoType() == CSSSelector::PseudoNot) {
    504             CSSSelectorList* selectorList = selector->selectorList();
     504            const CSSSelectorList* selectorList = selector->selectorList();
    505505
    506506            // FIXME: We probably should fix the parser and make it never produce :not rules with missing selector list.
    … …  
    904904
    905905        PseudoId ignoreDynamicPseudo = NOPSEUDO;
    906         CSSSelector* const & selector = context.selector;
     906        const CSSSelector* const & selector = context.selector;
    907907        for (subContext.selector = selector->selectorList()->first(); subContext.selector; subContext.selector = CSSSelectorList::next(subContext.selector)) {
    908908            if (match(subContext, ignoreDynamicPseudo, siblingTraversalStrategy) == SelectorMatches)
    … …  
    916916}
    917917
    918 bool SelectorChecker::checkScrollbarPseudoClass(Document* document, CSSSelector* sel) const
     918bool SelectorChecker::checkScrollbarPseudoClass(Document* document, const CSSSelector* selector) const
    919919{
    920920    RenderScrollbar* scrollbar = RenderScrollbar::scrollbarForStyleResolve();
    … …  
    923923    // FIXME: This is a temporary hack for resizers and scrollbar corners. Eventually :window-inactive should become a real
    924924    // pseudo class and just apply to everything.
    925     if (sel->pseudoType() == CSSSelector::PseudoWindowInactive)
     925    if (selector->pseudoType() == CSSSelector::PseudoWindowInactive)
    926926        return !document->page()->focusController()->isActive();
    927927
    … …  
    929929        return false;
    930930
    931     ASSERT(sel->m_match == CSSSelector::PseudoClass);
    932     switch (sel->pseudoType()) {
     931    ASSERT(selector->m_match == CSSSelector::PseudoClass);
     932    switch (selector->pseudoType()) {
    933933    case CSSSelector::PseudoEnabled:
    934934        return scrollbar->enabled();
    … …  
    10251025            {
    10261026                // :not(:visited) is equivalent to :link. Parser enforces that :not can't nest.
    1027                 CSSSelectorList* selectorList = selector->selectorList();
     1027                const CSSSelectorList* selectorList = selector->selectorList();
    10281028                if (!selectorList)
    10291029                    break;
    10301030
    1031                 for (CSSSelector* subSelector = selectorList->first(); subSelector; subSelector = subSelector->tagHistory()) {
     1031                for (const CSSSelector* subSelector = selectorList->first(); subSelector; subSelector = subSelector->tagHistory()) {
    10321032                    CSSSelector::PseudoType subType = subSelector->pseudoType();
    10331033                    if (subType == CSSSelector::PseudoVisited)

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

    r140371 r140530  
    5353    struct SelectorCheckingContext {
    5454        // Initial selector constructor
    55         SelectorCheckingContext(CSSSelector* selector, Element* element, VisitedMatchType visitedMatchType)
     55        SelectorCheckingContext(const CSSSelector* selector, Element* element, VisitedMatchType visitedMatchType)
    5656            : selector(selector)
    5757            , element(element)
    … …  
    6666        { }
    6767
    68         CSSSelector* selector;
     68        const CSSSelector* selector;
    6969        Element* element;
    7070        const ContainerNode* scope;
    … …  
    7878    };
    7979
    80     bool matches(CSSSelector*, Element*, bool isFastCheckableSelector = false) const;
     80    bool matches(const CSSSelector*, Element*, bool isFastCheckableSelector = false) const;
    8181    template<typename SiblingTraversalStrategy>
    8282    Match match(const SelectorCheckingContext&, PseudoId&, const SiblingTraversalStrategy&) const;
    … …  
    102102
    103103private:
    104     bool checkScrollbarPseudoClass(Document*, CSSSelector*) const;
     104    bool checkScrollbarPseudoClass(Document*, const CSSSelector*) const;
    105105    static bool isFrameFocused(const Element*);
    106106

  • trunk/Source/WebCore/css/StyleInvalidationAnalysis.cpp

    r137406 r140530  
    4545static bool determineSelectorScopes(const CSSSelectorList& selectorList, HashSet<AtomicStringImpl*>& idScopes, HashSet<AtomicStringImpl*>& classScopes)
    4646{
    47     for (CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(selector)) {
    48         CSSSelector* scopeSelector = 0;
     47    for (const CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(selector)) {
     48        const CSSSelector* scopeSelector = 0;
    4949        // This picks the widest scope, not the narrowest, to minimize the number of found scopes.
    50         for (CSSSelector* current = selector; current; current = current->tagHistory()) {
     50        for (const CSSSelector* current = selector; current; current = current->tagHistory()) {
    5151            // Prefer ids over classes.
    5252            if (current->m_match == CSSSelector::Id)

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

    r140371 r140530  
    698698    unsigned size = matchRequest.ruleSet->m_regionSelectorsAndRuleSets.size();
    699699    for (unsigned i = 0; i < size; ++i) {
    700         CSSSelector* regionSelector = matchRequest.ruleSet->m_regionSelectorsAndRuleSets.at(i).selector;
     700        const CSSSelector* regionSelector = matchRequest.ruleSet->m_regionSelectorsAndRuleSets.at(i).selector;
    701701        if (checkRegionSelector(regionSelector, static_cast<Element*>(m_regionForStyling->node()))) {
    702702            RuleSet* regionRules = matchRequest.ruleSet->m_regionSelectorsAndRuleSets.at(i).ruleSet.get();
    … …  
    22952295}
    22962296
    2297 bool StyleResolver::checkRegionSelector(CSSSelector* regionSelector, Element* regionElement)
     2297bool StyleResolver::checkRegionSelector(const CSSSelector* regionSelector, Element* regionElement)
    22982298{
    22992299    if (!regionSelector || !regionElement)
    … …  
    23022302    m_pseudoStyle = NOPSEUDO;
    23032303
    2304     for (CSSSelector* s = regionSelector; s; s = CSSSelectorList::next(s))
     2304    for (const CSSSelector* s = regionSelector; s; s = CSSSelectorList::next(s))
    23052305        if (m_selectorChecker.matches(s, regionElement))
    23062306            return true;

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

    r140173 r140530  
    374374
    375375    bool ruleMatches(const RuleData&, const ContainerNode* scope);
    376     bool checkRegionSelector(CSSSelector* regionSelector, Element* regionElement);
     376    bool checkRegionSelector(const CSSSelector* regionSelector, Element* regionElement);
    377377    void applyMatchedProperties(const MatchResult&, const Element*);
    378378    enum StyleApplicationPass {

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

    r139406 r140530  
    4141
    4242    unsigned selectorCount = 0;
    43     for (CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(selector))
     43    for (const CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(selector))
    4444        selectorCount++;
    4545
    4646    m_selectors.reserveInitialCapacity(selectorCount);
    47     for (CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(selector))
     47    for (const CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(selector))
    4848        m_selectors.uncheckedAppend(SelectorData(selector, SelectorChecker::isFastCheckableSelector(selector)));
    4949}
    … …  
    108108    if (canUseIdLookup(rootNode)) {
    109109        ASSERT(m_selectors.size() == 1);
    110         CSSSelector* selector = m_selectors[0].selector;
     110        const CSSSelector* selector = m_selectors[0].selector;
    111111        Element* element = rootNode->treeScope()->getElementById(selector->value());
    112112        if (!element || !(isTreeScopeRoot(rootNode) || element->isDescendantOf(rootNode)))

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

    r123451 r140530  
    4949private:
    5050    struct SelectorData {
    51         SelectorData(CSSSelector* selector, bool isFastCheckable) : selector(selector), isFastCheckable(isFastCheckable) { }
    52         CSSSelector* selector;
     51        SelectorData(const CSSSelector* selector, bool isFastCheckable) : selector(selector), isFastCheckable(isFastCheckable) { }
     52        const CSSSelector* selector;
    5353        bool isFastCheckable;
    5454    };

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

    r140371 r140530  
    410410                continue;
    411411            const CSSSelectorList& list = toHTMLContentElement(element)->selectorList();
    412             for (CSSSelector* selector = list.first(); selector; selector = CSSSelectorList::next(selector)) {
    413                 for (CSSSelector* component = selector; component; component = component->tagHistory())
     412            for (const CSSSelector* selector = list.first(); selector; selector = CSSSelectorList::next(selector)) {
     413                for (const CSSSelector* component = selector; component; component = component->tagHistory())
    414414                    m_selectFeatures.collectFeaturesFromSelector(component);
    415415            }

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

    r140371 r140530  
    4242}
    4343
    44 bool ContentSelectorChecker::checkContentSelector(CSSSelector* selector, const Vector<RefPtr<Node> >& siblings, int nth) const
     44bool ContentSelectorChecker::checkContentSelector(const CSSSelector* selector, const Vector<RefPtr<Node> >& siblings, int nth) const
    4545{
    4646    SelectorChecker::SelectorCheckingContext context(selector, toElement(siblings[nth].get()), SelectorChecker::VisitedMatchEnabled);
    … …  
    5252void ContentSelectorDataList::initialize(const CSSSelectorList& selectors)
    5353{
    54     for (CSSSelector* selector = selectors.first(); selector; selector = CSSSelectorList::next(selector))
     54    for (const CSSSelector* selector = selectors.first(); selector; selector = CSSSelectorList::next(selector))
    5555        m_selectors.append(selector);
    5656}

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

    r138571 r140530  
    4848    ContentSelectorChecker(Document*);
    4949
    50     bool checkContentSelector(CSSSelector*, const Vector<RefPtr<Node> >& siblings, int nthNode) const;
     50    bool checkContentSelector(const CSSSelector*, const Vector<RefPtr<Node> >& siblings, int nthNode) const;
    5151private:
    5252    SelectorChecker m_selectorChecker;
    … …  
    5959
    6060private:
    61     Vector<CSSSelector*> m_selectors;
     61    Vector<const CSSSelector*> m_selectors;
    6262};
    6363

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

    r140371 r140530  
    118118}
    119119
    120 static bool validateSubSelector(CSSSelector* selector)
     120static bool validateSubSelector(const CSSSelector* selector)
    121121{
    122122    switch (selector->m_match) {
    … …  
    163163}
    164164
    165 static bool validateSelector(CSSSelector* selector)
     165static bool validateSelector(const CSSSelector* selector)
    166166{
    167167    ASSERT(selector);
    … …  
    170170        return false;
    171171
    172     CSSSelector* prevSubSelector = selector;
    173     CSSSelector* subSelector = selector->tagHistory();
     172    const CSSSelector* prevSubSelector = selector;
     173    const CSSSelector* subSelector = selector->tagHistory();
    174174
    175175    while (subSelector) {
    … …  
    196196        return false;
    197197
    198     for (CSSSelector* selector = m_selectorList.first(); selector; selector = m_selectorList.next(selector)) {
     198    for (const CSSSelector* selector = m_selectorList.first(); selector; selector = m_selectorList.next(selector)) {
    199199        if (!validateSelector(selector))
    200200            return false;

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

    r138457 r140530  
    11641164        const CSSSelectorList& selectorList = rule->styleRule()->selectorList();
    11651165        long index = 0;
    1166         for (CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(selector)) {
     1166        for (const CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(selector)) {
    11671167            ExceptionCode ec;
    11681168            bool matched = element->webkitMatchesSelector(selector->selectorText(), ec);

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

    r139866 r140530  
    995995        selectors = TypeBuilder::Array<String>::create();
    996996        const CSSSelectorList& selectorList = rule->styleRule()->selectorList();
    997         for (CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(selector))
     997        for (const CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(selector))
    998998            selectors->addItem(selector->selectorText());
    999999    }
Note: See TracChangeset for help on using the changeset viewer.