Remove leftover cruft from scoped stylesheet implementation.
[WebKit-https.git] / Source / WebCore / css / RuleSet.h
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 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
33 namespace WebCore {
34
35 enum AddRuleFlags {
36     RuleHasNoSpecialState         = 0,
37     RuleHasDocumentSecurityOrigin = 1,
38     RuleCanUseFastCheckSelector   = 1 << 1,
39     RuleIsInRegionRule            = 1 << 2,
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 class RuleData {
58 public:
59     static const unsigned maximumSelectorComponentCount = 8192;
60
61     RuleData(StyleRule*, unsigned selectorIndex, unsigned position, AddRuleFlags);
62
63     unsigned position() const { return m_position; }
64     StyleRule* rule() const { return m_rule; }
65     const CSSSelector* selector() const { return m_rule->selectorList().selectorAt(m_selectorIndex); }
66     unsigned selectorIndex() const { return m_selectorIndex; }
67
68     bool hasFastCheckableSelector() const { return m_hasFastCheckableSelector; }
69     bool hasMultipartSelector() const { return m_hasMultipartSelector; }
70     bool hasRightmostSelectorMatchingHTMLBasedOnRuleHash() const { return m_hasRightmostSelectorMatchingHTMLBasedOnRuleHash; }
71     bool containsUncommonAttributeSelector() const { return m_containsUncommonAttributeSelector; }
72     unsigned specificity() const { return m_specificity; }
73     unsigned linkMatchType() const { return m_linkMatchType; }
74     bool hasDocumentSecurityOrigin() const { return m_hasDocumentSecurityOrigin; }
75     PropertyWhitelistType propertyWhitelistType(bool isMatchingUARules = false) const { return isMatchingUARules ? PropertyWhitelistNone : static_cast<PropertyWhitelistType>(m_propertyWhitelistType); }
76     // Try to balance between memory usage (there can be lots of RuleData objects) and good filtering performance.
77     static const unsigned maximumIdentifierCount = 4;
78     const unsigned* descendantSelectorIdentifierHashes() const { return m_descendantSelectorIdentifierHashes; }
79
80 #if ENABLE(CSS_SELECTOR_JIT)
81     SelectorCompilationStatus compilationStatus() const { return m_compilationStatus; }
82     JSC::MacroAssemblerCodeRef compiledSelectorCodeRef() const { return m_compiledSelectorCodeRef; }
83     void setCompiledSelector(SelectorCompilationStatus status, JSC::MacroAssemblerCodeRef codeRef) const
84     {
85         m_compilationStatus = status;
86         m_compiledSelectorCodeRef = codeRef;
87     }
88 #endif // ENABLE(CSS_SELECTOR_JIT)
89
90 private:
91     StyleRule* m_rule;
92     unsigned m_selectorIndex : 13;
93     // This number was picked fairly arbitrarily. We can probably lower it if we need to.
94     // Some simple testing showed <100,000 RuleData's on large sites.
95     unsigned m_position : 18;
96     unsigned m_hasFastCheckableSelector : 1;
97     unsigned m_specificity : 24;
98     unsigned m_hasMultipartSelector : 1;
99     unsigned m_hasRightmostSelectorMatchingHTMLBasedOnRuleHash : 1;
100     unsigned m_containsUncommonAttributeSelector : 1;
101     unsigned m_linkMatchType : 2; //  SelectorChecker::LinkMatchMask
102     unsigned m_hasDocumentSecurityOrigin : 1;
103     unsigned m_propertyWhitelistType : 2;
104     // Use plain array instead of a Vector to minimize memory overhead.
105     unsigned m_descendantSelectorIdentifierHashes[maximumIdentifierCount];
106 #if ENABLE(CSS_SELECTOR_JIT)
107     mutable SelectorCompilationStatus m_compilationStatus;
108     mutable JSC::MacroAssemblerCodeRef m_compiledSelectorCodeRef;
109 #endif // ENABLE(CSS_SELECTOR_JIT)
110 };
111     
112 struct SameSizeAsRuleData {
113 #if ENABLE(CSS_SELECTOR_JIT)
114     unsigned compilationStatus;
115     void* compiledSelectorPointer;
116     void* codeRefPtr;
117 #endif // ENABLE(CSS_SELECTOR_JIT)
118
119     void* a;
120     unsigned b;
121     unsigned c;
122     unsigned d[4];
123 };
124
125 COMPILE_ASSERT(sizeof(RuleData) == sizeof(SameSizeAsRuleData), RuleData_should_stay_small);
126
127 class RuleSet {
128     WTF_MAKE_NONCOPYABLE(RuleSet); WTF_MAKE_FAST_ALLOCATED;
129 public:
130     struct RuleSetSelectorPair {
131         RuleSetSelectorPair(const CSSSelector* selector, std::unique_ptr<RuleSet> ruleSet) : selector(selector), ruleSet(std::move(ruleSet)) { }
132         RuleSetSelectorPair(const RuleSetSelectorPair& pair) : selector(pair.selector), ruleSet(const_cast<RuleSetSelectorPair*>(&pair)->ruleSet.release()) { }
133
134         const CSSSelector* selector;
135         std::unique_ptr<RuleSet> ruleSet;
136     };
137
138     RuleSet();
139
140     typedef HashMap<AtomicStringImpl*, std::unique_ptr<Vector<RuleData>>> AtomRuleMap;
141
142     void addRulesFromSheet(StyleSheetContents*, const MediaQueryEvaluator&, StyleResolver* = 0);
143
144     void addStyleRule(StyleRule*, AddRuleFlags);
145     void addRule(StyleRule*, unsigned selectorIndex, AddRuleFlags);
146     void addPageRule(StyleRulePage*);
147     void addToRuleSet(AtomicStringImpl* key, AtomRuleMap&, const RuleData&);
148     void addRegionRule(StyleRuleRegion*, bool hasDocumentSecurityOrigin);
149     void shrinkToFit();
150     void disableAutoShrinkToFit() { m_autoShrinkToFitEnabled = false; }
151
152     const RuleFeatureSet& features() const { return m_features; }
153
154     const Vector<RuleData>* idRules(AtomicStringImpl* key) const { return m_idRules.get(key); }
155     const Vector<RuleData>* classRules(AtomicStringImpl* key) const { return m_classRules.get(key); }
156     const Vector<RuleData>* tagRules(AtomicStringImpl* key) const { return m_tagRules.get(key); }
157     const Vector<RuleData>* shadowPseudoElementRules(AtomicStringImpl* key) const { return m_shadowPseudoElementRules.get(key); }
158     const Vector<RuleData>* linkPseudoClassRules() const { return &m_linkPseudoClassRules; }
159 #if ENABLE(VIDEO_TRACK)
160     const Vector<RuleData>* cuePseudoRules() const { return &m_cuePseudoRules; }
161 #endif
162     const Vector<RuleData>* focusPseudoClassRules() const { return &m_focusPseudoClassRules; }
163     const Vector<RuleData>* universalRules() const { return &m_universalRules; }
164     const Vector<StyleRulePage*>& pageRules() const { return m_pageRules; }
165     const Vector<RuleSetSelectorPair>& regionSelectorsAndRuleSets() const { return m_regionSelectorsAndRuleSets; }
166
167     unsigned ruleCount() const { return m_ruleCount; }
168
169 private:
170     void addChildRules(const Vector<RefPtr<StyleRuleBase>>&, const MediaQueryEvaluator& medium, StyleResolver*, bool hasDocumentSecurityOrigin, AddRuleFlags);
171     bool findBestRuleSetAndAdd(const CSSSelector*, RuleData&);
172
173     AtomRuleMap m_idRules;
174     AtomRuleMap m_classRules;
175     AtomRuleMap m_tagRules;
176     AtomRuleMap m_shadowPseudoElementRules;
177     Vector<RuleData> m_linkPseudoClassRules;
178 #if ENABLE(VIDEO_TRACK)
179     Vector<RuleData> m_cuePseudoRules;
180 #endif
181     Vector<RuleData> m_focusPseudoClassRules;
182     Vector<RuleData> m_universalRules;
183     Vector<StyleRulePage*> m_pageRules;
184     unsigned m_ruleCount;
185     bool m_autoShrinkToFitEnabled;
186     RuleFeatureSet m_features;
187     Vector<RuleSetSelectorPair> m_regionSelectorsAndRuleSets;
188 };
189
190 inline RuleSet::RuleSet()
191     : m_ruleCount(0)
192     , m_autoShrinkToFitEnabled(true)
193 {
194 }
195
196 } // namespace WebCore
197
198 namespace WTF {
199 // RuleData is simple enough that initializing to 0 and moving with memcpy will totally work.
200 template<> struct VectorTraits<WebCore::RuleData> : SimpleClassVectorTraits { };
201
202 } // namespace WTF
203
204 #endif // RuleSet_h