DocumentStyleSheetCollection.cpp [plain text]
#include "config.h"
#include "DocumentStyleSheetCollection.h"
#include "CSSStyleSheet.h"
#include "DOMWrapperWorld.h"
#include "Document.h"
#include "Element.h"
#include "HTMLIFrameElement.h"
#include "HTMLLinkElement.h"
#include "HTMLNames.h"
#include "HTMLStyleElement.h"
#include "Page.h"
#include "PageGroup.h"
#include "ProcessingInstruction.h"
#include "SVGNames.h"
#include "SVGStyleElement.h"
#include "SelectorChecker.h"
#include "Settings.h"
#include "StyleInvalidationAnalysis.h"
#include "StyleResolver.h"
#include "StyleSheetContents.h"
#include "StyleSheetList.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)
{
}
DocumentStyleSheetCollection::~DocumentStyleSheetCollection()
{
if (m_pageUserSheet)
m_pageUserSheet->clearOwnerNode();
for (unsigned i = 0; i < m_injectedUserStyleSheets.size(); ++i)
m_injectedUserStyleSheets[i]->clearOwnerNode();
for (unsigned i = 0; i < m_injectedAuthorStyleSheets.size(); ++i)
m_injectedAuthorStyleSheets[i]->clearOwnerNode();
for (unsigned i = 0; i < m_userStyleSheets.size(); ++i)
m_userStyleSheets[i]->clearOwnerNode();
for (unsigned i = 0; i < m_authorStyleSheets.size(); ++i)
m_authorStyleSheets[i]->clearOwnerNode();
}
void DocumentStyleSheetCollection::combineCSSFeatureFlags()
{
StyleResolver* styleResolver = m_document->ensureStyleResolver();
m_usesSiblingRules = m_usesSiblingRules || styleResolver->usesSiblingRules();
m_usesFirstLineRules = m_usesFirstLineRules || styleResolver->usesFirstLineRules();
m_usesBeforeAfterRules = m_usesBeforeAfterRules || styleResolver->usesBeforeAfterRules();
}
void DocumentStyleSheetCollection::resetCSSFeatureFlags()
{
StyleResolver* styleResolver = m_document->ensureStyleResolver();
m_usesSiblingRules = styleResolver->usesSiblingRules();
m_usesFirstLineRules = styleResolver->usesFirstLineRules();
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 PageGroup& pageGroup = owningPage->group();
const UserStyleSheetMap* sheetsMap = pageGroup.userStyleSheets();
if (!sheetsMap)
return;
UserStyleSheetMap::const_iterator end = sheetsMap->end();
for (UserStyleSheetMap::const_iterator it = sheetsMap->begin(); it != end; ++it) {
const UserStyleSheetVector* sheets = it->value.get();
for (unsigned i = 0; i < sheets->size(); ++i) {
const UserStyleSheet* sheet = sheets->at(i).get();
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(PassRefPtr<StyleSheetContents> authorSheet)
{
ASSERT(!authorSheet->isUserStyleSheet());
m_authorStyleSheets.append(CSSStyleSheet::create(authorSheet, m_document));
m_document->styleResolverChanged(RecalcStyleImmediately);
}
void DocumentStyleSheetCollection::addUserSheet(PassRefPtr<StyleSheetContents> userSheet)
{
ASSERT(userSheet->isUserStyleSheet());
m_userStyleSheets.append(CSSStyleSheet::create(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;
StyleSheetCandidateListHashSet::iterator begin = m_styleSheetCandidateNodes.begin();
StyleSheetCandidateListHashSet::iterator end = m_styleSheetCandidateNodes.end();
for (StyleSheetCandidateListHashSet::iterator it = begin; it != end; ++it) {
Node* n = *it;
StyleSheet* sheet = 0;
if (n->nodeType() == Node::PROCESSING_INSTRUCTION_NODE) {
ProcessingInstruction* pi = static_cast<ProcessingInstruction*>(n);
sheet = pi->sheet();
#if ENABLE(XSLT)
if (pi->isXSL() && !m_document->transformSourceDocument()) {
if (!m_document->parsing())
m_document->applyXSLTransform(pi);
return;
}
#endif
} else if ((n->isHTMLElement() && (n->hasTagName(linkTag) || n->hasTagName(styleTag)))
#if ENABLE(SVG)
|| (n->isSVGElement() && n->hasTagName(SVGNames::styleTag))
#endif
) {
Element* e = toElement(n);
AtomicString title = e->getAttribute(titleAttr);
bool enabledViaScript = false;
if (e->hasLocalName(linkTag)) {
HTMLLinkElement* linkElement = static_cast<HTMLLinkElement*>(n);
if (linkElement->isDisabled())
continue;
enabledViaScript = linkElement->isEnabledViaScript();
if (linkElement->styleSheetIsLoading()) {
if (!enabledViaScript && !title.isEmpty() && m_preferredStylesheetSetName.isEmpty()) {
const AtomicString& rel = e->getAttribute(relAttr);
if (!rel.contains("alternate")) {
m_preferredStylesheetSetName = title;
m_selectedStylesheetSetName = title;
}
}
continue;
}
if (!linkElement->sheet())
title = nullAtom;
}
#if ENABLE(SVG)
if (n->isSVGElement() && n->hasTagName(SVGNames::styleTag))
sheet = static_cast<SVGStyleElement*>(n)->sheet();
else
#endif
if (e->hasLocalName(linkTag))
sheet = static_cast<HTMLLinkElement*>(n)->sheet();
else
sheet = static_cast<HTMLStyleElement*>(n)->sheet();
AtomicString rel = e->getAttribute(relAttr);
if (!enabledViaScript && !title.isEmpty()) {
if (m_preferredStylesheetSetName.isEmpty()) {
if (e->hasLocalName(styleTag) || !rel.contains("alternate"))
m_preferredStylesheetSetName = m_selectedStylesheetSetName = title;
}
if (title != m_preferredStylesheetSetName)
sheet = 0;
}
if (rel.contains("alternate") && title.isEmpty())
sheet = 0;
}
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;
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);
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);
}
}
static void collectActiveCSSStyleSheetsFromSeamlessParents(Vector<RefPtr<CSSStyleSheet> >& sheets, Document* document)
{
HTMLIFrameElement* seamlessParentIFrame = document->seamlessParentIFrame();
if (!seamlessParentIFrame)
return;
sheets.appendVector(seamlessParentIFrame->document()->styleSheetCollection()->activeAuthorStyleSheets());
}
bool DocumentStyleSheetCollection::updateActiveStyleSheets(UpdateFlag updateFlag)
{
if (m_document->inStyleRecalc()) {
m_pendingUpdateType = FullUpdate;
m_document->scheduleForcedStyleRecalc();
return false;
}
if (!m_document->renderer() || !m_document->attached())
return false;
Vector<RefPtr<StyleSheet> > activeStyleSheets;
collectActiveStyleSheets(activeStyleSheets);
Vector<RefPtr<CSSStyleSheet> > activeCSSStyleSheets;
activeCSSStyleSheets.appendVector(injectedAuthorStyleSheets());
activeCSSStyleSheets.appendVector(documentAuthorStyleSheets());
collectActiveCSSStyleSheetsFromSeamlessParents(activeCSSStyleSheets, m_document);
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.clear();
m_activeAuthorStyleSheets.swap(activeCSSStyleSheets);
m_styleSheetsForStyleSheetList.swap(activeStyleSheets);
m_usesRemUnits = styleSheetsUseRemUnits(m_activeAuthorStyleSheets);
m_pendingUpdateType = NoUpdate;
m_document->notifySeamlessChildDocumentsOfStylesheetUpdate();
return requiresFullStyleRecalc;
}
bool DocumentStyleSheetCollection::activeStyleSheetsContains(const CSSStyleSheet* sheet) const
{
if (!m_weakCopyOfActiveStyleSheetListForFastLookup) {
m_weakCopyOfActiveStyleSheetListForFastLookup = adoptPtr(new HashSet<const CSSStyleSheet*>);
for (unsigned i = 0; i < m_activeAuthorStyleSheets.size(); ++i)
m_weakCopyOfActiveStyleSheetListForFastLookup->add(m_activeAuthorStyleSheets[i].get());
}
return m_weakCopyOfActiveStyleSheetListForFastLookup->contains(sheet);
}
}