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
|
/*
* Copyright (C) 1999 Lars Knoll (knoll@kde.org)
* Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 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 "core/css/CSSKeyframesRule.h"
#include "core/css/MediaQueryEvaluator.h"
#include "core/css/RuleFeature.h"
#include "core/css/StyleRule.h"
#include "core/css/resolver/MediaQueryResult.h"
#include "wtf/Forward.h"
#include "wtf/HashMap.h"
#include "wtf/LinkedStack.h"
namespace WebCore {
enum AddRuleFlags {
RuleHasNoSpecialState = 0,
RuleHasDocumentSecurityOrigin = 1,
RuleCanUseFastCheckSelector = 1 << 1,
RuleIsInRegionRule = 1 << 2,
};
enum PropertyWhitelistType {
PropertyWhitelistNone = 0,
PropertyWhitelistRegion,
PropertyWhitelistCue
};
class CSSSelector;
class MediaQueryEvaluator;
class StyleRuleRegion;
class StyleSheetContents;
struct MinimalRuleData {
MinimalRuleData(StyleRule* rule, unsigned selectorIndex, AddRuleFlags flags)
: m_rule(rule)
, m_selectorIndex(selectorIndex)
, m_flags(flags)
{
}
StyleRule* m_rule;
unsigned m_selectorIndex;
AddRuleFlags m_flags;
};
class RuleData {
WTF_MAKE_FAST_ALLOCATED;
public:
RuleData(StyleRule*, unsigned selectorIndex, unsigned position, AddRuleFlags);
unsigned position() const { return m_position; }
StyleRule* rule() const { return m_rule; }
const CSSSelector* selector() const { return m_rule->selectorList().selectorAt(m_selectorIndex); }
unsigned selectorIndex() const { return m_selectorIndex; }
bool isLastInArray() const { return m_isLastInArray; }
void setLastInArray(bool flag) { m_isLastInArray = flag; }
bool hasFastCheckableSelector() const { return m_hasFastCheckableSelector; }
bool hasMultipartSelector() const { return m_hasMultipartSelector; }
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; }
private:
StyleRule* m_rule;
unsigned m_selectorIndex : 12;
unsigned m_isLastInArray : 1; // We store an array of RuleData objects in a primitive array.
// 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_hasFastCheckableSelector : 1;
unsigned m_specificity : 24;
unsigned m_hasMultipartSelector : 1;
unsigned m_hasRightmostSelectorMatchingHTMLBasedOnRuleHash : 1;
unsigned m_containsUncommonAttributeSelector : 1;
unsigned m_linkMatchType : 2; // SelectorChecker::LinkMatchMask
unsigned m_hasDocumentSecurityOrigin : 1;
unsigned m_propertyWhitelistType : 2;
// Use plain array instead of a Vector to minimize memory overhead.
unsigned m_descendantSelectorIdentifierHashes[maximumIdentifierCount];
};
struct SameSizeAsRuleData {
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:
static PassOwnPtr<RuleSet> create() { return adoptPtr(new RuleSet); }
void addRulesFromSheet(StyleSheetContents*, const MediaQueryEvaluator&, AddRuleFlags = RuleHasNoSpecialState);
void addStyleRule(StyleRule*, AddRuleFlags);
void addRule(StyleRule*, unsigned selectorIndex, AddRuleFlags);
const RuleFeatureSet& features() const { return m_features; }
const RuleData* idRules(StringImpl* key) const { ASSERT(!m_pendingRules); return m_idRules.get(key); }
const RuleData* classRules(StringImpl* key) const { ASSERT(!m_pendingRules); return m_classRules.get(key); }
const RuleData* tagRules(StringImpl* key) const { ASSERT(!m_pendingRules); return m_tagRules.get(key); }
const RuleData* shadowPseudoElementRules(StringImpl* key) const { ASSERT(!m_pendingRules); return m_shadowPseudoElementRules.get(key); }
const Vector<RuleData>* linkPseudoClassRules() const { ASSERT(!m_pendingRules); return &m_linkPseudoClassRules; }
const Vector<RuleData>* cuePseudoRules() const { ASSERT(!m_pendingRules); return &m_cuePseudoRules; }
const Vector<RuleData>* focusPseudoClassRules() const { ASSERT(!m_pendingRules); return &m_focusPseudoClassRules; }
const Vector<RuleData>* universalRules() const { ASSERT(!m_pendingRules); return &m_universalRules; }
const Vector<StyleRulePage*>& pageRules() const { ASSERT(!m_pendingRules); return m_pageRules; }
const Vector<StyleRuleViewport*>& viewportRules() const { ASSERT(!m_pendingRules); return m_viewportRules; }
const Vector<StyleRuleFontFace*>& fontFaceRules() const { return m_fontFaceRules; }
const Vector<StyleRuleKeyframes*>& keyframesRules() const { return m_keyframesRules; }
const Vector<MinimalRuleData>& treeBoundaryCrossingRules() const { return m_treeBoundaryCrossingRules; }
const Vector<MinimalRuleData>& shadowDistributedRules() const { return m_shadowDistributedRules; }
const MediaQueryResultList& viewportDependentMediaQueryResults() const { return m_viewportDependentMediaQueryResults; }
unsigned ruleCount() const { return m_ruleCount; }
void compactRulesIfNeeded()
{
if (!m_pendingRules)
return;
compactRules();
}
struct RuleSetSelectorPair {
RuleSetSelectorPair(const CSSSelector* selector, PassOwnPtr<RuleSet> ruleSet) : selector(selector), ruleSet(ruleSet) { }
RuleSetSelectorPair(const RuleSetSelectorPair& rs) : selector(rs.selector), ruleSet(const_cast<RuleSetSelectorPair*>(&rs)->ruleSet.release()) { }
const CSSSelector* selector;
OwnPtr<RuleSet> ruleSet;
};
Vector<RuleSetSelectorPair> m_regionSelectorsAndRuleSets;
private:
typedef HashMap<StringImpl*, OwnPtr<LinkedStack<RuleData> > > PendingRuleMap;
typedef HashMap<StringImpl*, OwnPtr<RuleData> > CompactRuleMap;
RuleSet()
: m_ruleCount(0)
{
}
void addToRuleSet(StringImpl* key, PendingRuleMap&, const RuleData&);
void addPageRule(StyleRulePage*);
void addViewportRule(StyleRuleViewport*);
void addFontFaceRule(StyleRuleFontFace*);
void addKeyframesRule(StyleRuleKeyframes*);
void addRegionRule(StyleRuleRegion*, bool hasDocumentSecurityOrigin);
void addChildRules(const Vector<RefPtr<StyleRuleBase> >&, const MediaQueryEvaluator& medium, AddRuleFlags);
bool findBestRuleSetAndAdd(const CSSSelector*, RuleData&);
void compactRules();
static void compactPendingRules(PendingRuleMap&, CompactRuleMap&);
struct PendingRuleMaps {
PendingRuleMap idRules;
PendingRuleMap classRules;
PendingRuleMap tagRules;
PendingRuleMap shadowPseudoElementRules;
};
PendingRuleMaps* ensurePendingRules()
{
if (!m_pendingRules)
m_pendingRules = adoptPtr(new PendingRuleMaps);
return m_pendingRules.get();
}
CompactRuleMap m_idRules;
CompactRuleMap m_classRules;
CompactRuleMap m_tagRules;
CompactRuleMap m_shadowPseudoElementRules;
Vector<RuleData> m_linkPseudoClassRules;
Vector<RuleData> m_cuePseudoRules;
Vector<RuleData> m_focusPseudoClassRules;
Vector<RuleData> m_universalRules;
RuleFeatureSet m_features;
Vector<StyleRulePage*> m_pageRules;
Vector<StyleRuleViewport*> m_viewportRules;
Vector<StyleRuleFontFace*> m_fontFaceRules;
Vector<StyleRuleKeyframes*> m_keyframesRules;
Vector<MinimalRuleData> m_treeBoundaryCrossingRules;
Vector<MinimalRuleData> m_shadowDistributedRules;
MediaQueryResultList m_viewportDependentMediaQueryResults;
unsigned m_ruleCount;
OwnPtr<PendingRuleMaps> m_pendingRules;
};
} // namespace WebCore
#endif // RuleSet_h
|
