bool StyleSheetContents::wrapperDeleteRule(unsigned index) { ASSERT(m_isMutable); SECURITY_DCHECK(index < ruleCount()); if (index < m_importRules.size()) { m_importRules[index]->clearParentStyleSheet(); if (m_importRules[index]->isFontFaceRule()) notifyRemoveFontFaceRule(toStyleRuleFontFace(m_importRules[index].get())); m_importRules.remove(index); return true; } index -= m_importRules.size(); if (index < m_namespaceRules.size()) { if (!m_childRules.isEmpty()) return false; m_namespaceRules.remove(index); return true; } index -= m_namespaceRules.size(); if (m_childRules[index]->isFontFaceRule()) notifyRemoveFontFaceRule(toStyleRuleFontFace(m_childRules[index].get())); m_childRules.remove(index); return true; }
bool StyleSheetContents::wrapperInsertRule(PassRefPtr<StyleRuleBase> rule, unsigned index) { ASSERT(m_isMutable); ASSERT(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; m_importRules.insert(childVectorIndex, static_cast<StyleRuleImport*>(rule.get())); return true; } // Inserting @import rule after a non-import rule is not allowed. if (rule->isImportRule()) return false; childVectorIndex -= m_importRules.size(); m_childRules.insert(childVectorIndex, rule); return true; }
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::wrapperDeleteRule(unsigned index) { ASSERT(m_isMutable); ASSERT_WITH_SECURITY_IMPLICATION(index < ruleCount()); unsigned childVectorIndex = index; if (hasCharsetRule()) { if (childVectorIndex == 0) { clearCharsetRule(); return; } --childVectorIndex; } if (childVectorIndex < m_importRules.size()) { m_importRules[childVectorIndex]->clearParentStyleSheet(); if (m_importRules[childVectorIndex]->isFontFaceRule()) notifyRemoveFontFaceRule(toStyleRuleFontFace(m_importRules[childVectorIndex].get())); m_importRules.remove(childVectorIndex); return; } childVectorIndex -= m_importRules.size(); if (m_childRules[childVectorIndex]->isFontFaceRule()) notifyRemoveFontFaceRule(toStyleRuleFontFace(m_childRules[childVectorIndex].get())); m_childRules.remove(childVectorIndex); }
bool StyleSheetContents::wrapperInsertRule(PassRefPtr<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 (!is<StyleRuleImport>(*rule)) return false; m_importRules.insert(childVectorIndex, downcast<StyleRuleImport>(rule.get())); 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 (is<StyleRuleImport>(*rule)) return false; childVectorIndex -= m_importRules.size(); m_childRules.insert(childVectorIndex, rule); return true; }
void DocumentRuleSets::initUserStyle(ExtensionStyleSheets& extensionStyleSheets, const MediaQueryEvaluator& medium, StyleResolver& resolver) { auto tempUserStyle = std::make_unique<RuleSet>(); if (CSSStyleSheet* pageUserSheet = extensionStyleSheets.pageUserSheet()) tempUserStyle->addRulesFromSheet(pageUserSheet->contents(), medium, &resolver); collectRulesFromUserStyleSheets(extensionStyleSheets.injectedUserStyleSheets(), *tempUserStyle, medium, resolver); collectRulesFromUserStyleSheets(extensionStyleSheets.documentUserStyleSheets(), *tempUserStyle, medium, resolver); if (tempUserStyle->ruleCount() > 0 || tempUserStyle->pageRules().size() > 0) m_userStyle = WTFMove(tempUserStyle); }
StyleRuleBase* StyleSheetContents::ruleAt(unsigned index) const { SECURITY_DCHECK(index < ruleCount()); if (index < m_importRules.size()) return m_importRules[index].get(); index -= m_importRules.size(); if (index < m_namespaceRules.size()) return m_namespaceRules[index].get(); index -= m_namespaceRules.size(); return m_childRules[index].get(); }
StyleRuleBase* StyleSheetContents::ruleAt(unsigned index) const { ASSERT(index < ruleCount()); unsigned childVectorIndex = index; if (hasCharsetRule()) { if (index == 0) return 0; --childVectorIndex; } if (childVectorIndex < m_importRules.size()) return m_importRules[childVectorIndex].get(); childVectorIndex -= m_importRules.size(); return m_childRules[childVectorIndex].get(); }
// Rough size estimate for the memory cache. unsigned StyleSheetContents::estimatedSizeInBytes() const { // Note that this does not take into account size of the strings hanging from // various objects. The assumption is that nearly all of of them are atomic // and would exist anyway. unsigned size = sizeof(*this); // FIXME: This ignores the children of media rules. // Most rules are StyleRules. size += ruleCount() * StyleRule::averageSizeInBytes(); for (unsigned i = 0; i < m_importRules.size(); ++i) { if (StyleSheetContents* sheet = m_importRules[i]->styleSheet()) size += sheet->estimatedSizeInBytes(); } return size; }
void StyleSheetContents::wrapperDeleteRule(unsigned index) { ASSERT(m_isMutable); ASSERT(index < ruleCount()); unsigned childVectorIndex = index; if (hasCharsetRule()) { if (childVectorIndex == 0) { clearCharsetRule(); return; } --childVectorIndex; } if (childVectorIndex < m_importRules.size()) { m_importRules.remove(childVectorIndex); return; } childVectorIndex -= m_importRules.size(); m_childRules.remove(childVectorIndex); }