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