Home | History | Annotate | Download | only in css
      1 /*
      2  * Copyright (C) 1999 Lars Knoll (knoll (at) kde.org)
      3  *           (C) 2004-2005 Allan Sandfeld Jensen (kde (at) carewolf.com)
      4  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit (at) nickshanks.com)
      5  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
      6  * Copyright (C) 2007 Alexey Proskuryakov <ap (at) webkit.org>
      7  * Copyright (C) 2007, 2008 Eric Seidel <eric (at) webkit.org>
      8  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
      9  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
     10  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
     11  * Copyright (C) 2012 Google Inc. All rights reserved.
     12  *
     13  * This library is free software; you can redistribute it and/or
     14  * modify it under the terms of the GNU Library General Public
     15  * License as published by the Free Software Foundation; either
     16  * version 2 of the License, or (at your option) any later version.
     17  *
     18  * This library is distributed in the hope that it will be useful,
     19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     21  * Library General Public License for more details.
     22  *
     23  * You should have received a copy of the GNU Library General Public License
     24  * along with this library; see the file COPYING.LIB.  If not, write to
     25  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     26  * Boston, MA 02110-1301, USA.
     27  */
     28 
     29 #include "config.h"
     30 #include "core/css/ElementRuleCollector.h"
     31 
     32 #include "core/css/CSSImportRule.h"
     33 #include "core/css/CSSKeyframesRule.h"
     34 #include "core/css/CSSMediaRule.h"
     35 #include "core/css/CSSRuleList.h"
     36 #include "core/css/CSSSelector.h"
     37 #include "core/css/CSSStyleRule.h"
     38 #include "core/css/CSSStyleSheet.h"
     39 #include "core/css/CSSSupportsRule.h"
     40 #include "core/css/SiblingTraversalStrategies.h"
     41 #include "core/css/StylePropertySet.h"
     42 #include "core/css/resolver/StyleResolver.h"
     43 #include "core/dom/shadow/ShadowRoot.h"
     44 #include "core/rendering/style/StyleInheritedData.h"
     45 
     46 namespace blink {
     47 
     48 ElementRuleCollector::ElementRuleCollector(const ElementResolveContext& context,
     49     const SelectorFilter& filter, RenderStyle* style)
     50     : m_context(context)
     51     , m_selectorFilter(filter)
     52     , m_style(style)
     53     , m_pseudoStyleRequest(NOPSEUDO)
     54     , m_mode(SelectorChecker::ResolvingStyle)
     55     , m_canUseFastReject(m_selectorFilter.parentStackIsConsistent(context.parentNode()))
     56     , m_sameOriginOnly(false)
     57     , m_matchingUARules(false)
     58 { }
     59 
     60 ElementRuleCollector::~ElementRuleCollector()
     61 {
     62 }
     63 
     64 MatchResult& ElementRuleCollector::matchedResult()
     65 {
     66     return m_result;
     67 }
     68 
     69 PassRefPtrWillBeRawPtr<StyleRuleList> ElementRuleCollector::matchedStyleRuleList()
     70 {
     71     ASSERT(m_mode == SelectorChecker::CollectingStyleRules);
     72     return m_styleRuleList.release();
     73 }
     74 
     75 PassRefPtrWillBeRawPtr<CSSRuleList> ElementRuleCollector::matchedCSSRuleList()
     76 {
     77     ASSERT(m_mode == SelectorChecker::CollectingCSSRules);
     78     return m_cssRuleList.release();
     79 }
     80 
     81 inline void ElementRuleCollector::addMatchedRule(const RuleData* rule, unsigned specificity, CascadeScope cascadeScope, CascadeOrder cascadeOrder, unsigned styleSheetIndex, const CSSStyleSheet* parentStyleSheet)
     82 {
     83     if (!m_matchedRules)
     84         m_matchedRules = adoptPtrWillBeNoop(new WillBeHeapVector<MatchedRule, 32>);
     85     m_matchedRules->append(MatchedRule(rule, specificity, cascadeScope, cascadeOrder, styleSheetIndex, parentStyleSheet));
     86 }
     87 
     88 void ElementRuleCollector::clearMatchedRules()
     89 {
     90     if (!m_matchedRules)
     91         return;
     92     m_matchedRules->clear();
     93 }
     94 
     95 inline StyleRuleList* ElementRuleCollector::ensureStyleRuleList()
     96 {
     97     if (!m_styleRuleList)
     98         m_styleRuleList = StyleRuleList::create();
     99     return m_styleRuleList.get();
    100 }
    101 
    102 inline StaticCSSRuleList* ElementRuleCollector::ensureRuleList()
    103 {
    104     if (!m_cssRuleList)
    105         m_cssRuleList = StaticCSSRuleList::create();
    106     return m_cssRuleList.get();
    107 }
    108 
    109 void ElementRuleCollector::addElementStyleProperties(const StylePropertySet* propertySet, bool isCacheable)
    110 {
    111     if (!propertySet)
    112         return;
    113     m_result.ranges.lastAuthorRule = m_result.matchedProperties.size();
    114     if (m_result.ranges.firstAuthorRule == -1)
    115         m_result.ranges.firstAuthorRule = m_result.ranges.lastAuthorRule;
    116     m_result.addMatchedProperties(propertySet);
    117     if (!isCacheable)
    118         m_result.isCacheable = false;
    119 }
    120 
    121 static bool rulesApplicableInCurrentTreeScope(const Element* element, const ContainerNode* scopingNode, bool matchingTreeBoundaryRules)
    122 {
    123     // [skipped, because already checked] a) it's a UA rule
    124     // b) We're mathcing tree boundary rules.
    125     if (matchingTreeBoundaryRules)
    126         return true;
    127     // c) the rules comes from a scoped style sheet within the same tree scope
    128     if (!scopingNode || element->treeScope() == scopingNode->treeScope())
    129         return true;
    130     // d) the rules comes from a scoped style sheet within an active shadow root whose host is the given element
    131     if (SelectorChecker::isHostInItsShadowTree(*element, scopingNode))
    132         return true;
    133     return false;
    134 }
    135 
    136 void ElementRuleCollector::collectMatchingRules(const MatchRequest& matchRequest, RuleRange& ruleRange, SelectorChecker::ContextFlags contextFlags, CascadeScope cascadeScope, CascadeOrder cascadeOrder, bool matchingTreeBoundaryRules)
    137 {
    138     ASSERT(matchRequest.ruleSet);
    139     ASSERT(m_context.element());
    140 
    141     Element& element = *m_context.element();
    142     const AtomicString& pseudoId = element.shadowPseudoId();
    143     if (!pseudoId.isEmpty()) {
    144         ASSERT(element.isStyledElement());
    145         collectMatchingRulesForList(matchRequest.ruleSet->shadowPseudoElementRules(pseudoId), contextFlags, ignoreCascadeScope, cascadeOrder, matchRequest, ruleRange);
    146     }
    147 
    148     if (element.isVTTElement())
    149         collectMatchingRulesForList(matchRequest.ruleSet->cuePseudoRules(), contextFlags, cascadeScope, cascadeOrder, matchRequest, ruleRange);
    150     // Check whether other types of rules are applicable in the current tree scope. Criteria for this:
    151     // a) it's a UA rule
    152     // b) the rules comes from a scoped style sheet within the same tree scope
    153     // c) the rules comes from a scoped style sheet within an active shadow root whose host is the given element
    154     // d) the rules can cross boundaries
    155     // b)-e) is checked in rulesApplicableInCurrentTreeScope.
    156     if (!m_matchingUARules && !rulesApplicableInCurrentTreeScope(&element, matchRequest.scope, matchingTreeBoundaryRules))
    157         return;
    158 
    159     // We need to collect the rules for id, class, tag, and everything else into a buffer and
    160     // then sort the buffer.
    161     if (element.hasID())
    162         collectMatchingRulesForList(matchRequest.ruleSet->idRules(element.idForStyleResolution()), contextFlags, cascadeScope, cascadeOrder, matchRequest, ruleRange);
    163     if (element.isStyledElement() && element.hasClass()) {
    164         for (size_t i = 0; i < element.classNames().size(); ++i)
    165             collectMatchingRulesForList(matchRequest.ruleSet->classRules(element.classNames()[i]), contextFlags, cascadeScope, cascadeOrder, matchRequest, ruleRange);
    166     }
    167 
    168     if (element.isLink())
    169         collectMatchingRulesForList(matchRequest.ruleSet->linkPseudoClassRules(), contextFlags, cascadeScope, cascadeOrder, matchRequest, ruleRange);
    170     if (SelectorChecker::matchesFocusPseudoClass(element))
    171         collectMatchingRulesForList(matchRequest.ruleSet->focusPseudoClassRules(), contextFlags, cascadeScope, cascadeOrder, matchRequest, ruleRange);
    172     collectMatchingRulesForList(matchRequest.ruleSet->tagRules(element.localName()), contextFlags, cascadeScope, cascadeOrder, matchRequest, ruleRange);
    173     collectMatchingRulesForList(matchRequest.ruleSet->universalRules(), contextFlags, cascadeScope, cascadeOrder, matchRequest, ruleRange);
    174 }
    175 
    176 CSSRuleList* ElementRuleCollector::nestedRuleList(CSSRule* rule)
    177 {
    178     switch (rule->type()) {
    179     case CSSRule::MEDIA_RULE:
    180         return toCSSMediaRule(rule)->cssRules();
    181     case CSSRule::KEYFRAMES_RULE:
    182         return toCSSKeyframesRule(rule)->cssRules();
    183     case CSSRule::SUPPORTS_RULE:
    184         return toCSSSupportsRule(rule)->cssRules();
    185     default:
    186         return 0;
    187     }
    188 }
    189 
    190 template<class CSSRuleCollection>
    191 CSSRule* ElementRuleCollector::findStyleRule(CSSRuleCollection* cssRules, StyleRule* styleRule)
    192 {
    193     if (!cssRules)
    194         return 0;
    195     CSSRule* result = 0;
    196     for (unsigned i = 0; i < cssRules->length() && !result; ++i) {
    197         CSSRule* cssRule = cssRules->item(i);
    198         CSSRule::Type cssRuleType = cssRule->type();
    199         if (cssRuleType == CSSRule::STYLE_RULE) {
    200             CSSStyleRule* cssStyleRule = toCSSStyleRule(cssRule);
    201             if (cssStyleRule->styleRule() == styleRule)
    202                 result = cssRule;
    203         } else if (cssRuleType == CSSRule::IMPORT_RULE) {
    204             CSSImportRule* cssImportRule = toCSSImportRule(cssRule);
    205             result = findStyleRule(cssImportRule->styleSheet(), styleRule);
    206         } else {
    207             result = findStyleRule(nestedRuleList(cssRule), styleRule);
    208         }
    209     }
    210     return result;
    211 }
    212 
    213 void ElementRuleCollector::appendCSSOMWrapperForRule(CSSStyleSheet* parentStyleSheet, StyleRule* rule)
    214 {
    215     // |parentStyleSheet| is 0 if and only if the |rule| is coming from User Agent. In this case,
    216     // it is safe to create CSSOM wrappers without parentStyleSheets as they will be used only
    217     // by inspector which will not try to edit them.
    218     RefPtrWillBeRawPtr<CSSRule> cssRule = nullptr;
    219     if (parentStyleSheet)
    220         cssRule = findStyleRule(parentStyleSheet, rule);
    221     else
    222         cssRule = rule->createCSSOMWrapper();
    223     ASSERT(!parentStyleSheet || cssRule);
    224     ensureRuleList()->rules().append(cssRule);
    225 }
    226 
    227 void ElementRuleCollector::sortAndTransferMatchedRules()
    228 {
    229     if (!m_matchedRules || m_matchedRules->isEmpty())
    230         return;
    231 
    232     sortMatchedRules();
    233 
    234     WillBeHeapVector<MatchedRule, 32>& matchedRules = *m_matchedRules;
    235     if (m_mode == SelectorChecker::CollectingStyleRules) {
    236         for (unsigned i = 0; i < matchedRules.size(); ++i)
    237             ensureStyleRuleList()->m_list.append(matchedRules[i].ruleData()->rule());
    238         return;
    239     }
    240 
    241     if (m_mode == SelectorChecker::CollectingCSSRules) {
    242         for (unsigned i = 0; i < matchedRules.size(); ++i)
    243             appendCSSOMWrapperForRule(const_cast<CSSStyleSheet*>(matchedRules[i].parentStyleSheet()), matchedRules[i].ruleData()->rule());
    244         return;
    245     }
    246 
    247     // Now transfer the set of matched rules over to our list of declarations.
    248     for (unsigned i = 0; i < matchedRules.size(); i++) {
    249         // FIXME: Matching should not modify the style directly.
    250         const RuleData* ruleData = matchedRules[i].ruleData();
    251         if (m_style && ruleData->containsUncommonAttributeSelector())
    252             m_style->setUnique();
    253         m_result.addMatchedProperties(&ruleData->rule()->properties(), ruleData->linkMatchType(), ruleData->propertyWhitelistType(m_matchingUARules));
    254     }
    255 }
    256 
    257 inline bool ElementRuleCollector::ruleMatches(const RuleData& ruleData, const ContainerNode* scope, SelectorChecker::ContextFlags contextFlags, SelectorChecker::MatchResult* result)
    258 {
    259     SelectorChecker selectorChecker(m_context.element()->document(), m_mode);
    260     SelectorChecker::SelectorCheckingContext context(ruleData.selector(), m_context.element(), SelectorChecker::VisitedMatchEnabled);
    261     context.elementStyle = m_style.get();
    262     context.scope = scope;
    263     context.pseudoId = m_pseudoStyleRequest.pseudoId;
    264     context.scrollbar = m_pseudoStyleRequest.scrollbar;
    265     context.scrollbarPart = m_pseudoStyleRequest.scrollbarPart;
    266     context.isUARule = m_matchingUARules;
    267     context.contextFlags = contextFlags;
    268     SelectorChecker::Match match = selectorChecker.match(context, DOMSiblingTraversalStrategy(), result);
    269     if (match != SelectorChecker::SelectorMatches)
    270         return false;
    271     if (m_pseudoStyleRequest.pseudoId != NOPSEUDO && m_pseudoStyleRequest.pseudoId != result->dynamicPseudo)
    272         return false;
    273     return true;
    274 }
    275 
    276 void ElementRuleCollector::collectRuleIfMatches(const RuleData& ruleData, SelectorChecker::ContextFlags contextFlags, CascadeScope cascadeScope, CascadeOrder cascadeOrder, const MatchRequest& matchRequest, RuleRange& ruleRange)
    277 {
    278     if (m_canUseFastReject && m_selectorFilter.fastRejectSelector<RuleData::maximumIdentifierCount>(ruleData.descendantSelectorIdentifierHashes()))
    279         return;
    280 
    281     StyleRule* rule = ruleData.rule();
    282     SelectorChecker::MatchResult result;
    283     if (ruleMatches(ruleData, matchRequest.scope, contextFlags, &result)) {
    284         // If the rule has no properties to apply, then ignore it in the non-debug mode.
    285         const StylePropertySet& properties = rule->properties();
    286         if (properties.isEmpty() && !matchRequest.includeEmptyRules)
    287             return;
    288         // FIXME: Exposing the non-standard getMatchedCSSRules API to web is the only reason this is needed.
    289         if (m_sameOriginOnly && !ruleData.hasDocumentSecurityOrigin())
    290             return;
    291 
    292         PseudoId dynamicPseudo = result.dynamicPseudo;
    293         // If we're matching normal rules, set a pseudo bit if
    294         // we really just matched a pseudo-element.
    295         if (dynamicPseudo != NOPSEUDO && m_pseudoStyleRequest.pseudoId == NOPSEUDO) {
    296             if (m_mode == SelectorChecker::CollectingCSSRules || m_mode == SelectorChecker::CollectingStyleRules)
    297                 return;
    298             // FIXME: Matching should not modify the style directly.
    299             if (!m_style || dynamicPseudo >= FIRST_INTERNAL_PSEUDOID)
    300                 return;
    301             if ((dynamicPseudo == BEFORE || dynamicPseudo == AFTER) && !ruleData.rule()->properties().hasProperty(CSSPropertyContent))
    302                 return;
    303             m_style->setHasPseudoStyle(dynamicPseudo);
    304         } else {
    305             // Update our first/last rule indices in the matched rules array.
    306             ++ruleRange.lastRuleIndex;
    307             if (ruleRange.firstRuleIndex == -1)
    308                 ruleRange.firstRuleIndex = ruleRange.lastRuleIndex;
    309 
    310             // Add this rule to our list of matched rules.
    311             addMatchedRule(&ruleData, result.specificity, cascadeScope, cascadeOrder, matchRequest.styleSheetIndex, matchRequest.styleSheet);
    312             return;
    313         }
    314     }
    315 }
    316 
    317 static inline bool compareRules(const MatchedRule& matchedRule1, const MatchedRule& matchedRule2)
    318 {
    319     if (matchedRule1.cascadeScope() != matchedRule2.cascadeScope())
    320         return matchedRule1.cascadeScope() > matchedRule2.cascadeScope();
    321 
    322     unsigned specificity1 = matchedRule1.specificity();
    323     unsigned specificity2 = matchedRule2.specificity();
    324     if (specificity1 != specificity2)
    325         return specificity1 < specificity2;
    326 
    327     return matchedRule1.position() < matchedRule2.position();
    328 }
    329 
    330 void ElementRuleCollector::sortMatchedRules()
    331 {
    332     ASSERT(m_matchedRules);
    333     std::sort(m_matchedRules->begin(), m_matchedRules->end(), compareRules);
    334 }
    335 
    336 bool ElementRuleCollector::hasAnyMatchingRules(RuleSet* ruleSet)
    337 {
    338     clearMatchedRules();
    339 
    340     m_mode = SelectorChecker::SharingRules;
    341     // To check whether a given RuleSet has any rule matching a given element,
    342     // should not see the element's treescope. Because RuleSet has no
    343     // information about "scope".
    344     int firstRuleIndex = -1, lastRuleIndex = -1;
    345     RuleRange ruleRange(firstRuleIndex, lastRuleIndex);
    346     // FIXME: Verify whether it's ok to ignore CascadeScope here.
    347     collectMatchingRules(MatchRequest(ruleSet), ruleRange, SelectorChecker::DefaultBehavior);
    348 
    349     return m_matchedRules && !m_matchedRules->isEmpty();
    350 }
    351 
    352 } // namespace blink
    353