Revert "Draw image filters directly under non-axis-aligned transforms"

This reverts commit f8f23b2.

Reason for revert: b/172617382 is creating issues for Android's Webview

Original change's description:
> Draw image filters directly under non-axis-aligned transforms
>
> This removes hacking the canvas CTM and wrapping the paint's image
> filter in a special MatrixTransform that computed a post-transform
> instead of its documented pre-transform effect. Performance-wise, the
> computed layer sizes should be about the same, but we avoid one less
> render target switch because we apply the transformation while drawing
> to the dst device, vs. transforming into another temporary layer and
> then drawing that to the dst device.
>
> Several important changes in behavior here:
> 1. The DeviceCM record no longer has a stashed matrix to restore and
>    holds its restoration paint directly.
> 2. Devices for image filter inputs can now have device-to-global
>    transforms that are not integer translates.
> 3. The MatrixTransform hack punted when there was perspective because it
>    could produce excessively large temporary images, but the new version
>    appears to work around that. We now impose a maximum layer size to
>    protect against that and automatically scale the layer to prevent it.
>    Perspective image filters otherwise now draw correctly.
> 6. Updated layer sizing code to use the new image filter APIs
> 7. Updated backdrop filter and restore filters to go through the same
>    code paths, although restore filters skip the intermediate image
>    transform.
>     - layer bounds and transforms now go through the updated skif API
>       and is hopefully more straight forward to understand.
> 8. Now we can optimize root color filter nodes of a filter DAG, even if
>    the entire DAG can't be represented as a color filter. The last node
>    is pulled off and composed with the restoration paint instead.
>
> Bug: skia:9074,skia:9283
> Change-Id: I1fa1d50135b9d6d453b02f89aa3cc3b54deab678
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/328376
> Commit-Queue: Michael Ludwig <[email protected]>
> Reviewed-by: Brian Salomon <[email protected]>

[email protected],[email protected],[email protected],[email protected],[email protected]

Change-Id: I098d0e4b8ee067b436400eb9fea047e629544eec
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:9074
Bug: skia:9283
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/332737
Reviewed-by: Michael Ludwig <[email protected]>
Reviewed-by: Derek Sollenberger <[email protected]>
Commit-Queue: Michael Ludwig <[email protected]>

Author: lhkbob

RELEASE_NOTES.txt

@@ -12,10 +12,6 @@ Milestone 88
   * Limit the types and intrinsics supported in SkRuntimeEffect to GLSL ES 1.00
     https://review.skia.org/332597
 
-  * Image filters with perspective, for saveLayer and draws, are now drawn correctly. Performance
-    and quality is highest if user bounds are provided to saveLayer.
-    https://review.skia.org/328376
-
   * Add AVIF support to SkHeifCodec.
 
   * Add support for creating SkSurfaceCharacterizations directly for use by a

include/core/SkCanvas.h

@@ -2557,6 +2557,13 @@ class SK_API SkCanvas {
 
     virtual void onDiscard();
 
+    // Clip rectangle bounds. Called internally by saveLayer.
+    // returns false if the entire rectangle is entirely clipped out
+    // If non-NULL, The imageFilter parameter will be used to expand the clip
+    // and offscreen bounds for any margin required by the filter DAG.
+    bool clipRectBounds(const SkRect* bounds, SaveLayerFlags flags, SkIRect* intersection,
+                        const SkImageFilter* imageFilter = nullptr);
+
     SkBaseDevice* getTopDevice() const;
 
 private:
@@ -2594,10 +2601,17 @@ class SK_API SkCanvas {
         // safely with 32 and 64 bit machines (to ensure the storage is enough)
         intptr_t          fStorage[32];
         class SkDrawIter* fImpl;    // this points at fStorage
+        SkPaint           fDefaultPaint;
         SkIPoint          fDeviceOrigin;
         bool              fDone;
     };
 
+    static bool BoundsAffectsClip(SaveLayerFlags);
+
+    static void DrawDeviceWithFilter(SkBaseDevice* src, const SkImageFilter* filter,
+                                     SkBaseDevice* dst, const SkIPoint& dstOrigin,
+                                     const SkMatrix& ctm);
+
     enum ShaderOverrideOpacity {
         kNone_ShaderOverrideOpacity,        //!< there is no overriding shader (bitmap or image)
         kOpaque_ShaderOverrideOpacity,      //!< the overriding shader is opaque
@@ -2626,7 +2640,7 @@ class SK_API SkCanvas {
     // the first N recs that can fit here mean we won't call malloc
     static constexpr int kMCRecSize      = 128;  // most recent measurement
     static constexpr int kMCRecCount     = 32;   // common depth for save/restores
-    static constexpr int kDeviceCMSize   = 96;   // most recent measurement
+    static constexpr int kDeviceCMSize   = 64;   // most recent measurement
 
     intptr_t fMCRecStorage[kMCRecSize * kMCRecCount / sizeof(intptr_t)];
     intptr_t fDeviceCMStorage[kDeviceCMSize / sizeof(intptr_t)];
@@ -2709,31 +2723,14 @@ class SK_API SkCanvas {
     void internalDrawPaint(const SkPaint& paint);
     void internalSaveLayer(const SaveLayerRec&, SaveLayerStrategy);
     void internalSaveBehind(const SkRect*);
+    void internalDrawDevice(SkBaseDevice*, const SkPaint*);
 
     void internalConcat44(const SkM44&);
 
     // shared by save() and saveLayer()
     void internalSave();
     void internalRestore();
 
-    enum class DeviceCompatibleWithFilter : bool {
-        // Check the src device's local-to-device matrix for compatibility with the filter, and if
-        // it is not compatible, introduce an intermediate image and transformation that allows the
-        // filter to be evaluated on the modified src content.
-        kUnknown = false,
-        // Assume that the src device's local-to-device matrix is compatible with the filter.
-        kYes     = true
-    };
-    /**
-     * Filters the contents of 'src' and draws the result into 'dst'. The filter is evaluated
-     * relative to the current canvas matrix, and src is drawn to dst using their relative transform
-     * 'paint' is applied after the filter and must not have a mask or image filter of its own.
-     * A null 'filter' behaves as if the identity filter were used.
-     */
-    void internalDrawDeviceWithFilter(SkBaseDevice* src, SkBaseDevice* dst,
-                                      const SkPaint& paint, const SkImageFilter* filter,
-                                      DeviceCompatibleWithFilter compat);
-
     /*
      *  Returns true if drawing the specified rect (or all if it is null) with the specified
      *  paint (or default if null) would overwrite the entire root device of the canvas