Add ChildrenAffectedByForwardPositionalRules bit for nth-child pseudo class marking
[WebKit-https.git] / Source / WebCore / style / StyleScope.h
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
5  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
6  * Copyright (C) 2004-2010, 2012-2013, 2015-2017 Apple Inc. All rights reserved.
7  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
8  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
9  * Copyright (C) 2011 Google Inc. All rights reserved.
10  *
11  * This library is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Library General Public
13  * License as published by the Free Software Foundation; either
14  * version 2 of the License, or (at your option) any later version.
15  *
16  * This library is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * Library General Public License for more details.
20  *
21  * You should have received a copy of the GNU Library General Public License
22  * along with this library; see the file COPYING.LIB.  If not, write to
23  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
24  * Boston, MA 02110-1301, USA.
25  *
26  */
27
28 #pragma once
29
30 #include "Timer.h"
31 #include <memory>
32 #include <wtf/FastMalloc.h>
33 #include <wtf/HashSet.h>
34 #include <wtf/ListHashSet.h>
35 #include <wtf/RefPtr.h>
36 #include <wtf/Vector.h>
37 #include <wtf/text/WTFString.h>
38
39 namespace WebCore {
40
41 class CSSStyleSheet;
42 class Document;
43 class Element;
44 class Node;
45 class ProcessingInstruction;
46 class StyleResolver;
47 class StyleSheet;
48 class StyleSheetContents;
49 class StyleSheetList;
50 class ShadowRoot;
51 class TreeScope;
52
53 namespace Style {
54
55 // This is used to identify style scopes that can affect an element.
56 // Scopes are in tree-of-trees order. Styles from earlier scopes win over later ones (modulo !important).
57 enum class ScopeOrdinal : int {
58     ContainingHost = -1, // Author-exposed UA pseudo classes from the host tree scope.
59     Element = 0, // Normal rules in the same tree where the element is.
60     FirstSlot = 1, // ::slotted rules in the parent's shadow tree. Values greater than FirstSlot indicate subsequent slots in the chain.
61     Shadow = std::numeric_limits<int>::max(), // :host rules in element's own shadow tree.
62 };
63
64 class Scope {
65     WTF_MAKE_FAST_ALLOCATED;
66 public:
67     explicit Scope(Document&);
68     explicit Scope(ShadowRoot&);
69
70     ~Scope();
71
72     const Vector<RefPtr<CSSStyleSheet>>& activeStyleSheets() const { return m_activeStyleSheets; }
73
74     const Vector<RefPtr<StyleSheet>>& styleSheetsForStyleSheetList();
75     const Vector<RefPtr<CSSStyleSheet>> activeStyleSheetsForInspector();
76
77     void addStyleSheetCandidateNode(Node&, bool createdByParser);
78     void removeStyleSheetCandidateNode(Node&);
79
80     String preferredStylesheetSetName() const { return m_preferredStylesheetSetName; }
81     String selectedStylesheetSetName() const { return m_selectedStylesheetSetName; }
82     void setPreferredStylesheetSetName(const String&);
83     void setSelectedStylesheetSetName(const String&);
84
85     void addPendingSheet(const Element&);
86     void removePendingSheet(const Element&);
87     void addPendingSheet(const ProcessingInstruction&);
88     void removePendingSheet(const ProcessingInstruction&);
89     bool hasPendingSheets() const;
90     bool hasPendingSheetsBeforeBody() const;
91     bool hasPendingSheetsInBody() const;
92     bool hasPendingSheet(const Element&) const;
93     bool hasPendingSheetInBody(const Element&) const;
94     bool hasPendingSheet(const ProcessingInstruction&) const;
95
96     bool usesStyleBasedEditability() { return m_usesStyleBasedEditability; }
97
98     bool activeStyleSheetsContains(const CSSStyleSheet*) const;
99
100     void evaluateMediaQueriesForViewportChange();
101     void evaluateMediaQueriesForAccessibilitySettingsChange();
102
103     // This is called when some stylesheet becomes newly enabled or disabled.
104     void didChangeActiveStyleSheetCandidates();
105     // This is called when contents of a stylesheet is mutated.
106     void didChangeStyleSheetContents();
107     // This is called when the environment where we intrepret the stylesheets changes (for example switching to printing).
108     // The change is assumed to potentially affect all author and user stylesheets including shadow roots.
109     WEBCORE_EXPORT void didChangeStyleSheetEnvironment();
110
111     bool hasPendingUpdate() const { return m_pendingUpdate || m_hasDescendantWithPendingUpdate; }
112     void flushPendingUpdate();
113
114 #if ENABLE(XSLT)
115     Vector<Ref<ProcessingInstruction>> collectXSLTransforms();
116 #endif
117
118     StyleResolver& resolver();
119     StyleResolver* resolverIfExists();
120     void clearResolver();
121     void releaseMemory();
122
123     const Document& document() const { return m_document; }
124
125     static Scope& forNode(Node&);
126     static Scope* forOrdinal(Element&, ScopeOrdinal);
127
128 private:
129     bool shouldUseSharedUserAgentShadowTreeStyleResolver() const;
130
131     void didRemovePendingStylesheet();
132
133     enum class UpdateType { ActiveSet, ContentsOrInterpretation };
134     void updateActiveStyleSheets(UpdateType);
135     void scheduleUpdate(UpdateType);
136
137     template <typename TestFunction> void evaluateMediaQueries(TestFunction&&);
138
139     WEBCORE_EXPORT void flushPendingSelfUpdate();
140     WEBCORE_EXPORT void flushPendingDescendantUpdates();
141
142     void collectActiveStyleSheets(Vector<RefPtr<StyleSheet>>&);
143
144     enum StyleResolverUpdateType {
145         Reconstruct,
146         Reset,
147         Additive
148     };
149     StyleResolverUpdateType analyzeStyleSheetChange(const Vector<RefPtr<CSSStyleSheet>>& newStylesheets, bool& requiresFullStyleRecalc);
150     void updateStyleResolver(Vector<RefPtr<CSSStyleSheet>>&, StyleResolverUpdateType);
151
152     void pendingUpdateTimerFired();
153     void clearPendingUpdate();
154
155     Document& m_document;
156     ShadowRoot* m_shadowRoot { nullptr };
157
158     std::unique_ptr<StyleResolver> m_resolver;
159
160     Vector<RefPtr<StyleSheet>> m_styleSheetsForStyleSheetList;
161     Vector<RefPtr<CSSStyleSheet>> m_activeStyleSheets;
162
163     Timer m_pendingUpdateTimer;
164
165     mutable std::unique_ptr<HashSet<const CSSStyleSheet*>> m_weakCopyOfActiveStyleSheetListForFastLookup;
166
167     // Track the currently loading top-level stylesheets needed for rendering.
168     // Sheets loaded using the @import directive are not included in this count.
169     // We use this count of pending sheets to detect when we can begin attaching
170     // elements and when it is safe to execute scripts.
171     HashSet<const ProcessingInstruction*> m_processingInstructionsWithPendingSheets;
172     HashSet<const Element*> m_elementsInHeadWithPendingSheets;
173     HashSet<const Element*> m_elementsInBodyWithPendingSheets;
174
175     std::optional<UpdateType> m_pendingUpdate;
176     bool m_hasDescendantWithPendingUpdate { false };
177
178     ListHashSet<Node*> m_styleSheetCandidateNodes;
179
180     String m_preferredStylesheetSetName;
181     String m_selectedStylesheetSetName;
182
183     bool m_usesStyleBasedEditability { false };
184     bool m_isUpdatingStyleResolver { false };
185 };
186
187 inline bool Scope::hasPendingSheets() const
188 {
189     return hasPendingSheetsBeforeBody() || !m_elementsInBodyWithPendingSheets.isEmpty();
190 }
191
192 inline bool Scope::hasPendingSheetsBeforeBody() const
193 {
194     return !m_elementsInHeadWithPendingSheets.isEmpty() || !m_processingInstructionsWithPendingSheets.isEmpty();
195 }
196
197 inline bool Scope::hasPendingSheetsInBody() const
198 {
199     return !m_elementsInBodyWithPendingSheets.isEmpty();
200 }
201
202 inline void Scope::flushPendingUpdate()
203 {
204     if (m_hasDescendantWithPendingUpdate)
205         flushPendingDescendantUpdates();
206     if (m_pendingUpdate)
207         flushPendingSelfUpdate();
208 }
209
210 inline ScopeOrdinal& operator++(ScopeOrdinal& ordinal)
211 {
212     ASSERT(ordinal < ScopeOrdinal::Shadow);
213     return ordinal = static_cast<ScopeOrdinal>(static_cast<int>(ordinal) + 1);
214 }
215
216 }
217 }