Remove CSS_FILTERS flag
[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 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 #ifndef FilterOperation_h
27 #define FilterOperation_h
28
29 #include "Color.h"
30 #include "FilterEffect.h"
31 #include "LayoutSize.h"
32 #include "Length.h"
33 #include <wtf/OwnPtr.h>
34 #include <wtf/PassOwnPtr.h>
35 #include <wtf/RefCounted.h>
36 #include <wtf/text/WTFString.h>
37
38 // Annoyingly, wingdi.h #defines this.
39 #ifdef PASSTHROUGH
40 #undef PASSTHROUGH
41 #endif
42
43 namespace WebCore {
44
45 // CSS Filters
46
47 class CachedSVGDocumentReference;
48
49 class FilterOperation : public RefCounted<FilterOperation> {
50 public:
51     enum OperationType {
52         REFERENCE, // url(#somefilter)
53         GRAYSCALE,
54         SEPIA,
55         SATURATE,
56         HUE_ROTATE,
57         INVERT,
58         OPACITY,
59         BRIGHTNESS,
60         CONTRAST,
61         BLUR,
62         DROP_SHADOW,
63         PASSTHROUGH,
64         DEFAULT,
65         NONE
66     };
67
68     virtual ~FilterOperation() { }
69
70     virtual PassRefPtr<FilterOperation> clone() const = 0;
71
72     virtual bool operator==(const FilterOperation&) const = 0;
73     bool operator!=(const FilterOperation& o) const { return !(*this == o); }
74
75     virtual PassRefPtr<FilterOperation> blend(const FilterOperation* /*from*/, double /*progress*/, bool /*blendToPassthrough*/ = false)
76     {
77         ASSERT(!blendingNeedsRendererSize());
78         return 0;
79     }
80
81     virtual PassRefPtr<FilterOperation> blend(const FilterOperation* /*from*/, double /*progress*/, const LayoutSize&, bool /*blendToPassthrough*/ = false)
82     {
83         ASSERT(blendingNeedsRendererSize());
84         return 0;
85     }
86
87     OperationType type() const { return m_type; }
88
89     bool isBasicColorMatrixFilterOperation() const
90     {
91         return m_type == GRAYSCALE || m_type == SEPIA || m_type == SATURATE || m_type == HUE_ROTATE;
92     }
93
94     bool isBasicComponentTransferFilterOperation() const
95     {
96         return m_type == INVERT || m_type == BRIGHTNESS || m_type == CONTRAST || m_type == OPACITY;
97     }
98
99     bool isSameType(const FilterOperation& o) const { return o.type() == m_type; }
100
101     // True if the alpha channel of any pixel can change under this operation.
102     virtual bool affectsOpacity() const { return false; }
103     // True if the the value of one pixel can affect the value of another pixel under this operation, such as blur.
104     virtual bool movesPixels() const { return false; }
105     // True if the filter needs the size of the box in order to calculate the animations.
106     virtual bool blendingNeedsRendererSize() const { return false; }
107
108 protected:
109     FilterOperation(OperationType type)
110         : m_type(type)
111     {
112     }
113
114     OperationType m_type;
115 };
116
117 #define FILTEROPERATION_TYPE_CASTS(ToValueTypeName, predicate) \
118     TYPE_CASTS_BASE(ToValueTypeName, WebCore::FilterOperation, value, value->predicate, value.predicate)
119
120 class WEBCORE_EXPORT DefaultFilterOperation : public FilterOperation {
121 public:
122     static PassRefPtr<DefaultFilterOperation> create(OperationType representedType)
123     {
124         return adoptRef(new DefaultFilterOperation(representedType));
125     }
126
127     virtual PassRefPtr<FilterOperation> clone() const override
128     {
129         return adoptRef(new DefaultFilterOperation(representedType()));
130     }
131
132     OperationType representedType() const { return m_representedType; }
133
134 private:
135     virtual bool operator==(const FilterOperation&) const override;
136
137     DefaultFilterOperation(OperationType representedType)
138         : FilterOperation(DEFAULT)
139         , m_representedType(representedType)
140     {
141     }
142
143     OperationType m_representedType;
144 };
145
146 FILTEROPERATION_TYPE_CASTS(DefaultFilterOperation, type() == FilterOperation::DEFAULT);
147
148
149 class PassthroughFilterOperation : public FilterOperation {
150 public:
151     static PassRefPtr<PassthroughFilterOperation> create()
152     {
153         return adoptRef(new PassthroughFilterOperation());
154     }
155
156     virtual PassRefPtr<FilterOperation> clone() const override
157     {
158         return adoptRef(new PassthroughFilterOperation());
159     }
160
161 private:
162     virtual bool operator==(const FilterOperation& o) const override
163     {
164         return isSameType(o);
165     }
166
167     PassthroughFilterOperation()
168         : FilterOperation(PASSTHROUGH)
169     {
170     }
171 };
172
173 FILTEROPERATION_TYPE_CASTS(PassthroughFilterOperation, type() == FilterOperation::PASSTHROUGH);
174
175 class ReferenceFilterOperation : public FilterOperation {
176 public:
177     static PassRefPtr<ReferenceFilterOperation> create(const String& url, const String& fragment)
178     {
179         return adoptRef(new ReferenceFilterOperation(url, fragment));
180     }
181     virtual ~ReferenceFilterOperation();
182
183     virtual PassRefPtr<FilterOperation> clone() const override
184     {
185         // Reference filters cannot be cloned.
186         ASSERT_NOT_REACHED();
187         return nullptr;
188     }
189
190     virtual bool affectsOpacity() const override { return true; }
191     virtual bool movesPixels() const override { return true; }
192
193     const String& url() const { return m_url; }
194     const String& fragment() const { return m_fragment; }
195
196     CachedSVGDocumentReference* cachedSVGDocumentReference() const { return m_cachedSVGDocumentReference.get(); }
197     CachedSVGDocumentReference* getOrCreateCachedSVGDocumentReference();
198
199     FilterEffect* filterEffect() const { return m_filterEffect.get(); }
200     void setFilterEffect(PassRefPtr<FilterEffect> filterEffect) { m_filterEffect = filterEffect; }
201
202 private:
203     ReferenceFilterOperation(const String& url, const String& fragment);
204
205     virtual bool operator==(const FilterOperation&) const override;
206
207     String m_url;
208     String m_fragment;
209     std::unique_ptr<CachedSVGDocumentReference> m_cachedSVGDocumentReference;
210     RefPtr<FilterEffect> m_filterEffect;
211 };
212
213 FILTEROPERATION_TYPE_CASTS(ReferenceFilterOperation, type() == FilterOperation::REFERENCE);
214
215 // GRAYSCALE, SEPIA, SATURATE and HUE_ROTATE are variations on a basic color matrix effect.
216 // For HUE_ROTATE, the angle of rotation is stored in m_amount.
217 class WEBCORE_EXPORT BasicColorMatrixFilterOperation : public FilterOperation {
218 public:
219     static PassRefPtr<BasicColorMatrixFilterOperation> create(double amount, OperationType type)
220     {
221         return adoptRef(new BasicColorMatrixFilterOperation(amount, type));
222     }
223
224     virtual PassRefPtr<FilterOperation> clone() const override
225     {
226         return adoptRef(new BasicColorMatrixFilterOperation(amount(), type()));
227     }
228
229     double amount() const { return m_amount; }
230
231     virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress, bool blendToPassthrough = false) override;
232
233 private:
234     virtual bool operator==(const FilterOperation&) const override;
235
236     double passthroughAmount() const;
237
238     BasicColorMatrixFilterOperation(double amount, OperationType type)
239         : FilterOperation(type)
240         , m_amount(amount)
241     {
242     }
243
244     double m_amount;
245 };
246
247 FILTEROPERATION_TYPE_CASTS(BasicColorMatrixFilterOperation, isBasicColorMatrixFilterOperation());
248
249 // INVERT, BRIGHTNESS, CONTRAST and OPACITY are variations on a basic component transfer effect.
250 class WEBCORE_EXPORT BasicComponentTransferFilterOperation : public FilterOperation {
251 public:
252     static PassRefPtr<BasicComponentTransferFilterOperation> create(double amount, OperationType type)
253     {
254         return adoptRef(new BasicComponentTransferFilterOperation(amount, type));
255     }
256
257     virtual PassRefPtr<FilterOperation> clone() const override
258     {
259         return adoptRef(new BasicComponentTransferFilterOperation(amount(), type()));
260     }
261
262     double amount() const { return m_amount; }
263
264     virtual bool affectsOpacity() const override { return m_type == OPACITY; }
265
266     virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress, bool blendToPassthrough = false) override;
267
268 private:
269     virtual bool operator==(const FilterOperation&) const override;
270
271     double passthroughAmount() const;
272
273     BasicComponentTransferFilterOperation(double amount, OperationType type)
274         : FilterOperation(type)
275         , m_amount(amount)
276     {
277     }
278
279     double m_amount;
280 };
281
282 FILTEROPERATION_TYPE_CASTS(BasicComponentTransferFilterOperation, isBasicComponentTransferFilterOperation());
283
284 class WEBCORE_EXPORT BlurFilterOperation : public FilterOperation {
285 public:
286     static PassRefPtr<BlurFilterOperation> create(Length stdDeviation)
287     {
288         return adoptRef(new BlurFilterOperation(WTF::move(stdDeviation)));
289     }
290
291     virtual PassRefPtr<FilterOperation> clone() const override
292     {
293         return adoptRef(new BlurFilterOperation(stdDeviation()));
294     }
295
296     const Length& stdDeviation() const { return m_stdDeviation; }
297
298     virtual bool affectsOpacity() const override { return true; }
299     virtual bool movesPixels() const override { return true; }
300
301     virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress, bool blendToPassthrough = false) override;
302
303 private:
304     virtual bool operator==(const FilterOperation&) const override;
305
306     BlurFilterOperation(Length stdDeviation)
307         : FilterOperation(BLUR)
308         , m_stdDeviation(WTF::move(stdDeviation))
309     {
310     }
311
312     Length m_stdDeviation;
313 };
314
315 FILTEROPERATION_TYPE_CASTS(BlurFilterOperation, type() == FilterOperation::BLUR);
316
317 class WEBCORE_EXPORT DropShadowFilterOperation : public FilterOperation {
318 public:
319     static PassRefPtr<DropShadowFilterOperation> create(const IntPoint& location, int stdDeviation, Color color)
320     {
321         return adoptRef(new DropShadowFilterOperation(location, stdDeviation, color));
322     }
323
324     virtual PassRefPtr<FilterOperation> clone() const override
325     {
326         return adoptRef(new DropShadowFilterOperation(location(), stdDeviation(), color()));
327     }
328
329     int x() const { return m_location.x(); }
330     int y() const { return m_location.y(); }
331     IntPoint location() const { return m_location; }
332     int stdDeviation() const { return m_stdDeviation; }
333     Color color() const { return m_color; }
334
335     virtual bool affectsOpacity() const override { return true; }
336     virtual bool movesPixels() const override { return true; }
337
338     virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress, bool blendToPassthrough = false) override;
339
340 private:
341     virtual bool operator==(const FilterOperation&) const override;
342
343     DropShadowFilterOperation(const IntPoint& location, int stdDeviation, Color color)
344         : FilterOperation(DROP_SHADOW)
345         , m_location(location)
346         , m_stdDeviation(stdDeviation)
347         , m_color(color)
348     {
349     }
350
351     IntPoint m_location; // FIXME: should location be in Lengths?
352     int m_stdDeviation;
353     Color m_color;
354 };
355
356 FILTEROPERATION_TYPE_CASTS(DropShadowFilterOperation, type() == FilterOperation::DROP_SHADOW);
357
358 } // namespace WebCore
359
360 #endif // FilterOperation_h