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
|
/*
* 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 StyleResolver;
class StyleRuleRegion;
class StyleSheetContents;
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; }
bool hasRightmostSelectorMatchingHTMLBasedOnRuleHash() const { return m_hasRightmostSelectorMatchingHTMLBasedOnRuleHash; }
bool containsUncommonAttributeSelector() const { return m_containsUncommonAttributeSelector; }
unsigned specificity() const { return m_specificity; }
unsigned linkMatchType() const { return m_linkMatchType; }
bool hasDocumentSecurityOrigin() const { return m_hasDocumentSecurityOrigin; }
PropertyWhitelistType propertyWhitelistType(bool isMatchingUARules = false) const { return isMatchingUARules ? PropertyWhitelistNone : 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; }
#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_specificity : 24;
unsigned m_hasRightmostSelectorMatchingHTMLBasedOnRuleHash : 1;
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(WTF::move(ruleSet)) { }
RuleSetSelectorPair(const RuleSetSelectorPair& pair) : selector(pair.selector), ruleSet(const_cast<RuleSetSelectorPair*>(&pair)->ruleSet.release()) { }
const CSSSelector* selector;
std::unique_ptr<RuleSet> ruleSet;
};
RuleSet();
typedef HashMap<AtomicStringImpl*, std::unique_ptr<Vector<RuleData>>> 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 Vector<RuleData>* idRules(AtomicStringImpl* key) const { return m_idRules.get(key); }
const Vector<RuleData>* classRules(AtomicStringImpl* key) const { return m_classRules.get(key); }
const Vector<RuleData>* tagRules(AtomicStringImpl* key) const { return m_tagRules.get(key); }
const Vector<RuleData>* shadowPseudoElementRules(AtomicStringImpl* key) const { return m_shadowPseudoElementRules.get(key); }
const Vector<RuleData>* linkPseudoClassRules() const { return &m_linkPseudoClassRules; }
#if ENABLE(VIDEO_TRACK)
const Vector<RuleData>* cuePseudoRules() const { return &m_cuePseudoRules; }
#endif
const Vector<RuleData>* focusPseudoClassRules() const { return &m_focusPseudoClassRules; }
const Vector<RuleData>* 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 { return !m_shadowPseudoElementRules.isEmpty(); }
private:
void addChildRules(const Vector<RefPtr<StyleRuleBase>>&, const MediaQueryEvaluator& medium, StyleResolver*, bool hasDocumentSecurityOrigin, AddRuleFlags);
AtomRuleMap m_idRules;
AtomRuleMap m_classRules;
AtomRuleMap m_tagRules;
AtomRuleMap m_shadowPseudoElementRules;
Vector<RuleData> m_linkPseudoClassRules;
#if ENABLE(VIDEO_TRACK)
Vector<RuleData> m_cuePseudoRules;
#endif
Vector<RuleData> m_focusPseudoClassRules;
Vector<RuleData> m_universalRules;
Vector<StyleRulePage*> m_pageRules;
unsigned m_ruleCount;
bool m_autoShrinkToFitEnabled;
RuleFeatureSet m_features;
Vector<RuleSetSelectorPair> m_regionSelectorsAndRuleSets;
};
inline RuleSet::RuleSet()
: m_ruleCount(0)
, m_autoShrinkToFitEnabled(true)
{
}
} // 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
|
