Web Inspector: NMI: migrate core instrumentation code to WTF namespace
[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 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 StylePropertySet;
35
36 class StyleRuleBase : public WTF::RefCountedBase {
37 public:
38     enum Type {
39         Unknown, // Not used.
40         Style,
41         Charset, // Not used. These are internally strings owned by the style sheet.
42         Import,
43         Media,
44         FontFace,
45         Page,
46         Keyframes,
47         Keyframe, // Not used. These are internally non-rule StyleKeyframe objects.
48         Region = 16
49     };
50     Type type() const { return static_cast<Type>(m_type); }
51     
52     bool isCharsetRule() const { return type() == Charset; }
53     bool isFontFaceRule() const { return type() == FontFace; }
54     bool isKeyframesRule() const { return type() == Keyframes; }
55     bool isMediaRule() const { return type() == Media; }
56     bool isPageRule() const { return type() == Page; }
57     bool isStyleRule() const { return type() == Style; }
58     bool isRegionRule() const { return type() == Region; }
59     bool isImportRule() const { return type() == Import; }
60
61     PassRefPtr<StyleRuleBase> copy() const;
62
63     int sourceLine() const { return m_sourceLine; }
64
65     void deref()
66     {
67         if (derefBase())
68             destroy();
69     }
70
71     // FIXME: There shouldn't be any need for the null parent version.
72     PassRefPtr<CSSRule> createCSSOMWrapper(CSSStyleSheet* parentSheet = 0) const;
73     PassRefPtr<CSSRule> createCSSOMWrapper(CSSRule* parentRule) const;
74
75     void reportMemoryUsage(MemoryObjectInfo*) const;
76
77 protected:
78     StyleRuleBase(Type type, signed sourceLine = 0) : m_type(type), m_sourceLine(sourceLine) { }
79     StyleRuleBase(const StyleRuleBase& o) : WTF::RefCountedBase(), m_type(o.m_type), m_sourceLine(o.m_sourceLine) { }
80
81     ~StyleRuleBase() { }
82
83 private:
84     void destroy();
85     
86     PassRefPtr<CSSRule> createCSSOMWrapper(CSSStyleSheet* parentSheet, CSSRule* parentRule) const;
87
88     unsigned m_type : 5;
89     signed m_sourceLine : 27;
90 };
91
92 class StyleRule : public StyleRuleBase {
93 public:
94     static PassRefPtr<StyleRule> create(int sourceLine) { return adoptRef(new StyleRule(sourceLine)); }
95     
96     ~StyleRule();
97
98     const CSSSelectorList& selectorList() const { return m_selectorList; }
99     const StylePropertySet* properties() const { return m_properties.get(); }
100     StylePropertySet* mutableProperties();
101     
102     void parserAdoptSelectorVector(CSSSelectorVector& selectors) { m_selectorList.adoptSelectorVector(selectors); }
103     void wrapperAdoptSelectorList(CSSSelectorList& selectors) { m_selectorList.adopt(selectors); }
104     void setProperties(PassRefPtr<StylePropertySet>);
105
106     PassRefPtr<StyleRule> copy() const { return adoptRef(new StyleRule(*this)); }
107
108     static unsigned averageSizeInBytes();
109     void reportDescendantMemoryUsage(MemoryObjectInfo*) const;
110
111 private:
112     StyleRule(int sourceLine);
113     StyleRule(const StyleRule&);
114
115     RefPtr<StylePropertySet> m_properties;
116     CSSSelectorList m_selectorList;
117 };
118
119 class StyleRuleFontFace : public StyleRuleBase {
120 public:
121     static PassRefPtr<StyleRuleFontFace> create() { return adoptRef(new StyleRuleFontFace); }
122     
123     ~StyleRuleFontFace();
124
125     const StylePropertySet* properties() const { return m_properties.get(); }
126     StylePropertySet* mutableProperties();
127
128     void setProperties(PassRefPtr<StylePropertySet>);
129
130     PassRefPtr<StyleRuleFontFace> copy() const { return adoptRef(new StyleRuleFontFace(*this)); }
131
132     void reportDescendantMemoryUsage(MemoryObjectInfo*) const;
133
134 private:
135     StyleRuleFontFace();
136     StyleRuleFontFace(const StyleRuleFontFace&);
137
138     RefPtr<StylePropertySet> m_properties;
139 };
140
141 class StyleRulePage : public StyleRuleBase {
142 public:
143     static PassRefPtr<StyleRulePage> create() { return adoptRef(new StyleRulePage); }
144
145     ~StyleRulePage();
146
147     const CSSSelector* selector() const { return m_selectorList.first(); }    
148     const StylePropertySet* properties() const { return m_properties.get(); }
149     StylePropertySet* mutableProperties();
150
151     void parserAdoptSelectorVector(CSSSelectorVector& selectors) { m_selectorList.adoptSelectorVector(selectors); }
152     void wrapperAdoptSelectorList(CSSSelectorList& selectors) { m_selectorList.adopt(selectors); }
153     void setProperties(PassRefPtr<StylePropertySet>);
154
155     PassRefPtr<StyleRulePage> copy() const { return adoptRef(new StyleRulePage(*this)); }
156
157     void reportDescendantMemoryUsage(MemoryObjectInfo*) const;
158
159 private:
160     StyleRulePage();
161     StyleRulePage(const StyleRulePage&);
162     
163     RefPtr<StylePropertySet> m_properties;
164     CSSSelectorList m_selectorList;
165 };
166
167 class StyleRuleBlock : public StyleRuleBase {
168 public:
169     const Vector<RefPtr<StyleRuleBase> >& childRules() const { return m_childRules; }
170     
171     void wrapperInsertRule(unsigned, PassRefPtr<StyleRuleBase>);
172     void wrapperRemoveRule(unsigned);
173
174     void reportDescendantMemoryUsage(MemoryObjectInfo*) const;
175     
176 protected:
177     StyleRuleBlock(Type, Vector<RefPtr<StyleRuleBase> >& adoptRule);
178     StyleRuleBlock(const StyleRuleBlock&);
179     
180 private:
181     Vector<RefPtr<StyleRuleBase> > m_childRules;
182 };
183
184 class StyleRuleMedia : public StyleRuleBlock {
185 public:
186     static PassRefPtr<StyleRuleMedia> create(PassRefPtr<MediaQuerySet> media, Vector<RefPtr<StyleRuleBase> >& adoptRules)
187     {
188         return adoptRef(new StyleRuleMedia(media, adoptRules));
189     }
190
191     MediaQuerySet* mediaQueries() const { return m_mediaQueries.get(); }
192
193     PassRefPtr<StyleRuleMedia> copy() const { return adoptRef(new StyleRuleMedia(*this)); }
194
195     void reportDescendantMemoryUsage(MemoryObjectInfo*) const;
196
197 private:
198     StyleRuleMedia(PassRefPtr<MediaQuerySet>, Vector<RefPtr<StyleRuleBase> >& adoptRules);
199     StyleRuleMedia(const StyleRuleMedia&);
200
201     RefPtr<MediaQuerySet> m_mediaQueries;
202 };
203
204 class StyleRuleRegion : public StyleRuleBlock {
205 public:
206     static PassRefPtr<StyleRuleRegion> create(CSSSelectorVector* selectors, Vector<RefPtr<StyleRuleBase> >& adoptRules)
207     {
208         return adoptRef(new StyleRuleRegion(selectors, adoptRules));
209     }
210
211     const CSSSelectorList& selectorList() const { return m_selectorList; }
212
213     PassRefPtr<StyleRuleRegion> copy() const { return adoptRef(new StyleRuleRegion(*this)); }
214
215     void reportDescendantMemoryUsage(MemoryObjectInfo*) const;
216
217 private:
218     StyleRuleRegion(CSSSelectorVector*, Vector<RefPtr<StyleRuleBase> >& adoptRules);
219     StyleRuleRegion(const StyleRuleRegion&);
220     
221     CSSSelectorList m_selectorList;
222 };
223
224 } // namespace WebCore
225
226 #endif // StyleRule_h