f902add8f56f3bb653876f4e49e199f2a6bc67d3
[WebKit-https.git] / Source / WebCore / css / RuleSet.h
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2003-2014 Apple Inc. All rights reserved.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB.  If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  *
20  */
21
22 #pragma once
23
24 #include "RuleFeature.h"
25 #include "SelectorCompiler.h"
26 #include "SelectorFilter.h"
27 #include "StyleRule.h"
28 #include <wtf/Forward.h>
29 #include <wtf/HashMap.h>
30 #include <wtf/text/AtomicString.h>
31 #include <wtf/text/AtomicStringHash.h>
32
33 namespace WebCore {
34
35 enum AddRuleFlags {
36     RuleHasNoSpecialState         = 0,
37     RuleHasDocumentSecurityOrigin = 1,
38 };
39     
40 enum PropertyWhitelistType {
41     PropertyWhitelistNone   = 0,
42     PropertyWhitelistMarker,
43 #if ENABLE(VIDEO_TRACK)
44     PropertyWhitelistCue
45 #endif
46 };
47
48 class CSSSelector;
49 class ContainerNode;
50 class MediaQueryEvaluator;
51 class Node;
52 class StyleResolver;
53 class StyleSheetContents;
54
55 enum class MatchBasedOnRuleHash : unsigned {
56     None,
57     Universal,
58     ClassA,
59     ClassB,
60     ClassC
61 };
62
63 class RuleData {
64 public:
65     static const unsigned maximumSelectorComponentCount = 8192;
66
67     RuleData(StyleRule*, unsigned selectorIndex, unsigned position, AddRuleFlags);
68
69     unsigned position() const { return m_position; }
70     StyleRule* rule() const { return m_rule.get(); }
71     const CSSSelector* selector() const { return m_rule->selectorList().selectorAt(m_selectorIndex); }
72     unsigned selectorIndex() const { return m_selectorIndex; }
73
74     bool canMatchPseudoElement() const { return m_canMatchPseudoElement; }
75     MatchBasedOnRuleHash matchBasedOnRuleHash() const { return static_cast<MatchBasedOnRuleHash>(m_matchBasedOnRuleHash); }
76     bool containsUncommonAttributeSelector() const { return m_containsUncommonAttributeSelector; }
77     unsigned linkMatchType() const { return m_linkMatchType; }
78     bool hasDocumentSecurityOrigin() const { return m_hasDocumentSecurityOrigin; }
79     PropertyWhitelistType propertyWhitelistType() const { return static_cast<PropertyWhitelistType>(m_propertyWhitelistType); }
80     const SelectorFilter::Hashes& descendantSelectorIdentifierHashes() const { return m_descendantSelectorIdentifierHashes; }
81
82     void disableSelectorFiltering() { m_descendantSelectorIdentifierHashes[0] = 0; }
83
84 #if ENABLE(CSS_SELECTOR_JIT)
85     SelectorCompilationStatus compilationStatus() const { return m_compilationStatus; }
86     JSC::MacroAssemblerCodeRef compiledSelectorCodeRef() const { return m_compiledSelectorCodeRef; }
87     void setCompiledSelector(SelectorCompilationStatus status, JSC::MacroAssemblerCodeRef codeRef) const
88     {
89         m_compilationStatus = status;
90         m_compiledSelectorCodeRef = codeRef;
91     }
92 #if CSS_SELECTOR_JIT_PROFILING
93     ~RuleData()
94     {
95         if (m_compiledSelectorCodeRef.code().executableAddress())
96             dataLogF("RuleData compiled selector %d \"%s\"\n", m_compiledSelectorUseCount, selector()->selectorText().utf8().data());
97     }
98     void compiledSelectorUsed() const { m_compiledSelectorUseCount++; }
99 #endif
100 #endif // ENABLE(CSS_SELECTOR_JIT)
101
102 private:
103     RefPtr<StyleRule> m_rule;
104     unsigned m_selectorIndex : 13;
105     unsigned m_hasDocumentSecurityOrigin : 1;
106     // This number was picked fairly arbitrarily. We can probably lower it if we need to.
107     // Some simple testing showed <100,000 RuleData's on large sites.
108     unsigned m_position : 18;
109     unsigned m_matchBasedOnRuleHash : 3;
110     unsigned m_canMatchPseudoElement : 1;
111     unsigned m_containsUncommonAttributeSelector : 1;
112     unsigned m_linkMatchType : 2; //  SelectorChecker::LinkMatchMask
113     unsigned m_propertyWhitelistType : 2;
114     SelectorFilter::Hashes m_descendantSelectorIdentifierHashes;
115 #if ENABLE(CSS_SELECTOR_JIT)
116     mutable SelectorCompilationStatus m_compilationStatus;
117     mutable JSC::MacroAssemblerCodeRef m_compiledSelectorCodeRef;
118 #if CSS_SELECTOR_JIT_PROFILING
119     mutable unsigned m_compiledSelectorUseCount;
120 #endif
121 #endif // ENABLE(CSS_SELECTOR_JIT)
122 };
123     
124 struct SameSizeAsRuleData {
125 #if ENABLE(CSS_SELECTOR_JIT)
126     unsigned compilationStatus;
127     void* compiledSelectorPointer;
128     void* codeRefPtr;
129 #if CSS_SELECTOR_JIT_PROFILING
130     unsigned compiledSelectorUseCount;
131 #endif
132 #endif // ENABLE(CSS_SELECTOR_JIT)
133
134     void* a;
135     unsigned b;
136     unsigned c;
137     unsigned d[4];
138 };
139
140 COMPILE_ASSERT(sizeof(RuleData) == sizeof(SameSizeAsRuleData), RuleData_should_stay_small);
141
142 class RuleSet {
143     WTF_MAKE_NONCOPYABLE(RuleSet); WTF_MAKE_FAST_ALLOCATED;
144 public:
145     struct RuleSetSelectorPair {
146         RuleSetSelectorPair(const CSSSelector* selector, std::unique_ptr<RuleSet> ruleSet) : selector(selector), ruleSet(WTFMove(ruleSet)) { }
147         RuleSetSelectorPair(const RuleSetSelectorPair& pair) : selector(pair.selector), ruleSet(const_cast<RuleSetSelectorPair*>(&pair)->ruleSet.release()) { }
148
149         const CSSSelector* selector;
150         std::unique_ptr<RuleSet> ruleSet;
151     };
152
153     RuleSet();
154     ~RuleSet();
155
156     typedef Vector<RuleData, 1> RuleDataVector;
157     typedef HashMap<AtomicString, std::unique_ptr<RuleDataVector>> AtomRuleMap;
158
159     void addRulesFromSheet(StyleSheetContents&, const MediaQueryEvaluator&, StyleResolver* = 0);
160
161     void addStyleRule(StyleRule*, AddRuleFlags);
162     void addRule(StyleRule*, unsigned selectorIndex, AddRuleFlags);
163     void addPageRule(StyleRulePage*);
164     void addToRuleSet(const AtomicString& key, AtomRuleMap&, const RuleData&);
165     void shrinkToFit();
166     void disableAutoShrinkToFit() { m_autoShrinkToFitEnabled = false; }
167
168     const RuleFeatureSet& features() const { return m_features; }
169
170     const RuleDataVector* idRules(const AtomicString& key) const { return m_idRules.get(key); }
171     const RuleDataVector* classRules(const AtomicString& key) const { return m_classRules.get(key); }
172     const RuleDataVector* tagRules(const AtomicString& key, bool isHTMLName) const;
173     const RuleDataVector* shadowPseudoElementRules(const AtomicString& key) const { return m_shadowPseudoElementRules.get(key); }
174     const RuleDataVector* linkPseudoClassRules() const { return &m_linkPseudoClassRules; }
175 #if ENABLE(VIDEO_TRACK)
176     const RuleDataVector* cuePseudoRules() const { return &m_cuePseudoRules; }
177 #endif
178     const RuleDataVector& hostPseudoClassRules() const { return m_hostPseudoClassRules; }
179     const RuleDataVector& slottedPseudoElementRules() const { return m_slottedPseudoElementRules; }
180     const RuleDataVector* focusPseudoClassRules() const { return &m_focusPseudoClassRules; }
181     const RuleDataVector* universalRules() const { return &m_universalRules; }
182
183     const Vector<StyleRulePage*>& pageRules() const { return m_pageRules; }
184
185     unsigned ruleCount() const { return m_ruleCount; }
186
187     bool hasShadowPseudoElementRules() const;
188     bool hasHostPseudoClassRulesMatchingInShadowTree() const { return m_hasHostPseudoClassRulesMatchingInShadowTree; }
189
190 private:
191     void addChildRules(const Vector<RefPtr<StyleRuleBase>>&, const MediaQueryEvaluator& medium, StyleResolver*, bool hasDocumentSecurityOrigin, bool isInitiatingElementInUserAgentShadowTree, AddRuleFlags);
192
193     AtomRuleMap m_idRules;
194     AtomRuleMap m_classRules;
195     AtomRuleMap m_tagLocalNameRules;
196     AtomRuleMap m_tagLowercaseLocalNameRules;
197     AtomRuleMap m_shadowPseudoElementRules;
198     RuleDataVector m_linkPseudoClassRules;
199 #if ENABLE(VIDEO_TRACK)
200     RuleDataVector m_cuePseudoRules;
201 #endif
202     RuleDataVector m_hostPseudoClassRules;
203     RuleDataVector m_slottedPseudoElementRules;
204     RuleDataVector m_focusPseudoClassRules;
205     RuleDataVector m_universalRules;
206     Vector<StyleRulePage*> m_pageRules;
207     unsigned m_ruleCount { 0 };
208     bool m_hasHostPseudoClassRulesMatchingInShadowTree { false };
209     bool m_autoShrinkToFitEnabled { true };
210     RuleFeatureSet m_features;
211 };
212
213 inline const RuleSet::RuleDataVector* RuleSet::tagRules(const AtomicString& key, bool isHTMLName) const
214 {
215     const AtomRuleMap* tagRules;
216     if (isHTMLName)
217         tagRules = &m_tagLowercaseLocalNameRules;
218     else
219         tagRules = &m_tagLocalNameRules;
220     return tagRules->get(key);
221 }
222
223 } // namespace WebCore
224
225 namespace WTF {
226
227 // RuleData is simple enough that initializing to 0 and moving with memcpy will totally work.
228 template<> struct VectorTraits<WebCore::RuleData> : SimpleClassVectorTraits { };
229
230 } // namespace WTF