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]>

Author: lhkbob

RELEASE_NOTES.txt

@@ -9,6 +9,10 @@ Milestone 88
 
   * <insert new release notes here>
 
+  * 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,13 +2557,6 @@ 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:
@@ -2601,17 +2594,10 @@ 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
@@ -2640,7 +2626,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   = 64;   // most recent measurement
+    static constexpr int kDeviceCMSize   = 96;   // most recent measurement
 
     intptr_t fMCRecStorage[kMCRecSize * kMCRecCount / sizeof(intptr_t)];
     intptr_t fDeviceCMStorage[kDeviceCMSize / sizeof(intptr_t)];
@@ -2723,14 +2709,31 @@ 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