Get OffsetImageFilter really working with SkSpecialImages

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 133 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 false, in which case both
      *  the result and offset parameters will be ignored by the caller.
      */
     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.
      * kBackward_MapDirection is used to determine which rect of the source
      * image would be required to fill the given rect (typically, clip bounds).
@@ skipping 92 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;
+
 #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&,
                                   SkBitmap* result, SkIPoint* offset) const;
@@ skipping 65 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;
+
     /**
      * This function recurses into its inputs with the given clip rect (first
      * argument), calls filterBounds() with the given map direction on each,
      * and unions the result (third argument). If the rect cannot be mapped,
      * false is returned and the destination rect is left unchanged.
      * 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
@@ skipping 49 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;
+
     /**
      *  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.
      *
      *  The effect can assume its vertexCoords space maps 1-to-1 with texels
@@ skipping 34 matching lines @@
  */
 #define SK_IMAGEFILTER_UNFLATTEN_COMMON(localVar, expectedCount)    \
     Common localVar;                                                \
     do {                                                            \
         if (!localVar.unflatten(buffer, expectedCount)) {           \
             return NULL;                                            \
         }                                                           \
     } while (0)
 
 #endif