DropShadowFilterOperation violates platform isolation
[WebKit-https.git] / Source / WebCore / platform / graphics / filters / FilterOperation.h
1 /*
2  * Copyright (C) 2011 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 COMPUTER, 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 COMPUTER, 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 #ifndef FilterOperation_h
27 #define FilterOperation_h
28
29 #if ENABLE(CSS_FILTERS)
30
31 #include "Length.h"
32 #include <wtf/OwnPtr.h>
33 #include <wtf/PassOwnPtr.h>
34 #include <wtf/RefCounted.h>
35 #include <wtf/text/AtomicString.h>
36
37 namespace WebCore {
38
39 // CSS Filters
40
41 class FilterOperation : public RefCounted<FilterOperation> {
42 public:
43     enum OperationType {
44         REFERENCE, // url(#somefilter)
45         GRAYSCALE,
46         SEPIA,
47         SATURATE,
48         HUE_ROTATE,
49         INVERT,
50         OPACITY,
51         GAMMA,
52         BLUR,
53         SHARPEN,
54         DROP_SHADOW,
55 #if ENABLE(CSS_SHADERS)
56         CUSTOM,
57 #endif
58         NONE
59     };
60
61     virtual ~FilterOperation() { }
62
63     virtual bool operator==(const FilterOperation&) const = 0;
64     bool operator!=(const FilterOperation& o) const { return !(*this == o); }
65
66     virtual OperationType getOperationType() const { return m_type; }
67     virtual bool isSameType(const FilterOperation& o) const { return o.getOperationType() == m_type; }
68
69 protected:
70     FilterOperation(OperationType type)
71         : m_type(type)
72     {
73     }
74
75     OperationType m_type;
76 };
77
78 // Each of the individual operations are provided here. Once they actually
79 // have code to apply their effect they'll move to separate files.
80 // At the moment we're just storing the data for roundtripping.
81
82 class ReferenceFilterOperation : public FilterOperation {
83 public:
84     static PassRefPtr<ReferenceFilterOperation> create(const AtomicString& reference, OperationType type)
85     {
86         return adoptRef(new ReferenceFilterOperation(reference, type));
87     }
88
89     const AtomicString& reference() const { return m_reference; }
90
91 private:
92
93     virtual bool operator==(const FilterOperation& o) const
94     {
95         if (!isSameType(o))
96             return false;
97         const ReferenceFilterOperation* other = static_cast<const ReferenceFilterOperation*>(&o);
98         return m_reference == other->m_reference;
99     }
100
101     ReferenceFilterOperation(const AtomicString& reference, OperationType type)
102         : FilterOperation(type)
103         , m_reference(reference)
104     {
105     }
106
107     AtomicString m_reference;
108 };
109
110 // GRAYSCALE, SEPIA, SATURATE and HUE_ROTATE are variations on a basic color matrix effect.
111 // For HUE_ROTATE, the angle of rotation is stored in m_amount.
112
113 class BasicColorMatrixFilterOperation : public FilterOperation {
114 public:
115     static PassRefPtr<BasicColorMatrixFilterOperation> create(double amount, OperationType type)
116     {
117         return adoptRef(new BasicColorMatrixFilterOperation(amount, type));
118     }
119
120     double amount() const { return m_amount; }
121
122 private:
123
124     virtual bool operator==(const FilterOperation& o) const
125     {
126         if (!isSameType(o))
127             return false;
128         const BasicColorMatrixFilterOperation* other = static_cast<const BasicColorMatrixFilterOperation*>(&o);
129         return m_amount == other->m_amount;
130     }
131
132     BasicColorMatrixFilterOperation(double amount, OperationType type)
133         : FilterOperation(type)
134         , m_amount(amount)
135     {
136     }
137
138     double m_amount;
139 };
140
141 // INVERT and OPACITY are variations on a basic component transfer effect.
142
143 class BasicComponentTransferFilterOperation : public FilterOperation {
144 public:
145     static PassRefPtr<BasicComponentTransferFilterOperation> create(double amount, OperationType type)
146     {
147         return adoptRef(new BasicComponentTransferFilterOperation(amount, type));
148     }
149
150     double amount() const { return m_amount; }
151
152 private:
153
154     virtual bool operator==(const FilterOperation& o) const
155     {
156         if (!isSameType(o))
157             return false;
158         const BasicComponentTransferFilterOperation* other = static_cast<const BasicComponentTransferFilterOperation*>(&o);
159         return m_amount == other->m_amount;
160     }
161
162     BasicComponentTransferFilterOperation(double amount, OperationType type)
163         : FilterOperation(type)
164         , m_amount(amount)
165     {
166     }
167
168     double m_amount;
169 };
170
171 class GammaFilterOperation : public FilterOperation {
172 public:
173     static PassRefPtr<GammaFilterOperation> create(double amplitude, double exponent, double offset, OperationType type)
174     {
175         return adoptRef(new GammaFilterOperation(amplitude, exponent, offset, type));
176     }
177
178     double amplitude() const { return m_amplitude; }
179     double exponent() const { return m_exponent; }
180     double offset() const { return m_offset; }
181
182 private:
183
184     virtual bool operator==(const FilterOperation& o) const
185     {
186         if (!isSameType(o))
187             return false;
188         const GammaFilterOperation* other = static_cast<const GammaFilterOperation*>(&o);
189         return m_amplitude == other->m_amplitude && m_exponent == other->m_exponent && m_offset == other->m_offset;
190     }
191
192     GammaFilterOperation(double amplitude, double exponent, double offset, OperationType type)
193         : FilterOperation(type)
194         , m_amplitude(amplitude)
195         , m_exponent(exponent)
196         , m_offset(offset)
197     {
198     }
199
200     double m_amplitude;
201     double m_exponent;
202     double m_offset;
203 };
204
205 class BlurFilterOperation : public FilterOperation {
206 public:
207     static PassRefPtr<BlurFilterOperation> create(Length stdDeviationX, Length stdDeviationY, OperationType type)
208     {
209         return adoptRef(new BlurFilterOperation(stdDeviationX, stdDeviationY, type));
210     }
211
212     Length stdDeviationX() const { return m_stdDeviationX; }
213     Length stdDeviationY() const { return m_stdDeviationY; }
214
215 private:
216
217     virtual bool operator==(const FilterOperation& o) const
218     {
219         if (!isSameType(o))
220             return false;
221         const BlurFilterOperation* other = static_cast<const BlurFilterOperation*>(&o);
222         return m_stdDeviationX == other->m_stdDeviationX && m_stdDeviationY == other->m_stdDeviationY;
223     }
224
225     BlurFilterOperation(Length stdDeviationX, Length stdDeviationY, OperationType type)
226         : FilterOperation(type)
227         , m_stdDeviationX(stdDeviationX)
228         , m_stdDeviationY(stdDeviationY)
229     {
230     }
231
232     Length m_stdDeviationX;
233     Length m_stdDeviationY;
234 };
235
236 class SharpenFilterOperation : public FilterOperation {
237 public:
238     static PassRefPtr<SharpenFilterOperation> create(double amount, Length radius, double threshold, OperationType type)
239     {
240         return adoptRef(new SharpenFilterOperation(amount, radius, threshold, type));
241     }
242
243     double amount() const { return m_amount; }
244     Length radius() const { return m_radius; }
245     double threshold() const { return m_threshold; }
246
247 private:
248
249     virtual bool operator==(const FilterOperation& o) const
250     {
251         if (!isSameType(o))
252             return false;
253         const SharpenFilterOperation* other = static_cast<const SharpenFilterOperation*>(&o);
254         return m_radius == other->m_radius && m_threshold == other->m_threshold && m_amount == other->m_amount;
255     }
256
257     SharpenFilterOperation(double amount, Length radius, double threshold, OperationType type)
258         : FilterOperation(type)
259         , m_amount(amount)
260         , m_radius(radius)
261         , m_threshold(threshold)
262     {
263     }
264
265     double m_amount;
266     Length m_radius;
267     double m_threshold;
268 };
269
270 class DropShadowFilterOperation : public FilterOperation {
271 public:
272     static PassRefPtr<DropShadowFilterOperation> create(int x, int y, int stdDeviation, Color color, OperationType type)
273     {
274         return adoptRef(new DropShadowFilterOperation(x, y, stdDeviation, color, type));
275     }
276
277     int x() const { return m_x; }
278     int y() const { return m_y; }
279     int stdDeviation() const { return m_stdDeviation; }
280     Color color() const { return m_color; }
281
282 private:
283
284     virtual bool operator==(const FilterOperation& o) const
285     {
286         if (!isSameType(o))
287             return false;
288         const DropShadowFilterOperation* other = static_cast<const DropShadowFilterOperation*>(&o);
289         return m_x == other->m_x && m_y == other->m_y && m_stdDeviation == other->m_stdDeviation && m_color == other->m_color;
290     }
291
292     DropShadowFilterOperation(int x, int y, int stdDeviation, Color color, OperationType type)
293         : FilterOperation(type)
294         , m_x(x)
295         , m_y(y)
296         , m_stdDeviation(stdDeviation)
297         , m_color(color)
298     {
299     }
300
301     int m_x;
302     int m_y;
303     int m_stdDeviation;
304     Color m_color;
305 };
306
307 } // namespace WebCore
308
309 #endif // ENABLE(CSS_FILTERS)
310
311 #endif // FilterOperation_h