Begin removing deprecated (and now, unused) ImageFilter code paths

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 93 matching lines @@
     private:
         SkRect fRect;
         uint32_t fFlags;
     };
 
     enum TileUsage {
         kPossible_TileUsage,    //!< the created device may be drawn tiled
         kNever_TileUsage,       //!< the created device will never be drawn tiled
     };
 
-    class Proxy {
-    public:
-        virtual ~Proxy() {}
-
-        virtual SkBaseDevice* createDevice(int width, int height,
-                                           TileUsage usage = kNever_TileUsage) = 0;
-    };
-
-    class DeviceProxy : public Proxy {
-    public:
-        DeviceProxy(SkBaseDevice* device) : fDevice(device) {}
-
-        SkBaseDevice* createDevice(int width, int height,
-                                   TileUsage usage = kNever_TileUsage) override;
-
-    private:
-        SkBaseDevice* fDevice;
-    };
-
     /**
      *  Request a new (result) image to be created from the src image.
      *
      *  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 null, in which case
@@ skipping 18 matching lines @@
      * be exact, but should never be smaller than the real answer. The default
      * implementation recursively unions all input bounds, or returns the
      * source rect if no inputs.
      */
     SkIRect filterBounds(const SkIRect& src, const SkMatrix& ctm,
                          MapDirection = kReverse_MapDirection) const;
 
 #if SK_SUPPORT_GPU
     static sk_sp<SkSpecialImage> DrawWithFP(GrContext* context, 
                                             sk_sp<GrFragmentProcessor> fp,
-                                            const SkIRect& bounds,
-                                            SkImageFilter::Proxy* proxy);
+                                            const SkIRect& bounds);
 #endif
 
     /**
      *  Returns whether this image filter is a color filter and puts the color filter into the
      *  "filterPtr" parameter if it can. Does nothing otherwise.
      *  If this returns false, then the filterPtr is unchanged.
      *  If this returns true, then if filterPtr is not null, it must be set to a ref'd colorfitler
      *  (i.e. it may not be set to NULL).
      */
     bool isColorFilterNode(SkColorFilter** filterPtr) const {
@@ skipping 27 matching lines @@
         return fInputs[i].get();
     }
 
     /**
      *  Returns whether any edges of the crop rect have been set. The crop
      *  rect is set at construction time, and determines which pixels from the
      *  input image will be processed, and which pixels in the output image will be allowed.
      *  The size of the crop rect should be
      *  used as the size of the destination image. The origin of this rect
      *  should be used to offset access to the input images, and should also
-     *  be added to the "offset" parameter in onFilterImage and
-     *  filterImageGPU(). (The latter ensures that the resulting buffer is
-     *  drawn in the correct location.)
+     *  be added to the "offset" parameter in onFilterImage.
      */
     bool cropRectIsSet() const { return fCropRect.flags() != 0x0; }
 
     CropRect getCropRect() const { return fCropRect; }
 
     // Default impl returns union of all input bounds.
     virtual SkRect computeFastBounds(const SkRect&) const;
 
     // Can this filter DAG compute the resulting bounds of an object-space rectangle?
     bool canComputeFastBounds() const;
@@ skipping 17 matching lines @@
                                                  SkFilterQuality,
                                                  sk_sp<SkImageFilter> input);
 #ifdef SK_SUPPORT_LEGACY_IMAGEFILTER_PTR
     static SkImageFilter* CreateMatrixFilter(const SkMatrix& matrix,
                                              SkFilterQuality filterQuality,
                                              SkImageFilter* input = nullptr) {
         return MakeMatrixFilter(matrix, filterQuality, sk_ref_sp<SkImageFilter>(input)).release();
     }
 #endif
 
-
-    sk_sp<SkSpecialImage> filterInput(int index,
-                                      SkSpecialImage* src,
-                                      const Context&, 
-                                      SkIPoint* offset) const;
-
     SK_TO_STRING_PUREVIRT()
     SK_DEFINE_FLATTENABLE_TYPE(SkImageFilter)
 
 protected:
     class Common {
     public:
         /**
          *  Attempt to unflatten the cropRect and the expected number of input filters.
          *  If any number of input filters is valid, pass -1.
          *  If this fails (i.e. corrupt buffer or contents) then return false and common will
@@ skipping 37 matching lines @@
      *  to perform image filtering.
      *
      *  src is the original primitive bitmap. If the filter has a connected
      *  input, it should recurse on that input and use that in place of src.
      *
      *  The matrix is the current matrix on the canvas.
      *
      *  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.
+     *  If the result image cannot be created (either because of error or if, say, the result
+     *  is entirely clipped out), this should return nullptr.
+     *  Callers that affect transparent black should explicitly handle nullptr
+     *  results and press on. In the error case this behavior will produce a better result
+     *  than nothing and is necessary for the clipped out case.
+     *  If the return value is nullptr then offset should be ignored.
      */
-    virtual bool onFilterImageDeprecated(Proxy*, const SkBitmap& src, const Context&,
-                                         SkBitmap* result, SkIPoint* offset) const;
-
     virtual sk_sp<SkSpecialImage> onFilterImage(SkSpecialImage* src, const Context&,
-                                                SkIPoint* offset) const;
+                                                SkIPoint* offset) const = 0;
 
     /**
      * 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 10 matching lines @@
      * kReverse_MapDirection is used to determine which pixels of the
      * input(s) would be required to fill the given destination rect
      * (e.g., clip bounds). NOTE: these operations may not be the
      * inverse of the other. For example, blurring expands the given rect
      * in both forward and reverse directions. Unlike
      * onFilterBounds(), this function is non-recursive.
      */
     virtual SkIRect onFilterNodeBounds(const SkIRect&, const SkMatrix&, MapDirection) const;
 
     // Helper function which invokes 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 is non-null, it
-    // calls filterImage() on that input, and returns true on success.
-    // i.e., return !getInput(index) || getInput(index)->filterImage(...);
-    bool filterInputDeprecated(int index, Proxy*, const SkBitmap& src, const Context&,
-                               SkBitmap* result, SkIPoint* offset) const;
+    // specified "index". If the input is null, it returns "src" and leaves
+    // "offset" untouched. If the input is non-null, it
+    // calls filterImage() on that input, and returns the result.
+    sk_sp<SkSpecialImage> filterInput(int index,
+                                      SkSpecialImage* src,
+                                      const Context&, 
+                                      SkIPoint* offset) const;
 
     /**
      *  Return true (and return a ref'd colorfilter) if this node in the DAG is just a
      *  colorfilter w/o CropRect constraints.
      */
     virtual bool onIsColorFilterNode(SkColorFilter** /*filterPtr*/) const {
         return false;
     }
 
     /** Given a "srcBounds" rect, computes destination bounds for this filter.
@@ skipping 24 matching lines @@
      *  filter requires by calling this node's
      *  onFilterNodeBounds(..., kReverse_MapDirection).
      */
     Context mapContext(const Context& ctx) const;
 
 private:
     friend class SkGraphics;
     static void PurgeCache();
 
     void init(sk_sp<SkImageFilter>* inputs, int inputCount, const CropRect* cropRect);
-    bool filterImageDeprecated(Proxy*, const SkBitmap& src, const Context&,
-                               SkBitmap* result, SkIPoint* offset) const;
 
     bool usesSrcInput() const { return fUsesSrcInput; }
     virtual bool affectsTransparentBlack() const { return false; }
 
     SkAutoSTArray<2, sk_sp<SkImageFilter>> fInputs;
 
     bool fUsesSrcInput;
     CropRect fCropRect;
     uint32_t fUniqueID; // Globally unique
     mutable SkTArray<Cache::Key> fCacheKeys;
     mutable SkMutex fMutex;
     typedef SkFlattenable INHERITED;
 };
 
 /**
  *  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