bool StyleSheetContents::wrapperInsertRule(StyleRuleBase* rule, unsigned index) { ASSERT(m_isMutable); SECURITY_DCHECK(index <= ruleCount()); if (index < m_importRules.size() || (index == m_importRules.size() && rule->isImportRule())) { // Inserting non-import rule before @import is not allowed. if (!rule->isImportRule()) return false; StyleRuleImport* importRule = toStyleRuleImport(rule); if (importRule->mediaQueries()) setHasMediaQueries(); m_importRules.insert(index, importRule); m_importRules[index]->setParentStyleSheet(this); m_importRules[index]->requestStyleSheet(); // FIXME: Stylesheet doesn't actually change meaningfully before the // imported sheets are loaded. return true; } // Inserting @import rule after a non-import rule is not allowed. if (rule->isImportRule()) return false; index -= m_importRules.size(); if (index < m_namespaceRules.size() || (index == m_namespaceRules.size() && rule->isNamespaceRule())) { // Inserting non-namespace rules other than import rule before @namespace is // not allowed. if (!rule->isNamespaceRule()) return false; // Inserting @namespace rule when rules other than import/namespace/charset // are present is not allowed. if (!m_childRules.isEmpty()) return false; StyleRuleNamespace* namespaceRule = toStyleRuleNamespace(rule); m_namespaceRules.insert(index, namespaceRule); // For now to be compatible with IE and Firefox if namespace rule with same // prefix is added irrespective of adding the rule at any index, last added // rule's value is considered. // TODO ([email protected]): As per spec last valid rule should be // considered, which means if namespace rule is added in the middle of // existing namespace rules, rule which comes later in rule list with same // prefix needs to be considered. parserAddNamespace(namespaceRule->prefix(), namespaceRule->uri()); return true; } if (rule->isNamespaceRule()) return false; index -= m_namespaceRules.size(); m_childRules.insert(index, rule); return true; }
void StyleSheetContents::parserAppendRule(StyleRuleBase* rule) { if (rule->isImportRule()) { // Parser enforces that @import rules come before anything else ASSERT(m_childRules.isEmpty()); StyleRuleImport* importRule = toStyleRuleImport(rule); if (importRule->mediaQueries()) setHasMediaQueries(); m_importRules.append(importRule); m_importRules.last()->setParentStyleSheet(this); m_importRules.last()->requestStyleSheet(); return; } if (rule->isNamespaceRule()) { // Parser enforces that @namespace rules come before all rules other than // import/charset rules ASSERT(m_childRules.isEmpty()); StyleRuleNamespace& namespaceRule = toStyleRuleNamespace(*rule); parserAddNamespace(namespaceRule.prefix(), namespaceRule.uri()); m_namespaceRules.append(&namespaceRule); return; } m_childRules.append(rule); }
void RuleSet::addRulesFromSheet(StyleSheetContents* sheet, const MediaQueryEvaluator& medium, AddRuleFlags addRuleFlags) { ASSERT(sheet); addRuleFlags = static_cast<AddRuleFlags>(addRuleFlags | RuleCanUseFastCheckSelector); const Vector<RefPtr<StyleRuleImport> >& importRules = sheet->importRules(); for (unsigned i = 0; i < importRules.size(); ++i) { StyleRuleImport* importRule = importRules[i].get(); if (importRule->styleSheet() && (!importRule->mediaQueries() || medium.eval(importRule->mediaQueries(), &m_viewportDependentMediaQueryResults))) addRulesFromSheet(importRule->styleSheet(), medium, addRuleFlags); } addChildRules(sheet->childRules(), medium, addRuleFlags); }
void RuleSet::addRulesFromSheet(StyleSheetContents* sheet, const MediaQueryEvaluator& medium, AddRuleFlags addRuleFlags) { TRACE_EVENT0("blink", "RuleSet::addRulesFromSheet"); ASSERT(sheet); const WillBeHeapVector<RefPtrWillBeMember<StyleRuleImport>>& importRules = sheet->importRules(); for (unsigned i = 0; i < importRules.size(); ++i) { StyleRuleImport* importRule = importRules[i].get(); if (importRule->styleSheet() && (!importRule->mediaQueries() || medium.eval(importRule->mediaQueries(), &m_viewportDependentMediaQueryResults))) addRulesFromSheet(importRule->styleSheet(), medium, addRuleFlags); } addChildRules(sheet->childRules(), medium, addRuleFlags); }
bool StyleSheetContents::wrapperInsertRule(PassRefPtrWillBeRawPtr<StyleRuleBase> rule, unsigned index) { ASSERT(m_isMutable); ASSERT_WITH_SECURITY_IMPLICATION(index <= ruleCount()); // Parser::parseRule doesn't currently allow @charset so we don't need to deal with it. ASSERT(!rule->isCharsetRule()); unsigned childVectorIndex = index; // m_childRules does not contain @charset which is always in index 0 if it exists. if (hasCharsetRule()) { if (childVectorIndex == 0) { // Nothing can be inserted before @charset. return false; } --childVectorIndex; } if (childVectorIndex < m_importRules.size() || (childVectorIndex == m_importRules.size() && rule->isImportRule())) { // Inserting non-import rule before @import is not allowed. if (!rule->isImportRule()) return false; StyleRuleImport* importRule = toStyleRuleImport(rule.get()); if (importRule->mediaQueries()) setHasMediaQueries(); m_importRules.insert(childVectorIndex, importRule); m_importRules[childVectorIndex]->setParentStyleSheet(this); m_importRules[childVectorIndex]->requestStyleSheet(); // FIXME: Stylesheet doesn't actually change meaningfully before the imported sheets are loaded. return true; } // Inserting @import rule after a non-import rule is not allowed. if (rule->isImportRule()) return false; if (rule->isMediaRule()) setHasMediaQueries(); childVectorIndex -= m_importRules.size(); if (rule->isFontFaceRule()) setHasFontFaceRule(true); m_childRules.insert(childVectorIndex, rule); return true; }
void RuleSet::addRulesFromSheet(StyleSheetContents* sheet, const MediaQueryEvaluator& medium, StyleResolver* resolver, const ContainerNode* scope) { ASSERT(sheet); const Vector<RefPtr<StyleRuleImport> >& importRules = sheet->importRules(); for (unsigned i = 0; i < importRules.size(); ++i) { StyleRuleImport* importRule = importRules[i].get(); if (importRule->styleSheet() && (!importRule->mediaQueries() || medium.eval(importRule->mediaQueries(), resolver))) addRulesFromSheet(importRule->styleSheet(), medium, resolver, scope); } bool hasDocumentSecurityOrigin = resolver && resolver->document()->securityOrigin()->canRequest(sheet->baseURL()); AddRuleFlags addRuleFlags = static_cast<AddRuleFlags>((hasDocumentSecurityOrigin ? RuleHasDocumentSecurityOrigin : 0) | (!scope ? RuleCanUseFastCheckSelector : 0)); addChildRules(sheet->childRules(), medium, resolver, scope, hasDocumentSecurityOrigin, addRuleFlags); if (m_autoShrinkToFitEnabled) shrinkToFit(); }
void StyleSheetContents::parserAppendRule(PassRefPtrWillBeRawPtr<StyleRuleBase> rule) { ASSERT(!rule->isCharsetRule()); if (rule->isImportRule()) { // Parser enforces that @import rules come before anything else except @charset. ASSERT(m_childRules.isEmpty()); StyleRuleImport* importRule = toStyleRuleImport(rule.get()); if (importRule->mediaQueries()) setHasMediaQueries(); m_importRules.append(importRule); m_importRules.last()->setParentStyleSheet(this); m_importRules.last()->requestStyleSheet(); return; } // Add warning message to inspector if dpi/dpcm values are used for screen media. if (rule->isMediaRule()) { setHasMediaQueries(); reportMediaQueryWarningIfNeeded(singleOwnerDocument(), toStyleRuleMedia(rule.get())->mediaQueries()); } m_childRules.append(rule); }
void CSSStyleSheet::addSubresourceStyleURLs(ListHashSet<KURL>& urls) { Deque<CSSStyleSheet*> styleSheetQueue; styleSheetQueue.append(this); while (!styleSheetQueue.isEmpty()) { CSSStyleSheet* styleSheet = styleSheetQueue.takeFirst(); for (unsigned i = 0; i < styleSheet->m_importRules.size(); ++i) { StyleRuleImport* importRule = styleSheet->m_importRules[i].get(); if (importRule->styleSheet()) { styleSheetQueue.append(importRule->styleSheet()); addSubresourceURL(urls, importRule->styleSheet()->baseURL()); } } for (unsigned i = 0; i < styleSheet->m_childRules.size(); ++i) { StyleRuleBase* rule = styleSheet->m_childRules[i].get(); if (rule->isStyleRule()) static_cast<StyleRule*>(rule)->properties()->addSubresourceStyleURLs(urls, this); else if (rule->isFontFaceRule()) static_cast<StyleRuleFontFace*>(rule)->properties()->addSubresourceStyleURLs(urls, this); } } }
void RuleSet::addRulesFromSheet(StyleSheetContents* sheet, const MediaQueryEvaluator& medium, StyleResolver* resolver, const ContainerNode* scope) { ASSERT(sheet); const Vector<RefPtr<StyleRuleImport> >& importRules = sheet->importRules(); for (unsigned i = 0; i < importRules.size(); ++i) { StyleRuleImport* importRule = importRules[i].get(); if (importRule->styleSheet() && (!importRule->mediaQueries() || medium.eval(importRule->mediaQueries(), resolver))) addRulesFromSheet(importRule->styleSheet(), medium, resolver, scope); } bool hasDocumentSecurityOrigin = resolver && resolver->document()->securityOrigin()->canRequest(sheet->baseURL()); AddRuleFlags addRuleFlags = static_cast<AddRuleFlags>((hasDocumentSecurityOrigin ? RuleHasDocumentSecurityOrigin : 0) | (!scope ? RuleCanUseFastCheckSelector : 0)); const Vector<RefPtr<StyleRuleBase> >& rules = sheet->childRules(); for (unsigned i = 0; i < rules.size(); ++i) { StyleRuleBase* rule = rules[i].get(); ASSERT(!rule->isImportRule()); if (rule->isStyleRule()) addStyleRule(static_cast<StyleRule*>(rule), addRuleFlags); else if (rule->isPageRule()) addPageRule(static_cast<StyleRulePage*>(rule)); else if (rule->isMediaRule()) { StyleRuleMedia* mediaRule = static_cast<StyleRuleMedia*>(rule); if ((!mediaRule->mediaQueries() || medium.eval(mediaRule->mediaQueries(), resolver))) { // Traverse child elements of the @media rule. const Vector<RefPtr<StyleRuleBase> >& childRules = mediaRule->childRules(); for (unsigned j = 0; j < childRules.size(); ++j) { StyleRuleBase* childRule = childRules[j].get(); if (childRule->isStyleRule()) addStyleRule(static_cast<StyleRule*>(childRule), addRuleFlags); else if (childRule->isPageRule()) addPageRule(static_cast<StyleRulePage*>(childRule)); else if (childRule->isFontFaceRule() && resolver) { // Add this font face to our set. // FIXME(BUG 72461): We don't add @font-face rules of scoped style sheets for the moment. if (scope) continue; const StyleRuleFontFace* fontFaceRule = static_cast<StyleRuleFontFace*>(childRule); resolver->fontSelector()->addFontFaceRule(fontFaceRule); resolver->invalidateMatchedPropertiesCache(); } else if (childRule->isKeyframesRule() && resolver) { // Add this keyframe rule to our set. // FIXME(BUG 72462): We don't add @keyframe rules of scoped style sheets for the moment. if (scope) continue; resolver->addKeyframeStyle(static_cast<StyleRuleKeyframes*>(childRule)); } #if ENABLE(CSS_DEVICE_ADAPTATION) else if (childRule->isViewportRule() && resolver && !resolver->affectedByViewportChange()) { // @viewport should not be scoped. if (scope) continue; resolver->viewportStyleResolver()->addViewportRule(static_cast<StyleRuleViewport*>(childRule)); } #endif } // for rules } // if rules } else if (rule->isFontFaceRule() && resolver) { // Add this font face to our set. // FIXME(BUG 72461): We don't add @font-face rules of scoped style sheets for the moment. if (scope) continue; const StyleRuleFontFace* fontFaceRule = static_cast<StyleRuleFontFace*>(rule); resolver->fontSelector()->addFontFaceRule(fontFaceRule); resolver->invalidateMatchedPropertiesCache(); } else if (rule->isKeyframesRule() && resolver) { // FIXME (BUG 72462): We don't add @keyframe rules of scoped style sheets for the moment. if (scope) continue; resolver->addKeyframeStyle(static_cast<StyleRuleKeyframes*>(rule)); } #if ENABLE(CSS_REGIONS) else if (rule->isRegionRule() && resolver) { // FIXME (BUG 72472): We don't add @-webkit-region rules of scoped style sheets for the moment. if (scope) continue; addRegionRule(static_cast<StyleRuleRegion*>(rule), hasDocumentSecurityOrigin); } #endif #if ENABLE(SHADOW_DOM) else if (rule->isHostRule()) resolver->addHostRule(static_cast<StyleRuleHost*>(rule), hasDocumentSecurityOrigin, scope); #endif #if ENABLE(CSS_DEVICE_ADAPTATION) else if (rule->isViewportRule() && resolver) { // @viewport should not be scoped. if (scope) continue; resolver->viewportStyleResolver()->addViewportRule(static_cast<StyleRuleViewport*>(rule)); } #endif } if (m_autoShrinkToFitEnabled) shrinkToFit(); }