Factory methods for heap-allocated SkImageFilter objects.

include/effects/SkMatrixConvolutionImageFilter.h

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkMatrixConvolutionImageFilter_DEFINED
 #define SkMatrixConvolutionImageFilter_DEFINED
 
@@ skipping 10 matching lines @@
 
 class SK_API SkMatrixConvolutionImageFilter : public SkImageFilter {
 public:
     /*! \enum TileMode */
     enum TileMode {
       kClamp_TileMode,         /*!< Clamp to the image's edge pixels. */
       kRepeat_TileMode,        /*!< Wrap around to the image's opposite edge. */
       kClampToBlack_TileMode,  /*!< Fill with transparent black. */
     };
 
+    virtual ~SkMatrixConvolutionImageFilter();
+
     /** Construct a matrix convolution image filter.
         @param kernelSize  The kernel size in pixels, in each dimension (N by M).
         @param kernel      The image processing kernel.  Must contain N * M
                            elements, in row order.
         @param gain        A scale factor applied to each pixel after
                            convolution.  This can be used to normalize the
                            kernel, if it does not sum to 1.
         @param bias        A bias factor added to each pixel after convolution.
         @param target      An offset applied to each pixel coordinate before
                            convolution.  This can be used to center the kernel
                            over the image (e.g., a 3x3 kernel should have a
                            target of {1, 1}).
         @param tileMode    How accesses outside the image are treated.  (@see
                            TileMode).
         @param convolveAlpha  If true, all channels are convolved.  If false,
                            only the RGB channels are convolved, and
                            alpha is copied from the source image.
         @param input       The input image filter.  If NULL, the src bitmap
                            passed to filterImage() is used instead.
         @param cropRect    The rectangle to which the output processing will be limited.
     */
-
-    SkMatrixConvolutionImageFilter(const SkISize& kernelSize,
-                                   const SkScalar* kernel,
-                                   SkScalar gain,
-                                   SkScalar bias,
-                                   const SkIPoint& target,
-                                   TileMode tileMode,
-                                   bool convolveAlpha,
-                                   SkImageFilter* input = NULL,
-                                   const CropRect* cropRect = NULL);
-    virtual ~SkMatrixConvolutionImageFilter();
+    static SkMatrixConvolutionImageFilter* Create(const SkISize& kernelSize,
+                                                  const SkScalar* kernel,
+                                                  SkScalar gain,
+                                                  SkScalar bias,
+                                                  const SkIPoint& target,

[reed1, 2014/03/04 16:56:42]

Nit: Seems funny to separate kernelSize and kernalTarget (my label) by 4
parameters.

Also, this seems like a good place for the factory to sanity check the inputs...
if the kernelTarget is outside of [0..kernelSize]...

[Stephen White, 2014/03/04 18:18:00]

I think that was just the order they appeared in the SVG spec. Moving it up
SGTM. Blink calls target "targetOffset". If we're going to go with something
different than those two, I'd prefer "kernelOffset".
Sounds good.

[Dominik Grewe, 2014/03/07 16:43:38]

There didn't seem to be a clear consensus here so I just went ahead a renamed
everything to kernelOffset for now.

+                                                  TileMode tileMode,
+                                                  bool convolveAlpha,
+                                                  SkImageFilter* input = NULL,
+                                                  const CropRect* cropRect = NULL) {
+        return SkNEW_ARGS(SkMatrixConvolutionImageFilter, (kernelSize, kernel, gain, bias,
+                                                           target, tileMode, convolveAlpha,
+                                                           input, cropRect));
+    }
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkMatrixConvolutionImageFilter)
 
 protected:
     SkMatrixConvolutionImageFilter(SkReadBuffer& buffer);
     virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
                                SkBitmap* result, SkIPoint* loc) const SK_OVERRIDE;
 
 #if SK_SUPPORT_GPU
     virtual bool asNewEffect(GrEffectRef** effect,
                              GrTexture*,
                              const SkMatrix& matrix,
                              const SkIRect& bounds) const SK_OVERRIDE;
 #endif
 
+#ifdef SK_SUPPORT_LEGACY_PUBLICEFFECTCONSTRUCTORS
+public:
+#endif
+    SkMatrixConvolutionImageFilter(const SkISize& kernelSize,
+                                   const SkScalar* kernel,
+                                   SkScalar gain,
+                                   SkScalar bias,
+                                   const SkIPoint& target,
+                                   TileMode tileMode,
+                                   bool convolveAlpha,
+                                   SkImageFilter* input = NULL,
+                                   const CropRect* cropRect = NULL);
+
 private:
     SkISize   fKernelSize;
     SkScalar* fKernel;
     SkScalar  fGain;
     SkScalar  fBias;
     SkIPoint  fTarget;
     TileMode  fTileMode;
     bool      fConvolveAlpha;
     typedef SkImageFilter INHERITED;
 
@@ skipping 11 matching lines @@
                               SkBitmap* result,
                               const SkIRect& rect,
                               const SkIRect& bounds) const;
     void filterBorderPixels(const SkBitmap& src,
                             SkBitmap* result,
                             const SkIRect& rect,
                             const SkIRect& bounds) const;
 };
 
 #endif