Further cleanup in FilterEffectRenderer.

Change FilterEffectRenderer not to be a subclass of Filter anymore, and instantiate a ReferenceFilter as a parent for all shorthand filters instead. Remove FilterEffectRendererHelper entirely, and put its remaining functionality into FilterEffectRenderer.

Replace the AffineTransform in Filter with a float scale parameter, since that's all it does now anyway. Note that applyHorizontal/VerticalScale() still need to remain separate, since SVGFilter applies further, possibly non-uniform scaling in its overrides of those functions.

prepareFilterEffect() and beginFilterEffect() have been merged. This removes an incorrect early-out, which fixes http://crbug.com/254449.

BUG=240827,254449

Review URL: https://codereview.chromium.org/644713004

git-svn-id: svn://svn.chromium.org/blink/trunk@183676 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/LayoutTests/TestExpectations

@@ -638,6 +638,7 @@ crbug.com/326524 virtual/threaded/compositing/visibility/visibility-simple-video
 crbug.com/342574 fast/css-generated-content/crash-selection-editing-removes-pseudo.html [ Crash ]
 
 crbug.com/346151 css3/filters/effect-reference-hidpi-hw.html [ Pass ImageOnlyFailure ]
+crbug.com/254449 css3/filters/effect-reference-tile.html [ NeedsRebaseline ]
 
 crbug.com/337732 fast/css/fontfaceset-download-error.html [ Pass Timeout ]
 

third_party/WebKit/Source/core/paint/LayerPainter.cpp

@@ -253,7 +253,7 @@ void LayerPainter::paintLayerContents(GraphicsContext* context, const LayerPaint
         beginTransparencyLayers(context, paintingInfo.rootLayer, paintingInfo.paintDirtyRect, paintingInfo.subPixelAccumulation, paintingInfo.paintBehavior);
 
     LayerPaintingInfo localPaintingInfo(paintingInfo);
-    FilterEffectRendererHelper filterPainter(m_renderLayer.filterRenderer() && m_renderLayer.paintsWithFilters());
+    bool haveFilterEffect = m_renderLayer.filterRenderer() && m_renderLayer.paintsWithFilters();
 
     LayerFragments layerFragments;
     if (shouldPaintContent || shouldPaintOutline || isPaintingOverlayScrollbars) {
@@ -265,34 +265,29 @@ void LayerPainter::paintLayerContents(GraphicsContext* context, const LayerPaint
         updatePaintingInfoForFragments(layerFragments, localPaintingInfo, paintFlags, shouldPaintContent, &offsetFromRoot);
     }
 
-    if (filterPainter.haveFilterEffect()) {
+    if (haveFilterEffect) {
         ASSERT(m_renderLayer.filterInfo());
 
         if (!rootRelativeBoundsComputed)
             rootRelativeBounds = m_renderLayer.physicalBoundingBoxIncludingReflectionAndStackingChildren(paintingInfo.rootLayer, offsetFromRoot);
 
-        if (filterPainter.prepareFilterEffect(&m_renderLayer, rootRelativeBounds, paintingInfo.paintDirtyRect)) {
-
-            // Do transparency and clipping before starting filter processing.
-            if (haveTransparency) {
-                // If we have a filter and transparency, we have to eagerly start a transparency layer here, rather than risk a child layer lazily starts one after filter processing.
-                beginTransparencyLayers(context, localPaintingInfo.rootLayer, paintingInfo.paintDirtyRect, paintingInfo.subPixelAccumulation, localPaintingInfo.paintBehavior);
-            }
-            // We'll handle clipping to the dirty rect before filter rasterization.
-            // Filter processing will automatically expand the clip rect and the offscreen to accommodate any filter outsets.
-            // FIXME: It is incorrect to just clip to the damageRect here once multiple fragments are involved.
-            ClipRect backgroundRect = layerFragments.isEmpty() ? ClipRect() : layerFragments[0].backgroundRect;
-            clipToRect(localPaintingInfo, context, backgroundRect, paintFlags);
-            // Subsequent code should not clip to the dirty rect, since we've already
-            // done it above, and doing it later will defeat the outsets.
-            localPaintingInfo.clipToDirtyRect = false;
-            filterPainter.beginFilterEffect(context);
-
-            if (!filterPainter.haveFilterEffect()) {
-                // If the the filter failed to start, undo the clip immediately
-                restoreClip(context, localPaintingInfo.paintDirtyRect, backgroundRect);
-            }
-
+        // Do transparency and clipping before starting filter processing.
+        if (haveTransparency) {
+            // If we have a filter and transparency, we have to eagerly start a transparency layer here, rather than risk a child layer lazily starts one after filter processing.
+            beginTransparencyLayers(context, localPaintingInfo.rootLayer, paintingInfo.paintDirtyRect, paintingInfo.subPixelAccumulation, localPaintingInfo.paintBehavior);
+        }
+        // We'll handle clipping to the dirty rect before filter rasterization.
+        // Filter processing will automatically expand the clip rect and the offscreen to accommodate any filter outsets.
+        // FIXME: It is incorrect to just clip to the damageRect here once multiple fragments are involved.
+        ClipRect backgroundRect = layerFragments.isEmpty() ? ClipRect() : layerFragments[0].backgroundRect;
+        clipToRect(localPaintingInfo, context, backgroundRect, paintFlags);
+        // Subsequent code should not clip to the dirty rect, since we've already
+        // done it above, and doing it later will defeat the outsets.
+        localPaintingInfo.clipToDirtyRect = false;
+        haveFilterEffect = m_renderLayer.filterRenderer()->beginFilterEffect(context, rootRelativeBounds);
+        if (!haveFilterEffect) {
+            // If the the filter failed to start, undo the clip immediately
+            restoreClip(context, localPaintingInfo.paintDirtyRect, backgroundRect);
         }
     }
 
@@ -343,11 +338,11 @@ void LayerPainter::paintLayerContents(GraphicsContext* context, const LayerPaint
     if (shouldPaintOverlayScrollbars)
         paintOverflowControlsForFragments(layerFragments, context, localPaintingInfo, paintFlags);
 
-    if (filterPainter.haveFilterEffect()) {
+    if (haveFilterEffect) {
         // Apply the correct clipping (ie. overflow: hidden).
         // FIXME: It is incorrect to just clip to the damageRect here once multiple fragments are involved.
         ClipRect backgroundRect = layerFragments.isEmpty() ? ClipRect() : layerFragments[0].backgroundRect;
-        filterPainter.endFilterEffect(context);
+        m_renderLayer.filterRenderer()->endFilterEffect(context);
         restoreClip(context, localPaintingInfo.paintDirtyRect, backgroundRect);
     }
 

third_party/WebKit/Source/core/rendering/FilterEffectRenderer.h

@@ -26,67 +26,35 @@
 #ifndef FilterEffectRenderer_h
 #define FilterEffectRenderer_h
 
-#include "core/svg/graphics/filters/SVGFilterBuilder.h"
-#include "platform/geometry/FloatRect.h"
-#include "platform/geometry/IntRectExtent.h"
-#include "platform/geometry/LayoutRect.h"
-#include "platform/graphics/ImageBuffer.h"
-#include "platform/graphics/filters/Filter.h"
 #include "platform/graphics/filters/FilterEffect.h"
-#include "platform/graphics/filters/FilterOperations.h"
-#include "platform/graphics/filters/SourceGraphic.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
+#include "wtf/Vector.h"
 
 namespace blink {
 
+class FilterOperations;
+class FloatRect;
 class GraphicsContext;
 class ReferenceFilter;
-class RenderLayer;
 class RenderObject;
 
-class FilterEffectRendererHelper {
-public:
-    FilterEffectRendererHelper(bool haveFilterEffect)
-        : m_renderLayer(0)
-        , m_haveFilterEffect(haveFilterEffect)
-    {
-    }
-
-    bool haveFilterEffect() const { return m_haveFilterEffect; }
-
-    bool prepareFilterEffect(RenderLayer*, const LayoutRect& filterBoxRect, const LayoutRect& dirtyRect);
-    void beginFilterEffect(GraphicsContext*);
-    void endFilterEffect(GraphicsContext*);
-private:
-    RenderLayer* m_renderLayer;
-
-    FloatRect m_filterBoxRect;
-    bool m_haveFilterEffect;
-};
-
-class FilterEffectRenderer final : public Filter
+class FilterEffectRenderer final : public RefCounted<FilterEffectRenderer>
 {
     WTF_MAKE_FAST_ALLOCATED;
 public:
+    virtual ~FilterEffectRenderer();
     static PassRefPtr<FilterEffectRenderer> create()
     {
         return adoptRef(new FilterEffectRenderer());
     }
 
-    void setSourceImageRect(const IntRect& sourceImageRect)
-    {
-        m_sourceDrawingRegion = sourceImageRect;
-    }
-    virtual IntRect sourceImageRect() const override { return m_sourceDrawingRegion; }
-
     bool build(RenderObject* renderer, const FilterOperations&);
-    void updateBackingStoreRect(const FloatRect& filterRect);
+    bool beginFilterEffect(GraphicsContext*, const FloatRect& filterBoxRect);
+    void endFilterEffect(GraphicsContext*);
     void clearIntermediateResults();
 
-    LayoutRect computeSourceImageRectForDirtyRect(const LayoutRect& dirtyRect);
-
     PassRefPtr<FilterEffect> lastEffect() const
     {
         return m_lastEffect;
@@ -94,11 +62,7 @@ public:
 private:
 
     FilterEffectRenderer();
-    virtual ~FilterEffectRenderer();
-
-    IntRect m_sourceDrawingRegion;
 
-    RefPtr<SourceGraphic> m_sourceGraphic;
     RefPtr<FilterEffect> m_lastEffect;
     Vector<RefPtr<ReferenceFilter> > m_referenceFilters;
 };

third_party/WebKit/Source/core/rendering/RenderLayer.cpp

@@ -2714,9 +2714,7 @@ FilterOperations RenderLayer::computeFilterOperations(const RenderStyle* style)
                 continue;
             ReferenceFilterOperation* referenceOperation = toReferenceFilterOperation(filterOperation);
             // FIXME: Cache the ReferenceFilter if it didn't change.
-            RefPtr<ReferenceFilter> referenceFilter = ReferenceFilter::create();
-            float zoom = style->effectiveZoom();
-            referenceFilter->setAbsoluteTransform(AffineTransform().scale(zoom, zoom));
+            RefPtr<ReferenceFilter> referenceFilter = ReferenceFilter::create(style->effectiveZoom());
             referenceFilter->setLastEffect(ReferenceFilterBuilder::build(referenceFilter.get(), renderer(), referenceFilter->sourceGraphic(),
                 referenceOperation));
             referenceOperation->setFilter(referenceFilter.release());

third_party/WebKit/Source/core/svg/graphics/filters/SVGFilter.cpp

@@ -26,7 +26,7 @@
 namespace blink {
 
 SVGFilter::SVGFilter(const IntRect& absoluteSourceDrawingRegion, const FloatRect& targetBoundingBox, const FloatRect& filterRegion, bool effectBBoxMode)
-    : Filter(AffineTransform())
+    : Filter(1.0f)
     , m_absoluteSourceDrawingRegion(absoluteSourceDrawingRegion)
     , m_targetBoundingBox(targetBoundingBox)
     , m_effectBBoxMode(effectBBoxMode)

third_party/WebKit/Source/platform/graphics/filters/FETurbulence.cpp

@@ -137,9 +137,8 @@ SkShader* FETurbulence::createShader()
     // and not the target bounding box scale (as SVGFilter::apply*Scale()
     // would do). Note also that we divide by the scale since this is
     // a frequency, not a period.
-    const AffineTransform& absoluteTransform = filter()->absoluteTransform();
-    float baseFrequencyX = m_baseFrequencyX / absoluteTransform.a();
-    float baseFrequencyY = m_baseFrequencyY / absoluteTransform.d();
+    float baseFrequencyX = m_baseFrequencyX / filter()->scale();
+    float baseFrequencyY = m_baseFrequencyY / filter()->scale();
     return (type() == FETURBULENCE_TYPE_FRACTALNOISE) ?
         SkPerlinNoiseShader::CreateFractalNoise(SkFloatToScalar(baseFrequencyX),
             SkFloatToScalar(baseFrequencyY), numOctaves(), SkFloatToScalar(seed()),

third_party/WebKit/Source/platform/graphics/filters/Filter.h

@@ -30,39 +30,16 @@ namespace blink {
 
 class PLATFORM_EXPORT Filter : public RefCounted<Filter> {
 public:
-    Filter(const AffineTransform& absoluteTransform)
-    : m_absoluteTransform(absoluteTransform)
-    , m_inverseTransform(absoluteTransform.inverse())
-    {
-        // Filters can only accept scaling and translating transformations, as coordinates
-        // in most primitives are given in horizontal and vertical directions.
-        ASSERT(!absoluteTransform.b() && !absoluteTransform.c());
-    }
+    Filter(float scale)
+    : m_scale(scale) { }
     virtual ~Filter() { }
 
-    const AffineTransform& absoluteTransform() const { return m_absoluteTransform; }
-
-    void setAbsoluteTransform(const AffineTransform& absoluteTransform)
-    {
-        // Filters can only accept scaling and translating transformations, as coordinates
-        // in most primitives are given in horizontal and vertical directions.
-        ASSERT(!absoluteTransform.b() && !absoluteTransform.c());
-        m_absoluteTransform = absoluteTransform;
-        m_inverseTransform = absoluteTransform.inverse();
-        m_absoluteFilterRegion = m_absoluteTransform.mapRect(m_filterRegion);
-    }
-    FloatPoint mapAbsolutePointToLocalPoint(const FloatPoint& point) const { return m_inverseTransform.mapPoint(point); }
-    FloatRect mapLocalRectToAbsoluteRect(const FloatRect& rect) const { return m_absoluteTransform.mapRect(rect); }
-    FloatRect mapAbsoluteRectToLocalRect(const FloatRect& rect) const { return m_inverseTransform.mapRect(rect); }
+    float scale() const { return m_scale; }
+    FloatRect mapLocalRectToAbsoluteRect(const FloatRect& rect) const { FloatRect result(rect); result.scale(m_scale); return result; }
+    FloatRect mapAbsoluteRectToLocalRect(const FloatRect& rect) const { FloatRect result(rect); result.scale(1.0f / m_scale); return result; }
+    virtual float applyHorizontalScale(float value) const { return m_scale * value; }
+    virtual float applyVerticalScale(float value) const { return m_scale * value; }
 
-    virtual float applyHorizontalScale(float value) const
-    {
-        return value * m_absoluteTransform.a();
-    }
-    virtual float applyVerticalScale(float value) const
-    {
-        return value * m_absoluteTransform.d();
-    }
     virtual FloatPoint3D resolve3dPoint(const FloatPoint3D& point) const { return point; }
 
     virtual IntRect sourceImageRect() const = 0;
@@ -73,12 +50,12 @@ public:
     void setFilterRegion(const FloatRect& rect)
     {
         m_filterRegion = rect;
-        m_absoluteFilterRegion = m_absoluteTransform.mapRect(m_filterRegion);
+        m_absoluteFilterRegion = rect;
+        m_absoluteFilterRegion.scale(m_scale);
     }
 
 private:
-    AffineTransform m_absoluteTransform;
-    AffineTransform m_inverseTransform;
+    float m_scale;
     FloatRect m_absoluteFilterRegion;
     FloatRect m_filterRegion;
 };

third_party/WebKit/Source/platform/graphics/filters/FilterEffect.cpp

@@ -260,7 +260,7 @@ SkImageFilter::CropRect FilterEffect::getCropRect(const FloatSize& cropOffset) c
         rect.setHeight(boundaries.height());
         flags |= SkImageFilter::CropRect::kHasBottom_CropEdge;
     }
-    rect.scale(filter()->absoluteTransform().a(), filter()->absoluteTransform().d());
+    rect.scale(filter()->scale());
     return SkImageFilter::CropRect(rect, flags);
 }
 

third_party/WebKit/Source/platform/graphics/filters/ImageFilterBuilderTest.cpp

@@ -42,7 +42,7 @@ protected:
     void colorSpaceTest()
     {
         // Build filter tree
-        RefPtr<ReferenceFilter> referenceFilter = ReferenceFilter::create();
+        RefPtr<ReferenceFilter> referenceFilter = ReferenceFilter::create(1.0f);
 
         // Add a dummy source graphic input
         RefPtr<FilterEffect> sourceEffect = referenceFilter->sourceGraphic();

third_party/WebKit/Source/platform/graphics/filters/ReferenceFilter.cpp

@@ -37,8 +37,8 @@
 
 namespace blink {
 
-ReferenceFilter::ReferenceFilter()
-    : Filter(AffineTransform())
+ReferenceFilter::ReferenceFilter(float scale)
+    : Filter(scale)
     , m_sourceGraphic(SourceGraphic::create(this))
 {
 }

third_party/WebKit/Source/platform/graphics/filters/ReferenceFilter.h

@@ -43,9 +43,9 @@ class FilterEffect;
 
 class PLATFORM_EXPORT ReferenceFilter: public Filter {
 public:
-    static PassRefPtr<ReferenceFilter> create()
+    static PassRefPtr<ReferenceFilter> create(float scale)
     {
-        return adoptRef(new ReferenceFilter());
+        return adoptRef(new ReferenceFilter(scale));
     }
 
     virtual IntRect sourceImageRect() const override { return IntRect(); };
@@ -56,7 +56,7 @@ public:
     SourceGraphic* sourceGraphic() const { return m_sourceGraphic.get(); }
 
 private:
-    ReferenceFilter();
+    ReferenceFilter(float scale);
     virtual ~ReferenceFilter();
 
     RefPtr<SourceGraphic> m_sourceGraphic;