Remove CSS Animation Triggers
[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     bool isCustomIdentValue() const { return m_classType == CustomIdentClass; }
116     bool isVariableReferenceValue() const { return m_classType == VariableReferenceClass; }
117     bool isPendingSubstitutionValue() const { return m_classType == PendingSubstitutionValueClass; }
118     
119     bool hasVariableReferences() const { return isVariableReferenceValue() || isPendingSubstitutionValue(); }
120
121     Ref<DeprecatedCSSOMValue> createDeprecatedCSSOMWrapper(CSSStyleDeclaration&) const;
122
123     bool traverseSubresources(const WTF::Function<bool (const CachedResource&)>& handler) const;
124
125     bool equals(const CSSValue&) const;
126     bool operator==(const CSSValue& other) const { return equals(other); }
127
128 protected:
129
130     static const size_t ClassTypeBits = 6;
131     enum ClassType {
132         PrimitiveClass,
133
134         // Image classes.
135         ImageClass,
136         CursorImageClass,
137
138         // Image generator classes.
139         CanvasClass,
140         NamedImageClass,
141         CrossfadeClass,
142         FilterImageClass,
143         LinearGradientClass,
144         RadialGradientClass,
145         ConicGradientClass,
146
147         // Timing function classes.
148         CubicBezierTimingFunctionClass,
149         StepsTimingFunctionClass,
150         FramesTimingFunctionClass,
151         SpringTimingFunctionClass,
152
153         // Other class types.
154         AspectRatioClass,
155         BorderImageSliceClass,
156         FontFeatureClass,
157 #if ENABLE(VARIATION_FONTS)
158         FontVariationClass,
159 #endif
160         FontClass,
161         FontStyleClass,
162         FontStyleRangeClass,
163         FontFaceSrcClass,
164         FunctionClass,
165
166         InheritedClass,
167         InitialClass,
168         UnsetClass,
169         RevertClass,
170
171         ReflectClass,
172         ShadowClass,
173         UnicodeRangeClass,
174         LineBoxContainClass,
175         CalculationClass,
176         GridTemplateAreasClass,
177
178         CSSContentDistributionClass,
179
180         CustomIdentClass,
181
182         CustomPropertyClass,
183         VariableReferenceClass,
184         PendingSubstitutionValueClass,
185
186         // List class types must appear after ValueListClass. Note CSSFunctionValue
187         // is deliberately excluded, since we don't want it exposed to the CSS OM
188         // as a list.
189         ValueListClass,
190         ImageSetClass,
191         GridLineNamesClass,
192         GridAutoRepeatClass,
193         // Do not append non-list class types here.
194     };
195
196 public:
197     static const size_t ValueListSeparatorBits = 2;
198     enum ValueListSeparator {
199         SpaceSeparator,
200         CommaSeparator,
201         SlashSeparator
202     };
203
204 protected:
205     ClassType classType() const { return static_cast<ClassType>(m_classType); }
206
207     explicit CSSValue(ClassType classType)
208         : m_primitiveUnitType(0)
209         , m_hasCachedCSSText(false)
210         , m_isQuirkValue(false)
211         , m_valueListSeparator(SpaceSeparator)
212         , m_classType(classType)
213     {
214     }
215
216     // NOTE: This class is non-virtual for memory and performance reasons.
217     // Don't go making it virtual again unless you know exactly what you're doing!
218
219     ~CSSValue() = default;
220
221 private:
222     WEBCORE_EXPORT void destroy();
223
224 protected:
225     // The bits in this section are only used by specific subclasses but kept here
226     // to maximize struct packing.
227
228     // CSSPrimitiveValue bits:
229     unsigned m_primitiveUnitType : 7; // CSSPrimitiveValue::UnitType
230     mutable unsigned m_hasCachedCSSText : 1;
231     unsigned m_isQuirkValue : 1;
232
233     unsigned m_valueListSeparator : ValueListSeparatorBits;
234
235 private:
236     unsigned m_classType : ClassTypeBits; // ClassType
237     
238 friend class CSSValueList;
239 };
240
241 template<typename CSSValueType>
242 inline bool compareCSSValueVector(const Vector<Ref<CSSValueType>>& firstVector, const Vector<Ref<CSSValueType>>& secondVector)
243 {
244     size_t size = firstVector.size();
245     if (size != secondVector.size())
246         return false;
247
248     for (size_t i = 0; i < size; ++i) {
249         auto& firstPtr = firstVector[i];
250         auto& secondPtr = secondVector[i];
251         if (firstPtr.ptr() == secondPtr.ptr() || firstPtr->equals(secondPtr))
252             continue;
253         return false;
254     }
255     return true;
256 }
257
258 template<typename CSSValueType>
259 inline bool compareCSSValuePtr(const RefPtr<CSSValueType>& first, const RefPtr<CSSValueType>& second)
260 {
261     return first ? second && first->equals(*second) : !second;
262 }
263
264 template<typename CSSValueType>
265 inline bool compareCSSValue(const Ref<CSSValueType>& first, const Ref<CSSValueType>& second)
266 {
267     return first.get().equals(second);
268 }
269
270 typedef HashMap<AtomicString, RefPtr<CSSCustomPropertyValue>> CustomPropertyValueMap;
271
272 } // namespace WebCore
273
274 #define SPECIALIZE_TYPE_TRAITS_CSS_VALUE(ToValueTypeName, predicate) \
275 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::ToValueTypeName) \
276     static bool isType(const WebCore::CSSValue& value) { return value.predicate; } \
277 SPECIALIZE_TYPE_TRAITS_END()