1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
|
/*
* Copyright (C) 1999 Lars Knoll (knoll@kde.org)
* Copyright (C) 2003-2014 Apple Inc. 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.
*
*/
#ifndef RuleSet_h
#define RuleSet_h
#include "RuleFeature.h"
#include "SelectorCompiler.h"
#include "StyleRule.h"
#include <wtf/Forward.h>
#include <wtf/HashMap.h>
#include <wtf/HashSet.h>
#include <wtf/text/AtomicString.h>
#include <wtf/text/CString.h>
namespace WebCore {
enum AddRuleFlags {
RuleHasNoSpecialState = 0,
RuleHasDocumentSecurityOrigin = 1,
RuleIsInRegionRule = 1 << 1,
};
enum PropertyWhitelistType {
PropertyWhitelistNone = 0,
PropertyWhitelistRegion,
#if ENABLE(VIDEO_TRACK)
PropertyWhitelistCue
#endif
};
class CSSSelector;
class ContainerNode;
class MediaQueryEvaluator;
class Node;
class StyleResolver;
class StyleRuleRegion;
class StyleSheetContents;
enum class MatchBasedOnRuleHash : unsigned {
None,
Universal,
ClassA,
ClassB,
ClassC
};
class RuleData {
public:
static const unsigned maximumSelectorComponentCount = 8192;
RuleData(StyleRule*, unsigned selectorIndex, unsigned position, AddRuleFlags);
unsigned position() const { return m_position; }
StyleRule* rule() const { return m_rule.get(); }
const CSSSelector* selector() const { return m_rule->selectorList().selectorAt(m_selectorIndex); }
unsigned selectorIndex() const { return m_selectorIndex; }
bool canMatchPseudoElement() const { return m_canMatchPseudoElement; }
MatchBasedOnRuleHash matchBasedOnRuleHash() const { return static_cast<MatchBasedOnRuleHash>(m_matchBasedOnRuleHash); }
bool containsUncommonAttributeSelector() const { return m_containsUncommonAttributeSelector; }
unsigned linkMatchType() const { return m_linkMatchType; }
bool hasDocumentSecurityOrigin() const { return m_hasDocumentSecurityOrigin; }
PropertyWhitelistType propertyWhitelistType() const { return static_cast<PropertyWhitelistType>(m_propertyWhitelistType); }
// Try to balance between memory usage (there can be lots of RuleData objects) and good filtering performance.
static const unsigned maximumIdentifierCount = 4;
const unsigned* descendantSelectorIdentifierHashes() const { return m_descendantSelectorIdentifierHashes; }
void disableSelectorFiltering() { m_descendantSelectorIdentifierHashes[0] = 0; }
#if ENABLE(CSS_SELECTOR_JIT)
SelectorCompilationStatus compilationStatus() const { return m_compilationStatus; }
JSC::MacroAssemblerCodeRef compiledSelectorCodeRef() const { return m_compiledSelectorCodeRef; }
void setCompiledSelector(SelectorCompilationStatus status, JSC::MacroAssemblerCodeRef codeRef) const
{
m_compilationStatus = status;
m_compiledSelectorCodeRef = codeRef;
}
#if CSS_SELECTOR_JIT_PROFILING
~RuleData()
{
if (m_compiledSelectorCodeRef.code().executableAddress())
dataLogF("RuleData compiled selector %d \"%s\"\n", m_compiledSelectorUseCount, selector()->selectorText().utf8().data());
}
void compiledSelectorUsed() const { m_compiledSelectorUseCount++; }
#endif
#endif // ENABLE(CSS_SELECTOR_JIT)
private:
RefPtr<StyleRule> m_rule;
unsigned m_selectorIndex : 13;
unsigned m_hasDocumentSecurityOrigin : 1;
// This number was picked fairly arbitrarily. We can probably lower it if we need to.
// Some simple testing showed <100,000 RuleData's on large sites.
unsigned m_position : 18;
unsigned m_matchBasedOnRuleHash : 3;
unsigned m_canMatchPseudoElement : 1;
unsigned m_containsUncommonAttributeSelector : 1;
unsigned m_linkMatchType : 2; // SelectorChecker::LinkMatchMask
unsigned m_propertyWhitelistType : 2;
// Use plain array instead of a Vector to minimize memory overhead.
unsigned m_descendantSelectorIdentifierHashes[maximumIdentifierCount];
#if ENABLE(CSS_SELECTOR_JIT)
mutable SelectorCompilationStatus m_compilationStatus;
mutable JSC::MacroAssemblerCodeRef m_compiledSelectorCodeRef;
#if CSS_SELECTOR_JIT_PROFILING
mutable unsigned m_compiledSelectorUseCount;
#endif
#endif // ENABLE(CSS_SELECTOR_JIT)
};
struct SameSizeAsRuleData {
#if ENABLE(CSS_SELECTOR_JIT)
unsigned compilationStatus;
void* compiledSelectorPointer;
void* codeRefPtr;
#if CSS_SELECTOR_JIT_PROFILING
unsigned compiledSelectorUseCount;
#endif
#endif // ENABLE(CSS_SELECTOR_JIT)
void* a;
unsigned b;
unsigned c;
unsigned d[4];
};
COMPILE_ASSERT(sizeof(RuleData) == sizeof(SameSizeAsRuleData), RuleData_should_stay_small);
class RuleSet {
WTF_MAKE_NONCOPYABLE(RuleSet); WTF_MAKE_FAST_ALLOCATED;
public:
struct RuleSetSelectorPair {
RuleSetSelectorPair(const CSSSelector* selector, std::unique_ptr<RuleSet> ruleSet) : selector(selector), ruleSet(WTFMove(ruleSet)) { }
RuleSetSelectorPair(const RuleSetSelectorPair& pair) : selector(pair.selector), ruleSet(const_cast<RuleSetSelectorPair*>(&pair)->ruleSet.release()) { }
const CSSSelector* selector;
std::unique_ptr<RuleSet> ruleSet;
};
RuleSet();
~RuleSet();
typedef Vector<RuleData, 1> RuleDataVector;
typedef HashMap<AtomicStringImpl*, std::unique_ptr<RuleDataVector>> AtomRuleMap;
void addRulesFromSheet(StyleSheetContents&, const MediaQueryEvaluator&, StyleResolver* = 0);
void addStyleRule(StyleRule*, AddRuleFlags);
void addRule(StyleRule*, unsigned selectorIndex, AddRuleFlags);
void addPageRule(StyleRulePage*);
void addToRuleSet(AtomicStringImpl* key, AtomRuleMap&, const RuleData&);
void addRegionRule(StyleRuleRegion*, bool hasDocumentSecurityOrigin);
void shrinkToFit();
void disableAutoShrinkToFit() { m_autoShrinkToFitEnabled = false; }
const RuleFeatureSet& features() const { return m_features; }
const RuleDataVector* idRules(AtomicStringImpl* key) const { return m_idRules.get(key); }
const RuleDataVector* classRules(AtomicStringImpl* key) const { return m_classRules.get(key); }
const RuleDataVector* tagRules(AtomicStringImpl* key, bool isHTMLName) const;
const RuleDataVector* shadowPseudoElementRules(AtomicStringImpl* key) const { return m_shadowPseudoElementRules.get(key); }
const RuleDataVector* linkPseudoClassRules() const { return &m_linkPseudoClassRules; }
#if ENABLE(VIDEO_TRACK)
const RuleDataVector* cuePseudoRules() const { return &m_cuePseudoRules; }
#endif
#if ENABLE(SHADOW_DOM)
const RuleDataVector& hostPseudoClassRules() const { return m_hostPseudoClassRules; }
#endif
const RuleDataVector* focusPseudoClassRules() const { return &m_focusPseudoClassRules; }
const RuleDataVector* universalRules() const { return &m_universalRules; }
const Vector<StyleRulePage*>& pageRules() const { return m_pageRules; }
const Vector<RuleSetSelectorPair>& regionSelectorsAndRuleSets() const { return m_regionSelectorsAndRuleSets; }
unsigned ruleCount() const { return m_ruleCount; }
bool hasShadowPseudoElementRules() const;
void copyShadowPseudoElementRulesFrom(const RuleSet&);
private:
void addChildRules(const Vector<RefPtr<StyleRuleBase>>&, const MediaQueryEvaluator& medium, StyleResolver*, bool hasDocumentSecurityOrigin, bool isInitiatingElementInUserAgentShadowTree, AddRuleFlags);
AtomRuleMap m_idRules;
AtomRuleMap m_classRules;
AtomRuleMap m_tagLocalNameRules;
AtomRuleMap m_tagLowercaseLocalNameRules;
AtomRuleMap m_shadowPseudoElementRules;
RuleDataVector m_linkPseudoClassRules;
#if ENABLE(VIDEO_TRACK)
RuleDataVector m_cuePseudoRules;
#endif
#if ENABLE(SHADOW_DOM)
RuleDataVector m_hostPseudoClassRules;
#endif
RuleDataVector m_focusPseudoClassRules;
RuleDataVector m_universalRules;
Vector<StyleRulePage*> m_pageRules;
unsigned m_ruleCount { 0 };
bool m_autoShrinkToFitEnabled { false };
RuleFeatureSet m_features;
Vector<RuleSetSelectorPair> m_regionSelectorsAndRuleSets;
};
inline const RuleSet::RuleDataVector* RuleSet::tagRules(AtomicStringImpl* key, bool isHTMLName) const
{
const AtomRuleMap* tagRules;
if (isHTMLName)
tagRules = &m_tagLowercaseLocalNameRules;
else
tagRules = &m_tagLocalNameRules;
return tagRules->get(key);
}
} // namespace WebCore
namespace WTF {
// RuleData is simple enough that initializing to 0 and moving with memcpy will totally work.
template<> struct VectorTraits<WebCore::RuleData> : SimpleClassVectorTraits { };
} // namespace WTF
#endif // RuleSet_h
|
