DocumentStyleSheetCollection.cpp [plain text]
#include "config.h"
#include "DocumentStyleSheetCollection.h"
#include "CSSStyleSheet.h"
#include "Element.h"
#include "HTMLIFrameElement.h"
#include "HTMLLinkElement.h"
#include "HTMLStyleElement.h"
#include "Page.h"
#include "PageGroup.h"
#include "ProcessingInstruction.h"
#include "SVGNames.h"
#include "SVGStyleElement.h"
#include "Settings.h"
#include "StyleInvalidationAnalysis.h"
#include "StyleResolver.h"
#include "StyleSheetContents.h"
#include "StyleSheetList.h"
#include "UserContentController.h"
#include "UserContentURLPattern.h"
namespace WebCore {
using namespace HTMLNames;
DocumentStyleSheetCollection::DocumentStyleSheetCollection(Document& document)
: m_document(document)
, m_pendingStylesheets(0)
, m_injectedStyleSheetCacheValid(false)
, m_hadActiveLoadingStylesheet(false)
, m_pendingUpdateType(NoUpdate)
, m_usesSiblingRules(false)
, m_usesSiblingRulesOverride(false)
, m_usesFirstLineRules(false)
, m_usesFirstLetterRules(false)
, m_usesBeforeAfterRules(false)
, m_usesBeforeAfterRulesOverride(false)
, m_usesRemUnits(false)
{
}
void DocumentStyleSheetCollection::combineCSSFeatureFlags()
{
const StyleResolver& styleResolver = m_document.ensureStyleResolver();
m_usesSiblingRules = m_usesSiblingRules || styleResolver.usesSiblingRules();
m_usesFirstLineRules = m_usesFirstLineRules || styleResolver.usesFirstLineRules();
m_usesFirstLetterRules = m_usesFirstLetterRules || styleResolver.usesFirstLetterRules();
m_usesBeforeAfterRules = m_usesBeforeAfterRules || styleResolver.usesBeforeAfterRules();
}
void DocumentStyleSheetCollection::resetCSSFeatureFlags()
{
const StyleResolver& styleResolver = m_document.ensureStyleResolver();
m_usesSiblingRules = styleResolver.usesSiblingRules();
m_usesFirstLineRules = styleResolver.usesFirstLineRules();
m_usesFirstLetterRules = styleResolver.usesFirstLetterRules();
m_usesBeforeAfterRules = styleResolver.usesBeforeAfterRules();
}
CSSStyleSheet* DocumentStyleSheetCollection::pageUserSheet()
{
if (m_pageUserSheet)
return m_pageUserSheet.get();
Page* owningPage = m_document.page();
if (!owningPage)
return 0;
String userSheetText = owningPage->userStyleSheet();
if (userSheetText.isEmpty())
return 0;
m_pageUserSheet = CSSStyleSheet::createInline(m_document, m_document.settings()->userStyleSheetLocation());
m_pageUserSheet->contents().setIsUserStyleSheet(true);
m_pageUserSheet->contents().parseString(userSheetText);
return m_pageUserSheet.get();
}
void DocumentStyleSheetCollection::clearPageUserSheet()
{
if (m_pageUserSheet) {
m_pageUserSheet = 0;
m_document.styleResolverChanged(DeferRecalcStyle);
}
}
void DocumentStyleSheetCollection::updatePageUserSheet()
{
clearPageUserSheet();
if (pageUserSheet())
m_document.styleResolverChanged(RecalcStyleImmediately);
}
const Vector<RefPtr<CSSStyleSheet>>& DocumentStyleSheetCollection::injectedUserStyleSheets() const
{
updateInjectedStyleSheetCache();
return m_injectedUserStyleSheets;
}
const Vector<RefPtr<CSSStyleSheet>>& DocumentStyleSheetCollection::injectedAuthorStyleSheets() const
{
updateInjectedStyleSheetCache();
return m_injectedAuthorStyleSheets;
}
void DocumentStyleSheetCollection::updateInjectedStyleSheetCache() const
{
if (m_injectedStyleSheetCacheValid)
return;
m_injectedStyleSheetCacheValid = true;
m_injectedUserStyleSheets.clear();
m_injectedAuthorStyleSheets.clear();
Page* owningPage = m_document.page();
if (!owningPage)
return;
const auto* userContentController = owningPage->userContentController();
if (!userContentController)
return;
const UserStyleSheetMap* userStyleSheets = userContentController->userStyleSheets();
if (!userStyleSheets)
return;
for (auto& styleSheets : userStyleSheets->values()) {
for (const auto& sheet : *styleSheets) {
if (sheet->injectedFrames() == InjectInTopFrameOnly && m_document.ownerElement())
continue;
if (!UserContentURLPattern::matchesPatterns(m_document.url(), sheet->whitelist(), sheet->blacklist()))
continue;
RefPtr<CSSStyleSheet> groupSheet = CSSStyleSheet::createInline(const_cast<Document&>(m_document), sheet->url());
bool isUserStyleSheet = sheet->level() == UserStyleUserLevel;
if (isUserStyleSheet)
m_injectedUserStyleSheets.append(groupSheet);
else
m_injectedAuthorStyleSheets.append(groupSheet);
groupSheet->contents().setIsUserStyleSheet(isUserStyleSheet);
groupSheet->contents().parseString(sheet->source());
}
}
}
void DocumentStyleSheetCollection::invalidateInjectedStyleSheetCache()
{
if (!m_injectedStyleSheetCacheValid)
return;
m_injectedStyleSheetCacheValid = false;
if (m_injectedUserStyleSheets.isEmpty() && m_injectedAuthorStyleSheets.isEmpty())
return;
m_document.styleResolverChanged(DeferRecalcStyle);
}
void DocumentStyleSheetCollection::addAuthorSheet(PassRef<StyleSheetContents> authorSheet)
{
ASSERT(!authorSheet.get().isUserStyleSheet());
m_authorStyleSheets.append(CSSStyleSheet::create(WTF::move(authorSheet), &m_document));
m_document.styleResolverChanged(RecalcStyleImmediately);
}
void DocumentStyleSheetCollection::addUserSheet(PassRef<StyleSheetContents> userSheet)
{
ASSERT(userSheet.get().isUserStyleSheet());
m_userStyleSheets.append(CSSStyleSheet::create(WTF::move(userSheet), &m_document));
m_document.styleResolverChanged(RecalcStyleImmediately);
}
void DocumentStyleSheetCollection::removePendingSheet(RemovePendingSheetNotificationType notification)
{
ASSERT(m_pendingStylesheets > 0);
m_pendingStylesheets--;
#ifdef INSTRUMENT_LAYOUT_SCHEDULING
if (!ownerElement())
printf("Stylesheet loaded at time %d. %d stylesheets still remain.\n", elapsedTime(), m_pendingStylesheets);
#endif
if (m_pendingStylesheets)
return;
if (notification == RemovePendingSheetNotifyLater) {
m_document.setNeedsNotifyRemoveAllPendingStylesheet();
return;
}
m_document.didRemoveAllPendingStylesheet();
}
void DocumentStyleSheetCollection::addStyleSheetCandidateNode(Node& node, bool createdByParser)
{
if (!node.inDocument())
return;
if ((createdByParser && m_document.body()) || m_styleSheetCandidateNodes.isEmpty()) {
m_styleSheetCandidateNodes.add(&node);
return;
}
StyleSheetCandidateListHashSet::iterator begin = m_styleSheetCandidateNodes.begin();
StyleSheetCandidateListHashSet::iterator end = m_styleSheetCandidateNodes.end();
StyleSheetCandidateListHashSet::iterator it = end;
Node* followingNode = 0;
do {
--it;
Node* n = *it;
unsigned short position = n->compareDocumentPosition(&node);
if (position == Node::DOCUMENT_POSITION_FOLLOWING) {
m_styleSheetCandidateNodes.insertBefore(followingNode, &node);
return;
}
followingNode = n;
} while (it != begin);
m_styleSheetCandidateNodes.insertBefore(followingNode, &node);
}
void DocumentStyleSheetCollection::removeStyleSheetCandidateNode(Node& node)
{
m_styleSheetCandidateNodes.remove(&node);
}
void DocumentStyleSheetCollection::collectActiveStyleSheets(Vector<RefPtr<StyleSheet>>& sheets)
{
if (m_document.settings() && !m_document.settings()->authorAndUserStylesEnabled())
return;
for (auto& node : m_styleSheetCandidateNodes) {
StyleSheet* sheet = nullptr;
if (node->nodeType() == Node::PROCESSING_INSTRUCTION_NODE) {
ProcessingInstruction* pi = toProcessingInstruction(node);
sheet = pi->sheet();
#if ENABLE(XSLT)
if (pi->isXSL() && !m_document.transformSourceDocument()) {
if (!m_document.parsing())
m_document.applyXSLTransform(pi);
return;
}
#endif
} else if ((node->isHTMLElement() && (toHTMLElement(*node).hasTagName(linkTag) || toHTMLElement(*node).hasTagName(styleTag))) || (node->isSVGElement() && toSVGElement(*node).hasTagName(SVGNames::styleTag))) {
Element& element = toElement(*node);
AtomicString title = element.getAttribute(titleAttr);
bool enabledViaScript = false;
if (isHTMLLinkElement(element)) {
HTMLLinkElement& linkElement = toHTMLLinkElement(element);
if (linkElement.isDisabled())
continue;
enabledViaScript = linkElement.isEnabledViaScript();
if (linkElement.styleSheetIsLoading()) {
if (!enabledViaScript && !title.isEmpty() && m_preferredStylesheetSetName.isEmpty()) {
if (!linkElement.fastGetAttribute(relAttr).contains("alternate")) {
m_preferredStylesheetSetName = title;
m_selectedStylesheetSetName = title;
}
}
continue;
}
if (!linkElement.sheet())
title = nullAtom;
}
if (isSVGStyleElement(element))
sheet = toSVGStyleElement(element).sheet();
else if (isHTMLLinkElement(element))
sheet = toHTMLLinkElement(element).sheet();
else
sheet = toHTMLStyleElement(element).sheet();
auto& rel = element.fastGetAttribute(relAttr);
if (!enabledViaScript && !title.isEmpty()) {
if (m_preferredStylesheetSetName.isEmpty()) {
if (isHTMLStyleElement(element) || !rel.contains("alternate"))
m_preferredStylesheetSetName = m_selectedStylesheetSetName = title;
}
if (title != m_preferredStylesheetSetName)
sheet = nullptr;
}
if (rel.contains("alternate") && title.isEmpty())
sheet = nullptr;
}
if (sheet)
sheets.append(sheet);
}
}
void DocumentStyleSheetCollection::analyzeStyleSheetChange(UpdateFlag updateFlag, const Vector<RefPtr<CSSStyleSheet>>& newStylesheets, StyleResolverUpdateType& styleResolverUpdateType, bool& requiresFullStyleRecalc)
{
styleResolverUpdateType = Reconstruct;
requiresFullStyleRecalc = true;
bool hasActiveLoadingStylesheet = false;
unsigned newStylesheetCount = newStylesheets.size();
for (unsigned i = 0; i < newStylesheetCount; ++i) {
if (newStylesheets[i]->isLoading())
hasActiveLoadingStylesheet = true;
}
if (m_hadActiveLoadingStylesheet && !hasActiveLoadingStylesheet) {
m_hadActiveLoadingStylesheet = false;
return;
}
m_hadActiveLoadingStylesheet = hasActiveLoadingStylesheet;
if (updateFlag != OptimizedUpdate)
return;
if (!m_document.styleResolverIfExists())
return;
StyleResolver& styleResolver = *m_document.styleResolverIfExists();
unsigned oldStylesheetCount = m_activeAuthorStyleSheets.size();
if (newStylesheetCount < oldStylesheetCount)
return;
Vector<StyleSheetContents*> addedSheets;
unsigned newIndex = 0;
for (unsigned oldIndex = 0; oldIndex < oldStylesheetCount; ++oldIndex) {
if (newIndex >= newStylesheetCount)
return;
while (m_activeAuthorStyleSheets[oldIndex] != newStylesheets[newIndex]) {
addedSheets.append(&newStylesheets[newIndex]->contents());
++newIndex;
if (newIndex == newStylesheetCount)
return;
}
++newIndex;
}
bool hasInsertions = !addedSheets.isEmpty();
while (newIndex < newStylesheetCount) {
addedSheets.append(&newStylesheets[newIndex]->contents());
++newIndex;
}
styleResolverUpdateType = hasInsertions ? Reset : Additive;
if (!m_document.body() || m_document.hasNodesWithPlaceholderStyle())
return;
StyleInvalidationAnalysis invalidationAnalysis(addedSheets, styleResolver.mediaQueryEvaluator());
if (invalidationAnalysis.dirtiesAllStyle())
return;
invalidationAnalysis.invalidateStyle(m_document);
requiresFullStyleRecalc = false;
}
static bool styleSheetsUseRemUnits(const Vector<RefPtr<CSSStyleSheet>>& sheets)
{
for (unsigned i = 0; i < sheets.size(); ++i) {
if (sheets[i]->contents().usesRemUnits())
return true;
}
return false;
}
static void filterEnabledNonemptyCSSStyleSheets(Vector<RefPtr<CSSStyleSheet>>& result, const Vector<RefPtr<StyleSheet>>& sheets)
{
for (unsigned i = 0; i < sheets.size(); ++i) {
if (!sheets[i]->isCSSStyleSheet())
continue;
if (sheets[i]->disabled())
continue;
CSSStyleSheet* sheet = static_cast<CSSStyleSheet*>(sheets[i].get());
if (!sheet->length())
continue;
result.append(sheet);
}
}
bool DocumentStyleSheetCollection::updateActiveStyleSheets(UpdateFlag updateFlag)
{
if (m_document.inStyleRecalc()) {
m_pendingUpdateType = FullUpdate;
m_document.scheduleForcedStyleRecalc();
return false;
}
if (!m_document.hasLivingRenderTree())
return false;
Vector<RefPtr<StyleSheet>> activeStyleSheets;
collectActiveStyleSheets(activeStyleSheets);
Vector<RefPtr<CSSStyleSheet>> activeCSSStyleSheets;
activeCSSStyleSheets.appendVector(injectedAuthorStyleSheets());
activeCSSStyleSheets.appendVector(documentAuthorStyleSheets());
filterEnabledNonemptyCSSStyleSheets(activeCSSStyleSheets, activeStyleSheets);
StyleResolverUpdateType styleResolverUpdateType;
bool requiresFullStyleRecalc;
analyzeStyleSheetChange(updateFlag, activeCSSStyleSheets, styleResolverUpdateType, requiresFullStyleRecalc);
if (styleResolverUpdateType == Reconstruct)
m_document.clearStyleResolver();
else {
StyleResolver& styleResolver = m_document.ensureStyleResolver();
if (styleResolverUpdateType == Reset) {
styleResolver.ruleSets().resetAuthorStyle();
styleResolver.appendAuthorStyleSheets(0, activeCSSStyleSheets);
} else {
ASSERT(styleResolverUpdateType == Additive);
styleResolver.appendAuthorStyleSheets(m_activeAuthorStyleSheets.size(), activeCSSStyleSheets);
}
resetCSSFeatureFlags();
}
m_weakCopyOfActiveStyleSheetListForFastLookup = nullptr;
m_activeAuthorStyleSheets.swap(activeCSSStyleSheets);
m_styleSheetsForStyleSheetList.swap(activeStyleSheets);
m_usesRemUnits = styleSheetsUseRemUnits(m_activeAuthorStyleSheets);
m_pendingUpdateType = NoUpdate;
return requiresFullStyleRecalc;
}
bool DocumentStyleSheetCollection::activeStyleSheetsContains(const CSSStyleSheet* sheet) const
{
if (!m_weakCopyOfActiveStyleSheetListForFastLookup) {
m_weakCopyOfActiveStyleSheetListForFastLookup = std::make_unique<HashSet<const CSSStyleSheet*>>();
for (unsigned i = 0; i < m_activeAuthorStyleSheets.size(); ++i)
m_weakCopyOfActiveStyleSheetListForFastLookup->add(m_activeAuthorStyleSheets[i].get());
}
return m_weakCopyOfActiveStyleSheetListForFastLookup->contains(sheet);
}
void DocumentStyleSheetCollection::detachFromDocument()
{
if (m_pageUserSheet)
m_pageUserSheet->detachFromDocument();
for (unsigned i = 0; i < m_injectedUserStyleSheets.size(); ++i)
m_injectedUserStyleSheets[i]->detachFromDocument();
for (unsigned i = 0; i < m_injectedAuthorStyleSheets.size(); ++i)
m_injectedAuthorStyleSheets[i]->detachFromDocument();
for (unsigned i = 0; i < m_userStyleSheets.size(); ++i)
m_userStyleSheets[i]->detachFromDocument();
for (unsigned i = 0; i < m_authorStyleSheets.size(); ++i)
m_authorStyleSheets[i]->detachFromDocument();
}
}