Remove PassRefPtr use from the "css" directory, related cleanup
[WebKit-https.git] / Source / WebCore / css / CSSGradientValue.h
1 /*
2  * Copyright (C) 2008 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #pragma once
27
28 #include "CSSImageGeneratorValue.h"
29 #include "CSSPrimitiveValue.h"
30 #include <wtf/Vector.h>
31
32 namespace WebCore {
33
34 class FloatPoint;
35 class Gradient;
36 class StyleResolver;
37
38 enum CSSGradientType {
39     CSSDeprecatedLinearGradient,
40     CSSDeprecatedRadialGradient,
41     CSSPrefixedLinearGradient,
42     CSSPrefixedRadialGradient,
43     CSSLinearGradient,
44     CSSRadialGradient
45 };
46 enum CSSGradientRepeat { NonRepeating, Repeating };
47
48 struct CSSGradientColorStop {
49     RefPtr<CSSPrimitiveValue> m_position; // percentage or length
50     RefPtr<CSSPrimitiveValue> m_color;
51     Color m_resolvedColor;
52     bool m_colorIsDerivedFromElement = false;
53     bool isMidpoint = false;
54     bool operator==(const CSSGradientColorStop& other) const
55     {
56         return compareCSSValuePtr(m_color, other.m_color)
57             && compareCSSValuePtr(m_position, other.m_position);
58     }
59 };
60
61 class CSSGradientValue : public CSSImageGeneratorValue {
62 public:
63     RefPtr<Image> image(RenderElement&, const FloatSize&);
64
65     void setFirstX(RefPtr<CSSPrimitiveValue>&& val) { m_firstX = WTFMove(val); }
66     void setFirstY(RefPtr<CSSPrimitiveValue>&& val) { m_firstY = WTFMove(val); }
67     void setSecondX(RefPtr<CSSPrimitiveValue>&& val) { m_secondX = WTFMove(val); }
68     void setSecondY(RefPtr<CSSPrimitiveValue>&& val) { m_secondY = WTFMove(val); }
69
70     void addStop(const CSSGradientColorStop& stop) { m_stops.append(stop); }
71
72     unsigned stopCount() const { return m_stops.size(); }
73
74     void sortStopsIfNeeded();
75
76     bool isRepeating() const { return m_repeating; }
77
78     CSSGradientType gradientType() const { return m_gradientType; }
79
80     bool isFixedSize() const { return false; }
81     FloatSize fixedSize(const RenderElement&) const { return FloatSize(); }
82
83     bool isPending() const { return false; }
84     bool knownToBeOpaque() const;
85
86     void loadSubimages(CachedResourceLoader&, const ResourceLoaderOptions&) { }
87     Ref<CSSGradientValue> gradientWithStylesResolved(const StyleResolver&);
88
89 protected:
90     CSSGradientValue(ClassType classType, CSSGradientRepeat repeat, CSSGradientType gradientType)
91         : CSSImageGeneratorValue(classType)
92         , m_stopsSorted(false)
93         , m_gradientType(gradientType)
94         , m_repeating(repeat == Repeating)
95     {
96     }
97
98     CSSGradientValue(const CSSGradientValue& other, ClassType classType, CSSGradientType gradientType)
99         : CSSImageGeneratorValue(classType)
100         , m_firstX(other.m_firstX)
101         , m_firstY(other.m_firstY)
102         , m_secondX(other.m_secondX)
103         , m_secondY(other.m_secondY)
104         , m_stops(other.m_stops)
105         , m_stopsSorted(other.m_stopsSorted)
106         , m_gradientType(gradientType)
107         , m_repeating(other.isRepeating() ? Repeating : NonRepeating)
108     {
109     }
110
111     void addStops(Gradient&, const CSSToLengthConversionData&, float maxLengthForRepeat = 0);
112
113     // Resolve points/radii to front end values.
114     FloatPoint computeEndPoint(CSSPrimitiveValue*, CSSPrimitiveValue*, const CSSToLengthConversionData&, const FloatSize&);
115
116     bool isCacheable() const;
117
118     // Points. Some of these may be null.
119     RefPtr<CSSPrimitiveValue> m_firstX;
120     RefPtr<CSSPrimitiveValue> m_firstY;
121
122     RefPtr<CSSPrimitiveValue> m_secondX;
123     RefPtr<CSSPrimitiveValue> m_secondY;
124
125     // Stops
126     Vector<CSSGradientColorStop, 2> m_stops;
127     bool m_stopsSorted;
128     CSSGradientType m_gradientType;
129     bool m_repeating;
130 };
131
132 class CSSLinearGradientValue final : public CSSGradientValue {
133 public:
134     static Ref<CSSLinearGradientValue> create(CSSGradientRepeat repeat, CSSGradientType gradientType = CSSLinearGradient)
135     {
136         return adoptRef(*new CSSLinearGradientValue(repeat, gradientType));
137     }
138
139     void setAngle(Ref<CSSPrimitiveValue>&& val) { m_angle = WTFMove(val); }
140
141     String customCSSText() const;
142
143     // Create the gradient for a given size.
144     Ref<Gradient> createGradient(RenderElement&, const FloatSize&);
145
146     Ref<CSSLinearGradientValue> clone() const
147     {
148         return adoptRef(*new CSSLinearGradientValue(*this));
149     }
150
151     bool equals(const CSSLinearGradientValue&) const;
152
153 private:
154     CSSLinearGradientValue(CSSGradientRepeat repeat, CSSGradientType gradientType = CSSLinearGradient)
155         : CSSGradientValue(LinearGradientClass, repeat, gradientType)
156     {
157     }
158
159     CSSLinearGradientValue(const CSSLinearGradientValue& other)
160         : CSSGradientValue(other, LinearGradientClass, other.gradientType())
161         , m_angle(other.m_angle)
162     {
163     }
164
165     RefPtr<CSSPrimitiveValue> m_angle; // may be null.
166 };
167
168 class CSSRadialGradientValue final : public CSSGradientValue {
169 public:
170     static Ref<CSSRadialGradientValue> create(CSSGradientRepeat repeat, CSSGradientType gradientType = CSSRadialGradient)
171     {
172         return adoptRef(*new CSSRadialGradientValue(repeat, gradientType));
173     }
174
175     Ref<CSSRadialGradientValue> clone() const
176     {
177         return adoptRef(*new CSSRadialGradientValue(*this));
178     }
179
180     String customCSSText() const;
181
182     void setFirstRadius(RefPtr<CSSPrimitiveValue>&& val) { m_firstRadius = WTFMove(val); }
183     void setSecondRadius(RefPtr<CSSPrimitiveValue>&& val) { m_secondRadius = WTFMove(val); }
184
185     void setShape(RefPtr<CSSPrimitiveValue>&& val) { m_shape = WTFMove(val); }
186     void setSizingBehavior(RefPtr<CSSPrimitiveValue>&& val) { m_sizingBehavior = WTFMove(val); }
187
188     void setEndHorizontalSize(RefPtr<CSSPrimitiveValue>&& val) { m_endHorizontalSize = WTFMove(val); }
189     void setEndVerticalSize(RefPtr<CSSPrimitiveValue>&& val) { m_endVerticalSize = WTFMove(val); }
190
191     // Create the gradient for a given size.
192     Ref<Gradient> createGradient(RenderElement&, const FloatSize&);
193
194     bool equals(const CSSRadialGradientValue&) const;
195
196 private:
197     CSSRadialGradientValue(CSSGradientRepeat repeat, CSSGradientType gradientType = CSSRadialGradient)
198         : CSSGradientValue(RadialGradientClass, repeat, gradientType)
199     {
200     }
201
202     CSSRadialGradientValue(const CSSRadialGradientValue& other)
203         : CSSGradientValue(other, RadialGradientClass, other.gradientType())
204         , m_firstRadius(other.m_firstRadius)
205         , m_secondRadius(other.m_secondRadius)
206         , m_shape(other.m_shape)
207         , m_sizingBehavior(other.m_sizingBehavior)
208         , m_endHorizontalSize(other.m_endHorizontalSize)
209         , m_endVerticalSize(other.m_endVerticalSize)
210     {
211     }
212
213     // Resolve points/radii to front end values.
214     float resolveRadius(CSSPrimitiveValue&, const CSSToLengthConversionData&, float* widthOrHeight = 0);
215
216     // These may be null for non-deprecated gradients.
217     RefPtr<CSSPrimitiveValue> m_firstRadius;
218     RefPtr<CSSPrimitiveValue> m_secondRadius;
219
220     // The below are only used for non-deprecated gradients. Any of them may be null.
221     RefPtr<CSSPrimitiveValue> m_shape;
222     RefPtr<CSSPrimitiveValue> m_sizingBehavior;
223
224     RefPtr<CSSPrimitiveValue> m_endHorizontalSize;
225     RefPtr<CSSPrimitiveValue> m_endVerticalSize;
226 };
227
228 } // namespace WebCore
229
230 SPECIALIZE_TYPE_TRAITS_CSS_VALUE(CSSGradientValue, isGradientValue())
231 SPECIALIZE_TYPE_TRAITS_CSS_VALUE(CSSLinearGradientValue, isLinearGradientValue())
232 SPECIALIZE_TYPE_TRAITS_CSS_VALUE(CSSRadialGradientValue, isRadialGradientValue())