| /* |
| * Copyright (C) 1999 Lars Knoll (knoll@kde.org) |
| * (C) 1999 Antti Koivisto (koivisto@kde.org) |
| * (C) 2001 Dirk Mueller (mueller@kde.org) |
| * (C) 2006 Alexey Proskuryakov (ap@webkit.org) |
| * Copyright (C) 2004-2009, 2011-2012, 2015-2017 Apple Inc. All rights reserved. |
| * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/) |
| * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved. |
| * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies) |
| * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Library General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public License |
| * along with this library; see the file COPYING.LIB. If not, write to |
| * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| */ |
| |
| #include "config.h" |
| #include "StyleScope.h" |
| |
| #include "CSSCounterStyleRegistry.h" |
| #include "CSSFontSelector.h" |
| #include "CSSStyleSheet.h" |
| #include "ContainerNodeInlines.h" |
| #include "DocumentInlines.h" |
| #include "DocumentView.h" |
| #include "Element.h" |
| #include "ElementAncestorIteratorInlines.h" |
| #include "ElementChildIteratorInlines.h" |
| #include "ElementRareData.h" |
| #include "ExtensionStyleSheets.h" |
| #include "HTMLHeadElement.h" |
| #include "HTMLIFrameElement.h" |
| #include "HTMLLinkElement.h" |
| #include "HTMLSlotElement.h" |
| #include "HTMLStyleElement.h" |
| #include "InspectorInstrumentation.h" |
| #include "Logging.h" |
| #include "MatchResultCache.h" |
| #include "ProcessingInstruction.h" |
| #include "RenderBoxInlines.h" |
| #include "RenderElementStyleInlines.h" |
| #include "RenderLayer.h" |
| #include "RenderObjectInlines.h" |
| #include "RenderView.h" |
| #include "RuleSet.h" |
| #include "SVGElementTypeHelpers.h" |
| #include "SVGStyleElement.h" |
| #include "Settings.h" |
| #include "ShadowRoot.h" |
| #include "StyleDocumentScope.h" |
| #include "StyleableInlines.h" |
| #include "StyleBuilder.h" |
| #include "StyleCustomPropertyRegistry.h" |
| #include "StyleInvalidator.h" |
| #include "StyleResolver.h" |
| #include "StyleSheetContents.h" |
| #include "StyleSheetList.h" |
| #include "UserContentController.h" |
| #include "UserContentURLPattern.h" |
| #include "UserStyleSheet.h" |
| #include <wtf/SetForScope.h> |
| #include <wtf/TZoneMallocInlines.h> |
| |
| namespace WebCore { |
| |
| using namespace HTMLNames; |
| |
| namespace Style { |
| |
| WTF_MAKE_TZONE_ALLOCATED_IMPL(Scope); |
| |
| Scope::Scope(Document& document) |
| : m_document(document) |
| , m_pendingUpdateTimer(*this, &Scope::pendingUpdateTimerFired) |
| , m_customPropertyRegistry(makeUniqueRef<CustomPropertyRegistry>(*this)) |
| , m_counterStyleRegistry(makeUniqueRef<CSSCounterStyleRegistry>()) |
| { |
| } |
| |
| Scope::Scope(ShadowRoot& shadowRoot) |
| : m_document(shadowRoot.documentScope()) |
| , m_shadowRoot(&shadowRoot) |
| , m_pendingUpdateTimer(*this, &Scope::pendingUpdateTimerFired) |
| , m_customPropertyRegistry(makeUniqueRef<CustomPropertyRegistry>(*this)) |
| , m_counterStyleRegistry(makeUniqueRef<CSSCounterStyleRegistry>()) |
| { |
| } |
| |
| Scope::~Scope() |
| { |
| ASSERT(!hasPendingSheets()); |
| weakPtrFactory().revokeAll(); |
| } |
| |
| Resolver& Scope::resolver() |
| { |
| if (!m_resolver) { |
| if (auto* documentScope = dynamicDowncast<DocumentScope>(*this)) |
| documentScope->createDocumentResolver(); |
| else |
| createOrFindSharedShadowTreeResolver(); |
| |
| if (m_resolver->ruleSets().features().usesHasPseudoClass) |
| m_usesHasPseudoClass = true; |
| } |
| return *m_resolver; |
| } |
| |
| void Scope::createOrFindSharedShadowTreeResolver() |
| { |
| ASSERT(!m_resolver); |
| ASSERT(m_shadowRoot); |
| |
| RELEASE_ASSERT(!m_isUpdatingStyleResolver); |
| |
| auto key = makeResolverSharingKey(); |
| |
| auto result = documentScope().m_sharedShadowTreeResolvers.ensure(WTF::move(key), [&] { |
| SetForScope isUpdatingStyleResolver { m_isUpdatingStyleResolver, true }; |
| |
| m_resolver = Resolver::create(m_document, Resolver::ScopeType::ShadowTree); |
| |
| m_resolver->ruleSets().setUsesSharedUserStyle(!isForUserAgentShadowTree()); |
| protect(m_resolver)->appendAuthorStyleSheets(m_activeStyleSheets); |
| |
| return protect(*m_resolver); |
| }); |
| |
| if (!result.isNewEntry) { |
| m_resolver = result.iterator->value.ptr(); |
| m_resolver->setSharedBetweenShadowTrees(); |
| return; |
| } |
| |
| static constexpr auto maximimumSharedResolverCount = 256; |
| if (documentScope().m_sharedShadowTreeResolvers.size() > maximimumSharedResolverCount) |
| documentScope().m_sharedShadowTreeResolvers.remove(documentScope().m_sharedShadowTreeResolvers.random()); |
| } |
| |
| void Scope::unshareShadowTreeResolverBeforeMutation() |
| { |
| ASSERT(m_shadowRoot); |
| |
| documentScope().m_sharedShadowTreeResolvers.remove(makeResolverSharingKey()); |
| } |
| |
| auto Scope::makeResolverSharingKey() -> ResolverSharingKey |
| { |
| constexpr bool isNonEmptyHashTableValue = true; |
| return { |
| m_activeStyleSheets.map([&](auto& sheet) { return protect(&sheet->contents()); }), |
| isForUserAgentShadowTree(), |
| isNonEmptyHashTableValue |
| }; |
| } |
| |
| void Scope::clearResolver() |
| { |
| RELEASE_ASSERT(!m_isUpdatingStyleResolver); |
| RELEASE_ASSERT(!m_document->isResolvingTreeStyle()); |
| |
| m_resolver = nullptr; |
| customPropertyRegistry().clearRegisteredFromStylesheets(); |
| counterStyleRegistry().clearAuthorCounterStyles(); |
| } |
| |
| void Scope::registerSubstitutionAttribute(const AtomString& attributeName, AttributeAffectsShadowTree affectsShadowTree) const |
| { |
| auto lowercaseName = attributeName.convertToASCIILowercase(); |
| if (affectsShadowTree == AttributeAffectsShadowTree::Yes) |
| m_substitutionAttributes.set(lowercaseName, AttributeAffectsShadowTree::Yes); |
| else |
| m_substitutionAttributes.add(lowercaseName, AttributeAffectsShadowTree::No); |
| } |
| |
| void Scope::releaseMemory() |
| { |
| #if ENABLE(CSS_SELECTOR_JIT) |
| for (auto& sheet : m_activeStyleSheets) { |
| protect(sheet->contents())->traverseRules([] (const StyleRuleBase& rule) { |
| if (auto* styleRule = dynamicDowncast<StyleRule>(rule)) |
| styleRule->releaseCompiledSelectors(); |
| return false; |
| }); |
| } |
| #endif |
| clearResolver(); |
| } |
| |
| Scope& Scope::forNode(Node& node) |
| { |
| ASSERT(node.isConnected()); |
| auto* shadowRoot = node.containingShadowRoot(); |
| if (shadowRoot) |
| return shadowRoot->styleScope(); |
| return node.document().styleScope(); |
| } |
| |
| const Scope& Scope::forNode(const Node& node) |
| { |
| return forNode(const_cast<Node&>(node)); |
| } |
| |
| Scope* Scope::forOrdinal(Element& element, ScopeOrdinal ordinal) |
| { |
| if (auto* pseudoElement = dynamicDowncast<PseudoElement>(element)) |
| return forOrdinal(*protect(pseudoElement->hostElement()), ordinal); |
| |
| if (ordinal == ScopeOrdinal::Element) |
| return &forNode(element); |
| if (ordinal == ScopeOrdinal::Shadow) { |
| auto* shadowRoot = element.shadowRoot(); |
| return shadowRoot ? &shadowRoot->styleScope() : nullptr; |
| } |
| if (ordinal <= ScopeOrdinal::ContainingHost) { |
| RefPtr host = hostForScopeOrdinal(element, ordinal); |
| return host ? &forNode(*host) : nullptr; |
| } |
| RefPtr slot = assignedSlotForScopeOrdinal(element, ordinal); |
| return slot ? &forNode(*slot) : nullptr; |
| } |
| |
| const Scope* Scope::forOrdinal(const Element& element, ScopeOrdinal ordinal) |
| { |
| return forOrdinal(const_cast<Element&>(element), ordinal); |
| } |
| |
| void Scope::addPendingSheet(const Element& element) |
| { |
| ASSERT(!hasPendingSheet(element)); |
| |
| bool isInHead = ancestorsOfType<HTMLHeadElement>(element).first(); |
| |
| LOG_WITH_STREAM(StyleSheets, stream << "Scope " << this << " addPendingSheet() " << element << " isInHead " << isInHead); |
| |
| if (isInHead) |
| m_elementsInHeadWithPendingSheets.add(element); |
| else |
| m_elementsInBodyWithPendingSheets.add(element); |
| } |
| |
| // This method is called whenever a top-level stylesheet has finished loading. |
| void Scope::removePendingSheet(const Element& element) |
| { |
| ASSERT(hasPendingSheet(element)); |
| |
| if (!m_elementsInHeadWithPendingSheets.remove(element)) |
| m_elementsInBodyWithPendingSheets.remove(element); |
| |
| didRemovePendingStylesheet(); |
| } |
| |
| void Scope::addPendingSheet(const ProcessingInstruction& processingInstruction) |
| { |
| ASSERT(!m_processingInstructionsWithPendingSheets.contains(processingInstruction)); |
| |
| m_processingInstructionsWithPendingSheets.add(processingInstruction); |
| } |
| |
| void Scope::removePendingSheet(const ProcessingInstruction& processingInstruction) |
| { |
| ASSERT(m_processingInstructionsWithPendingSheets.contains(processingInstruction)); |
| |
| m_processingInstructionsWithPendingSheets.remove(processingInstruction); |
| |
| didRemovePendingStylesheet(); |
| } |
| |
| bool Scope::hasPendingSheets() const |
| { |
| return hasPendingSheetsBeforeBody() || !m_elementsInBodyWithPendingSheets.isEmptyIgnoringNullReferences(); |
| } |
| |
| bool Scope::hasPendingSheetsBeforeBody() const |
| { |
| return !m_elementsInHeadWithPendingSheets.isEmptyIgnoringNullReferences() || !m_processingInstructionsWithPendingSheets.isEmptyIgnoringNullReferences(); |
| } |
| |
| bool Scope::hasPendingSheetsInBody() const |
| { |
| return !m_elementsInBodyWithPendingSheets.isEmptyIgnoringNullReferences(); |
| } |
| |
| void Scope::didRemovePendingStylesheet() |
| { |
| if (hasPendingSheets()) |
| return; |
| |
| didChangeActiveStyleSheetCandidates(); |
| |
| if (!m_shadowRoot) |
| m_document->didRemoveAllPendingStylesheet(); |
| } |
| |
| bool Scope::hasPendingSheet(const Element& element) const |
| { |
| return m_elementsInHeadWithPendingSheets.contains(element) || hasPendingSheetInBody(element); |
| } |
| |
| bool Scope::hasPendingSheetInBody(const Element& element) const |
| { |
| return m_elementsInBodyWithPendingSheets.contains(element); |
| } |
| |
| bool Scope::hasPendingSheet(const ProcessingInstruction& processingInstruction) const |
| { |
| return m_processingInstructionsWithPendingSheets.contains(processingInstruction); |
| } |
| |
| void Scope::addStyleSheetCandidateNode(Node& node, bool createdByParser) |
| { |
| if (!node.isConnected()) |
| return; |
| |
| // Until the <body> exists, we have no choice but to compare document positions, |
| // since styles outside of the body and head continue to be shunted into the head |
| // (and thus can shift to end up before dynamically added DOM content that is also |
| // outside the body). |
| if ((createdByParser && m_document->bodyOrFrameset()) || m_styleSheetCandidateNodes.isEmptyIgnoringNullReferences()) { |
| m_styleSheetCandidateNodes.add(node); |
| return; |
| } |
| |
| // Determine an appropriate insertion point. |
| auto begin = m_styleSheetCandidateNodes.begin(); |
| auto end = m_styleSheetCandidateNodes.end(); |
| auto it = end; |
| RefPtr<Node> followingNode; |
| do { |
| --it; |
| Ref<Node> n = *it; |
| unsigned short position = n->compareDocumentPosition(node); |
| if (position == Node::DOCUMENT_POSITION_FOLLOWING) { |
| if (followingNode) |
| m_styleSheetCandidateNodes.insertBefore(*followingNode, node); |
| else |
| m_styleSheetCandidateNodes.appendOrMoveToLast(node); |
| return; |
| } |
| followingNode = WTF::move(n); |
| } while (it != begin); |
| |
| LOG_WITH_STREAM(StyleSheets, stream << "Scope " << this << " addStyleSheetCandidateNode() " << node); |
| |
| m_styleSheetCandidateNodes.insertBefore(*followingNode, node); |
| } |
| |
| void Scope::establishPreferredStylesheetSetName(const Element& element, const CSSStyleSheet& sheet) |
| { |
| // Per CSSOM spec "add a CSS style sheet", the preferred CSS style sheet set |
| // name is established when a sheet is added, based on insertion order — not |
| // tree order. This is called at sheet-creation time so that a later-inserted |
| // stylesheet placed earlier in tree order does not override the name. |
| // https://drafts.csswg.org/cssom/#add-a-css-style-sheet |
| if (!documentScope().m_preferredStylesheetSetName.isEmpty()) |
| return; |
| |
| if (element.isInShadowTree()) |
| return; |
| |
| auto title = sheet.title(); |
| if (title.isNull() || title.isEmpty()) |
| return; |
| |
| if (is<HTMLStyleElement>(element)) |
| documentScope().m_preferredStylesheetSetName = title; |
| else if (auto* linkElement = dynamicDowncast<HTMLLinkElement>(element)) { |
| if (!linkElement->isEnabledViaScript() && !linkElement->attributeWithoutSynchronization(HTMLNames::relAttr).contains("alternate"_s)) |
| documentScope().m_preferredStylesheetSetName = title; |
| } |
| } |
| |
| void Scope::removeStyleSheetCandidateNode(Node& node) |
| { |
| if (m_styleSheetCandidateNodes.remove(node)) |
| didChangeActiveStyleSheetCandidates(); |
| } |
| |
| #if ENABLE(XSLT) |
| // FIXME: <https://webkit.org/b/178830> Remove XSLT relaed code from Style::Scope. |
| Vector<Ref<ProcessingInstruction>> Scope::collectXSLTransforms() |
| { |
| Vector<Ref<ProcessingInstruction>> processingInstructions; |
| for (Ref node : m_styleSheetCandidateNodes) { |
| if (RefPtr processingInstruction = dynamicDowncast<ProcessingInstruction>(node); processingInstruction && processingInstruction->isXSL()) |
| processingInstructions.append(*processingInstruction); |
| } |
| return processingInstructions; |
| } |
| #endif |
| |
| auto Scope::collectActiveStyleSheets() -> ActiveStyleSheetCollection |
| { |
| if (!m_document->settings().authorAndUserStylesEnabled()) |
| return { }; |
| |
| LOG_WITH_STREAM(StyleSheets, stream << "Scope " << this << " collectActiveStyleSheets()"); |
| |
| Vector<Ref<StyleSheet>> sheets; |
| Vector<Ref<StyleSheet>> styleSheetsForStyleSheetsList; |
| |
| for (Ref node : m_styleSheetCandidateNodes) { |
| RefPtr<StyleSheet> sheet; |
| if (RefPtr processingInstruction = dynamicDowncast<ProcessingInstruction>(node)) { |
| if (!processingInstruction->isCSS()) |
| continue; |
| // We don't support linking to embedded CSS stylesheets, see <https://bugs.webkit.org/show_bug.cgi?id=49281> for discussion. |
| sheet = processingInstruction->sheet(); |
| if (sheet) |
| styleSheetsForStyleSheetsList.append(*sheet); |
| LOG_WITH_STREAM(StyleSheets, stream << " adding sheet " << sheet << " from ProcessingInstruction node " << node); |
| } else if (isAnyOf<HTMLLinkElement, HTMLStyleElement, SVGStyleElement>(node)) { |
| Ref element = uncheckedDowncast<Element>(node); |
| AtomString title = element->isInShadowTree() ? nullAtom() : element->attributeWithoutSynchronization(titleAttr); |
| bool enabledViaScript = false; |
| if (RefPtr linkElement = dynamicDowncast<HTMLLinkElement>(element.get())) { |
| // <LINK> element |
| if (linkElement->isDisabled()) |
| continue; |
| enabledViaScript = linkElement->isEnabledViaScript(); |
| if (linkElement->styleSheetIsLoading()) { |
| // it is loading but we should still decide which style sheet set to use |
| if (!enabledViaScript && !title.isEmpty() && documentScope().m_preferredStylesheetSetName.isEmpty()) { |
| if (!linkElement->attributeWithoutSynchronization(relAttr).contains("alternate"_s)) |
| documentScope().m_preferredStylesheetSetName = title; |
| } |
| continue; |
| } |
| if (!linkElement->sheet()) |
| title = nullAtom(); |
| } |
| // Get the current preferred styleset. This is the |
| // set of sheets that will be enabled. |
| if (RefPtr svgStyleElement = dynamicDowncast<SVGStyleElement>(element.get())) |
| sheet = svgStyleElement->sheet(); |
| else if (RefPtr htmlLinkElement = dynamicDowncast<HTMLLinkElement>(element.get())) |
| sheet = htmlLinkElement->sheet(); |
| else |
| sheet = downcast<HTMLStyleElement>(element.get()).sheet(); |
| |
| if (sheet) |
| styleSheetsForStyleSheetsList.append(*sheet); |
| |
| // Check to see if this sheet belongs to a styleset |
| // (thus making it PREFERRED or ALTERNATE rather than |
| // PERSISTENT). |
| auto& rel = element->attributeWithoutSynchronization(relAttr); |
| if (!enabledViaScript && sheet && !title.isEmpty()) { |
| // Yes, we have a title. |
| if (documentScope().m_preferredStylesheetSetName.isEmpty()) { |
| // No preferred set has been established. If |
| // we are NOT an alternate sheet, then establish |
| // us as the preferred set. Otherwise, just ignore |
| // this sheet. |
| if (is<HTMLStyleElement>(element.get()) || !rel.contains("alternate"_s)) |
| documentScope().m_preferredStylesheetSetName = title; |
| } |
| if (title != documentScope().m_preferredStylesheetSetName) |
| sheet = nullptr; |
| } |
| |
| if (rel.contains("alternate"_s) && title.isEmpty()) |
| sheet = nullptr; |
| |
| if (sheet) |
| LOG_WITH_STREAM(StyleSheets, stream << " adding sheet " << sheet << " from " << node); |
| } |
| if (sheet) |
| sheets.append(sheet.releaseNonNull()); |
| } |
| |
| auto canActivateAdoptedStyleSheet = [&](auto& sheet) { |
| if (sheet.disabled()) |
| return false; |
| return sheet.title().isEmpty() || sheet.title() == documentScope().m_preferredStylesheetSetName; |
| }; |
| |
| for (auto& adoptedStyleSheet : treeScope().adoptedStyleSheets()) { |
| if (!canActivateAdoptedStyleSheet(adoptedStyleSheet.get())) |
| continue; |
| sheets.append(adoptedStyleSheet.get()); |
| } |
| |
| return { WTF::move(sheets), WTF::move(styleSheetsForStyleSheetsList) }; |
| } |
| |
| Scope::StyleSheetChange Scope::analyzeStyleSheetChange(const Vector<Ref<CSSStyleSheet>>& newStylesheets) |
| { |
| unsigned newStylesheetCount = newStylesheets.size(); |
| |
| RefPtr resolver = resolverIfExists(); |
| if (!resolver) |
| return { ResolverUpdateType::Reconstruct }; |
| |
| if (resolver->isSharedBetweenShadowTrees()) |
| return { ResolverUpdateType::Reconstruct }; |
| |
| // Find out which stylesheets are new. |
| unsigned oldStylesheetCount = m_activeStyleSheets.size(); |
| if (newStylesheetCount < oldStylesheetCount) |
| return { ResolverUpdateType::Reconstruct }; |
| |
| Vector<Ref<StyleSheetContents>> addedSheets; |
| unsigned newIndex = 0; |
| for (unsigned oldIndex = 0; oldIndex < oldStylesheetCount; ++oldIndex) { |
| if (newIndex >= newStylesheetCount) |
| return { ResolverUpdateType::Reconstruct }; |
| |
| while (m_activeStyleSheets[oldIndex] != newStylesheets[newIndex]) { |
| addedSheets.append(protect(newStylesheets[newIndex]->contents())); |
| ++newIndex; |
| if (newIndex == newStylesheetCount) |
| return { ResolverUpdateType::Reconstruct }; |
| } |
| ++newIndex; |
| } |
| bool hasInsertions = !addedSheets.isEmpty(); |
| while (newIndex < newStylesheetCount) { |
| addedSheets.append(protect(newStylesheets[newIndex]->contents())); |
| ++newIndex; |
| } |
| |
| // If all new sheets were added at the end of the list we can just add them to existing Resolver. |
| // If there were insertions we need to re-add all the stylesheets so rules are ordered correctly. |
| return { hasInsertions ? ResolverUpdateType::Reset : ResolverUpdateType::Additive, WTF::move(addedSheets) }; |
| } |
| |
| static void filterEnabledNonemptyCSSStyleSheets(Vector<Ref<CSSStyleSheet>>& result, const Vector<Ref<StyleSheet>>& sheets) |
| { |
| for (auto& sheet : sheets) { |
| RefPtr styleSheet = dynamicDowncast<CSSStyleSheet>(sheet.get()); |
| if (!styleSheet) |
| continue; |
| if (styleSheet->isLoading()) |
| continue; |
| if (styleSheet->disabled()) |
| continue; |
| if (!styleSheet->length()) |
| continue; |
| result.append(*styleSheet); |
| } |
| } |
| |
| void Scope::updateActiveStyleSheets(UpdateType updateType) |
| { |
| RELEASE_ASSERT(!m_isUpdatingStyleResolver); |
| ASSERT(!m_pendingUpdate); |
| |
| if (!m_document->canEverRender()) |
| return; |
| |
| if (m_document->inStyleRecalc() || m_document->inRenderTreeUpdate()) { |
| // Protect against deleting style resolver in the middle of a style resolution. |
| // Crash stacks indicate we can get here when a resource load fails synchronously (for example due to content blocking). |
| // FIXME: These kind of cases should be eliminated and this path replaced by an assert. |
| m_pendingUpdate = UpdateType::ContentsOrInterpretation; |
| m_document->scheduleFullStyleRebuild(); |
| return; |
| } |
| |
| auto collection = collectActiveStyleSheets(); |
| |
| Vector<Ref<CSSStyleSheet>> activeCSSStyleSheets; |
| |
| if (!isForUserAgentShadowTree()) { |
| activeCSSStyleSheets.appendVector(m_document->extensionStyleSheets().injectedAuthorStyleSheets()); |
| activeCSSStyleSheets.appendVector(m_document->extensionStyleSheets().authorStyleSheetsForTesting()); |
| } |
| |
| filterEnabledNonemptyCSSStyleSheets(activeCSSStyleSheets, collection.activeStyleSheets); |
| |
| LOG_WITH_STREAM(StyleSheets, stream << "Scope::updateActiveStyleSheets for document " << m_document << " sheets " << activeCSSStyleSheets); |
| |
| auto styleSheetChange = StyleSheetChange { ResolverUpdateType::Reconstruct }; |
| if (updateType == UpdateType::ActiveSet) |
| styleSheetChange = analyzeStyleSheetChange(activeCSSStyleSheets); |
| |
| updateResolver(activeCSSStyleSheets, styleSheetChange.resolverUpdateType); |
| |
| m_weakCopyOfActiveStyleSheetListForFastLookup.clear(); |
| m_activeStyleSheets.swap(activeCSSStyleSheets); |
| m_styleSheetsForStyleSheetList.swap(collection.styleSheetsForStyleSheetList); |
| |
| InspectorInstrumentation::activeStyleSheetsUpdated(m_document); |
| |
| for (const auto& sheet : m_activeStyleSheets) { |
| if (sheet->contents().usesStyleBasedEditability()) |
| m_usesStyleBasedEditability = true; |
| } |
| |
| if (m_resolver && m_resolver->ruleSets().features().usesHasPseudoClass) |
| m_usesHasPseudoClass = true; |
| |
| invalidateStyleAfterStyleSheetChange(styleSheetChange); |
| } |
| |
| void Scope::invalidateStyleAfterStyleSheetChange(const StyleSheetChange& styleSheetChange) |
| { |
| if (m_shadowRoot && !m_shadowRoot->isConnected()) |
| return; |
| |
| // If we are already parsing the body and so may have significant amount of elements, put some effort into trying to avoid style recalcs. |
| bool invalidateAll = !m_document->bodyOrFrameset() || m_document->hasNodesWithMissingStyle(); |
| |
| if (styleSheetChange.resolverUpdateType == ResolverUpdateType::Reconstruct || invalidateAll) { |
| Invalidator::invalidateAllStyle(*this); |
| return; |
| } |
| |
| Invalidator invalidator(styleSheetChange.addedSheets, m_resolver->mediaQueryEvaluator()); |
| invalidator.invalidateStyle(*this); |
| } |
| |
| void Scope::updateResolver(std::span<const Ref<CSSStyleSheet>> activeStyleSheets, ResolverUpdateType updateType) |
| { |
| if (updateType == ResolverUpdateType::Reconstruct) { |
| clearResolver(); |
| return; |
| } |
| |
| if (m_shadowRoot) |
| unshareShadowTreeResolverBeforeMutation(); |
| |
| SetForScope isUpdatingStyleResolver { m_isUpdatingStyleResolver, true }; |
| |
| if (updateType == ResolverUpdateType::Reset) { |
| customPropertyRegistry().clearRegisteredFromStylesheets(); |
| counterStyleRegistry().clearAuthorCounterStyles(); |
| m_resolver->ruleSets().resetAuthorStyle(); |
| protect(m_resolver)->appendAuthorStyleSheets(activeStyleSheets); |
| return; |
| } |
| |
| ASSERT(updateType == ResolverUpdateType::Additive); |
| ASSERT(activeStyleSheets.size() >= m_activeStyleSheets.size()); |
| |
| auto firstNewIndex = m_activeStyleSheets.size(); |
| protect(m_resolver)->appendAuthorStyleSheets(activeStyleSheets.subspan(firstNewIndex)); |
| } |
| |
| const Vector<Ref<CSSStyleSheet>> Scope::activeStyleSheetsForInspector() |
| { |
| Vector<Ref<CSSStyleSheet>> result; |
| |
| if (CheckedPtr extensionStyleSheets = m_document->extensionStyleSheetsIfExists()) { |
| if (RefPtr pageUserSheet = extensionStyleSheets->pageUserSheet()) |
| result.append(*pageUserSheet); |
| result.appendVector(extensionStyleSheets->documentUserStyleSheets()); |
| result.appendVector(extensionStyleSheets->injectedUserStyleSheets()); |
| result.appendVector(extensionStyleSheets->injectedAuthorStyleSheets()); |
| result.appendVector(extensionStyleSheets->authorStyleSheetsForTesting()); |
| } |
| |
| for (auto& styleSheet : m_styleSheetsForStyleSheetList) { |
| RefPtr sheet = dynamicDowncast<CSSStyleSheet>(styleSheet.get()); |
| if (!sheet) |
| continue; |
| |
| if (sheet->disabled()) |
| continue; |
| |
| result.append(*sheet); |
| } |
| |
| return result; |
| } |
| |
| bool Scope::activeStyleSheetsContains(const CSSStyleSheet& sheet) const |
| { |
| if (m_activeStyleSheets.isEmpty()) |
| return false; |
| |
| if (m_weakCopyOfActiveStyleSheetListForFastLookup.isEmpty()) { |
| for (auto& activeStyleSheet : m_activeStyleSheets) |
| m_weakCopyOfActiveStyleSheetListForFastLookup.add(activeStyleSheet.get()); |
| } |
| return m_weakCopyOfActiveStyleSheetListForFastLookup.contains(sheet); |
| } |
| |
| void Scope::flushPendingSelfUpdate() |
| { |
| ASSERT(m_pendingUpdate); |
| |
| auto updateType = *m_pendingUpdate; |
| |
| clearPendingUpdate(); |
| |
| updateActiveStyleSheets(updateType); |
| } |
| |
| void Scope::flushPendingDescendantUpdates() |
| { |
| ASSERT(m_hasDescendantWithPendingUpdate); |
| ASSERT(!m_shadowRoot); |
| for (auto& descendantShadowRoot : m_document->inDocumentShadowRoots()) |
| const_cast<ShadowRoot&>(descendantShadowRoot).styleScope().flushPendingUpdate(); |
| m_hasDescendantWithPendingUpdate = false; |
| } |
| |
| void Scope::clearPendingUpdate() |
| { |
| m_pendingUpdateTimer.stop(); |
| m_pendingUpdate = { }; |
| } |
| |
| TreeScope& Scope::treeScope() |
| { |
| if (m_shadowRoot) |
| return *m_shadowRoot; |
| return m_document; |
| } |
| |
| void Scope::scheduleUpdate(UpdateType update) |
| { |
| if (update == UpdateType::ContentsOrInterpretation) { |
| // :host and ::slotted rules might go away. |
| if (m_shadowRoot) { |
| Invalidator::invalidateHostAndSlottedStyleIfNeeded(protect(*m_shadowRoot)); |
| unshareShadowTreeResolverBeforeMutation(); |
| } |
| |
| clearResolver(); |
| |
| if (auto* documentScope = dynamicDowncast<DocumentScope>(*this)) |
| documentScope->m_matchResultCache = { }; |
| } |
| |
| if (!m_pendingUpdate || *m_pendingUpdate < update) { |
| m_pendingUpdate = update; |
| if (m_shadowRoot) |
| documentScope().m_hasDescendantWithPendingUpdate = true; |
| } |
| |
| if (m_pendingUpdateTimer.isActive()) |
| return; |
| m_pendingUpdateTimer.startOneShot(0_s); |
| } |
| |
| void Scope::didChangeActiveStyleSheetCandidates() |
| { |
| scheduleUpdate(UpdateType::ActiveSet); |
| } |
| |
| void Scope::didChangeStyleSheetContents() |
| { |
| scheduleUpdate(UpdateType::ContentsOrInterpretation); |
| } |
| |
| void Scope::didChangeViewportSize() |
| { |
| Ref<ContainerNode> rootNode = m_document; |
| if (m_shadowRoot) |
| rootNode = *m_shadowRoot; |
| else { |
| if (!m_document->hasStyleWithViewportUnits()) |
| return; |
| |
| for (Ref descendantShadowRoot : m_document->inDocumentShadowRoots()) { |
| if (descendantShadowRoot->mode() == ShadowRootMode::UserAgent) |
| continue; |
| const_cast<ShadowRoot&>(descendantShadowRoot.get()).styleScope().didChangeViewportSize(); |
| } |
| } |
| |
| RefPtr resolver = resolverIfExists(); |
| if (!resolver) |
| return; |
| resolver->clearCachedDeclarationsAffectedByViewportUnits(); |
| |
| if (customPropertyRegistry().invalidatePropertiesWithViewportUnits(m_document)) { |
| if (!m_shadowRoot) { |
| if (RefPtr element = m_document->documentElement()) |
| element->invalidateStyleForSubtree(); |
| } |
| return; |
| } |
| |
| // Lazily resolved pseudo-element styles are cached on the element's style and only re-resolved |
| // when the element is invalidated, so their viewport units have to be accounted for here too. |
| auto usesViewportUnits = [](const Style::ComputedStyle& style) { |
| if (style.usesViewportUnits()) |
| return true; |
| for (auto& [identifier, pseudoElementStyle] : style.pseudoElementStyles()) { |
| if (pseudoElementStyle->usesViewportUnits()) |
| return true; |
| } |
| return false; |
| }; |
| |
| // FIXME: Ideally, we should save the list of elements that have viewport units and only iterate over those. |
| for (RefPtr element = ElementTraversal::firstWithin(rootNode); element; element = ElementTraversal::nextIncludingPseudo(*element)) { |
| bool styleableHasViewportUnitAnimation = Styleable::fromElement(*element).viewportSizeDidChange(); |
| auto* renderer = element->renderer(); |
| if (styleableHasViewportUnitAnimation || (renderer && usesViewportUnits(renderer->style()))) |
| element->invalidateStyle(); |
| } |
| } |
| |
| void Scope::invalidateMatchedDeclarationsCache() |
| { |
| if (!m_shadowRoot) { |
| for (auto& descendantShadowRoot : m_document->inDocumentShadowRoots()) |
| const_cast<ShadowRoot&>(descendantShadowRoot).styleScope().invalidateMatchedDeclarationsCache(); |
| } |
| |
| if (RefPtr resolver = resolverIfExists()) |
| resolver->invalidateMatchedDeclarationsCache(); |
| } |
| |
| void Scope::pendingUpdateTimerFired() |
| { |
| flushPendingUpdate(); |
| } |
| |
| const Vector<Ref<StyleSheet>>& Scope::styleSheetsForStyleSheetList() |
| { |
| // FIXME: StyleSheetList content should be updated separately from style resolver updates. |
| if (m_document->canEverRender()) |
| flushPendingUpdate(); |
| else if (m_pendingUpdate) { |
| // Documents that never make renderers (e.g. created by DOMParser) can't do full |
| // style updates but should still have an accessible styleSheets collection per spec. |
| m_pendingUpdate = { }; |
| m_styleSheetsForStyleSheetList = collectActiveStyleSheets().styleSheetsForStyleSheetList; |
| } |
| return m_styleSheetsForStyleSheetList; |
| } |
| |
| DocumentScope& Scope::documentScope() |
| { |
| return m_document->styleScope(); |
| } |
| |
| bool Scope::isForUserAgentShadowTree() const |
| { |
| return m_shadowRoot && m_shadowRoot->mode() == ShadowRootMode::UserAgent; |
| } |
| |
| RefPtr<HTMLSlotElement> assignedSlotForScopeOrdinal(const Element& element, ScopeOrdinal scopeOrdinal) |
| { |
| ASSERT(scopeOrdinal >= ScopeOrdinal::FirstSlot); |
| auto* slot = element.assignedSlot(); |
| for (auto scopeDepth = ScopeOrdinal::FirstSlot; slot && scopeDepth != scopeOrdinal; ++scopeDepth) |
| slot = slot->assignedSlot(); |
| return slot; |
| } |
| |
| RefPtr<Element> hostForScopeOrdinal(const Element& element, ScopeOrdinal scopeOrdinal) |
| { |
| ASSERT(scopeOrdinal <= ScopeOrdinal::ContainingHost); |
| auto* host = element.shadowHost(); |
| for (auto scopeDepth = ScopeOrdinal::ContainingHost; host && scopeDepth != scopeOrdinal; --scopeDepth) |
| host = host->shadowHost(); |
| return host; |
| } |
| |
| CheckedPtr<const Scope> Scope::hostScope() const |
| { |
| if (!m_shadowRoot || !m_shadowRoot->host()) |
| return nullptr; |
| return &forNode(*m_shadowRoot->host()); |
| } |
| |
| } |
| } |
