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