Changeset 225650 in webkit


Ignore:
Timestamp:
Dec 7, 2017 3:58:39 PM (6 years ago)
Author:
Antti Koivisto
Message:

Move security origin filtering for getMatchedCSSRules out of StyleResolver
​https://bugs.webkit.org/show_bug.cgi?id=180468

Reviewed by Zalan Bujtas.

The non-standard getMatchedCSSRules API should not return rules from stylesheets in different security origins.
To implement this we currently have lots of invasive code in StyleResolver, RuleSets and ElementRuleCollector
basically passing around a bit. This also makes RuleSets document specific blocking optimizations.

This patches replaces the mechanism with a bit in StyleRule which is much simpler.

  • css/DocumentRuleSets.cpp:

(WebCore::makeRuleSet):

  • css/ElementRuleCollector.cpp:

(WebCore::ElementRuleCollector::collectMatchingRulesForList):

  • css/ElementRuleCollector.h:

(WebCore::ElementRuleCollector::setPseudoStyleRequest):
(WebCore::ElementRuleCollector::setSameOriginOnly): Deleted.

  • css/RuleFeature.cpp:

(WebCore::RuleFeatureSet::collectFeatures):

  • css/RuleFeature.h:

(WebCore::RuleFeature::RuleFeature):

  • css/RuleSet.cpp:

(WebCore::RuleData::RuleData):
(WebCore::RuleSet::addRule):
(WebCore::RuleSet::addChildRules):
(WebCore::RuleSet::addRulesFromSheet):
(WebCore::RuleSet::addStyleRule):

  • css/RuleSet.h:

(WebCore::RuleData::linkMatchType const):
(WebCore::RuleData::hasDocumentSecurityOrigin const): Deleted.

  • css/StyleResolver.cpp:

(WebCore::StyleResolver::pseudoStyleRulesForElement):

  • css/StyleResolver.h:
  • css/StyleRule.cpp:

(WebCore::StyleRule::StyleRule):
(WebCore::StyleRule::createForSplitting):
(WebCore::StyleRule::splitIntoMultipleRulesWithMaximumSelectorComponentCount const):
(WebCore::StyleRule::create): Deleted.

  • css/StyleRule.h:

(WebCore::StyleRuleBase::StyleRuleBase):
(WebCore::StyleRuleBase::hasDocumentSecurityOrigin const):

Add a bit.

  • css/parser/CSSParser.cpp:

(WebCore::CSSParserContext::CSSParserContext):

Include hasDocumentSecurityOrigin bit to parser context. This means that a stylesheet data structures
can't be shared between a contexts where this differs. This likely very rare in practice.

(WebCore::operator==):

  • css/parser/CSSParserImpl.cpp:

(WebCore::CSSParserImpl::consumeStyleRule):

  • css/parser/CSSParserMode.h:

(WebCore::CSSParserContextHash::hash):

  • editing/EditingStyle.cpp:

(WebCore::EditingStyle::mergeStyleFromRules):

  • page/DOMWindow.cpp:

(WebCore::DOMWindow::getMatchedCSSRules const):

Filter out rules from different security origin after getting them from style resolver.

Location:
trunk/Source/WebCore
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r225649 r225650  
     12017-12-07  Antti Koivisto  <antti@apple.com>
     2
     3        Move security origin filtering for getMatchedCSSRules out of StyleResolver
     4        https://bugs.webkit.org/show_bug.cgi?id=180468
     5
     6        Reviewed by Zalan Bujtas.
     7
     8        The non-standard getMatchedCSSRules API should not return rules from stylesheets in different security origins.
     9        To implement this we currently have lots of invasive code in StyleResolver, RuleSets and ElementRuleCollector
     10        basically passing around a bit. This also makes RuleSets document specific blocking optimizations.
     11
     12        This patches replaces the mechanism with a bit in StyleRule which is much simpler.
     13
     14        * css/DocumentRuleSets.cpp:
     15        (WebCore::makeRuleSet):
     16        * css/ElementRuleCollector.cpp:
     17        (WebCore::ElementRuleCollector::collectMatchingRulesForList):
     18        * css/ElementRuleCollector.h:
     19        (WebCore::ElementRuleCollector::setPseudoStyleRequest):
     20        (WebCore::ElementRuleCollector::setSameOriginOnly): Deleted.
     21        * css/RuleFeature.cpp:
     22        (WebCore::RuleFeatureSet::collectFeatures):
     23        * css/RuleFeature.h:
     24        (WebCore::RuleFeature::RuleFeature):
     25        * css/RuleSet.cpp:
     26        (WebCore::RuleData::RuleData):
     27        (WebCore::RuleSet::addRule):
     28        (WebCore::RuleSet::addChildRules):
     29        (WebCore::RuleSet::addRulesFromSheet):
     30        (WebCore::RuleSet::addStyleRule):
     31        * css/RuleSet.h:
     32        (WebCore::RuleData::linkMatchType const):
     33        (WebCore::RuleData::hasDocumentSecurityOrigin const): Deleted.
     34        * css/StyleResolver.cpp:
     35        (WebCore::StyleResolver::pseudoStyleRulesForElement):
     36        * css/StyleResolver.h:
     37        * css/StyleRule.cpp:
     38        (WebCore::StyleRule::StyleRule):
     39        (WebCore::StyleRule::createForSplitting):
     40        (WebCore::StyleRule::splitIntoMultipleRulesWithMaximumSelectorComponentCount const):
     41        (WebCore::StyleRule::create): Deleted.
     42        * css/StyleRule.h:
     43        (WebCore::StyleRuleBase::StyleRuleBase):
     44        (WebCore::StyleRuleBase::hasDocumentSecurityOrigin const):
     45
     46            Add a bit.
     47
     48        * css/parser/CSSParser.cpp:
     49        (WebCore::CSSParserContext::CSSParserContext):
     50
     51            Include hasDocumentSecurityOrigin bit to parser context. This means that a stylesheet data structures
     52            can't be shared between a contexts where this differs. This likely very rare in practice.
     53
     54        (WebCore::operator==):
     55        * css/parser/CSSParserImpl.cpp:
     56        (WebCore::CSSParserImpl::consumeStyleRule):
     57        * css/parser/CSSParserMode.h:
     58        (WebCore::CSSParserContextHash::hash):
     59        * editing/EditingStyle.cpp:
     60        (WebCore::EditingStyle::mergeStyleFromRules):
     61        * page/DOMWindow.cpp:
     62        (WebCore::DOMWindow::getMatchedCSSRules const):
     63
     64            Filter out rules from different security origin after getting them from style resolver.
     65
    1662017-12-07  Zalan Bujtas  <zalan@apple.com>
    267

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

    r224495 r225650  
    115115    auto ruleSet = std::make_unique<RuleSet>();
    116116    for (size_t i = 0; i < size; ++i)
    117         ruleSet->addRule(rules[i].rule, rules[i].selectorIndex, rules[i].hasDocumentSecurityOrigin ? RuleHasDocumentSecurityOrigin : RuleHasNoSpecialState);
     117        ruleSet->addRule(rules[i].rule, rules[i].selectorIndex);
    118118    ruleSet->shrinkToFit();
    119119    return ruleSet;

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

    r225482 r225650  
    477477            continue;
    478478
    479         // FIXME: Exposing the non-standard getMatchedCSSRules API to web is the only reason this is needed.
    480         if (m_sameOriginOnly && !ruleData.hasDocumentSecurityOrigin())
    481             continue;
    482 
    483479        unsigned specificity;
    484480        if (ruleMatches(ruleData, specificity))

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

    r224495 r225650  
    5555    void setMode(SelectorChecker::Mode mode) { m_mode = mode; }
    5656    void setPseudoStyleRequest(const PseudoStyleRequest& request) { m_pseudoStyleRequest = request; }
    57     void setSameOriginOnly(bool f) { m_sameOriginOnly = f; }
    5857    void setMedium(const MediaQueryEvaluator* medium) { m_isPrintStyle = medium->mediaTypeMatchSpecific("print"); }
    5958
    … …  
    9897    bool m_isPrintStyle { false };
    9998    PseudoStyleRequest m_pseudoStyleRequest { NOPSEUDO };
    100     bool m_sameOriginOnly { false };
    10199    SelectorChecker::Mode m_mode { SelectorChecker::Mode::ResolvingStyle };
    102100    bool m_isMatchingSlottedPseudoElements { false };

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

    r214255 r225650  
    9797    recursivelyCollectFeaturesFromSelector(selectorFeatures, *ruleData.selector());
    9898    if (selectorFeatures.hasSiblingSelector)
    99         siblingRules.append(RuleFeature(ruleData.rule(), ruleData.selectorIndex(), ruleData.hasDocumentSecurityOrigin()));
     99        siblingRules.append(RuleFeature(ruleData.rule(), ruleData.selectorIndex()));
    100100    if (ruleData.containsUncommonAttributeSelector())
    101         uncommonAttributeRules.append(RuleFeature(ruleData.rule(), ruleData.selectorIndex(), ruleData.hasDocumentSecurityOrigin()));
     101        uncommonAttributeRules.append(RuleFeature(ruleData.rule(), ruleData.selectorIndex()));
    102102    for (auto& className : selectorFeatures.classesMatchingAncestors) {
    103103        auto addResult = ancestorClassRules.ensure(className, [] {
    104104            return std::make_unique<Vector<RuleFeature>>();
    105105        });
    106         addResult.iterator->value->append(RuleFeature(ruleData.rule(), ruleData.selectorIndex(), ruleData.hasDocumentSecurityOrigin()));
     106        addResult.iterator->value->append(RuleFeature(ruleData.rule(), ruleData.selectorIndex()));
    107107    }
    108108    for (auto* selector : selectorFeatures.attributeSelectorsMatchingAncestors) {
    … …  
    112112        });
    113113        auto& rules = *addResult.iterator->value;
    114         rules.features.append(RuleFeature(ruleData.rule(), ruleData.selectorIndex(), ruleData.hasDocumentSecurityOrigin()));
     114        rules.features.append(RuleFeature(ruleData.rule(), ruleData.selectorIndex()));
    115115        // Deduplicate selectors.
    116116        rules.selectors.add(makeAttributeSelectorKey(*selector), selector);

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

    r214255 r225650  
    3535
    3636struct RuleFeature {
    37     RuleFeature(StyleRule* rule, unsigned selectorIndex, bool hasDocumentSecurityOrigin)
     37    RuleFeature(StyleRule* rule, unsigned selectorIndex)
    3838        : rule(rule)
    3939        , selectorIndex(selectorIndex)
    40         , hasDocumentSecurityOrigin(hasDocumentSecurityOrigin)
    41     {
     40    {
    4241    }
    4342    StyleRule* rule;
    4443    unsigned selectorIndex;
    45     bool hasDocumentSecurityOrigin;
    4644};
    4745

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

    r225596 r225650  
    149149}
    150150
    151 RuleData::RuleData(StyleRule* rule, unsigned selectorIndex, unsigned position, AddRuleFlags addRuleFlags)
     151RuleData::RuleData(StyleRule* rule, unsigned selectorIndex, unsigned position)
    152152    : m_rule(rule)
    153153    , m_selectorIndex(selectorIndex)
    154     , m_hasDocumentSecurityOrigin(addRuleFlags & RuleHasDocumentSecurityOrigin)
    155154    , m_position(position)
    156155    , m_matchBasedOnRuleHash(static_cast<unsigned>(computeMatchBasedOnRuleHash(*selector())))
    … …  
    203202}
    204203
    205 void RuleSet::addRule(StyleRule* rule, unsigned selectorIndex, AddRuleFlags addRuleFlags)
    206 {
    207     RuleData ruleData(rule, selectorIndex, m_ruleCount++, addRuleFlags);
     204void RuleSet::addRule(StyleRule* rule, unsigned selectorIndex)
     205{
     206    RuleData ruleData(rule, selectorIndex, m_ruleCount++);
    208207    m_features.collectFeatures(ruleData);
    209208
    … …  
    361360}
    362361
    363 void RuleSet::addChildRules(const Vector<RefPtr<StyleRuleBase>>& rules, const MediaQueryEvaluator& medium, StyleResolver* resolver, bool hasDocumentSecurityOrigin, bool isInitiatingElementInUserAgentShadowTree, AddRuleFlags addRuleFlags)
     362void RuleSet::addChildRules(const Vector<RefPtr<StyleRuleBase>>& rules, const MediaQueryEvaluator& medium, StyleResolver* resolver, bool isInitiatingElementInUserAgentShadowTree)
    364363{
    365364    for (auto& rule : rules) {
    366365        if (is<StyleRule>(*rule))
    367             addStyleRule(downcast<StyleRule>(rule.get()), addRuleFlags);
     366            addStyleRule(downcast<StyleRule>(rule.get()));
    368367        else if (is<StyleRulePage>(*rule))
    369368            addPageRule(downcast<StyleRulePage>(rule.get()));
    … …  
    371370            auto& mediaRule = downcast<StyleRuleMedia>(*rule);
    372371            if ((!mediaRule.mediaQueries() || medium.evaluate(*mediaRule.mediaQueries(), resolver)))
    373                 addChildRules(mediaRule.childRules(), medium, resolver, hasDocumentSecurityOrigin, isInitiatingElementInUserAgentShadowTree, addRuleFlags);
     372                addChildRules(mediaRule.childRules(), medium, resolver, isInitiatingElementInUserAgentShadowTree);
    374373        } else if (is<StyleRuleFontFace>(*rule) && resolver) {
    375374            // Add this font face to our set.
    … …  
    379378            resolver->addKeyframeStyle(downcast<StyleRuleKeyframes>(*rule));
    380379        else if (is<StyleRuleSupports>(*rule) && downcast<StyleRuleSupports>(*rule).conditionIsSupported())
    381             addChildRules(downcast<StyleRuleSupports>(*rule).childRules(), medium, resolver, hasDocumentSecurityOrigin, isInitiatingElementInUserAgentShadowTree, addRuleFlags);
     380            addChildRules(downcast<StyleRuleSupports>(*rule).childRules(), medium, resolver, isInitiatingElementInUserAgentShadowTree);
    382381#if ENABLE(CSS_DEVICE_ADAPTATION)
    383382        else if (is<StyleRuleViewport>(*rule) && resolver) {
    … …  
    395394    }
    396395
    397     bool hasDocumentSecurityOrigin = resolver && resolver->document().securityOrigin().canRequest(sheet.baseURL());
    398     AddRuleFlags addRuleFlags = static_cast<AddRuleFlags>((hasDocumentSecurityOrigin ? RuleHasDocumentSecurityOrigin : 0));
    399 
    400396    // FIXME: Skip Content Security Policy check when stylesheet is in a user agent shadow tree.
    401397    // See <https://bugs.webkit.org/show_bug.cgi?id=146663>.
    402398    bool isInitiatingElementInUserAgentShadowTree = false;
    403     addChildRules(sheet.childRules(), medium, resolver, hasDocumentSecurityOrigin, isInitiatingElementInUserAgentShadowTree, addRuleFlags);
     399    addChildRules(sheet.childRules(), medium, resolver, isInitiatingElementInUserAgentShadowTree);
    404400
    405401    if (m_autoShrinkToFitEnabled)
    … …  
    407403}
    408404
    409 void RuleSet::addStyleRule(StyleRule* rule, AddRuleFlags addRuleFlags)
     405void RuleSet::addStyleRule(StyleRule* rule)
    410406{
    411407    for (size_t selectorIndex = 0; selectorIndex != notFound; selectorIndex = rule->selectorList().indexOfNextSelectorAfter(selectorIndex))
    412         addRule(rule, selectorIndex, addRuleFlags);
     408        addRule(rule, selectorIndex);
    413409}
    414410

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

    r225482 r225650  
    3333namespace WebCore {
    3434
    35 enum AddRuleFlags {
    36     RuleHasNoSpecialState         = 0,
    37     RuleHasDocumentSecurityOrigin = 1,
    38 };
    39    
    4035enum PropertyWhitelistType {
    4136    PropertyWhitelistNone   = 0,
    … …  
    6560    static const unsigned maximumSelectorComponentCount = 8192;
    6661
    67     RuleData(StyleRule*, unsigned selectorIndex, unsigned position, AddRuleFlags);
     62    RuleData(StyleRule*, unsigned selectorIndex, unsigned position);
    6863
    6964    unsigned position() const { return m_position; }
    … …  
    7671    bool containsUncommonAttributeSelector() const { return m_containsUncommonAttributeSelector; }
    7772    unsigned linkMatchType() const { return m_linkMatchType; }
    78     bool hasDocumentSecurityOrigin() const { return m_hasDocumentSecurityOrigin; }
    7973    PropertyWhitelistType propertyWhitelistType() const { return static_cast<PropertyWhitelistType>(m_propertyWhitelistType); }
    8074    const SelectorFilter::Hashes& descendantSelectorIdentifierHashes() const { return m_descendantSelectorIdentifierHashes; }
    … …  
    10397    RefPtr<StyleRule> m_rule;
    10498    unsigned m_selectorIndex : 13;
    105     unsigned m_hasDocumentSecurityOrigin : 1;
    10699    // This number was picked fairly arbitrarily. We can probably lower it if we need to.
    107100    // Some simple testing showed <100,000 RuleData's on large sites.
    … …  
    159152    void addRulesFromSheet(StyleSheetContents&, const MediaQueryEvaluator&, StyleResolver* = 0);
    160153
    161     void addStyleRule(StyleRule*, AddRuleFlags);
    162     void addRule(StyleRule*, unsigned selectorIndex, AddRuleFlags);
     154    void addStyleRule(StyleRule*);
     155    void addRule(StyleRule*, unsigned selectorIndex);
    163156    void addPageRule(StyleRulePage*);
    164157    void addToRuleSet(const AtomicString& key, AtomRuleMap&, const RuleData&);
    … …  
    189182
    190183private:
    191     void addChildRules(const Vector<RefPtr<StyleRuleBase>>&, const MediaQueryEvaluator& medium, StyleResolver*, bool hasDocumentSecurityOrigin, bool isInitiatingElementInUserAgentShadowTree, AddRuleFlags);
     184    void addChildRules(const Vector<RefPtr<StyleRuleBase>>&, const MediaQueryEvaluator& medium, StyleResolver*, bool isInitiatingElementInUserAgentShadowTree);
    192185
    193186    AtomRuleMap m_idRules;

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

    r225641 r225650  
    11331133    }
    11341134
    1135     if (m_matchAuthorAndUserStyles && (rulesToInclude & AuthorCSSRules)) {
    1136         collector.setSameOriginOnly(!(rulesToInclude & CrossOriginCSSRules));
    1137 
    1138         // Check the rules in author sheets.
     1135    if (m_matchAuthorAndUserStyles && (rulesToInclude & AuthorCSSRules))
    11391136        collector.matchAuthorRules(rulesToInclude & EmptyCSSRules);
    1140     }
    11411137
    11421138    return collector.matchedRuleList();

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

    r225485 r225650  
    168168        AuthorCSSRules      = 1 << 2,
    169169        EmptyCSSRules       = 1 << 3,
    170         CrossOriginCSSRules = 1 << 4,
    171         AllButEmptyCSSRules = UAAndUserCSSRules | AuthorCSSRules | CrossOriginCSSRules,
     170        AllButEmptyCSSRules = UAAndUserCSSRules | AuthorCSSRules,
    172171        AllCSSRules         = AllButEmptyCSSRules | EmptyCSSRules,
    173172    };

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

    r223728 r225650  
    182182}
    183183
    184 StyleRule::StyleRule(Ref<StylePropertiesBase>&& properties)
    185     : StyleRuleBase(Style)
     184StyleRule::StyleRule(Ref<StylePropertiesBase>&& properties, bool hasDocumentSecurityOrigin)
     185    : StyleRuleBase(Style, hasDocumentSecurityOrigin)
    186186    , m_properties(WTFMove(properties))
    187187{
    … …  
    211211}
    212212
    213 Ref<StyleRule> StyleRule::create(const Vector<const CSSSelector*>& selectors, Ref<StyleProperties>&& properties)
     213Ref<StyleRule> StyleRule::createForSplitting(const Vector<const CSSSelector*>& selectors, Ref<StyleProperties>&& properties, bool hasDocumentSecurityOrigin)
    214214{
    215215    ASSERT_WITH_SECURITY_IMPLICATION(!selectors.isEmpty());
    … …  
    218218        new (NotNull, &selectorListArray[i]) CSSSelector(*selectors.at(i));
    219219    selectorListArray[selectors.size() - 1].setLastInSelectorList();
    220     auto rule = StyleRule::create(WTFMove(properties));
     220    auto rule = StyleRule::create(WTFMove(properties), hasDocumentSecurityOrigin);
    221221    rule.get().parserAdoptSelectorArray(selectorListArray);
    222222    return rule;
    … …  
    236236
    237237        if (componentsInThisSelector.size() + componentsSinceLastSplit.size() > maxCount && !componentsSinceLastSplit.isEmpty()) {
    238             rules.append(create(componentsSinceLastSplit, const_cast<StyleProperties&>(properties())));
     238            rules.append(createForSplitting(componentsSinceLastSplit, const_cast<StyleProperties&>(properties()), hasDocumentSecurityOrigin()));
    239239            componentsSinceLastSplit.clear();
    240240        }
    … …  
    244244
    245245    if (!componentsSinceLastSplit.isEmpty())
    246         rules.append(create(componentsSinceLastSplit, const_cast<StyleProperties&>(properties())));
     246        rules.append(createForSplitting(componentsSinceLastSplit, const_cast<StyleProperties&>(properties()), hasDocumentSecurityOrigin()));
    247247
    248248    return rules;

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

    r223728 r225650  
    8787
    8888protected:
    89     StyleRuleBase(Type type)
     89    StyleRuleBase(Type type, bool hasDocumentSecurityOrigin = false)
    9090        : m_type(type)
    91         { }
     91        , m_hasDocumentSecurityOrigin(hasDocumentSecurityOrigin)
     92    {
     93    }
    9294
    9395    StyleRuleBase(const StyleRuleBase& o)
    9496        : WTF::RefCountedBase()
    9597        , m_type(o.m_type)
    96         { }
     98        , m_hasDocumentSecurityOrigin(o.m_hasDocumentSecurityOrigin)
     99    {
     100    }
    97101
    98102    ~StyleRuleBase() = default;
    99103
     104    bool hasDocumentSecurityOrigin() const { return m_hasDocumentSecurityOrigin; }
     105
    100106private:
    101107    WEBCORE_EXPORT void destroy();
    … …  
    104110
    105111    unsigned m_type : 5;
     112    // This is only needed to support getMatchedCSSRules.
     113    unsigned m_hasDocumentSecurityOrigin : 1;
    106114};
    107115
    … …  
    109117    WTF_MAKE_FAST_ALLOCATED;
    110118public:
    111     static Ref<StyleRule> create(Ref<StylePropertiesBase>&& properties)
    112     {
    113         return adoptRef(*new StyleRule(WTFMove(properties)));
     119    static Ref<StyleRule> create(Ref<StylePropertiesBase>&& properties, bool hasDocumentSecurityOrigin)
     120    {
     121        return adoptRef(*new StyleRule(WTFMove(properties), hasDocumentSecurityOrigin));
    114122    }
    115123   
    … …  
    122130    const StyleProperties* propertiesWithoutDeferredParsing() const;
    123131
     132    using StyleRuleBase::hasDocumentSecurityOrigin;
     133
    124134    void parserAdoptSelectorVector(Vector<std::unique_ptr<CSSParserSelector>>& selectors) { m_selectorList.adoptSelectorVector(selectors); }
    125135    void wrapperAdoptSelectorList(CSSSelectorList& selectors) { m_selectorList = WTFMove(selectors); }
    … …  
    133143
    134144private:
    135     StyleRule(Ref<StylePropertiesBase>&&);
     145    StyleRule(Ref<StylePropertiesBase>&&, bool hasDocumentSecurityOrigin);
    136146    StyleRule(const StyleRule&);
    137147
    138     static Ref<StyleRule> create(const Vector<const CSSSelector*>&, Ref<StyleProperties>&&);
     148    static Ref<StyleRule> createForSplitting(const Vector<const CSSSelector*>&, Ref<StyleProperties>&&, bool hasDocumentSecurityOrigin);
    139149
    140150    mutable Ref<StylePropertiesBase> m_properties;

  • trunk/Source/WebCore/css/parser/CSSParser.cpp

    r224165 r225650  
    7373}
    7474
    75 CSSParserContext::CSSParserContext(Document& document, const URL& baseURL, const String& charset)
    76     : baseURL(baseURL.isNull() ? document.baseURL() : baseURL)
     75CSSParserContext::CSSParserContext(Document& document, const URL& sheetBaseURL, const String& charset)
     76    : baseURL(sheetBaseURL.isNull() ? document.baseURL() : sheetBaseURL)
    7777    , charset(charset)
    7878    , mode(document.inQuirksMode() ? HTMLQuirksMode : HTMLStandardMode)
    7979    , isHTMLDocument(document.isHTMLDocument())
    8080    , cssGridLayoutEnabled(document.isCSSGridLayoutEnabled())
     81    , hasDocumentSecurityOrigin(document.securityOrigin().canRequest(baseURL))
    8182{
    8283    needsSiteSpecificQuirks = document.settings().needsSiteSpecificQuirks();
    … …  
    112113        && a.constantPropertiesEnabled == b.constantPropertiesEnabled
    113114        && a.conicGradientsEnabled == b.conicGradientsEnabled
    114         && a.deferredCSSParserEnabled == b.deferredCSSParserEnabled;
     115        && a.deferredCSSParserEnabled == b.deferredCSSParserEnabled
     116        && a.hasDocumentSecurityOrigin == b.hasDocumentSecurityOrigin;
    115117}
    116118

  • trunk/Source/WebCore/css/parser/CSSParserImpl.cpp

    r222259 r225650  
    739739        blockCopy.consumeWhitespace();
    740740        if (!blockCopy.atEnd()) {
    741             rule = StyleRule::create(createDeferredStyleProperties(block));
     741            rule = StyleRule::create(createDeferredStyleProperties(block), m_context.hasDocumentSecurityOrigin);
    742742            rule->wrapperAdoptSelectorList(selectorList);
    743743            return rule;
    … …  
    746746
    747747    consumeDeclarationList(block, StyleRule::Style);
    748     rule = StyleRule::create(createStyleProperties(m_parsedProperties, m_context.mode));
     748    rule = StyleRule::create(createStyleProperties(m_parsedProperties, m_context.mode), m_context.hasDocumentSecurityOrigin);
    749749    rule->wrapperAdoptSelectorList(selectorList);
    750750    return rule;

  • trunk/Source/WebCore/css/parser/CSSParserMode.h

    r224165 r225650  
    108108    bool conicGradientsEnabled { false };
    109109    bool deferredCSSParserEnabled { false };
     110    // This is only needed to support getMatchedCSSRules.
     111    bool hasDocumentSecurityOrigin { false };
    110112
    111113    URL completeURL(const String& url) const
    … …  
    142144            & key.conicGradientsEnabled                     << 8
    143145            & key.deferredCSSParserEnabled                  << 9
    144             & key.mode                                      << 10;
     146            & key.hasDocumentSecurityOrigin                 << 10
     147            & key.mode                                      << 11;
    145148        hash ^= WTF::intHash(bits);
    146149        return hash;

  • trunk/Source/WebCore/editing/EditingStyle.cpp

    r224649 r225650  
    12701270{
    12711271    RefPtr<MutableStyleProperties> styleFromMatchedRules = styleFromMatchedRulesForElement(element,
    1272         StyleResolver::AuthorCSSRules | StyleResolver::CrossOriginCSSRules);
     1272        StyleResolver::AuthorCSSRules);
    12731273    // Styles from the inline style declaration, held in the variable "style", take precedence
    12741274    // over those from matched rules.

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

    r225142 r225650  
    14831483    if (!authorOnly)
    14841484        rulesToInclude |= StyleResolver::UAAndUserCSSRules;
    1485     if (m_frame->settings().crossOriginCheckInGetMatchedCSSRulesDisabled())
    1486         rulesToInclude |= StyleResolver::CrossOriginCSSRules;
    14871485
    14881486    PseudoId pseudoId = CSSSelector::pseudoId(pseudoType);
    … …  
    14921490        return nullptr;
    14931491
     1492    bool allowCrossOrigin = m_frame->settings().crossOriginCheckInGetMatchedCSSRulesDisabled();
     1493
    14941494    RefPtr<StaticCSSRuleList> ruleList = StaticCSSRuleList::create();
    1495     for (auto& rule : matchedRules)
     1495    for (auto& rule : matchedRules) {
     1496        if (!allowCrossOrigin && !rule->hasDocumentSecurityOrigin())
     1497            continue;
    14961498        ruleList->rules().append(rule->createCSSOMWrapper());
     1499    }
     1500
     1501    if (ruleList->rules().isEmpty())
     1502        return nullptr;
    14971503
    14981504    return ruleList;
Note: See TracChangeset for help on using the changeset viewer.