Add support for the frames() timing function
[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 #pragma once
22
23 #include "URLHash.h"
24 #include <wtf/Function.h>
25 #include <wtf/HashMap.h>
26 #include <wtf/RefCounted.h>
27 #include <wtf/RefPtr.h>
28 #include <wtf/TypeCasts.h>
29
30 namespace WebCore {
31
32 class CSSCustomPropertyValue;
33 class CSSStyleDeclaration;
34 class CachedResource;
35 class DeprecatedCSSOMValue;
36 class StyleSheetContents;
37
38 enum CSSPropertyID : uint16_t;
39
40 class CSSValue : public RefCounted<CSSValue> {
41 public:
42     enum Type {
43         CSS_INHERIT = 0,
44         CSS_PRIMITIVE_VALUE = 1,
45         CSS_VALUE_LIST = 2,
46         CSS_CUSTOM = 3,
47         CSS_INITIAL = 4,
48         CSS_UNSET = 5,
49         CSS_REVERT = 6
50     };
51
52     // Override RefCounted's deref() to ensure operator delete is called on
53     // the appropriate subclass type.
54     void deref()
55     {
56         if (derefBase())
57             destroy();
58     }
59
60     Type cssValueType() const;
61     String cssText() const;
62
63     bool isPrimitiveValue() const { return m_classType == PrimitiveClass; }
64     bool isValueList() const { return m_classType >= ValueListClass; }
65     
66     bool isBaseValueList() const { return m_classType == ValueListClass; }
67         
68
69     bool isAspectRatioValue() const { return m_classType == AspectRatioClass; }
70     bool isBorderImageSliceValue() const { return m_classType == BorderImageSliceClass; }
71     bool isCanvasValue() const { return m_classType == CanvasClass; }
72     bool isCrossfadeValue() const { return m_classType == CrossfadeClass; }
73     bool isCursorImageValue() const { return m_classType == CursorImageClass; }
74     bool isCustomPropertyValue() const { return m_classType == CustomPropertyClass; }
75     bool isFunctionValue() const { return m_classType == FunctionClass; }
76     bool isFontFeatureValue() const { return m_classType == FontFeatureClass; }
77 #if ENABLE(VARIATION_FONTS)
78     bool isFontVariationValue() const { return m_classType == FontVariationClass; }
79 #endif
80     bool isFontFaceSrcValue() const { return m_classType == FontFaceSrcClass; }
81     bool isFontValue() const { return m_classType == FontClass; }
82     bool isFontStyleValue() const { return m_classType == FontStyleClass; }
83     bool isFontStyleRangeValue() const { return m_classType == FontStyleRangeClass; }
84     bool isImageGeneratorValue() const { return m_classType >= CanvasClass && m_classType <= ConicGradientClass; }
85     bool isGradientValue() const { return m_classType >= LinearGradientClass && m_classType <= ConicGradientClass; }
86     bool isNamedImageValue() const { return m_classType == NamedImageClass; }
87     bool isImageSetValue() const { return m_classType == ImageSetClass; }
88     bool isImageValue() const { return m_classType == ImageClass; }
89     bool isImplicitInitialValue() const;
90     bool isInheritedValue() const { return m_classType == InheritedClass; }
91     bool isInitialValue() const { return m_classType == InitialClass; }
92     bool isUnsetValue() const { return m_classType == UnsetClass; }
93     bool isRevertValue() const { return m_classType == RevertClass; }
94     bool isGlobalKeyword() const { return isInheritedValue() || isInitialValue() || isUnsetValue() || isRevertValue(); }
95     bool treatAsInitialValue(CSSPropertyID) const;
96     bool treatAsInheritedValue(CSSPropertyID) const;
97     bool isLinearGradientValue() const { return m_classType == LinearGradientClass; }
98     bool isRadialGradientValue() const { return m_classType == RadialGradientClass; }
99     bool isConicGradientValue() const { return m_classType == ConicGradientClass; }
100     bool isReflectValue() const { return m_classType == ReflectClass; }
101     bool isShadowValue() const { return m_classType == ShadowClass; }
102     bool isCubicBezierTimingFunctionValue() const { return m_classType == CubicBezierTimingFunctionClass; }
103     bool isStepsTimingFunctionValue() const { return m_classType == StepsTimingFunctionClass; }
104     bool isFramesTimingFunctionValue() const { return m_classType == FramesTimingFunctionClass; }
105     bool isSpringTimingFunctionValue() const { return m_classType == SpringTimingFunctionClass; }
106     bool isLineBoxContainValue() const { return m_classType == LineBoxContainClass; }
107     bool isCalcValue() const {return m_classType == CalculationClass; }
108     bool isFilterImageValue() const { return m_classType == FilterImageClass; }
109     bool isContentDistributionValue() const { return m_classType == CSSContentDistributionClass; }
110     bool isGridAutoRepeatValue() const { return m_classType == GridAutoRepeatClass; }
111     bool isGridTemplateAreasValue() const { return m_classType == GridTemplateAreasClass; }
112     bool isGridLineNamesValue() const { return m_classType == GridLineNamesClass; }
113     bool isUnicodeRangeValue() const { return m_classType == UnicodeRangeClass; }
114
115 #if ENABLE(CSS_ANIMATIONS_LEVEL_2)
116     bool isAnimationTriggerScrollValue() const { return m_classType == AnimationTriggerScrollClass; }
117 #endif
118
119     bool isCustomIdentValue() const { return m_classType == CustomIdentClass; }
120     bool isVariableReferenceValue() const { return m_classType == VariableReferenceClass; }
121     bool isPendingSubstitutionValue() const { return m_classType == PendingSubstitutionValueClass; }
122     
123     bool hasVariableReferences() const { return isVariableReferenceValue() || isPendingSubstitutionValue(); }
124
125     Ref<DeprecatedCSSOMValue> createDeprecatedCSSOMWrapper(CSSStyleDeclaration&) const;
126
127     bool traverseSubresources(const WTF::Function<bool (const CachedResource&)>& handler) const;
128
129     bool equals(const CSSValue&) const;
130     bool operator==(const CSSValue& other) const { return equals(other); }
131
132 protected:
133
134     static const size_t ClassTypeBits = 6;
135     enum ClassType {
136         PrimitiveClass,
137
138         // Image classes.
139         ImageClass,
140         CursorImageClass,
141
142         // Image generator classes.
143         CanvasClass,
144         NamedImageClass,
145         CrossfadeClass,
146         FilterImageClass,
147         LinearGradientClass,
148         RadialGradientClass,
149         ConicGradientClass,
150
151         // Timing function classes.
152         CubicBezierTimingFunctionClass,
153         StepsTimingFunctionClass,
154         FramesTimingFunctionClass,
155         SpringTimingFunctionClass,
156
157         // Other class types.
158         AspectRatioClass,
159         BorderImageSliceClass,
160         FontFeatureClass,
161 #if ENABLE(VARIATION_FONTS)
162         FontVariationClass,
163 #endif
164         FontClass,
165         FontStyleClass,
166         FontStyleRangeClass,
167         FontFaceSrcClass,
168         FunctionClass,
169
170         InheritedClass,
171         InitialClass,
172         UnsetClass,
173         RevertClass,
174
175         ReflectClass,
176         ShadowClass,
177         UnicodeRangeClass,
178         LineBoxContainClass,
179         CalculationClass,
180         GridTemplateAreasClass,
181 #if ENABLE(CSS_ANIMATIONS_LEVEL_2)
182         AnimationTriggerScrollClass,
183 #endif
184
185         CSSContentDistributionClass,
186         
187         CustomIdentClass,
188
189         CustomPropertyClass,
190         VariableReferenceClass,
191         PendingSubstitutionValueClass,
192
193         // List class types must appear after ValueListClass. Note CSSFunctionValue
194         // is deliberately excluded, since we don't want it exposed to the CSS OM
195         // as a list.
196         ValueListClass,
197         ImageSetClass,
198         GridLineNamesClass,
199         GridAutoRepeatClass,
200         // Do not append non-list class types here.
201     };
202
203 public:
204     static const size_t ValueListSeparatorBits = 2;
205     enum ValueListSeparator {
206         SpaceSeparator,
207         CommaSeparator,
208         SlashSeparator
209     };
210
211 protected:
212     ClassType classType() const { return static_cast<ClassType>(m_classType); }
213
214     explicit CSSValue(ClassType classType)
215         : m_primitiveUnitType(0)
216         , m_hasCachedCSSText(false)
217         , m_isQuirkValue(false)
218         , m_valueListSeparator(SpaceSeparator)
219         , m_classType(classType)
220     {
221     }
222
223     // NOTE: This class is non-virtual for memory and performance reasons.
224     // Don't go making it virtual again unless you know exactly what you're doing!
225
226     ~CSSValue() = default;
227
228 private:
229     WEBCORE_EXPORT void destroy();
230
231 protected:
232     // The bits in this section are only used by specific subclasses but kept here
233     // to maximize struct packing.
234
235     // CSSPrimitiveValue bits:
236     unsigned m_primitiveUnitType : 7; // CSSPrimitiveValue::UnitType
237     mutable unsigned m_hasCachedCSSText : 1;
238     unsigned m_isQuirkValue : 1;
239
240     unsigned m_valueListSeparator : ValueListSeparatorBits;
241
242 private:
243     unsigned m_classType : ClassTypeBits; // ClassType
244     
245 friend class CSSValueList;
246 };
247
248 template<typename CSSValueType>
249 inline bool compareCSSValueVector(const Vector<Ref<CSSValueType>>& firstVector, const Vector<Ref<CSSValueType>>& secondVector)
250 {
251     size_t size = firstVector.size();
252     if (size != secondVector.size())
253         return false;
254
255     for (size_t i = 0; i < size; ++i) {
256         auto& firstPtr = firstVector[i];
257         auto& secondPtr = secondVector[i];
258         if (firstPtr.ptr() == secondPtr.ptr() || firstPtr->equals(secondPtr))
259             continue;
260         return false;
261     }
262     return true;
263 }
264
265 template<typename CSSValueType>
266 inline bool compareCSSValuePtr(const RefPtr<CSSValueType>& first, const RefPtr<CSSValueType>& second)
267 {
268     return first ? second && first->equals(*second) : !second;
269 }
270
271 template<typename CSSValueType>
272 inline bool compareCSSValue(const Ref<CSSValueType>& first, const Ref<CSSValueType>& second)
273 {
274     return first.get().equals(second);
275 }
276
277 typedef HashMap<AtomicString, RefPtr<CSSCustomPropertyValue>> CustomPropertyValueMap;
278
279 } // namespace WebCore
280
281 #define SPECIALIZE_TYPE_TRAITS_CSS_VALUE(ToValueTypeName, predicate) \
282 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::ToValueTypeName) \
283     static bool isType(const WebCore::CSSValue& value) { return value.predicate; } \
284 SPECIALIZE_TYPE_TRAITS_END()