remove subclassing from ImageFilter::Proxy

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
 
 #include "SkFilterQuality.h"
 #include "SkFlattenable.h"
 #include "SkMatrix.h"
 #include "SkRect.h"
+#include "SkSurfaceProps.h"
 #include "SkTemplates.h"
 
+class GrFragmentProcessor;
+class GrTexture;
+class SkBaseDevice;
 class SkBitmap;
 class SkColorFilter;
-class SkBaseDevice;
-class SkSurfaceProps;
 struct SkIPoint;
-class GrFragmentProcessor;
-class GrTexture;
 
 /**
  *  Base class for image filters. If one is installed in the paint, then
  *  all drawing occurs as usual, but it is as if the drawing happened into an
  *  offscreen (before the xfermode is applied). This offscreen bitmap will
  *  then be handed to the imagefilter, who in turn creates a new bitmap which
  *  is what will finally be drawn to the device (using the original xfermode).
  */
 class SK_API SkImageFilter : public SkFlattenable {
 public:
@@ skipping 34 matching lines @@
     public:
         Context(const SkMatrix& ctm, const SkIRect& clipBounds, Cache* cache) :
             fCTM(ctm), fClipBounds(clipBounds), fCache(cache) {
         }
         const SkMatrix& ctm() const { return fCTM; }
         const SkIRect& clipBounds() const { return fClipBounds; }
         Cache* cache() const { return fCache; }
     private:
         SkMatrix fCTM;
         SkIRect  fClipBounds;
-        Cache* fCache;
+        Cache*   fCache;
     };
 
     class Proxy {
     public:
-        virtual ~Proxy() {};
-
-        virtual SkBaseDevice* createDevice(int width, int height) = 0;
+        Proxy(SkBaseDevice* device, const SkSurfaceProps& props)
+            : fDevice(device)
+            , fProps(props.flags(), kUnknown_SkPixelGeometry)
+        {}
+        
+        SkBaseDevice* createDevice(int width, int height);
         // returns true if the proxy handled the filter itself. if this returns
         // false then the filter's code will be called.
-        virtual bool filterImage(const SkImageFilter*, const SkBitmap& src,
-                                 const Context&,
-                                 SkBitmap* result, SkIPoint* offset) = 0;
-        virtual const SkSurfaceProps* surfaceProps() const = 0;
+        bool filterImage(const SkImageFilter*, const SkBitmap& src, const SkImageFilter::Context&,
+                         SkBitmap* result, SkIPoint* offset);
+        const SkSurfaceProps& surfaceProps() const { return fProps; }
+        
+    private:
+        SkBaseDevice*        fDevice;
+        const SkSurfaceProps fProps;
     };
+    
 
     /**
      *  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.
      *
      *  Offset is the amount to translate the resulting image relative to the
      *  src when it is drawn. This is an out-param.
@@ skipping 256 matching lines @@
  */
 #define SK_IMAGEFILTER_UNFLATTEN_COMMON(localVar, expectedCount)    \
     Common localVar;                                                \
     do {                                                            \
         if (!localVar.unflatten(buffer, expectedCount)) {           \
             return NULL;                                            \
         }                                                           \
     } while (0)
 
 #endif