Swap over to using SkImageFilter::filterImage instead of filterImageDeprecated

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 119 matching lines @@
         // false then the filter's code will be called.
         bool filterImage(const SkImageFilter*, const SkBitmap& src, const SkImageFilter::Context&,
                          SkBitmap* result, SkIPoint* offset) override;
 
     private:
         SkBaseDevice* fDevice;
     };
 
     /**
      *  Request a new (result) image to be created from the src image.
-     *  If the src has no pixels (isNull()) then the request just wants to
-     *  receive the config and width/height of the result.
      *
-     *  The matrix is the current matrix on the canvas.
+     *  The context contains the environment in which the filter is occurring.
+     *  It includes the clip bounds, CTM and cache.
      *
      *  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 false, in which case both
-     *  the result and offset parameters will be ignored by the caller.
+     *  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.
      */
-    bool filterImageDeprecated(Proxy*, const SkBitmap& src, const Context&,
-                               SkBitmap* result, SkIPoint* offset) const;
-
     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.
@@ skipping 289 matching lines @@
      *  The clip bounds are adjusted to accommodate any margins that this
      *  filter requires by calling this node's
      *  onFilterNodeBounds(..., kReverse_MapDirection).
      */
     Context mapContext(const Context& ctx) const;
 
 private:
     friend class SkGraphics;
     static void PurgeCache();
 
+    bool filterImageDeprecated(Proxy*, const SkBitmap& src, const Context&,
+                               SkBitmap* result, SkIPoint* offset) const;
+
     bool usesSrcInput() const { return fUsesSrcInput; }
 
     typedef SkFlattenable INHERITED;
     int fInputCount;
     SkImageFilter** fInputs;
     bool fUsesSrcInput;
     CropRect fCropRect;
     uint32_t fUniqueID; // Globally unique
     mutable SkTArray<Cache::Key> fCacheKeys;
     mutable SkMutex fMutex;
 };
 
 /**
  *  Helper to unflatten the common data, and return NULL if we fail.
  */
 #define SK_IMAGEFILTER_UNFLATTEN_COMMON(localVar, expectedCount)    \
     Common localVar;                                                \
     do {                                                            \
         if (!localVar.unflatten(buffer, expectedCount)) {           \
             return NULL;                                            \
         }                                                           \
     } while (0)
 
 #endif