Remove the memory instrumentation code
[WebKit-https.git] / Source / WebCore / css / StyleRule.h
1 /*
2  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
3  * (C) 2002-2003 Dirk Mueller (mueller@kde.org)
4  * Copyright (C) 2002, 2006, 2008, 2012, 2013 Apple Inc. All rights reserved.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public License
17  * along with this library; see the file COPYING.LIB.  If not, write to
18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  * Boston, MA 02110-1301, USA.
20  */
21
22 #ifndef StyleRule_h
23 #define StyleRule_h
24
25 #include "CSSSelectorList.h"
26 #include "MediaList.h"
27 #include <wtf/RefPtr.h>
28
29 namespace WebCore {
30
31 class CSSRule;
32 class CSSStyleRule;
33 class CSSStyleSheet;
34 class MutableStylePropertySet;
35 class StylePropertySet;
36
37 class StyleRuleBase : public WTF::RefCountedBase {
38     WTF_MAKE_FAST_ALLOCATED;
39 public:
40     enum Type {
41         Unknown, // Not used.
42         Style,
43         Charset, // Not used. These are internally strings owned by the style sheet.
44         Import,
45         Media,
46         FontFace,
47         Page,
48         Keyframes,
49         Keyframe, // Not used. These are internally non-rule StyleKeyframe objects.
50 #if ENABLE(CSS3_CONDITIONAL_RULES)
51         Supports = 12,
52 #endif
53 #if ENABLE(CSS_DEVICE_ADAPTATION)
54         Viewport = 15,
55 #endif
56         Region = 16,
57 #if ENABLE(CSS_SHADERS)
58         Filter = 17,
59 #endif
60 #if ENABLE(SHADOW_DOM)
61         HostInternal = 18, // Spec says Host = 1001, but we can use only 5 bit for type().
62 #endif
63     };
64
65     Type type() const { return static_cast<Type>(m_type); }
66     
67     bool isCharsetRule() const { return type() == Charset; }
68     bool isFontFaceRule() const { return type() == FontFace; }
69     bool isKeyframesRule() const { return type() == Keyframes; }
70     bool isMediaRule() const { return type() == Media; }
71     bool isPageRule() const { return type() == Page; }
72     bool isStyleRule() const { return type() == Style; }
73     bool isRegionRule() const { return type() == Region; }
74 #if ENABLE(CSS3_CONDITIONAL_RULES)
75     bool isSupportsRule() const { return type() == Supports; }
76 #endif
77 #if ENABLE(CSS_DEVICE_ADAPTATION)
78     bool isViewportRule() const { return type() == Viewport; }
79 #endif
80     bool isImportRule() const { return type() == Import; }
81 #if ENABLE(SHADOW_DOM)
82     bool isHostRule() const { return type() == HostInternal; }
83 #endif
84 #if ENABLE(CSS_SHADERS)
85     bool isFilterRule() const { return type() == Filter; }
86 #endif
87
88     PassRefPtr<StyleRuleBase> copy() const;
89
90     int sourceLine() const { return m_sourceLine; }
91
92     void deref()
93     {
94         if (derefBase())
95             destroy();
96     }
97
98     // FIXME: There shouldn't be any need for the null parent version.
99     PassRefPtr<CSSRule> createCSSOMWrapper(CSSStyleSheet* parentSheet = 0) const;
100     PassRefPtr<CSSRule> createCSSOMWrapper(CSSRule* parentRule) const;
101
102 protected:
103     StyleRuleBase(Type type, signed sourceLine = 0) : m_type(type), m_sourceLine(sourceLine) { }
104     StyleRuleBase(const StyleRuleBase& o) : WTF::RefCountedBase(), m_type(o.m_type), m_sourceLine(o.m_sourceLine) { }
105
106     ~StyleRuleBase() { }
107
108 private:
109     void destroy();
110     
111     PassRefPtr<CSSRule> createCSSOMWrapper(CSSStyleSheet* parentSheet, CSSRule* parentRule) const;
112
113     unsigned m_type : 5;
114     signed m_sourceLine : 27;
115 };
116
117 class StyleRule : public StyleRuleBase {
118     WTF_MAKE_FAST_ALLOCATED;
119 public:
120     static PassRefPtr<StyleRule> create(int sourceLine) { return adoptRef(new StyleRule(sourceLine)); }
121     
122     ~StyleRule();
123
124     const CSSSelectorList& selectorList() const { return m_selectorList; }
125     const StylePropertySet* properties() const { return m_properties.get(); }
126     MutableStylePropertySet* mutableProperties();
127     
128     void parserAdoptSelectorVector(Vector<OwnPtr<CSSParserSelector> >& selectors) { m_selectorList.adoptSelectorVector(selectors); }
129     void wrapperAdoptSelectorList(CSSSelectorList& selectors) { m_selectorList.adopt(selectors); }
130     void setProperties(PassRefPtr<StylePropertySet>);
131
132     PassRefPtr<StyleRule> copy() const { return adoptRef(new StyleRule(*this)); }
133
134     static unsigned averageSizeInBytes();
135
136 private:
137     StyleRule(int sourceLine);
138     StyleRule(const StyleRule&);
139
140     RefPtr<StylePropertySet> m_properties;
141     CSSSelectorList m_selectorList;
142 };
143
144 class StyleRuleFontFace : public StyleRuleBase {
145 public:
146     static PassRefPtr<StyleRuleFontFace> create() { return adoptRef(new StyleRuleFontFace); }
147     
148     ~StyleRuleFontFace();
149
150     const StylePropertySet* properties() const { return m_properties.get(); }
151     MutableStylePropertySet* mutableProperties();
152
153     void setProperties(PassRefPtr<StylePropertySet>);
154
155     PassRefPtr<StyleRuleFontFace> copy() const { return adoptRef(new StyleRuleFontFace(*this)); }
156
157
158 private:
159     StyleRuleFontFace();
160     StyleRuleFontFace(const StyleRuleFontFace&);
161
162     RefPtr<StylePropertySet> m_properties;
163 };
164
165 class StyleRulePage : public StyleRuleBase {
166 public:
167     static PassRefPtr<StyleRulePage> create() { return adoptRef(new StyleRulePage); }
168
169     ~StyleRulePage();
170
171     const CSSSelector* selector() const { return m_selectorList.first(); }    
172     const StylePropertySet* properties() const { return m_properties.get(); }
173     MutableStylePropertySet* mutableProperties();
174
175     void parserAdoptSelectorVector(Vector<OwnPtr<CSSParserSelector> >& selectors) { m_selectorList.adoptSelectorVector(selectors); }
176     void wrapperAdoptSelectorList(CSSSelectorList& selectors) { m_selectorList.adopt(selectors); }
177     void setProperties(PassRefPtr<StylePropertySet>);
178
179     PassRefPtr<StyleRulePage> copy() const { return adoptRef(new StyleRulePage(*this)); }
180
181 private:
182     StyleRulePage();
183     StyleRulePage(const StyleRulePage&);
184     
185     RefPtr<StylePropertySet> m_properties;
186     CSSSelectorList m_selectorList;
187 };
188
189 class StyleRuleGroup : public StyleRuleBase {
190 public:
191     const Vector<RefPtr<StyleRuleBase> >& childRules() const { return m_childRules; }
192     
193     void wrapperInsertRule(unsigned, PassRefPtr<StyleRuleBase>);
194     void wrapperRemoveRule(unsigned);
195     
196 protected:
197     StyleRuleGroup(Type, Vector<RefPtr<StyleRuleBase> >& adoptRule);
198     StyleRuleGroup(const StyleRuleGroup&);
199     
200 private:
201     Vector<RefPtr<StyleRuleBase> > m_childRules;
202 };
203
204 class StyleRuleMedia : public StyleRuleGroup {
205 public:
206     static PassRefPtr<StyleRuleMedia> create(PassRefPtr<MediaQuerySet> media, Vector<RefPtr<StyleRuleBase> >& adoptRules)
207     {
208         return adoptRef(new StyleRuleMedia(media, adoptRules));
209     }
210
211     MediaQuerySet* mediaQueries() const { return m_mediaQueries.get(); }
212
213     PassRefPtr<StyleRuleMedia> copy() const { return adoptRef(new StyleRuleMedia(*this)); }
214
215 private:
216     StyleRuleMedia(PassRefPtr<MediaQuerySet>, Vector<RefPtr<StyleRuleBase> >& adoptRules);
217     StyleRuleMedia(const StyleRuleMedia&);
218
219     RefPtr<MediaQuerySet> m_mediaQueries;
220 };
221
222 #if ENABLE(CSS3_CONDITIONAL_RULES)
223 class StyleRuleSupports : public StyleRuleGroup {
224 public:
225     static PassRefPtr<StyleRuleSupports> create(const String& conditionText, bool conditionIsSupported, Vector<RefPtr<StyleRuleBase> >& adoptRules)
226     {
227         return adoptRef(new StyleRuleSupports(conditionText, conditionIsSupported, adoptRules));
228     }
229
230     String conditionText() const { return m_conditionText; }
231     bool conditionIsSupported() const { return m_conditionIsSupported; }
232     PassRefPtr<StyleRuleSupports> copy() const { return adoptRef(new StyleRuleSupports(*this)); }
233
234 private:
235     StyleRuleSupports(const String& conditionText, bool conditionIsSupported, Vector<RefPtr<StyleRuleBase> >& adoptRules);
236     StyleRuleSupports(const StyleRuleSupports&);
237
238     String m_conditionText;
239     bool m_conditionIsSupported;
240 };
241 #endif
242
243 class StyleRuleRegion : public StyleRuleGroup {
244 public:
245     static PassRefPtr<StyleRuleRegion> create(Vector<OwnPtr<CSSParserSelector> >* selectors, Vector<RefPtr<StyleRuleBase> >& adoptRules)
246     {
247         return adoptRef(new StyleRuleRegion(selectors, adoptRules));
248     }
249
250     const CSSSelectorList& selectorList() const { return m_selectorList; }
251
252     PassRefPtr<StyleRuleRegion> copy() const { return adoptRef(new StyleRuleRegion(*this)); }
253
254 private:
255     StyleRuleRegion(Vector<OwnPtr<CSSParserSelector> >*, Vector<RefPtr<StyleRuleBase> >& adoptRules);
256     StyleRuleRegion(const StyleRuleRegion&);
257     
258     CSSSelectorList m_selectorList;
259 };
260
261 #if ENABLE(SHADOW_DOM)
262 class StyleRuleHost : public StyleRuleGroup {
263 public:
264     static PassRefPtr<StyleRuleHost> create(Vector<RefPtr<StyleRuleBase> >& adoptRules)
265     {
266         return adoptRef(new StyleRuleHost(adoptRules));
267     }
268
269     PassRefPtr<StyleRuleHost> copy() const { return adoptRef(new StyleRuleHost(*this)); }
270
271 private:
272     StyleRuleHost(Vector<RefPtr<StyleRuleBase> >& adoptRules) : StyleRuleGroup(HostInternal, adoptRules) { }
273     StyleRuleHost(const StyleRuleHost& o) : StyleRuleGroup(o) { }
274 };
275 #endif
276
277 #if ENABLE(CSS_DEVICE_ADAPTATION)
278 class StyleRuleViewport : public StyleRuleBase {
279 public:
280     static PassRefPtr<StyleRuleViewport> create() { return adoptRef(new StyleRuleViewport); }
281
282     ~StyleRuleViewport();
283
284     const StylePropertySet* properties() const { return m_properties.get(); }
285     MutableStylePropertySet* mutableProperties();
286
287     void setProperties(PassRefPtr<StylePropertySet>);
288
289     PassRefPtr<StyleRuleViewport> copy() const { return adoptRef(new StyleRuleViewport(*this)); }
290
291 private:
292     StyleRuleViewport();
293     StyleRuleViewport(const StyleRuleViewport&);
294
295     RefPtr<StylePropertySet> m_properties;
296 };
297 #endif // ENABLE(CSS_DEVICE_ADAPTATION)
298
299 inline const StyleRuleMedia* toStyleRuleMedia(const StyleRuleGroup* rule)
300 {
301     ASSERT_WITH_SECURITY_IMPLICATION(!rule || rule->isMediaRule());
302     return static_cast<const StyleRuleMedia*>(rule);
303 }
304
305 #if ENABLE(CSS3_CONDITIONAL_RULES)
306 inline const StyleRuleSupports* toStyleRuleSupports(const StyleRuleGroup* rule)
307 {
308     ASSERT_WITH_SECURITY_IMPLICATION(!rule || rule->isSupportsRule());
309     return static_cast<const StyleRuleSupports*>(rule);
310 }
311 #endif
312
313 inline const StyleRuleRegion* toStyleRuleRegion(const StyleRuleGroup* rule)
314 {
315     ASSERT_WITH_SECURITY_IMPLICATION(!rule || rule->isRegionRule());
316     return static_cast<const StyleRuleRegion*>(rule);
317 }
318
319 #if ENABLE(CSS_SHADERS)
320 class StyleRuleFilter : public StyleRuleBase {
321 public:
322     static PassRefPtr<StyleRuleFilter> create(const String& filterName) { return adoptRef(new StyleRuleFilter(filterName)); }
323
324     ~StyleRuleFilter();
325
326     const String& filterName() const { return m_filterName; }
327
328     const StylePropertySet* properties() const { return m_properties.get(); }
329     MutableStylePropertySet* mutableProperties();
330
331     void setProperties(PassRefPtr<StylePropertySet>);
332
333     PassRefPtr<StyleRuleFilter> copy() const { return adoptRef(new StyleRuleFilter(*this)); }
334
335 private:
336     StyleRuleFilter(const String&);
337     StyleRuleFilter(const StyleRuleFilter&);
338
339     String m_filterName;
340     RefPtr<StylePropertySet> m_properties;
341 };
342 #endif // ENABLE(CSS_SHADERS)
343
344 } // namespace WebCore
345
346 #endif // StyleRule_h