[Filters] Make Filter and FilterEffects create FilterStyles

https://bugs.webkit.org/show_bug.cgi?id=248318
rdar://102651202

Reviewed by Simon Fraser.

A FilterStyle is a structure composed of a GraphicsStyle and the geometry of the
FilterEffect. A vector of FilterStyles will be used to apply a chain of FilterEffects
to the GraphicsContext. The FilterStyle can only be created by effects which takes
one and only one input.

* Source/WTF/wtf/PlatformHave.h:
* Source/WTF/wtf/PlatformUse.h:
* Source/WebCore/Headers.cmake:
* Source/WebCore/PAL/pal/spi/cg/CoreGraphicsSPI.h:
* Source/WebCore/WebCore.xcodeproj/project.pbxproj:
* Source/WebCore/page/Page.cpp:
(WebCore::Page::preferredFilterRenderingModes const):
* Source/WebCore/platform/graphics/cg/GraphicsContextCG.cpp:
(WebCore::setCGStyle):
(WebCore::GraphicsContextCG::didUpdateState):
* Source/WebCore/platform/graphics/filters/FEColorMatrix.cpp:
(WebCore::FEColorMatrix::supportedFilterRenderingModes const):
(WebCore::FEColorMatrix::createGraphicsStyle const):
* Source/WebCore/platform/graphics/filters/FEColorMatrix.h:
* Source/WebCore/platform/graphics/filters/FEComponentTransfer.cpp:
(WebCore::FEComponentTransfer::supportedFilterRenderingModes const):
* Source/WebCore/platform/graphics/filters/FEDropShadow.cpp:
(WebCore::FEDropShadow::supportedFilterRenderingModes const):
(WebCore::FEDropShadow::createGraphicsStyle const):
* Source/WebCore/platform/graphics/filters/FEDropShadow.h:
* Source/WebCore/platform/graphics/filters/FEGaussianBlur.cpp:
(WebCore::FEGaussianBlur::supportedFilterRenderingModes const):
(WebCore::FEGaussianBlur::createGraphicsStyle const):
* Source/WebCore/platform/graphics/filters/FEGaussianBlur.h:
* Source/WebCore/platform/graphics/filters/Filter.cpp:
(WebCore::Filter::createFilterStyles const):
* Source/WebCore/platform/graphics/filters/Filter.h:
* Source/WebCore/platform/graphics/filters/FilterEffect.cpp:
(WebCore::FilterEffect::createFilterStyles const):
(WebCore::FilterEffect::createFilterStyle const):
* Source/WebCore/platform/graphics/filters/FilterEffect.h:
(WebCore::FilterEffect::numberOfImageInputs const):
(WebCore::FilterEffect::numberOfEffectInputs const):
(WebCore::FilterEffect::createGraphicsStyle const):
* Source/WebCore/platform/graphics/filters/FilterFunction.h:
(WebCore::FilterFunction::createFilterStyles const):
* Source/WebCore/platform/graphics/filters/FilterStyle.h: Added.
* Source/WebCore/platform/graphics/filters/SourceGraphic.cpp:
(WebCore::SourceGraphic::supportedFilterRenderingModes const):
* Source/WebCore/rendering/CSSFilter.cpp:
(WebCore::CSSFilter::createFilterStyles const):
* Source/WebCore/rendering/CSSFilter.h:
* Source/WebCore/svg/graphics/filters/SVGFilter.cpp:
(WebCore::SVGFilter::apply):
(WebCore::SVGFilter::createFilterStyles const):
* Source/WebCore/svg/graphics/filters/SVGFilter.h:

Canonical link: https://commits.webkit.org/257045@main

Source/WTF/wtf/PlatformHave.h

@@ -1356,3 +1356,11 @@
     || ((PLATFORM(IOS) || PLATFORM(MACCATALYST)) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 160000)
 #define HAVE_CONTINUITY_CAMEARA 1
 #endif
+
+#if !defined(HAVE_CGSTYLE_CREATE_SHADOW2) \
+    && ((PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 130000) \
+    || ((PLATFORM(IOS) || PLATFORM(MACCATALYST)) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 160000) \
+    || (PLATFORM(WATCHOS) && __WATCH_OS_VERSION_MIN_REQUIRED >= 90000) \
+    || (PLATFORM(APPLETV) && __TV_OS_VERSION_MIN_REQUIRED >= 160000))
+#define HAVE_CGSTYLE_CREATE_SHADOW2 1
+#endif

Source/WTF/wtf/PlatformUse.h

@@ -371,3 +371,7 @@
 #if (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED < 130000)
 #define USE_AVIF 1
 #endif
+
+#if PLATFORM(COCOA) && (HAVE(CGSTYLE_CREATE_SHADOW2) || HAVE(CGSTYLE_COLORMATRIX_BLUR))
+#define USE_GRAPHICS_CONTEXT_FILTERS 1
+#endif

Source/WebCore/Headers.cmake

@@ -1765,6 +1765,7 @@ set(WebCore_PRIVATE_FRAMEWORK_HEADERS
     platform/graphics/filters/FilterOperations.h
     platform/graphics/filters/FilterRenderingMode.h
     platform/graphics/filters/FilterResults.h
+    platform/graphics/filters/FilterStyle.h
     platform/graphics/filters/LightSource.h
     platform/graphics/filters/PointLightSource.h
     platform/graphics/filters/SourceAlpha.h

Source/WebCore/PAL/pal/spi/cg/CoreGraphicsSPI.h

@@ -190,7 +190,7 @@ struct CGShadowStyle {
 };
 typedef struct CGShadowStyle CGShadowStyle;
 
-#if HAVE(CORE_GRAPHICS_STYLES)
+#if HAVE(CGSTYLE_COLORMATRIX_BLUR)
 struct CGGaussianBlurStyle {
     unsigned version;
     CGFloat radius;
@@ -209,7 +209,7 @@ typedef CF_ENUM (int32_t, CGStyleType)
     kCGStyleUnknown = 0,
     kCGStyleShadow = 1,
     kCGStyleFocusRing = 2,
-#if HAVE(CORE_GRAPHICS_STYLES)
+#if HAVE(CGSTYLE_COLORMATRIX_BLUR)
     kCGStyleGaussianBlur = 3,
     kCGStyleColorMatrix = 4,
 #endif
@@ -366,8 +366,10 @@ CGGradientRef CGGradientCreateWithColorsAndOptions(CGColorSpaceRef, CFArrayRef,
 extern const CFStringRef kCGGradientInterpolatesPremultiplied;
 #endif
 
-#if HAVE(CORE_GRAPHICS_STYLES)
+#if HAVE(CGSTYLE_CREATE_SHADOW2)
 CGStyleRef CGStyleCreateShadow2(CGSize offset, CGFloat radius, CGColorRef);
+#endif
+#if HAVE(CGSTYLE_COLORMATRIX_BLUR)
 CGStyleRef CGStyleCreateGaussianBlur(const CGGaussianBlurStyle*);
 CGStyleRef CGStyleCreateColorMatrix(const CGColorMatrixStyle*);
 #endif

Source/WebCore/WebCore.xcodeproj/project.pbxproj

@@ -2462,6 +2462,7 @@
 		726D56E2253AE28D0002EF90 /* PlatformImage.h in Headers */ = {isa = PBXBuildFile; fileRef = 726D56E1253AE0430002EF90 /* PlatformImage.h */; settings = {ATTRIBUTES = (Private, ); }; };
 		726D56E3253AE3660002EF90 /* NativeImage.h in Headers */ = {isa = PBXBuildFile; fileRef = 55A336F61D8209F40022C4C7 /* NativeImage.h */; settings = {ATTRIBUTES = (Private, ); }; };
 		727003E6292F2DD50094C64B /* FilterRenderingMode.h in Headers */ = {isa = PBXBuildFile; fileRef = 727003E5292F2DBB0094C64B /* FilterRenderingMode.h */; settings = {ATTRIBUTES = (Private, ); }; };
+		7272D337292F818E00F74D99 /* FilterStyle.h in Headers */ = {isa = PBXBuildFile; fileRef = 7272D336292F767D00F74D99 /* FilterStyle.h */; settings = {ATTRIBUTES = (Private, ); }; };
 		727A7F3A24078B84004D2931 /* ImageBufferIOSurfaceBackend.h in Headers */ = {isa = PBXBuildFile; fileRef = 72BAC3AB23E1E544008D741C /* ImageBufferIOSurfaceBackend.h */; settings = {ATTRIBUTES = (Private, ); }; };
 		728D4791279A48B700BA7C0E /* FilterEffectApplier.h in Headers */ = {isa = PBXBuildFile; fileRef = 72A13A9F274C5CC700E2A88E /* FilterEffectApplier.h */; settings = {ATTRIBUTES = (Private, ); }; };
 		7299BC6723D6A53200CC6883 /* AlphaPremultiplication.h in Headers */ = {isa = PBXBuildFile; fileRef = 7299BC6423D686A600CC6883 /* AlphaPremultiplication.h */; settings = {ATTRIBUTES = (Private, ); }; };
@@ -11811,6 +11812,7 @@
 		726CDE25275B489700A445B2 /* SVGFilterExpression.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SVGFilterExpression.h; sourceTree = "<group>"; };
 		726D56E1253AE0430002EF90 /* PlatformImage.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = PlatformImage.h; sourceTree = "<group>"; };
 		727003E5292F2DBB0094C64B /* FilterRenderingMode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FilterRenderingMode.h; sourceTree = "<group>"; };
+		7272D336292F767D00F74D99 /* FilterStyle.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FilterStyle.h; sourceTree = "<group>"; };
 		727AFED11A2EA6A0000442E8 /* EXTsRGB.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = EXTsRGB.cpp; sourceTree = "<group>"; };
 		727AFED21A2EA6A0000442E8 /* EXTsRGB.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EXTsRGB.h; sourceTree = "<group>"; };
 		727AFED31A2EA6A0000442E8 /* EXTsRGB.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = EXTsRGB.idl; sourceTree = "<group>"; };
@@ -27987,6 +27989,7 @@
 				727003E5292F2DBB0094C64B /* FilterRenderingMode.h */,
 				724DCF1D28485C330026ACF4 /* FilterResults.cpp */,
 				7211B5D6276536820076FEF8 /* FilterResults.h */,
+				7272D336292F767D00F74D99 /* FilterStyle.h */,
 				724E09062901CD27000AF3EB /* FilterTargetSwitcher.cpp */,
 				724E09072901CD27000AF3EB /* FilterTargetSwitcher.h */,
 				84730D741248F0B300D3A9C9 /* LightSource.h */,
@@ -35826,6 +35829,7 @@
 				49ECEB701499790D00CDD3A4 /* FilterOperations.h in Headers */,
 				727003E6292F2DD50094C64B /* FilterRenderingMode.h in Headers */,
 				72D73644278461A000398663 /* FilterResults.h in Headers */,
+				7272D337292F818E00F74D99 /* FilterStyle.h in Headers */,
 				372C00D9129619F8005C9575 /* FindOptions.h in Headers */,
 				A8CFF04F0A154F09000A4234 /* FixedTableLayout.h in Headers */,
 				6FB17476283A8FF40067D8CA /* FlexFormattingConstraints.h in Headers */,

Source/WebCore/page/Page.cpp

@@ -3833,7 +3833,7 @@ OptionSet<FilterRenderingMode> Page::preferredFilterRenderingModes() const
     OptionSet<FilterRenderingMode> modes = FilterRenderingMode::Software;
 #if USE(CORE_IMAGE)
     if (settings().acceleratedFiltersEnabled())
-        modes = modes | FilterRenderingMode::Accelerated;
+        modes.add(FilterRenderingMode::Accelerated);
 #endif
     return modes;
 }

Source/WebCore/platform/graphics/cg/GraphicsContextCG.cpp

@@ -1077,7 +1077,7 @@ void GraphicsContextCG::clearCGShadow()
     CGContextSetShadowWithColor(platformContext(), CGSizeZero, 0, 0);
 }
 
-#if HAVE(CORE_GRAPHICS_STYLES)
+#if PLATFORM(COCOA)
 static void setCGStyle(CGContextRef context, const std::optional<GraphicsStyle>& style)
 {
     if (!style) {
@@ -1087,18 +1087,36 @@ static void setCGStyle(CGContextRef context, const std::optional<GraphicsStyle>&
 
     auto cgStyle = WTF::switchOn(*style,
         [&] (const GraphicsDropShadow& dropShadow) -> RetainPtr<CGStyleRef> {
+#if HAVE(CGSTYLE_CREATE_SHADOW2)
             return adoptCF(CGStyleCreateShadow2(dropShadow.offset, dropShadow.radius.width(), cachedCGColor(dropShadow.color).get()));
+#else
+            ASSERT_NOT_REACHED();
+            UNUSED_PARAM(dropShadow);
+            return nullptr;
+#endif
         },
         [&] (const GraphicsGaussianBlur& gaussianBlur) -> RetainPtr<CGStyleRef> {
+#if HAVE(CGSTYLE_COLORMATRIX_BLUR)
             ASSERT(gaussianBlur.radius.width() == gaussianBlur.radius.height());
             CGGaussianBlurStyle gaussianBlurStyle = { 1, gaussianBlur.radius.width() };
             return adoptCF(CGStyleCreateGaussianBlur(&gaussianBlurStyle));
+#else
+            ASSERT_NOT_REACHED();
+            UNUSED_PARAM(gaussianBlur);
+            return nullptr;
+#endif
         },
         [&] (const GraphicsColorMatrix& colorMatrix) -> RetainPtr<CGStyleRef> {
+#if HAVE(CGSTYLE_COLORMATRIX_BLUR)
             CGColorMatrixStyle colorMatrixStyle = { 1, { 0 } };
             for (auto value : colorMatrix.values)
                 colorMatrixStyle.matrix[i] = value;
             return adoptCF(CGStyleCreateColorMatrix(&colorMatrixStyle));
+#else
+            ASSERT_NOT_REACHED();
+            UNUSED_PARAM(colorMatrix);
+            return nullptr;
+#endif
         }
     );
 
@@ -1137,7 +1155,7 @@ void GraphicsContextCG::didUpdateState(GraphicsContextState& state)
             break;
 
         case GraphicsContextState::Change::Style:
-#if HAVE(CORE_GRAPHICS_STYLES)
+#if PLATFORM(COCOA)
             setCGStyle(context, state.style());
 #endif
             break;

Source/WebCore/platform/graphics/filters/FEColorMatrix.cpp

@@ -115,7 +115,11 @@ OptionSet<FilterRenderingMode> FEColorMatrix::supportedFilterRenderingModes() co
     OptionSet<FilterRenderingMode> modes = FilterRenderingMode::Software;
 #if USE(CORE_IMAGE)
     if (FEColorMatrixCoreImageApplier::supportsCoreImageRendering(*this))
-        modes = modes | FilterRenderingMode::Accelerated;
+        modes.add(FilterRenderingMode::Accelerated);
+#endif
+#if HAVE(CGSTYLE_COLORMATRIX_BLUR)
+    if (m_type == FECOLORMATRIX_TYPE_MATRIX)
+        modes.add(FilterRenderingMode::GraphicsContext);
 #endif
     return modes;
 }
@@ -134,6 +138,13 @@ std::unique_ptr<FilterEffectApplier> FEColorMatrix::createSoftwareApplier() cons
     return FilterEffectApplier::create<FEColorMatrixSoftwareApplier>(*this);
 }
 
+std::optional<GraphicsStyle> FEColorMatrix::createGraphicsStyle(const Filter&) const
+{
+    std::array<float, 20> values;
+    std::copy_n(m_values.begin(), std::min<size_t>(m_values.size(), 20), values.begin());
+    return GraphicsColorMatrix { values };
+}
+
 static TextStream& operator<<(TextStream& ts, const ColorMatrixType& type)
 {
     switch (type) {

Source/WebCore/platform/graphics/filters/FEColorMatrix.h

@@ -58,8 +58,10 @@ class FEColorMatrix : public FilterEffect {
     bool resultIsAlphaImage(const FilterImageVector& inputs) const override;
 
     OptionSet<FilterRenderingMode> supportedFilterRenderingModes() const override;
+
     std::unique_ptr<FilterEffectApplier> createAcceleratedApplier() const override;
     std::unique_ptr<FilterEffectApplier> createSoftwareApplier() const override;
+    std::optional<GraphicsStyle> createGraphicsStyle(const Filter&) const override;
 
     WTF::TextStream& externalRepresentation(WTF::TextStream&, FilterRepresentation) const override;
 

Source/WebCore/platform/graphics/filters/FEComponentTransfer.cpp

@@ -62,7 +62,7 @@ OptionSet<FilterRenderingMode> FEComponentTransfer::supportedFilterRenderingMode
     OptionSet<FilterRenderingMode> modes = FilterRenderingMode::Software;
 #if USE(CORE_IMAGE)
     if (FEComponentTransferCoreImageApplier::supportsCoreImageRendering(*this))
-        modes = modes | FilterRenderingMode::Accelerated;
+        modes.add(FilterRenderingMode::Accelerated);
 #endif
     return modes;
 }

Source/WebCore/platform/graphics/filters/FEDropShadow.cpp

@@ -121,6 +121,25 @@ IntOutsets FEDropShadow::calculateOutsets(const FloatSize& offset, const FloatSi
     return { top, right, bottom, left };
 }
 
+OptionSet<FilterRenderingMode> FEDropShadow::supportedFilterRenderingModes() const
+{
+    OptionSet<FilterRenderingMode> modes = FilterRenderingMode::Software;
+#if HAVE(CGSTYLE_CREATE_SHADOW2)
+    if (m_stdX == m_stdY)
+        modes.add(FilterRenderingMode::GraphicsContext);
+#endif
+    return modes;
+}
+
+std::optional<GraphicsStyle> FEDropShadow::createGraphicsStyle(const Filter& filter) const
+{
+    auto offset = filter.resolvedSize({ m_dx, m_dy });
+    auto radius = FEGaussianBlur::calculateUnscaledKernelSize(filter.resolvedSize({ m_stdX, m_stdY }));
+    auto color = m_shadowColor.colorWithAlpha(m_shadowOpacity);
+
+    return GraphicsDropShadow { offset, radius, color };
+}
+
 std::unique_ptr<FilterEffectApplier> FEDropShadow::createSoftwareApplier() const
 {
     return FilterEffectApplier::create<FEDropShadowSoftwareApplier>(*this);

Source/WebCore/platform/graphics/filters/FEDropShadow.h

@@ -57,7 +57,10 @@ class FEDropShadow : public FilterEffect {
 
     FloatRect calculateImageRect(const Filter&, Span<const FloatRect> inputImageRects, const FloatRect& primitiveSubregion) const override;
 
+    OptionSet<FilterRenderingMode> supportedFilterRenderingModes() const override;
+
     std::unique_ptr<FilterEffectApplier> createSoftwareApplier() const override;
+    std::optional<GraphicsStyle> createGraphicsStyle(const Filter&) const override;
 
     WTF::TextStream& externalRepresentation(WTF::TextStream&, FilterRepresentation) const override;
 

Source/WebCore/platform/graphics/filters/FEGaussianBlur.cpp

@@ -140,11 +140,27 @@ bool FEGaussianBlur::resultIsAlphaImage(const FilterImageVector& inputs) const
     return inputs[0]->isAlphaImage();
 }
 
+OptionSet<FilterRenderingMode> FEGaussianBlur::supportedFilterRenderingModes() const
+{
+    OptionSet<FilterRenderingMode> modes = FilterRenderingMode::Software;
+#if HAVE(CGSTYLE_COLORMATRIX_BLUR)
+    if (m_stdX == m_stdY)
+        modes.add(FilterRenderingMode::GraphicsContext);
+#endif
+    return modes;
+}
+
 std::unique_ptr<FilterEffectApplier> FEGaussianBlur::createSoftwareApplier() const
 {
     return FilterEffectApplier::create<FEGaussianBlurSoftwareApplier>(*this);
 }
 
+std::optional<GraphicsStyle> FEGaussianBlur::createGraphicsStyle(const Filter& filter) const
+{
+    auto radius = calculateUnscaledKernelSize(filter.resolvedSize({ m_stdX, m_stdY }));
+    return GraphicsGaussianBlur { radius };
+}
+
 TextStream& FEGaussianBlur::externalRepresentation(TextStream& ts, FilterRepresentation representation) const
 {
     ts << indent << "[feGaussianBlur";

Source/WebCore/platform/graphics/filters/FEGaussianBlur.h

@@ -56,7 +56,10 @@ class FEGaussianBlur : public FilterEffect {
 
     bool resultIsAlphaImage(const FilterImageVector& inputs) const override;
 
+    OptionSet<FilterRenderingMode> supportedFilterRenderingModes() const override;
+
     std::unique_ptr<FilterEffectApplier> createSoftwareApplier() const override;
+    std::optional<GraphicsStyle> createGraphicsStyle(const Filter&) const override;
 
     WTF::TextStream& externalRepresentation(WTF::TextStream&, FilterRepresentation) const override;
 

Source/WebCore/platform/graphics/filters/Filter.cpp

@@ -29,6 +29,7 @@
 #include "FilterEffect.h"
 #include "FilterImage.h"
 #include "FilterResults.h"
+#include "FilterStyle.h"
 #include "ImageBuffer.h"
 
 namespace WebCore {
@@ -130,4 +131,16 @@ RefPtr<FilterImage> Filter::apply(ImageBuffer* sourceImage, const FloatRect& sou
     return result;
 }
 
+FilterStyleVector Filter::createFilterStyles(const FloatRect& sourceImageRect) const
+{
+    auto input = FilterStyle { std::nullopt, m_filterRegion, sourceImageRect };
+    auto result = createFilterStyles(input);
+    if (result.isEmpty())
+        return { };
+
+    result.reverse();
+    result.shrinkToFit();
+    return result;
+}
+
 } // namespace WebCore

Source/WebCore/platform/graphics/filters/Filter.h

@@ -37,6 +37,7 @@ class FilterResults;
 
 class Filter : public FilterFunction {
     using FilterFunction::apply;
+    using FilterFunction::createFilterStyles;
 
 public:
     enum class ClipOperation { Intersect, Unite };
@@ -70,13 +71,16 @@ class Filter : public FilterFunction {
 
     bool clampFilterRegionIfNeeded();
 
-    virtual RefPtr<FilterImage> apply(FilterImage* sourceImage, FilterResults&) = 0;
     WEBCORE_EXPORT RefPtr<FilterImage> apply(ImageBuffer* sourceImage, const FloatRect& sourceImageRect, FilterResults&);
+    WEBCORE_EXPORT FilterStyleVector createFilterStyles(const FloatRect& sourceImageRect) const;
 
 protected:
     using FilterFunction::FilterFunction;
     Filter(Filter::Type, const FloatSize& filterScale, ClipOperation, const FloatRect& filterRegion = { });
 
+    virtual RefPtr<FilterImage> apply(FilterImage* sourceImage, FilterResults&) = 0;
+    virtual FilterStyleVector createFilterStyles(const FilterStyle& sourceStyle) const = 0;
+
 private:
     FilterRenderingMode m_filterRenderingMode { FilterRenderingMode::Software };
     FloatSize m_filterScale;

Source/WebCore/platform/graphics/filters/FilterEffect.cpp

@@ -175,6 +175,22 @@ RefPtr<FilterImage> FilterEffect::apply(const Filter& filter, const FilterImageV
     return result;
 }
 
+FilterStyleVector FilterEffect::createFilterStyles(const Filter& filter, const FilterStyle& input) const
+{
+    return { createFilterStyle(filter, input) };
+}
+
+FilterStyle FilterEffect::createFilterStyle(const Filter& filter, const FilterStyle& input, const std::optional<FilterEffectGeometry>& geometry) const
+{
+    ASSERT(supportedFilterRenderingModes().contains(FilterRenderingMode::GraphicsContext));
+
+    auto primitiveSubregion = calculatePrimitiveSubregion(filter, { &input.primitiveSubregion, 1 }, geometry);
+    auto imageRect = calculateImageRect(filter, { &input.imageRect, 1 }, primitiveSubregion);
+
+    auto style = createGraphicsStyle(filter);
+    return FilterStyle { style, primitiveSubregion, imageRect };
+}
+
 TextStream& FilterEffect::externalRepresentation(TextStream& ts, FilterRepresentation representation) const
 {
     // FIXME: We should dump the subRegions of the filter primitives here later. This isn't

Source/WebCore/platform/graphics/filters/FilterEffect.h

@@ -44,16 +44,18 @@ class FilterEffect : public FilterFunction {
     const DestinationColorSpace& operatingColorSpace() const { return m_operatingColorSpace; }
     virtual void setOperatingColorSpace(const DestinationColorSpace& colorSpace) { m_operatingColorSpace = colorSpace; }
 
+    unsigned numberOfImageInputs() const { return filterType() == FilterEffect::Type::SourceGraphic ? 1 : numberOfEffectInputs(); }
     FilterImageVector takeImageInputs(FilterImageVector& stack) const;
+
     RefPtr<FilterImage> apply(const Filter&, const FilterImageVector& inputs, FilterResults&, const std::optional<FilterEffectGeometry>& = std::nullopt);
+    FilterStyle createFilterStyle(const Filter&, const FilterStyle& input, const std::optional<FilterEffectGeometry>& = std::nullopt) const;
 
     WTF::TextStream& externalRepresentation(WTF::TextStream&, FilterRepresentation) const override;
 
 protected:
     using FilterFunction::FilterFunction;
 
     virtual unsigned numberOfEffectInputs() const { return 1; }
-    unsigned numberOfImageInputs() const { return filterType() == FilterEffect::Type::SourceGraphic ? 1 : numberOfEffectInputs(); }
 
     FloatRect calculatePrimitiveSubregion(const Filter&, Span<const FloatRect> inputPrimitiveSubregions, const std::optional<FilterEffectGeometry>&) const;
 
@@ -74,8 +76,10 @@ class FilterEffect : public FilterFunction {
 
     virtual std::unique_ptr<FilterEffectApplier> createAcceleratedApplier() const { return nullptr; }
     virtual std::unique_ptr<FilterEffectApplier> createSoftwareApplier() const = 0;
+    virtual std::optional<GraphicsStyle> createGraphicsStyle(const Filter&) const { return std::nullopt; }
 
     RefPtr<FilterImage> apply(const Filter&, FilterImage& input, FilterResults&) override;
+    FilterStyleVector createFilterStyles(const Filter&, const FilterStyle& input) const override;
 
     DestinationColorSpace m_operatingColorSpace { DestinationColorSpace::SRGB() };
 };

Source/WebCore/platform/graphics/filters/FilterFunction.h

@@ -29,6 +29,7 @@
 #include "FilterImage.h"
 #include "FilterImageVector.h"
 #include "FilterRenderingMode.h"
+#include "FilterStyle.h"
 #include "FloatRect.h"
 #include "LengthBox.h"
 #include <wtf/RefCounted.h>
@@ -96,6 +97,7 @@ class FilterFunction : public RefCounted<FilterFunction> {
 
     virtual OptionSet<FilterRenderingMode> supportedFilterRenderingModes() const { return FilterRenderingMode::Software; }
     virtual RefPtr<FilterImage> apply(const Filter&, FilterImage&, FilterResults&) { return nullptr; }
+    virtual FilterStyleVector createFilterStyles(const Filter&, const FilterStyle&) const { return { }; }
 
     virtual WTF::TextStream& externalRepresentation(WTF::TextStream&, FilterRepresentation = FilterRepresentation::TestOutput) const = 0;