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