Unreviewed, rolling out r156253.
[WebKit-https.git] / Source / WebCore / css / CSSValue.h
1 /*
2  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2004, 2005, 2006, 2007, 2008 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 #ifndef CSSValue_h
22 #define CSSValue_h
23
24 #include "ExceptionCode.h"
25 #include "KURLHash.h"
26 #include <wtf/ListHashSet.h>
27 #include <wtf/RefCounted.h>
28 #include <wtf/RefPtr.h>
29
30 namespace WebCore {
31
32 class StyleSheetContents;
33     
34 // FIXME: The current CSSValue and subclasses should be turned into internal types (StyleValue).
35 // The few subtypes that are actually exposed in CSSOM can be seen in the cloneForCSSOM() function.
36 // They should be handled by separate wrapper classes.
37
38 // Please don't expose more CSSValue types to the web.
39 class CSSValue : public RefCounted<CSSValue> {
40 public:
41     enum Type {
42         CSS_INHERIT = 0,
43         CSS_PRIMITIVE_VALUE = 1,
44         CSS_VALUE_LIST = 2,
45         CSS_CUSTOM = 3,
46         CSS_INITIAL = 4
47
48     };
49
50     // Override RefCounted's deref() to ensure operator delete is called on
51     // the appropriate subclass type.
52     void deref()
53     {
54         if (derefBase())
55             destroy();
56     }
57
58     Type cssValueType() const;
59
60     String cssText() const;
61     void setCssText(const String&, ExceptionCode&) { } // FIXME: Not implemented.
62 #if ENABLE(CSS_VARIABLES)
63     String serializeResolvingVariables(const HashMap<AtomicString, String>&) const;
64 #endif
65
66     bool isPrimitiveValue() const { return m_classType == PrimitiveClass; }
67     bool isValueList() const { return m_classType >= ValueListClass; }
68     
69     bool isBaseValueList() const { return m_classType == ValueListClass; }
70         
71
72     bool isAspectRatioValue() const { return m_classType == AspectRatioClass; }
73     bool isBorderImageSliceValue() const { return m_classType == BorderImageSliceClass; }
74     bool isCrossfadeValue() const { return m_classType == CrossfadeClass; }
75     bool isCursorImageValue() const { return m_classType == CursorImageClass; }
76     bool isFontFeatureValue() const { return m_classType == FontFeatureClass; }
77     bool isFontValue() const { return m_classType == FontClass; }
78     bool isImageGeneratorValue() const { return m_classType >= CanvasClass && m_classType <= RadialGradientClass; }
79     bool isGradientValue() const { return m_classType >= LinearGradientClass && m_classType <= RadialGradientClass; }
80 #if ENABLE(CSS_IMAGE_SET)
81     bool isImageSetValue() const { return m_classType == ImageSetClass; }
82 #endif
83     bool isImageValue() const { return m_classType == ImageClass; }
84     bool isImplicitInitialValue() const;
85     bool isInheritedValue() const { return m_classType == InheritedClass; }
86     bool isInitialValue() const { return m_classType == InitialClass; }
87     bool isReflectValue() const { return m_classType == ReflectClass; }
88     bool isShadowValue() const { return m_classType == ShadowClass; }
89     bool isCubicBezierTimingFunctionValue() const { return m_classType == CubicBezierTimingFunctionClass; }
90     bool isStepsTimingFunctionValue() const { return m_classType == StepsTimingFunctionClass; }
91     bool isWebKitCSSTransformValue() const { return m_classType == WebKitCSSTransformClass; }
92     bool isCSSLineBoxContainValue() const { return m_classType == LineBoxContainClass; }
93     bool isCalculationValue() const {return m_classType == CalculationClass; }
94 #if ENABLE(CSS_FILTERS)
95     bool isFilterImageValue() const { return m_classType == FilterImageClass; }
96     bool isWebKitCSSFilterValue() const { return m_classType == WebKitCSSFilterClass; }
97 #if ENABLE(CSS_SHADERS)
98     bool isWebKitCSSArrayFunctionValue() const { return m_classType == WebKitCSSArrayFunctionValueClass; }
99     bool isWebKitCSSMatFunctionValue() const { return m_classType == WebKitCSSMatFunctionValueClass; }
100     bool isWebKitCSSMixFunctionValue() const { return m_classType == WebKitCSSMixFunctionValueClass; }
101     bool isWebKitCSSShaderValue() const { return m_classType == WebKitCSSShaderClass; }
102 #endif
103 #endif // ENABLE(CSS_FILTERS)
104 #if ENABLE(CSS_VARIABLES)
105     bool isVariableValue() const { return m_classType == VariableClass; }
106 #endif
107 #if ENABLE(SVG)
108     bool isSVGColor() const { return m_classType == SVGColorClass || m_classType == SVGPaintClass; }
109     bool isSVGPaint() const { return m_classType == SVGPaintClass; }
110     bool isWebKitCSSSVGDocumentValue() const { return m_classType == WebKitCSSSVGDocumentClass; }
111 #endif
112     
113     bool isCSSOMSafe() const { return m_isCSSOMSafe; }
114     bool isSubtypeExposedToCSSOM() const
115     { 
116         return isPrimitiveValue() 
117 #if ENABLE(SVG)
118             || isSVGColor()
119 #endif
120             || isValueList();
121     }
122
123     PassRefPtr<CSSValue> cloneForCSSOM() const;
124
125     void addSubresourceStyleURLs(ListHashSet<KURL>&, const StyleSheetContents*) const;
126
127     bool hasFailedOrCanceledSubresources() const;
128
129     bool equals(const CSSValue&) const;
130
131 protected:
132
133     static const size_t ClassTypeBits = 6;
134     enum ClassType {
135         PrimitiveClass,
136
137         // Image classes.
138         ImageClass,
139         CursorImageClass,
140
141         // Image generator classes.
142         CanvasClass,
143         CrossfadeClass,
144 #if ENABLE(CSS_FILTERS)
145         FilterImageClass,
146 #endif
147         LinearGradientClass,
148         RadialGradientClass,
149
150         // Timing function classes.
151         CubicBezierTimingFunctionClass,
152         StepsTimingFunctionClass,
153
154         // Other class types.
155         AspectRatioClass,
156         BorderImageSliceClass,
157         FontFeatureClass,
158         FontClass,
159         FontFaceSrcClass,
160         FunctionClass,
161
162         InheritedClass,
163         InitialClass,
164
165         ReflectClass,
166         ShadowClass,
167         UnicodeRangeClass,
168         LineBoxContainClass,
169         CalculationClass,
170 #if ENABLE(CSS_FILTERS) && ENABLE(CSS_SHADERS)
171         WebKitCSSShaderClass,
172 #endif
173 #if ENABLE(CSS_VARIABLES)
174         VariableClass,
175 #endif
176 #if ENABLE(SVG)
177         SVGColorClass,
178         SVGPaintClass,
179         WebKitCSSSVGDocumentClass,
180 #endif
181
182         // List class types must appear after ValueListClass.
183         ValueListClass,
184 #if ENABLE(CSS_IMAGE_SET)
185         ImageSetClass,
186 #endif
187 #if ENABLE(CSS_FILTERS)
188         WebKitCSSFilterClass,
189 #if ENABLE(CSS_SHADERS)
190         WebKitCSSArrayFunctionValueClass,
191         WebKitCSSMatFunctionValueClass,
192         WebKitCSSMixFunctionValueClass,
193 #endif
194 #endif
195         WebKitCSSTransformClass,
196         // Do not append non-list class types here.
197     };
198
199     static const size_t ValueListSeparatorBits = 2;
200     enum ValueListSeparator {
201         SpaceSeparator,
202         CommaSeparator,
203         SlashSeparator
204     };
205
206     ClassType classType() const { return static_cast<ClassType>(m_classType); }
207
208     explicit CSSValue(ClassType classType, bool isCSSOMSafe = false)
209         : m_isCSSOMSafe(isCSSOMSafe)
210         , m_isTextClone(false)
211         , m_primitiveUnitType(0)
212         , m_hasCachedCSSText(false)
213         , m_isQuirkValue(false)
214         , m_valueListSeparator(SpaceSeparator)
215         , m_classType(classType)
216     {
217     }
218
219     // NOTE: This class is non-virtual for memory and performance reasons.
220     // Don't go making it virtual again unless you know exactly what you're doing!
221
222     ~CSSValue() { }
223
224 private:
225     void destroy();
226
227 protected:
228     unsigned m_isCSSOMSafe : 1;
229     unsigned m_isTextClone : 1;
230     // The bits in this section are only used by specific subclasses but kept here
231     // to maximize struct packing.
232
233     // CSSPrimitiveValue bits:
234     unsigned m_primitiveUnitType : 7; // CSSPrimitiveValue::UnitTypes
235     mutable unsigned m_hasCachedCSSText : 1;
236     unsigned m_isQuirkValue : 1;
237
238     unsigned m_valueListSeparator : ValueListSeparatorBits;
239
240 private:
241     unsigned m_classType : ClassTypeBits; // ClassType
242 };
243
244 template<typename CSSValueType>
245 inline bool compareCSSValueVector(const Vector<RefPtr<CSSValueType> >& firstVector, const Vector<RefPtr<CSSValueType> >& secondVector)
246 {
247     size_t size = firstVector.size();
248     if (size != secondVector.size())
249         return false;
250
251     for (size_t i = 0; i < size; i++) {
252         const RefPtr<CSSValueType>& firstPtr = firstVector[i];
253         const RefPtr<CSSValueType>& secondPtr = secondVector[i];
254         if (firstPtr == secondPtr || (firstPtr && secondPtr && firstPtr->equals(*secondPtr)))
255             continue;
256         return false;
257     }
258     return true;
259 }
260
261 template<typename CSSValueType>
262 inline bool compareCSSValuePtr(const RefPtr<CSSValueType>& first, const RefPtr<CSSValueType>& second)
263 {
264     return first ? second && first->equals(*second) : !second;
265 }
266
267 } // namespace WebCore
268
269 #endif // CSSValue_h