Changeset 251289 in webkit


Ignore:
Timestamp:
Oct 18, 2019 11:08:43 AM (5 years ago)
Author:
Antti Koivisto
Message:

ElementRuleCollector function signature cleanups
​https://bugs.webkit.org/show_bug.cgi?id=203153

Reviewed by Zalan Bujtas.

Many functions in ElementRuleCollector take repetitive arguments that can be removed:

  • Make includeEmptyRules argument a class member
  • Remove RuleRange argument, update the ranges in rule transfer step.
  • css/ElementRuleCollector.cpp:

(WebCore::MatchRequest::MatchRequest):
(WebCore::ElementRuleCollector::addMatchedRule):
(WebCore::ElementRuleCollector::collectMatchingRules):
(WebCore::ElementRuleCollector::sortAndTransferMatchedRules):
(WebCore::ElementRuleCollector::transferMatchedRules):
(WebCore::ElementRuleCollector::matchAuthorRules):
(WebCore::ElementRuleCollector::matchesAnyAuthorRules):
(WebCore::ElementRuleCollector::collectMatchingAuthorRules):
(WebCore::ElementRuleCollector::matchAuthorShadowPseudoElementRules):
(WebCore::ElementRuleCollector::matchHostPseudoClassRules):
(WebCore::ElementRuleCollector::matchSlottedPseudoElementRules):
(WebCore::ElementRuleCollector::matchPartPseudoElementRules):
(WebCore::ElementRuleCollector::matchPartPseudoElementRulesForScope):
(WebCore::ElementRuleCollector::collectMatchingShadowPseudoElementRules):
(WebCore::ElementRuleCollector::collectSlottedPseudoElementRulesForSlot):
(WebCore::ElementRuleCollector::matchUserRules):
(WebCore::ElementRuleCollector::matchUARules):
(WebCore::ElementRuleCollector::collectMatchingRulesForList):
(WebCore::ElementRuleCollector::matchAllRules):
(WebCore::ElementRuleCollector::hasAnyMatchingRules):

  • css/ElementRuleCollector.h:

(WebCore::ElementRuleCollector::setIncludeEmptyRules):
(WebCore::ElementRuleCollector::transferMatchedRules):

Range update happens now here based on the supplied argument.

  • css/StyleResolver.cpp:

(WebCore::StyleResolver::pseudoStyleForElement):
(WebCore::StyleResolver::pseudoStyleRulesForElement):

Location:
trunk/Source/WebCore
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r251285 r251289  
     12019-10-18  Antti Koivisto  <antti@apple.com>
     2
     3        ElementRuleCollector function signature cleanups
     4        https://bugs.webkit.org/show_bug.cgi?id=203153
     5
     6        Reviewed by Zalan Bujtas.
     7
     8        Many functions in ElementRuleCollector take repetitive arguments that can be removed:
     9
     10        - Make includeEmptyRules argument a class member
     11        - Remove RuleRange argument, update the ranges in rule transfer step.
     12
     13        * css/ElementRuleCollector.cpp:
     14        (WebCore::MatchRequest::MatchRequest):
     15        (WebCore::ElementRuleCollector::addMatchedRule):
     16        (WebCore::ElementRuleCollector::collectMatchingRules):
     17        (WebCore::ElementRuleCollector::sortAndTransferMatchedRules):
     18        (WebCore::ElementRuleCollector::transferMatchedRules):
     19        (WebCore::ElementRuleCollector::matchAuthorRules):
     20        (WebCore::ElementRuleCollector::matchesAnyAuthorRules):
     21        (WebCore::ElementRuleCollector::collectMatchingAuthorRules):
     22        (WebCore::ElementRuleCollector::matchAuthorShadowPseudoElementRules):
     23        (WebCore::ElementRuleCollector::matchHostPseudoClassRules):
     24        (WebCore::ElementRuleCollector::matchSlottedPseudoElementRules):
     25        (WebCore::ElementRuleCollector::matchPartPseudoElementRules):
     26        (WebCore::ElementRuleCollector::matchPartPseudoElementRulesForScope):
     27        (WebCore::ElementRuleCollector::collectMatchingShadowPseudoElementRules):
     28        (WebCore::ElementRuleCollector::collectSlottedPseudoElementRulesForSlot):
     29        (WebCore::ElementRuleCollector::matchUserRules):
     30        (WebCore::ElementRuleCollector::matchUARules):
     31        (WebCore::ElementRuleCollector::collectMatchingRulesForList):
     32        (WebCore::ElementRuleCollector::matchAllRules):
     33        (WebCore::ElementRuleCollector::hasAnyMatchingRules):
     34        * css/ElementRuleCollector.h:
     35        (WebCore::ElementRuleCollector::setIncludeEmptyRules):
     36        (WebCore::ElementRuleCollector::transferMatchedRules):
     37
     38        Range update happens now here based on the supplied argument.
     39
     40        * css/StyleResolver.cpp:
     41        (WebCore::StyleResolver::pseudoStyleForElement):
     42        (WebCore::StyleResolver::pseudoStyleRulesForElement):
     43x
    1442019-10-18  Antti Koivisto  <antti@apple.com>
    245

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

    r251285 r251289  
    6969class MatchRequest {
    7070public:
    71     MatchRequest(const RuleSet* ruleSet, bool includeEmptyRules = false, Style::ScopeOrdinal styleScopeOrdinal = Style::ScopeOrdinal::Element)
     71    MatchRequest(const RuleSet* ruleSet, Style::ScopeOrdinal styleScopeOrdinal = Style::ScopeOrdinal::Element)
    7272        : ruleSet(ruleSet)
    73         , includeEmptyRules(includeEmptyRules)
    7473        , styleScopeOrdinal(styleScopeOrdinal)
    7574    {
    7675    }
    7776    const RuleSet* ruleSet;
    78     const bool includeEmptyRules;
    7977    Style::ScopeOrdinal styleScopeOrdinal;
    8078};
    … …  
    110108}
    111109
    112 inline void ElementRuleCollector::addMatchedRule(const RuleData& ruleData, unsigned specificity, Style::ScopeOrdinal styleScopeOrdinal, StyleResolver::RuleRange& ruleRange)
    113 {
    114     // Update our first/last rule indices in the matched rules array.
    115     if (ruleRange.lastRuleIndex != -1)
    116         ++ruleRange.lastRuleIndex;
    117     else {
    118         ruleRange.lastRuleIndex = m_result.matchedProperties().size();
    119         ruleRange.firstRuleIndex = ruleRange.lastRuleIndex;
    120     }
    121 
     110inline void ElementRuleCollector::addMatchedRule(const RuleData& ruleData, unsigned specificity, Style::ScopeOrdinal styleScopeOrdinal)
     111{
    122112    m_matchedRules.append({ &ruleData, specificity, styleScopeOrdinal });
    123113}
    … …  
    147137}
    148138
    149 void ElementRuleCollector::collectMatchingRules(const MatchRequest& matchRequest, StyleResolver::RuleRange& ruleRange)
     139void ElementRuleCollector::collectMatchingRules(const MatchRequest& matchRequest)
    150140{
    151141    ASSERT(matchRequest.ruleSet);
    … …  
    154144    auto* shadowRoot = element().containingShadowRoot();
    155145    if (shadowRoot && shadowRoot->mode() == ShadowRootMode::UserAgent)
    156         collectMatchingShadowPseudoElementRules(matchRequest, ruleRange);
     146        collectMatchingShadowPseudoElementRules(matchRequest);
    157147
    158148    // We need to collect the rules for id, class, tag, and everything else into a buffer and
    … …  
    160150    auto& id = element().idForStyleResolution();
    161151    if (!id.isNull())
    162         collectMatchingRulesForList(matchRequest.ruleSet->idRules(id), matchRequest, ruleRange);
     152        collectMatchingRulesForList(matchRequest.ruleSet->idRules(id), matchRequest);
    163153    if (element().hasClass()) {
    164154        for (size_t i = 0; i < element().classNames().size(); ++i)
    165             collectMatchingRulesForList(matchRequest.ruleSet->classRules(element().classNames()[i]), matchRequest, ruleRange);
     155            collectMatchingRulesForList(matchRequest.ruleSet->classRules(element().classNames()[i]), matchRequest);
    166156    }
    167157
    168158    if (element().isLink())
    169         collectMatchingRulesForList(matchRequest.ruleSet->linkPseudoClassRules(), matchRequest, ruleRange);
     159        collectMatchingRulesForList(matchRequest.ruleSet->linkPseudoClassRules(), matchRequest);
    170160    if (SelectorChecker::matchesFocusPseudoClass(element()))
    171         collectMatchingRulesForList(matchRequest.ruleSet->focusPseudoClassRules(), matchRequest, ruleRange);
    172     collectMatchingRulesForList(matchRequest.ruleSet->tagRules(element().localName(), element().isHTMLElement() && element().document().isHTMLDocument()), matchRequest, ruleRange);
    173     collectMatchingRulesForList(matchRequest.ruleSet->universalRules(), matchRequest, ruleRange);
    174 }
    175 
    176 void ElementRuleCollector::sortAndTransferMatchedRules()
     161        collectMatchingRulesForList(matchRequest.ruleSet->focusPseudoClassRules(), matchRequest);
     162    collectMatchingRulesForList(matchRequest.ruleSet->tagRules(element().localName(), element().isHTMLElement() && element().document().isHTMLDocument()), matchRequest);
     163    collectMatchingRulesForList(matchRequest.ruleSet->universalRules(), matchRequest);
     164}
     165
     166void ElementRuleCollector::sortAndTransferMatchedRules(DeclarationOrigin declarationOrigin)
    177167{
    178168    if (m_matchedRules.isEmpty())
    … …  
    181171    sortMatchedRules();
    182172
    183     transferMatchedRules();
    184 }
    185 
    186 void ElementRuleCollector::transferMatchedRules(Optional<Style::ScopeOrdinal> fromScope)
    187 {
     173    transferMatchedRules(declarationOrigin);
     174}
     175
     176void ElementRuleCollector::transferMatchedRules(DeclarationOrigin declarationOrigin, Optional<Style::ScopeOrdinal> fromScope)
     177{
     178    if (m_matchedRules.size() <= m_matchedRuleTransferIndex)
     179        return;
     180
     181    auto rangeForDeclarationOrigin = [&]() {
     182        switch (declarationOrigin) {
     183        case DeclarationOrigin::UserAgent: return m_result.ranges.UARuleRange();
     184        case DeclarationOrigin::Author: return m_result.ranges.authorRuleRange();
     185        case DeclarationOrigin::User: return m_result.ranges.userRuleRange();
     186        }
     187    }();
     188
     189    // FIXME: Range updating should be done by MatchResults type
     190    // FIXME: MatchResults shouldn't be in StyleResolver namespace.
     191    bool updateRanges = m_mode != SelectorChecker::Mode::CollectingRules;
     192    if (updateRanges && rangeForDeclarationOrigin.firstRuleIndex == -1)
     193        rangeForDeclarationOrigin.firstRuleIndex = m_result.matchedRules.size();
     194
    188195    for (; m_matchedRuleTransferIndex < m_matchedRules.size(); ++m_matchedRuleTransferIndex) {
    189196        auto& matchedRule = m_matchedRules[m_matchedRuleTransferIndex];
    … …  
    198205        m_result.addMatchedProperties(matchedRule.ruleData->rule()->properties(), matchedRule.ruleData->rule(), matchedRule.ruleData->linkMatchType(), matchedRule.ruleData->propertyWhitelistType(), matchedRule.styleScopeOrdinal);
    199206    }
    200 }
    201 
    202 void ElementRuleCollector::matchAuthorRules(bool includeEmptyRules)
     207
     208    if (updateRanges)
     209        rangeForDeclarationOrigin.lastRuleIndex = m_result.matchedRules.size() - 1;
     210}
     211
     212void ElementRuleCollector::matchAuthorRules()
    203213{
    204214    clearMatchedRules();
    205215
    206     collectMatchingAuthorRules(includeEmptyRules);
    207 
    208     sortAndTransferMatchedRules();
     216    collectMatchingAuthorRules();
     217
     218    sortAndTransferMatchedRules(DeclarationOrigin::Author);
    209219}
    210220
    … …  
    214224
    215225    // FIXME: This should bail out on first match.
    216     collectMatchingAuthorRules(false);
     226    collectMatchingAuthorRules();
    217227
    218228    return !m_matchedRules.isEmpty();
    219229}
    220230
    221 void ElementRuleCollector::collectMatchingAuthorRules(bool includeEmptyRules)
    222 {
    223     StyleResolver::RuleRange ruleRange = m_result.ranges.authorRuleRange();
    224 
     231void ElementRuleCollector::collectMatchingAuthorRules()
     232{
    225233    {
    226         MatchRequest matchRequest(&m_authorStyle, includeEmptyRules);
    227         collectMatchingRules(matchRequest, ruleRange);
     234        MatchRequest matchRequest(&m_authorStyle);
     235        collectMatchingRules(matchRequest);
    228236    }
    229237
    230238    auto* parent = element().parentElement();
    231239    if (parent && parent->shadowRoot())
    232         matchSlottedPseudoElementRules(includeEmptyRules, ruleRange);
     240        matchSlottedPseudoElementRules();
    233241
    234242    if (element().shadowRoot())
    235         matchHostPseudoClassRules(includeEmptyRules, ruleRange);
     243        matchHostPseudoClassRules();
    236244
    237245    if (element().isInShadowTree()) {
    238         matchAuthorShadowPseudoElementRules(includeEmptyRules, ruleRange);
    239         matchPartPseudoElementRules(includeEmptyRules, ruleRange);
    240     }
    241 }
    242 
    243 void ElementRuleCollector::matchAuthorShadowPseudoElementRules(bool includeEmptyRules, StyleResolver::RuleRange& ruleRange)
     246        matchAuthorShadowPseudoElementRules();
     247        matchPartPseudoElementRules();
     248    }
     249}
     250
     251void ElementRuleCollector::matchAuthorShadowPseudoElementRules()
    244252{
    245253    ASSERT(element().isInShadowTree());
    … …  
    249257    // Look up shadow pseudo elements also from the host scope author style as they are web-exposed.
    250258    auto& hostAuthorRules = Style::Scope::forNode(*shadowRoot.host()).resolver().ruleSets().authorStyle();
    251     MatchRequest hostAuthorRequest { &hostAuthorRules, includeEmptyRules, Style::ScopeOrdinal::ContainingHost };
    252     collectMatchingShadowPseudoElementRules(hostAuthorRequest, ruleRange);
    253 }
    254 
    255 void ElementRuleCollector::matchHostPseudoClassRules(bool includeEmptyRules, StyleResolver::RuleRange& ruleRange)
     259    MatchRequest hostAuthorRequest { &hostAuthorRules, Style::ScopeOrdinal::ContainingHost };
     260    collectMatchingShadowPseudoElementRules(hostAuthorRequest);
     261}
     262
     263void ElementRuleCollector::matchHostPseudoClassRules()
    256264{
    257265    ASSERT(element().shadowRoot());
    … …  
    264272    SetForScope<bool> change(m_isMatchingHostPseudoClass, true);
    265273
    266     MatchRequest hostMatchRequest { nullptr, includeEmptyRules, Style::ScopeOrdinal::Shadow };
    267     collectMatchingRulesForList(&shadowHostRules, hostMatchRequest, ruleRange);
    268 }
    269 
    270 void ElementRuleCollector::matchSlottedPseudoElementRules(bool includeEmptyRules, StyleResolver::RuleRange& ruleRange)
     274    MatchRequest hostMatchRequest { nullptr, Style::ScopeOrdinal::Shadow };
     275    collectMatchingRulesForList(&shadowHostRules, hostMatchRequest);
     276}
     277
     278void ElementRuleCollector::matchSlottedPseudoElementRules()
    271279{
    272280    auto* slot = element().assignedSlot();
    … …  
    280288        // FIXME: This is really part of the slot style and could be cached when resolving it.
    281289        ElementRuleCollector collector(*slot, styleScope.resolver().ruleSets().authorStyle(), nullptr);
    282         auto slottedPseudoElementRules = collector.collectSlottedPseudoElementRulesForSlot(includeEmptyRules);
     290        auto slottedPseudoElementRules = collector.collectSlottedPseudoElementRulesForSlot();
    283291        if (!slottedPseudoElementRules)
    284292            continue;
    … …  
    286294        SetForScope<bool> change(m_isMatchingSlottedPseudoElements, true);
    287295
    288         MatchRequest scopeMatchRequest(nullptr, includeEmptyRules, styleScopeOrdinal);
    289         collectMatchingRulesForList(slottedPseudoElementRules.get(), scopeMatchRequest, ruleRange);
     296        MatchRequest scopeMatchRequest(nullptr, styleScopeOrdinal);
     297        collectMatchingRulesForList(slottedPseudoElementRules.get(), scopeMatchRequest);
    290298
    291299        m_keepAliveSlottedPseudoElementRules.append(WTFMove(slottedPseudoElementRules));
    … …  
    293301}
    294302
    295 void ElementRuleCollector::matchPartPseudoElementRules(bool includeEmptyRules, StyleResolver::RuleRange& ruleRange)
     303void ElementRuleCollector::matchPartPseudoElementRules()
    296304{
    297305    ASSERT(element().isInShadowTree());
    … …  
    303311        return;
    304312
    305     matchPartPseudoElementRulesForScope(*partMatchingElement.containingShadowRoot(), includeEmptyRules, ruleRange);
    306 }
    307 
    308 void ElementRuleCollector::matchPartPseudoElementRulesForScope(const ShadowRoot& scopeShadowRoot, bool includeEmptyRules, StyleResolver::RuleRange& ruleRange)
     313    matchPartPseudoElementRulesForScope(*partMatchingElement.containingShadowRoot());
     314}
     315
     316void ElementRuleCollector::matchPartPseudoElementRulesForScope(const ShadowRoot& scopeShadowRoot)
    309317{
    310318    auto& shadowHost = *scopeShadowRoot.host();
    … …  
    313321
    314322        auto& hostAuthorRules = Style::Scope::forNode(shadowHost).resolver().ruleSets().authorStyle();
    315         MatchRequest hostAuthorRequest { &hostAuthorRules, includeEmptyRules, Style::ScopeOrdinal::ContainingHost };
    316         collectMatchingRulesForList(&hostAuthorRules.partPseudoElementRules(), hostAuthorRequest, ruleRange);
     323        MatchRequest hostAuthorRequest { &hostAuthorRules, Style::ScopeOrdinal::ContainingHost };
     324        collectMatchingRulesForList(&hostAuthorRules.partPseudoElementRules(), hostAuthorRequest);
    317325    }
    318326
    … …  
    322330
    323331    if (auto* parentScopeShadowRoot = shadowHost.containingShadowRoot())
    324         matchPartPseudoElementRulesForScope(*parentScopeShadowRoot, includeEmptyRules, ruleRange);
    325 }
    326 
    327 void ElementRuleCollector::collectMatchingShadowPseudoElementRules(const MatchRequest& matchRequest, StyleResolver::RuleRange& ruleRange)
     332        matchPartPseudoElementRulesForScope(*parentScopeShadowRoot);
     333}
     334
     335void ElementRuleCollector::collectMatchingShadowPseudoElementRules(const MatchRequest& matchRequest)
    328336{
    329337    ASSERT(matchRequest.ruleSet);
    … …  
    334342    // FXIME: WebVTT should not be done by styling UA shadow trees like this.
    335343    if (element().isWebVTTElement())
    336         collectMatchingRulesForList(rules.cuePseudoRules(), matchRequest, ruleRange);
     344        collectMatchingRulesForList(rules.cuePseudoRules(), matchRequest);
    337345#endif
    338346    auto& pseudoId = element().shadowPseudoId();
    339347    if (!pseudoId.isEmpty())
    340         collectMatchingRulesForList(rules.shadowPseudoElementRules(pseudoId), matchRequest, ruleRange);
    341 }
    342 
    343 std::unique_ptr<RuleSet::RuleDataVector> ElementRuleCollector::collectSlottedPseudoElementRulesForSlot(bool includeEmptyRules)
     348        collectMatchingRulesForList(rules.shadowPseudoElementRules(pseudoId), matchRequest);
     349}
     350
     351std::unique_ptr<RuleSet::RuleDataVector> ElementRuleCollector::collectSlottedPseudoElementRulesForSlot()
    344352{
    345353    ASSERT(is<HTMLSlotElement>(element()));
    … …  
    350358
    351359    // Match global author rules.
    352     MatchRequest matchRequest(&m_authorStyle, includeEmptyRules);
    353     StyleResolver::RuleRange ruleRange = m_result.ranges.authorRuleRange();
    354     collectMatchingRulesForList(&m_authorStyle.slottedPseudoElementRules(), matchRequest, ruleRange);
     360    MatchRequest matchRequest(&m_authorStyle);
     361    collectMatchingRulesForList(&m_authorStyle.slottedPseudoElementRules(), matchRequest);
    355362
    356363    if (m_matchedRules.isEmpty())
    … …  
    365372}
    366373
    367 void ElementRuleCollector::matchUserRules(bool includeEmptyRules)
     374void ElementRuleCollector::matchUserRules()
    368375{
    369376    if (!m_userStyle)
    … …  
    372379    clearMatchedRules();
    373380
    374     MatchRequest matchRequest(m_userStyle, includeEmptyRules);
    375     StyleResolver::RuleRange ruleRange = m_result.ranges.userRuleRange();
    376     collectMatchingRules(matchRequest, ruleRange);
    377 
    378     sortAndTransferMatchedRules();
     381    MatchRequest matchRequest(m_userStyle);
     382    collectMatchingRules(matchRequest);
     383
     384    sortAndTransferMatchedRules(DeclarationOrigin::User);
    379385}
    380386
    … …  
    400406    clearMatchedRules();
    401407   
    402     StyleResolver::RuleRange ruleRange = m_result.ranges.UARuleRange();
    403     collectMatchingRules(MatchRequest(&rules), ruleRange);
    404 
    405     sortAndTransferMatchedRules();
     408    collectMatchingRules(MatchRequest(&rules));
     409
     410    sortAndTransferMatchedRules(DeclarationOrigin::UserAgent);
    406411}
    407412
    … …  
    515520}
    516521
    517 void ElementRuleCollector::collectMatchingRulesForList(const RuleSet::RuleDataVector* rules, const MatchRequest& matchRequest, StyleResolver::RuleRange& ruleRange)
     522void ElementRuleCollector::collectMatchingRulesForList(const RuleSet::RuleDataVector* rules, const MatchRequest& matchRequest)
    518523{
    519524    if (!rules)
    … …  
    535540        // and that means we always have to consider it.
    536541        const StyleProperties* properties = rule->propertiesWithoutDeferredParsing();
    537         if (properties && properties->isEmpty() && !matchRequest.includeEmptyRules)
     542        if (properties && properties->isEmpty() && !m_shouldIncludeEmptyRules)
    538543            continue;
    539544
    540545        unsigned specificity;
    541546        if (ruleMatches(ruleData, specificity))
    542             addMatchedRule(ruleData, specificity, matchRequest.styleScopeOrdinal, ruleRange);
     547            addMatchedRule(ruleData, specificity, matchRequest.styleScopeOrdinal);
    543548    }
    544549}
    … …  
    567572    // Now we check user sheet rules.
    568573    if (matchAuthorAndUserStyles)
    569         matchUserRules(false);
     574        matchUserRules();
    570575
    571576    // Now check author rules, beginning first with presentational attributes mapped from HTML.
    … …  
    590595        clearMatchedRules();
    591596
    592         collectMatchingAuthorRules(false);
     597        collectMatchingAuthorRules();
    593598        sortMatchedRules();
    594599
    595         transferMatchedRules(Style::ScopeOrdinal::Element);
     600        transferMatchedRules(DeclarationOrigin::Author, Style::ScopeOrdinal::Element);
    596601
    597602        // Inline style behaves as if it has higher specificity than any rule.
    … …  
    599604
    600605        // Rules from the host scope override inline style.
    601         transferMatchedRules(Style::ScopeOrdinal::ContainingHost);
     606        transferMatchedRules(DeclarationOrigin::Author, Style::ScopeOrdinal::ContainingHost);
    602607    }
    603608}
    … …  
    623628
    624629    m_mode = SelectorChecker::Mode::CollectingRulesIgnoringVirtualPseudoElements;
    625     int firstRuleIndex = -1, lastRuleIndex = -1;
    626     StyleResolver::RuleRange ruleRange(firstRuleIndex, lastRuleIndex);
    627     collectMatchingRules(MatchRequest(ruleSet), ruleRange);
     630    collectMatchingRules(MatchRequest(ruleSet));
    628631
    629632    return !m_matchedRules.isEmpty();

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

    r251285 r251289  
    4848    ElementRuleCollector(const Element&, const RuleSet& authorStyle, const SelectorFilter*);
    4949
     50    void setIncludeEmptyRules(bool value) { m_shouldIncludeEmptyRules = value; }
     51
    5052    void matchAllRules(bool matchAuthorAndUserStyles, bool includeSMILProperties);
    5153    void matchUARules();
    52     void matchAuthorRules(bool includeEmptyRules);
    53     void matchUserRules(bool includeEmptyRules);
     54    void matchAuthorRules();
     55    void matchUserRules();
    5456
    5557    bool matchesAnyAuthorRules();
    … …  
    7577    void matchUARules(const RuleSet&);
    7678
    77     void collectMatchingAuthorRules(bool includeEmptyRules);
     79    void collectMatchingAuthorRules();
    7880    void addElementInlineStyleProperties(bool includeSMILProperties);
    7981
    80     void matchAuthorShadowPseudoElementRules(bool includeEmptyRules, StyleResolver::RuleRange&);
    81     void matchHostPseudoClassRules(bool includeEmptyRules, StyleResolver::RuleRange&);
    82     void matchSlottedPseudoElementRules(bool includeEmptyRules, StyleResolver::RuleRange&);
    83     void matchPartPseudoElementRules(bool includeEmptyRules, StyleResolver::RuleRange&);
    84     void matchPartPseudoElementRulesForScope(const ShadowRoot& scopeShadowRoot, bool includeEmptyRules, StyleResolver::RuleRange&);
     82    void matchAuthorShadowPseudoElementRules();
     83    void matchHostPseudoClassRules();
     84    void matchSlottedPseudoElementRules();
     85    void matchPartPseudoElementRules();
     86    void matchPartPseudoElementRulesForScope(const ShadowRoot& scopeShadowRoot);
    8587
    86     void collectMatchingShadowPseudoElementRules(const MatchRequest&, StyleResolver::RuleRange&);
    87     std::unique_ptr<RuleSet::RuleDataVector> collectSlottedPseudoElementRulesForSlot(bool includeEmptyRules);
     88    void collectMatchingShadowPseudoElementRules(const MatchRequest&);
     89    std::unique_ptr<RuleSet::RuleDataVector> collectSlottedPseudoElementRulesForSlot();
    8890
    89     void collectMatchingRules(const MatchRequest&, StyleResolver::RuleRange&);
    90     void collectMatchingRulesForList(const RuleSet::RuleDataVector*, const MatchRequest&, StyleResolver::RuleRange&);
     91    void collectMatchingRules(const MatchRequest&);
     92    void collectMatchingRulesForList(const RuleSet::RuleDataVector*, const MatchRequest&);
    9193    bool ruleMatches(const RuleData&, unsigned &specificity);
    9294
    9395    void sortMatchedRules();
    94     void sortAndTransferMatchedRules();
    95     void transferMatchedRules(Optional<Style::ScopeOrdinal> forScope = { });
    9696
    97     void addMatchedRule(const RuleData&, unsigned specificity, Style::ScopeOrdinal, StyleResolver::RuleRange&);
     97    enum class DeclarationOrigin { UserAgent, Author, User };
     98    void sortAndTransferMatchedRules(DeclarationOrigin);
     99    void transferMatchedRules(DeclarationOrigin, Optional<Style::ScopeOrdinal> forScope = { });
     100
     101    void addMatchedRule(const RuleData&, unsigned specificity, Style::ScopeOrdinal);
    98102
    99103    const Element& element() const { return m_element.get(); }
    … …  
    105109    const SelectorFilter* m_selectorFilter { nullptr };
    106110
     111    bool m_shouldIncludeEmptyRules { false };
    107112    bool m_isPrintStyle { false };
    108113    PseudoStyleRequest m_pseudoStyleRequest { PseudoId::None };

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

    r251285 r251289  
    585585
    586586    if (m_matchAuthorAndUserStyles) {
    587         collector.matchUserRules(false);
    588         collector.matchAuthorRules(false);
     587        collector.matchUserRules();
     588        collector.matchAuthorRules();
    589589    }
    590590
    … …  
    12581258    collector.setPseudoStyleRequest(PseudoStyleRequest(pseudoId));
    12591259    collector.setMedium(&m_mediaQueryEvaluator);
     1260    collector.setIncludeEmptyRules(rulesToInclude & EmptyCSSRules);
    12601261
    12611262    if (rulesToInclude & UAAndUserCSSRules) {
    … …  
    12651266        // Now we check user sheet rules.
    12661267        if (m_matchAuthorAndUserStyles)
    1267             collector.matchUserRules(rulesToInclude & EmptyCSSRules);
     1268            collector.matchUserRules();
    12681269    }
    12691270
    12701271    if (m_matchAuthorAndUserStyles && (rulesToInclude & AuthorCSSRules))
    1271         collector.matchAuthorRules(rulesToInclude & EmptyCSSRules);
     1272        collector.matchAuthorRules();
    12721273
    12731274    return collector.matchedRuleList();
Note: See TracChangeset for help on using the changeset viewer.