Switch new SkImageFilter internal methods over to sk_sp

include/core/SkImageFilter.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkImageFilter_DEFINED
 #define SkImageFilter_DEFINED
 
@@ skipping 132 matching lines @@
      *
      *  Offset is the amount to translate the resulting image relative to the
      *  src when it is drawn. This is an out-param.
      *
      *  If the result image cannot be created, return null, in which case
      *  the offset parameters will be ignored by the caller.
      *
      *  TODO: Right now the imagefilters sometimes return empty result bitmaps/
      *        specialimages. That doesn't seem quite right.
      */
-    SkSpecialImage* filterImage(SkSpecialImage* src, const Context&, SkIPoint* offset) const;
+    sk_sp<SkSpecialImage> filterImage(SkSpecialImage* src, const Context&, SkIPoint* offset) const;
 
     enum MapDirection {
         kForward_MapDirection,
         kReverse_MapDirection
     };
     /**
      * Map a device-space rect recursively forward or backward through the
      * filter DAG. kForward_MapDirection is used to determine which pixels of
      * the destination canvas a source image rect would touch after filtering.
      * kReverse_MapDirection is used to determine which rect of the source
@@ skipping 93 matching lines @@
      */
     SkImageFilter* newWithLocalMatrix(const SkMatrix& matrix) const;
 
     /**
      * Create an SkMatrixImageFilter, which transforms its input by the given matrix.
      */
     static SkImageFilter* CreateMatrixFilter(const SkMatrix& matrix,
                                              SkFilterQuality,
                                              SkImageFilter* input = NULL);
 
-    SkSpecialImage* filterInput(int index,
-                                SkSpecialImage* src,
-                                const Context&, 
-                                SkIPoint* offset) const;
+    sk_sp<SkSpecialImage> filterInput(int index,
+                                      SkSpecialImage* src,
+                                      const Context&, 
+                                      SkIPoint* offset) const;
 
 #if SK_SUPPORT_GPU
     // Helper function which invokes GPU filter processing on the
     // input at the specified "index". If the input is null, it leaves
     // "result" and "offset" untouched, and returns true. If the input
     // has a GPU implementation, it will be invoked directly.
     // Otherwise, the filter will be processed in software and
     // uploaded to the GPU.
     bool filterInputGPUDeprecated(int index, SkImageFilter::Proxy* proxy,
                                   const SkBitmap& src, const Context&,
@@ skipping 66 matching lines @@
      *  Offset is the amount to translate the resulting image relative to the
      *  src when it is drawn. This is an out-param.
      *
      *  If the result image cannot be created, this should false, in which
      *  case both the result and offset parameters will be ignored by the
      *  caller.
      */
     virtual bool onFilterImageDeprecated(Proxy*, const SkBitmap& src, const Context&,
                                          SkBitmap* result, SkIPoint* offset) const;
 
-    virtual SkSpecialImage* onFilterImage(SkSpecialImage* src, const Context&,
-                                          SkIPoint* offset) const;
+    virtual sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* src, const Context&,
+                                                SkIPoint* offset) const;
 
     /**
      * This function recurses into its inputs with the given rect (first
      * argument), calls filterBounds() with the given map direction on each,
      * and returns the union of those results. If a derived class has special
      * recursion requirements (e.g., it has an input which does not participate
      * in bounds computation), it can be overridden here.
      *
      * Note that this function is *not* responsible for mapping the rect for
      * this node's filter bounds requirements (i.e., calling
@@ skipping 48 matching lines @@
      *  the source bitmap's bounds, it creates a new bitmap in "result" and
      *  pads the edges with transparent black. In that case, the srcOffset is
      *  modified to be the same as the bounds, since no further adjustment is
      *  needed by the caller. This version should only be used by filters
      *  which are not capable of processing a smaller source bitmap into a
      *  larger destination.
      */
     bool applyCropRectDeprecated(const Context&, Proxy* proxy, const SkBitmap& src,
                                  SkIPoint* srcOffset, SkIRect* bounds, SkBitmap* result) const;
 
-    SkSpecialImage* applyCropRect(const Context&, SkSpecialImage* src, SkIPoint* srcOffset,
-                                  SkIRect* bounds) const;
+    sk_sp<SkSpecialImage> applyCropRect(const Context&, SkSpecialImage* src, SkIPoint* srcOffset,
+                                        SkIRect* bounds) const;
 
     /**
      *  Returns true if the filter can be expressed a single-pass
      *  GrProcessor, used to process this filter on the GPU, or false if
      *  not.
      *
      *  If effect is non-NULL, a new GrProcessor instance is stored
      *  in it.  The caller assumes ownership of the stage, and it is up to the
      *  caller to unref it.
      *
@@ skipping 38 matching lines @@
  */
 #define SK_IMAGEFILTER_UNFLATTEN_COMMON(localVar, expectedCount)    \
     Common localVar;                                                \
     do {                                                            \
         if (!localVar.unflatten(buffer, expectedCount)) {           \
             return NULL;                                            \
         }                                                           \
     } while (0)
 
 #endif