Use WTF::Function instead of std::function in more places in WebCore/
[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 "ExceptionOr.h"
24 #include "URLHash.h"
25 #include <wtf/Function.h>
26 #include <wtf/HashMap.h>
27 #include <wtf/ListHashSet.h>
28 #include <wtf/RefCounted.h>
29 #include <wtf/RefPtr.h>
30 #include <wtf/TypeCasts.h>
31
32 namespace WebCore {
33
34 class CSSCustomPropertyValue;
35 class CachedResource;
36 class DeprecatedCSSOMValue;
37 class StyleSheetContents;
38
39 enum CSSPropertyID : uint16_t;
40
41 class CSSValue : public RefCounted<CSSValue> {
42 public:
43     enum Type {
44         CSS_INHERIT = 0,
45         CSS_PRIMITIVE_VALUE = 1,
46         CSS_VALUE_LIST = 2,
47         CSS_CUSTOM = 3,
48         CSS_INITIAL = 4,
49         CSS_UNSET = 5,
50         CSS_REVERT = 6
51     };
52
53     // Override RefCounted's deref() to ensure operator delete is called on
54     // the appropriate subclass type.
55     void deref()
56     {
57         if (derefBase())
58             destroy();
59     }
60
61     Type cssValueType() const;
62     String cssText() const;
63
64     bool isPrimitiveValue() const { return m_classType == PrimitiveClass; }
65     bool isValueList() const { return m_classType >= ValueListClass; }
66     
67     bool isBaseValueList() const { return m_classType == ValueListClass; }
68         
69
70     bool isAspectRatioValue() const { return m_classType == AspectRatioClass; }
71     bool isBorderImageSliceValue() const { return m_classType == BorderImageSliceClass; }
72     bool isCanvasValue() const { return m_classType == CanvasClass; }
73     bool isCrossfadeValue() const { return m_classType == CrossfadeClass; }
74     bool isCursorImageValue() const { return m_classType == CursorImageClass; }
75     bool isCustomPropertyValue() const { return m_classType == CustomPropertyClass; }
76     bool isFunctionValue() const { return m_classType == FunctionClass; }
77     bool isFontFeatureValue() const { return m_classType == FontFeatureClass; }
78 #if ENABLE(VARIATION_FONTS)
79     bool isFontVariationValue() const { return m_classType == FontVariationClass; }
80 #endif
81     bool isFontFaceSrcValue() const { return m_classType == FontFaceSrcClass; }
82     bool isFontValue() const { return m_classType == FontClass; }
83     bool isFontStyleValue() const { return m_classType == FontStyleClass; }
84     bool isFontStyleRangeValue() const { return m_classType == FontStyleRangeClass; }
85     bool isImageGeneratorValue() const { return m_classType >= CanvasClass && m_classType <= RadialGradientClass; }
86     bool isGradientValue() const { return m_classType >= LinearGradientClass && m_classType <= RadialGradientClass; }
87     bool isNamedImageValue() const { return m_classType == NamedImageClass; }
88     bool isImageSetValue() const { return m_classType == ImageSetClass; }
89     bool isImageValue() const { return m_classType == ImageClass; }
90     bool isImplicitInitialValue() const;
91     bool isInheritedValue() const { return m_classType == InheritedClass; }
92     bool isInitialValue() const { return m_classType == InitialClass; }
93     bool isUnsetValue() const { return m_classType == UnsetClass; }
94     bool isRevertValue() const { return m_classType == RevertClass; }
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 isReflectValue() const { return m_classType == ReflectClass; }
100     bool isShadowValue() const { return m_classType == ShadowClass; }
101     bool isCubicBezierTimingFunctionValue() const { return m_classType == CubicBezierTimingFunctionClass; }
102     bool isStepsTimingFunctionValue() const { return m_classType == StepsTimingFunctionClass; }
103     bool isSpringTimingFunctionValue() const { return m_classType == SpringTimingFunctionClass; }
104     bool isLineBoxContainValue() const { return m_classType == LineBoxContainClass; }
105     bool isCalcValue() const {return m_classType == CalculationClass; }
106     bool isFilterImageValue() const { return m_classType == FilterImageClass; }
107     bool isContentDistributionValue() const { return m_classType == CSSContentDistributionClass; }
108     bool isGridAutoRepeatValue() const { return m_classType == GridAutoRepeatClass; }
109     bool isGridTemplateAreasValue() const { return m_classType == GridTemplateAreasClass; }
110     bool isGridLineNamesValue() const { return m_classType == GridLineNamesClass; }
111     bool isUnicodeRangeValue() const { return m_classType == UnicodeRangeClass; }
112
113 #if ENABLE(CSS_ANIMATIONS_LEVEL_2)
114     bool isAnimationTriggerScrollValue() const { return m_classType == AnimationTriggerScrollClass; }
115 #endif
116
117     bool isCustomIdentValue() const { return m_classType == CustomIdentClass; }
118     bool isVariableReferenceValue() const { return m_classType == VariableReferenceClass; }
119     bool isPendingSubstitutionValue() const { return m_classType == PendingSubstitutionValueClass; }
120     
121     bool hasVariableReferences() const { return isVariableReferenceValue() || isPendingSubstitutionValue(); }
122
123     Ref<DeprecatedCSSOMValue> createDeprecatedCSSOMWrapper() const;
124
125     bool traverseSubresources(const WTF::Function<bool (const CachedResource&)>& handler) const;
126
127     bool equals(const CSSValue&) const;
128     bool operator==(const CSSValue& other) const { return equals(other); }
129
130 protected:
131
132     static const size_t ClassTypeBits = 6;
133     enum ClassType {
134         PrimitiveClass,
135
136         // Image classes.
137         ImageClass,
138         CursorImageClass,
139
140         // Image generator classes.
141         CanvasClass,
142         NamedImageClass,
143         CrossfadeClass,
144         FilterImageClass,
145         LinearGradientClass,
146         RadialGradientClass,
147
148         // Timing function classes.
149         CubicBezierTimingFunctionClass,
150         StepsTimingFunctionClass,
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 #if ENABLE(CSS_ANIMATIONS_LEVEL_2)
178         AnimationTriggerScrollClass,
179 #endif
180
181         CSSContentDistributionClass,
182         
183         CustomIdentClass,
184
185         CustomPropertyClass,
186         VariableReferenceClass,
187         PendingSubstitutionValueClass,
188
189         // List class types must appear after ValueListClass. Note CSSFunctionValue
190         // is deliberately excluded, since we don't want it exposed to the CSS OM
191         // as a list.
192         ValueListClass,
193         ImageSetClass,
194         GridLineNamesClass,
195         GridAutoRepeatClass,
196         // Do not append non-list class types here.
197     };
198
199 public:
200     static const size_t ValueListSeparatorBits = 2;
201     enum ValueListSeparator {
202         SpaceSeparator,
203         CommaSeparator,
204         SlashSeparator
205     };
206
207 protected:
208     ClassType classType() const { return static_cast<ClassType>(m_classType); }
209
210     explicit CSSValue(ClassType classType)
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     WEBCORE_EXPORT void destroy();
226
227 protected:
228     // The bits in this section are only used by specific subclasses but kept here
229     // to maximize struct packing.
230
231     // CSSPrimitiveValue bits:
232     unsigned m_primitiveUnitType : 7; // CSSPrimitiveValue::UnitType
233     mutable unsigned m_hasCachedCSSText : 1;
234     unsigned m_isQuirkValue : 1;
235
236     unsigned m_valueListSeparator : ValueListSeparatorBits;
237
238 private:
239     unsigned m_classType : ClassTypeBits; // ClassType
240     
241 friend class CSSValueList;
242 };
243
244 template<typename CSSValueType>
245 inline bool compareCSSValueVector(const Vector<Ref<CSSValueType>>& firstVector, const Vector<Ref<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         auto& firstPtr = firstVector[i];
253         auto& secondPtr = secondVector[i];
254         if (firstPtr.ptr() == secondPtr.ptr() || 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 template<typename CSSValueType>
268 inline bool compareCSSValue(const Ref<CSSValueType>& first, const Ref<CSSValueType>& second)
269 {
270     return first.get().equals(second);
271 }
272
273 typedef HashMap<AtomicString, RefPtr<CSSCustomPropertyValue>> CustomPropertyValueMap;
274
275 } // namespace WebCore
276
277 #define SPECIALIZE_TYPE_TRAITS_CSS_VALUE(ToValueTypeName, predicate) \
278 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::ToValueTypeName) \
279     static bool isType(const WebCore::CSSValue& value) { return value.predicate; } \
280 SPECIALIZE_TYPE_TRAITS_END()