Use "= default" to denote default constructor or destructor
[WebKit-https.git] / Source / WebCore / platform / graphics / filters / FilterOperation.h
index 2306b7e..d9eb530 100644 (file)
 #ifndef FilterOperation_h
 #define FilterOperation_h
 
-#if ENABLE(CSS_FILTERS)
-
 #include "Color.h"
-#include "FilterEffect.h"
 #include "LayoutSize.h"
 #include "Length.h"
-#include <wtf/OwnPtr.h>
-#include <wtf/PassOwnPtr.h>
 #include <wtf/RefCounted.h>
+#include <wtf/TypeCasts.h>
 #include <wtf/text/WTFString.h>
 
 // Annoyingly, wingdi.h #defines this.
@@ -46,7 +42,10 @@ namespace WebCore {
 
 // CSS Filters
 
+class CachedResourceLoader;
 class CachedSVGDocumentReference;
+class FilterEffect;
+struct ResourceLoaderOptions;
 
 class FilterOperation : public RefCounted<FilterOperation> {
 public:
@@ -67,21 +66,16 @@ public:
         NONE
     };
 
-    virtual ~FilterOperation() { }
+    virtual ~FilterOperation() = default;
+
+    virtual Ref<FilterOperation> clone() const = 0;
 
     virtual bool operator==(const FilterOperation&) const = 0;
     bool operator!=(const FilterOperation& o) const { return !(*this == o); }
 
-    virtual PassRefPtr<FilterOperation> blend(const FilterOperation* /*from*/, double /*progress*/, bool /*blendToPassthrough*/ = false)
-    {
-        ASSERT(!blendingNeedsRendererSize());
-        return 0;
-    }
-
-    virtual PassRefPtr<FilterOperation> blend(const FilterOperation* /*from*/, double /*progress*/, const LayoutSize&, bool /*blendToPassthrough*/ = false)
+    virtual RefPtr<FilterOperation> blend(const FilterOperation* /*from*/, double /*progress*/, bool /*blendToPassthrough*/ = false)
     {
-        ASSERT(blendingNeedsRendererSize());
-        return 0;
+        return nullptr;
     }
 
     OperationType type() const { return m_type; }
@@ -100,10 +94,10 @@ public:
 
     // True if the alpha channel of any pixel can change under this operation.
     virtual bool affectsOpacity() const { return false; }
-    // True if the the value of one pixel can affect the value of another pixel under this operation, such as blur.
+    // True if the value of one pixel can affect the value of another pixel under this operation, such as blur.
     virtual bool movesPixels() const { return false; }
-    // True if the filter needs the size of the box in order to calculate the animations.
-    virtual bool blendingNeedsRendererSize() const { return false; }
+    // True if the filter should not be allowed to work on content that is not available from this security origin.
+    virtual bool shouldBeRestrictedBySecurityOrigin() const { return false; }
 
 protected:
     FilterOperation(OperationType type)
@@ -114,20 +108,22 @@ protected:
     OperationType m_type;
 };
 
-#define FILTEROPERATION_TYPE_CASTS(ToValueTypeName, predicate) \
-    TYPE_CASTS_BASE(ToValueTypeName, WebCore::FilterOperation, value, value->predicate, value.predicate)
-
-class DefaultFilterOperation : public FilterOperation {
+class WEBCORE_EXPORT DefaultFilterOperation : public FilterOperation {
 public:
-    static PassRefPtr<DefaultFilterOperation> create(OperationType representedType)
+    static Ref<DefaultFilterOperation> create(OperationType representedType)
+    {
+        return adoptRef(*new DefaultFilterOperation(representedType));
+    }
+
+    Ref<FilterOperation> clone() const override
     {
-        return adoptRef(new DefaultFilterOperation(representedType));
+        return adoptRef(*new DefaultFilterOperation(representedType()));
     }
 
     OperationType representedType() const { return m_representedType; }
 
 private:
-    virtual bool operator==(const FilterOperation&) const override;
+    bool operator==(const FilterOperation&) const override;
 
     DefaultFilterOperation(OperationType representedType)
         : FilterOperation(DEFAULT)
@@ -138,18 +134,20 @@ private:
     OperationType m_representedType;
 };
 
-FILTEROPERATION_TYPE_CASTS(DefaultFilterOperation, type() == FilterOperation::DEFAULT);
-
-
 class PassthroughFilterOperation : public FilterOperation {
 public:
-    static PassRefPtr<PassthroughFilterOperation> create()
+    static Ref<PassthroughFilterOperation> create()
+    {
+        return adoptRef(*new PassthroughFilterOperation());
+    }
+
+    Ref<FilterOperation> clone() const override
     {
-        return adoptRef(new PassthroughFilterOperation());
+        return adoptRef(*new PassthroughFilterOperation());
     }
 
 private:
-    virtual bool operator==(const FilterOperation& o) const override
+    bool operator==(const FilterOperation& o) const override
     {
         return isSameType(o);
     }
@@ -160,32 +158,41 @@ private:
     }
 };
 
-FILTEROPERATION_TYPE_CASTS(PassthroughFilterOperation, type() == FilterOperation::PASSTHROUGH);
-
 class ReferenceFilterOperation : public FilterOperation {
 public:
-    static PassRefPtr<ReferenceFilterOperation> create(const String& url, const String& fragment)
+    static Ref<ReferenceFilterOperation> create(const String& url, const String& fragment)
     {
-        return adoptRef(new ReferenceFilterOperation(url, fragment));
+        return adoptRef(*new ReferenceFilterOperation(url, fragment));
     }
     virtual ~ReferenceFilterOperation();
 
-    virtual bool affectsOpacity() const override { return true; }
-    virtual bool movesPixels() const override { return true; }
+    Ref<FilterOperation> clone() const override
+    {
+        // Reference filters cannot be cloned.
+        RELEASE_ASSERT_NOT_REACHED();
+        return *static_cast<FilterOperation*>(nullptr);
+    }
+
+    bool affectsOpacity() const override { return true; }
+    bool movesPixels() const override { return true; }
+    // FIXME: This only needs to return true for graphs that include ConvolveMatrix, DisplacementMap, Morphology and possibly Lighting.
+    // https://bugs.webkit.org/show_bug.cgi?id=171753
+    bool shouldBeRestrictedBySecurityOrigin() const override { return true; }
 
     const String& url() const { return m_url; }
     const String& fragment() const { return m_fragment; }
 
+    void loadExternalDocumentIfNeeded(CachedResourceLoader&, const ResourceLoaderOptions&);
+
     CachedSVGDocumentReference* cachedSVGDocumentReference() const { return m_cachedSVGDocumentReference.get(); }
-    CachedSVGDocumentReference* getOrCreateCachedSVGDocumentReference();
 
     FilterEffect* filterEffect() const { return m_filterEffect.get(); }
-    void setFilterEffect(PassRefPtr<FilterEffect> filterEffect) { m_filterEffect = filterEffect; }
+    void setFilterEffect(RefPtr<FilterEffect>&&);
 
 private:
     ReferenceFilterOperation(const String& url, const String& fragment);
 
-    virtual bool operator==(const FilterOperation&) const override;
+    bool operator==(const FilterOperation&) const override;
 
     String m_url;
     String m_fragment;
@@ -193,23 +200,26 @@ private:
     RefPtr<FilterEffect> m_filterEffect;
 };
 
-FILTEROPERATION_TYPE_CASTS(ReferenceFilterOperation, type() == FilterOperation::REFERENCE);
-
 // GRAYSCALE, SEPIA, SATURATE and HUE_ROTATE are variations on a basic color matrix effect.
 // For HUE_ROTATE, the angle of rotation is stored in m_amount.
-class BasicColorMatrixFilterOperation : public FilterOperation {
+class WEBCORE_EXPORT BasicColorMatrixFilterOperation : public FilterOperation {
 public:
-    static PassRefPtr<BasicColorMatrixFilterOperation> create(double amount, OperationType type)
+    static Ref<BasicColorMatrixFilterOperation> create(double amount, OperationType type)
+    {
+        return adoptRef(*new BasicColorMatrixFilterOperation(amount, type));
+    }
+
+    Ref<FilterOperation> clone() const override
     {
-        return adoptRef(new BasicColorMatrixFilterOperation(amount, type));
+        return adoptRef(*new BasicColorMatrixFilterOperation(amount(), type()));
     }
 
     double amount() const { return m_amount; }
 
-    virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress, bool blendToPassthrough = false) override;
+    RefPtr<FilterOperation> blend(const FilterOperation* from, double progress, bool blendToPassthrough = false) override;
 
 private:
-    virtual bool operator==(const FilterOperation&) const override;
+    bool operator==(const FilterOperation&) const override;
 
     double passthroughAmount() const;
 
@@ -222,24 +232,27 @@ private:
     double m_amount;
 };
 
-FILTEROPERATION_TYPE_CASTS(BasicColorMatrixFilterOperation, isBasicColorMatrixFilterOperation());
-
 // INVERT, BRIGHTNESS, CONTRAST and OPACITY are variations on a basic component transfer effect.
-class BasicComponentTransferFilterOperation : public FilterOperation {
+class WEBCORE_EXPORT BasicComponentTransferFilterOperation : public FilterOperation {
 public:
-    static PassRefPtr<BasicComponentTransferFilterOperation> create(double amount, OperationType type)
+    static Ref<BasicComponentTransferFilterOperation> create(double amount, OperationType type)
+    {
+        return adoptRef(*new BasicComponentTransferFilterOperation(amount, type));
+    }
+
+    Ref<FilterOperation> clone() const override
     {
-        return adoptRef(new BasicComponentTransferFilterOperation(amount, type));
+        return adoptRef(*new BasicComponentTransferFilterOperation(amount(), type()));
     }
 
     double amount() const { return m_amount; }
 
-    virtual bool affectsOpacity() const override { return m_type == OPACITY; }
+    bool affectsOpacity() const override { return m_type == OPACITY; }
 
-    virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress, bool blendToPassthrough = false) override;
+    RefPtr<FilterOperation> blend(const FilterOperation* from, double progress, bool blendToPassthrough = false) override;
 
 private:
-    virtual bool operator==(const FilterOperation&) const override;
+    bool operator==(const FilterOperation&) const override;
 
     double passthroughAmount() const;
 
@@ -252,58 +265,64 @@ private:
     double m_amount;
 };
 
-FILTEROPERATION_TYPE_CASTS(BasicComponentTransferFilterOperation, isBasicComponentTransferFilterOperation());
-
-class BlurFilterOperation : public FilterOperation {
+class WEBCORE_EXPORT BlurFilterOperation : public FilterOperation {
 public:
-    static PassRefPtr<BlurFilterOperation> create(Length stdDeviation)
+    static Ref<BlurFilterOperation> create(Length stdDeviation)
+    {
+        return adoptRef(*new BlurFilterOperation(WTFMove(stdDeviation)));
+    }
+
+    Ref<FilterOperation> clone() const override
     {
-        return adoptRef(new BlurFilterOperation(std::move(stdDeviation)));
+        return adoptRef(*new BlurFilterOperation(stdDeviation()));
     }
 
     const Length& stdDeviation() const { return m_stdDeviation; }
 
-    virtual bool affectsOpacity() const override { return true; }
-    virtual bool movesPixels() const override { return true; }
+    bool affectsOpacity() const override { return true; }
+    bool movesPixels() const override { return true; }
 
-    virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress, bool blendToPassthrough = false) override;
+    RefPtr<FilterOperation> blend(const FilterOperation* from, double progress, bool blendToPassthrough = false) override;
 
 private:
-    virtual bool operator==(const FilterOperation&) const override;
+    bool operator==(const FilterOperation&) const override;
 
     BlurFilterOperation(Length stdDeviation)
         : FilterOperation(BLUR)
-        , m_stdDeviation(std::move(stdDeviation))
+        , m_stdDeviation(WTFMove(stdDeviation))
     {
     }
 
     Length m_stdDeviation;
 };
 
-FILTEROPERATION_TYPE_CASTS(BlurFilterOperation, type() == FilterOperation::BLUR);
-
-class DropShadowFilterOperation : public FilterOperation {
+class WEBCORE_EXPORT DropShadowFilterOperation : public FilterOperation {
 public:
-    static PassRefPtr<DropShadowFilterOperation> create(const IntPoint& location, int stdDeviation, Color color)
+    static Ref<DropShadowFilterOperation> create(const IntPoint& location, int stdDeviation, const Color& color)
+    {
+        return adoptRef(*new DropShadowFilterOperation(location, stdDeviation, color));
+    }
+
+    Ref<FilterOperation> clone() const override
     {
-        return adoptRef(new DropShadowFilterOperation(location, stdDeviation, color));
+        return adoptRef(*new DropShadowFilterOperation(location(), stdDeviation(), color()));
     }
 
     int x() const { return m_location.x(); }
     int y() const { return m_location.y(); }
     IntPoint location() const { return m_location; }
     int stdDeviation() const { return m_stdDeviation; }
-    Color color() const { return m_color; }
+    const Color& color() const { return m_color; }
 
-    virtual bool affectsOpacity() const override { return true; }
-    virtual bool movesPixels() const override { return true; }
+    bool affectsOpacity() const override { return true; }
+    bool movesPixels() const override { return true; }
 
-    virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress, bool blendToPassthrough = false) override;
+    RefPtr<FilterOperation> blend(const FilterOperation* from, double progress, bool blendToPassthrough = false) override;
 
 private:
-    virtual bool operator==(const FilterOperation&) const override;
+    bool operator==(const FilterOperation&) const override;
 
-    DropShadowFilterOperation(const IntPoint& location, int stdDeviation, Color color)
+    DropShadowFilterOperation(const IntPoint& location, int stdDeviation, const Color& color)
         : FilterOperation(DROP_SHADOW)
         , m_location(location)
         , m_stdDeviation(stdDeviation)
@@ -316,10 +335,21 @@ private:
     Color m_color;
 };
 
-FILTEROPERATION_TYPE_CASTS(DropShadowFilterOperation, type() == FilterOperation::DROP_SHADOW);
+WEBCORE_EXPORT WTF::TextStream& operator<<(WTF::TextStream&, const FilterOperation&);
 
 } // namespace WebCore
 
-#endif // ENABLE(CSS_FILTERS)
+#define SPECIALIZE_TYPE_TRAITS_FILTEROPERATION(ToValueTypeName, predicate) \
+SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::ToValueTypeName) \
+    static bool isType(const WebCore::FilterOperation& operation) { return operation.predicate; } \
+SPECIALIZE_TYPE_TRAITS_END()
+
+SPECIALIZE_TYPE_TRAITS_FILTEROPERATION(DefaultFilterOperation, type() == WebCore::FilterOperation::DEFAULT)
+SPECIALIZE_TYPE_TRAITS_FILTEROPERATION(PassthroughFilterOperation, type() == WebCore::FilterOperation::PASSTHROUGH)
+SPECIALIZE_TYPE_TRAITS_FILTEROPERATION(ReferenceFilterOperation, type() == WebCore::FilterOperation::REFERENCE)
+SPECIALIZE_TYPE_TRAITS_FILTEROPERATION(BasicColorMatrixFilterOperation, isBasicColorMatrixFilterOperation())
+SPECIALIZE_TYPE_TRAITS_FILTEROPERATION(BasicComponentTransferFilterOperation, isBasicComponentTransferFilterOperation())
+SPECIALIZE_TYPE_TRAITS_FILTEROPERATION(BlurFilterOperation, type() == WebCore::FilterOperation::BLUR)
+SPECIALIZE_TYPE_TRAITS_FILTEROPERATION(DropShadowFilterOperation, type() == WebCore::FilterOperation::DROP_SHADOW)
 
 #endif // FilterOperation_h