Source/WebCore:
[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 "StyleProperties.h"
28 #include <wtf/BumpArena.h>
29 #include <wtf/RefPtr.h>
30 #include <wtf/TypeCasts.h>
31
32 namespace WebCore {
33
34 class CSSRule;
35 class CSSStyleRule;
36 class CSSStyleSheet;
37 class MutableStyleProperties;
38 class StyleProperties;
39
40 class StyleRuleBase : public WTF::RefCountedBase {
41     WTF_MAKE_BUMPARENA_ALLOCATED;
42 public:
43     enum Type {
44         Unknown, // Not used.
45         Style,
46         Charset, // Not used. These are internally strings owned by the style sheet.
47         Import,
48         Media,
49         FontFace,
50         Page,
51         Keyframes,
52         Keyframe, // Not used. These are internally non-rule StyleKeyframe objects.
53         Supports = 12,
54 #if ENABLE(CSS_DEVICE_ADAPTATION)
55         Viewport = 15,
56 #endif
57         Region = 16,
58     };
59
60     Type type() const { return static_cast<Type>(m_type); }
61     
62     bool isCharsetRule() const { return type() == Charset; }
63     bool isFontFaceRule() const { return type() == FontFace; }
64     bool isKeyframesRule() const { return type() == Keyframes; }
65     bool isMediaRule() const { return type() == Media; }
66     bool isPageRule() const { return type() == Page; }
67     bool isStyleRule() const { return type() == Style; }
68     bool isRegionRule() const { return type() == Region; }
69     bool isSupportsRule() const { return type() == Supports; }
70 #if ENABLE(CSS_DEVICE_ADAPTATION)
71     bool isViewportRule() const { return type() == Viewport; }
72 #endif
73     bool isImportRule() const { return type() == Import; }
74
75     Ref<StyleRuleBase> copy() const;
76
77     int sourceLine() const { return m_sourceLine; }
78
79     void deref()
80     {
81         if (derefBase())
82             destroy();
83     }
84
85     // FIXME: There shouldn't be any need for the null parent version.
86     PassRefPtr<CSSRule> createCSSOMWrapper(CSSStyleSheet* parentSheet = 0) const;
87     PassRefPtr<CSSRule> createCSSOMWrapper(CSSRule* parentRule) const;
88
89 protected:
90     StyleRuleBase(Type type, signed sourceLine = 0) : m_type(type), m_sourceLine(sourceLine) { }
91     StyleRuleBase(const StyleRuleBase& o) : WTF::RefCountedBase(), m_type(o.m_type), m_sourceLine(o.m_sourceLine) { }
92
93     ~StyleRuleBase() { }
94
95 private:
96     void destroy();
97     
98     PassRefPtr<CSSRule> createCSSOMWrapper(CSSStyleSheet* parentSheet, CSSRule* parentRule) const;
99
100     unsigned m_type : 5;
101     signed m_sourceLine : 27;
102 };
103
104 class StyleRule : public StyleRuleBase {
105 public:
106     static Ref<StyleRule> create(BumpArena* arena, int sourceLine, Ref<StyleProperties>&& properties)
107     {
108         return adoptRef(*new (arena) StyleRule(sourceLine, WTFMove(properties)));
109     }
110     
111     ~StyleRule();
112
113     const CSSSelectorList& selectorList() const { return m_selectorList; }
114     const StyleProperties& properties() const { return m_properties; }
115     MutableStyleProperties& mutableProperties();
116     
117     void parserAdoptSelectorVector(BumpArena* arena, Vector<std::unique_ptr<CSSParserSelector>>& selectors) { m_selectorList.adoptSelectorVector(arena, selectors); }
118     void wrapperAdoptSelectorList(CSSSelectorList& selectors) { m_selectorList = WTFMove(selectors); }
119     void parserAdoptSelectorArray(CSSSelector* selectors) { m_selectorList.adoptSelectorArray(selectors); }
120
121     Ref<StyleRule> copy() const { return adoptRef(*new StyleRule(*this)); }
122
123     Vector<RefPtr<StyleRule>> splitIntoMultipleRulesWithMaximumSelectorComponentCount(unsigned) const;
124
125     static unsigned averageSizeInBytes();
126
127 private:
128     StyleRule(int sourceLine, Ref<StyleProperties>&&);
129     StyleRule(const StyleRule&);
130
131     static Ref<StyleRule> create(BumpArena*, int sourceLine, const Vector<const CSSSelector*>&, Ref<StyleProperties>&&);
132
133     Ref<StyleProperties> m_properties;
134     CSSSelectorList m_selectorList;
135 };
136
137 class StyleRuleFontFace : public StyleRuleBase {
138 public:
139     static Ref<StyleRuleFontFace> create(BumpArena* arena, Ref<StyleProperties>&& properties) { return adoptRef(*new (arena) StyleRuleFontFace(WTFMove(properties))); }
140     
141     ~StyleRuleFontFace();
142
143     const StyleProperties& properties() const { return m_properties; }
144     MutableStyleProperties& mutableProperties();
145
146     Ref<StyleRuleFontFace> copy() const { return adoptRef(*new StyleRuleFontFace(*this)); }
147
148
149 private:
150     explicit StyleRuleFontFace(Ref<StyleProperties>&&);
151     StyleRuleFontFace(const StyleRuleFontFace&);
152
153     Ref<StyleProperties> m_properties;
154 };
155
156 class StyleRulePage : public StyleRuleBase {
157 public:
158     static Ref<StyleRulePage> create(BumpArena* arena, Ref<StyleProperties>&& properties) { return adoptRef(*new (arena) StyleRulePage(WTFMove(properties))); }
159
160     ~StyleRulePage();
161
162     const CSSSelector* selector() const { return m_selectorList.first(); }    
163     const StyleProperties& properties() const { return m_properties; }
164     MutableStyleProperties& mutableProperties();
165
166     void parserAdoptSelectorVector(BumpArena* arena, Vector<std::unique_ptr<CSSParserSelector>>& selectors) { m_selectorList.adoptSelectorVector(arena, selectors); }
167     void wrapperAdoptSelectorList(CSSSelectorList& selectors) { m_selectorList = WTFMove(selectors); }
168
169     Ref<StyleRulePage> copy() const { return adoptRef(*new StyleRulePage(*this)); }
170
171 private:
172     explicit StyleRulePage(Ref<StyleProperties>&&);
173     StyleRulePage(const StyleRulePage&);
174     
175     Ref<StyleProperties> m_properties;
176     CSSSelectorList m_selectorList;
177 };
178
179 class StyleRuleGroup : public StyleRuleBase {
180 public:
181     const Vector<RefPtr<StyleRuleBase>>& childRules() const { return m_childRules; }
182     
183     void wrapperInsertRule(unsigned, Ref<StyleRuleBase>&&);
184     void wrapperRemoveRule(unsigned);
185     
186 protected:
187     StyleRuleGroup(Type, Vector<RefPtr<StyleRuleBase>>& adoptRule);
188     StyleRuleGroup(const StyleRuleGroup&);
189     
190 private:
191     Vector<RefPtr<StyleRuleBase>> m_childRules;
192 };
193
194 class StyleRuleMedia : public StyleRuleGroup {
195 public:
196     static Ref<StyleRuleMedia> create(BumpArena* arena, PassRefPtr<MediaQuerySet> media, Vector<RefPtr<StyleRuleBase>>& adoptRules)
197     {
198         return adoptRef(*new (arena) StyleRuleMedia(media, adoptRules));
199     }
200
201     MediaQuerySet* mediaQueries() const { return m_mediaQueries.get(); }
202
203     Ref<StyleRuleMedia> copy() const { return adoptRef(*new StyleRuleMedia(*this)); }
204
205 private:
206     StyleRuleMedia(PassRefPtr<MediaQuerySet>, Vector<RefPtr<StyleRuleBase>>& adoptRules);
207     StyleRuleMedia(const StyleRuleMedia&);
208
209     RefPtr<MediaQuerySet> m_mediaQueries;
210 };
211
212 class StyleRuleSupports : public StyleRuleGroup {
213 public:
214     static Ref<StyleRuleSupports> create(BumpArena* arena, const String& conditionText, bool conditionIsSupported, Vector<RefPtr<StyleRuleBase>>& adoptRules)
215     {
216         return adoptRef(*new (arena) StyleRuleSupports(conditionText, conditionIsSupported, adoptRules));
217     }
218
219     String conditionText() const { return m_conditionText; }
220     bool conditionIsSupported() const { return m_conditionIsSupported; }
221     Ref<StyleRuleSupports> copy() const { return adoptRef(*new StyleRuleSupports(*this)); }
222
223 private:
224     StyleRuleSupports(const String& conditionText, bool conditionIsSupported, Vector<RefPtr<StyleRuleBase>>& adoptRules);
225     StyleRuleSupports(const StyleRuleSupports&);
226
227     String m_conditionText;
228     bool m_conditionIsSupported;
229 };
230
231 class StyleRuleRegion : public StyleRuleGroup {
232 public:
233     static Ref<StyleRuleRegion> create(BumpArena* arena, Vector<std::unique_ptr<CSSParserSelector>>* selectors, Vector<RefPtr<StyleRuleBase>>& adoptRules)
234     {
235         return adoptRef(*new (arena) StyleRuleRegion(selectors, adoptRules));
236     }
237
238     const CSSSelectorList& selectorList() const { return m_selectorList; }
239
240     Ref<StyleRuleRegion> copy() const { return adoptRef(*new StyleRuleRegion(*this)); }
241
242 private:
243     StyleRuleRegion(Vector<std::unique_ptr<CSSParserSelector>>*, Vector<RefPtr<StyleRuleBase>>& adoptRules);
244     StyleRuleRegion(const StyleRuleRegion&);
245     
246     CSSSelectorList m_selectorList;
247 };
248
249 #if ENABLE(CSS_DEVICE_ADAPTATION)
250 class StyleRuleViewport : public StyleRuleBase {
251 public:
252     static Ref<StyleRuleViewport> create(BumpArena* arena, Ref<StyleProperties>&& properties) { return adoptRef(*new (arena) StyleRuleViewport(WTFMove(properties))); }
253
254     ~StyleRuleViewport();
255
256     const StyleProperties& properties() const { return m_properties.get(); }
257     MutableStyleProperties& mutableProperties();
258
259     Ref<StyleRuleViewport> copy() const { return adoptRef(*new StyleRuleViewport(*this)); }
260
261 private:
262     explicit StyleRuleViewport(Ref<StyleProperties>&&);
263     StyleRuleViewport(const StyleRuleViewport&);
264
265     Ref<StyleProperties> m_properties;
266 };
267 #endif // ENABLE(CSS_DEVICE_ADAPTATION)
268
269 } // namespace WebCore
270
271 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRule)
272     static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isStyleRule(); }
273 SPECIALIZE_TYPE_TRAITS_END()
274
275 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleFontFace)
276     static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isFontFaceRule(); }
277 SPECIALIZE_TYPE_TRAITS_END()
278
279 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleMedia)
280     static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isMediaRule(); }
281 SPECIALIZE_TYPE_TRAITS_END()
282
283 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRulePage)
284     static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isPageRule(); }
285 SPECIALIZE_TYPE_TRAITS_END()
286
287 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleSupports)
288     static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isSupportsRule(); }
289 SPECIALIZE_TYPE_TRAITS_END()
290
291 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleRegion)
292     static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isRegionRule(); }
293 SPECIALIZE_TYPE_TRAITS_END()
294
295 #if ENABLE(CSS_DEVICE_ADAPTATION)
296 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::StyleRuleViewport)
297     static bool isType(const WebCore::StyleRuleBase& rule) { return rule.isViewportRule(); }
298 SPECIALIZE_TYPE_TRAITS_END()
299 #endif // ENABLE(CSS_DEVICE_ADAPTATION)
300
301 #endif // StyleRule_h