change internals over to SkPixmap and stop using accessBitmap

include/core/SkDevice.h

 /*
  * Copyright 2010 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkDevice_DEFINED
 #define SkDevice_DEFINED
 
@@ skipping 64 matching lines @@
     /** Return the bitmap associated with this device. Call this each time you need
         to access the bitmap, as it notifies the subclass to perform any flushing
         etc. before you examine the pixels.
         @param changePixels set to true if the caller plans to change the pixels
         @return the device's bitmap
     */
     const SkBitmap& accessBitmap(bool changePixels);
 
     bool writePixels(const SkImageInfo&, const void*, size_t rowBytes, int x, int y);
 
-    void* accessPixels(SkImageInfo* info, size_t* rowBytes);
+    bool accessPixels(SkPixmap* pmap);
 
     /**
      * Return the device's associated gpu render target, or NULL.
      */
     virtual GrRenderTarget* accessRenderTarget() { return NULL; }
 
 
     /**
      *  Return the device's origin: its offset in device coordinates from
      *  the default origin in its canvas' matrix/clip
@@ skipping 136 matching lines @@
     virtual void drawPatch(const SkDraw&, const SkPoint cubics[12], const SkColor colors[4],
                            const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint);
     /** The SkDevice passed will be an SkDevice which was returned by a call to
         onCreateDevice on this device with kNeverTile_TileExpectation.
      */
     virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
                             const SkPaint&) = 0;
 
     virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len, const SkPath&,
                                 const SkMatrix*, const SkPaint&);
+
     bool readPixels(const SkImageInfo&, void* dst, size_t rowBytes, int x, int y);
+    bool peekPixels(SkPixmap*);
 
     ///////////////////////////////////////////////////////////////////////////
 
     /** Update as needed the pixel value in the bitmap, so that the caller can
         access the pixels directly.
         @return The device contents as a bitmap
     */
     virtual const SkBitmap& onAccessBitmap() = 0;
 
     /**
@@ skipping 12 matching lines @@
      *  If the device does not recognize or support this filter,
      *  it just returns false and leaves result and offset unchanged.
      */
     virtual bool filterImage(const SkImageFilter*, const SkBitmap&,
                              const SkImageFilter::Context&,
                              SkBitmap* /*result*/, SkIPoint* /*offset*/) {
         return false;
     }
 
 protected:
-    // default impl returns NULL
-    virtual SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&);
-
-    // default impl returns NULL
-    virtual const void* peekPixels(SkImageInfo*, size_t* rowBytes);
+    virtual SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) { return NULL; }
+    virtual bool onPeekPixels(SkPixmap*) { return false; }
 
     /**
      *  The caller is responsible for "pre-clipping" the dst. The impl can assume that the dst
      *  image at the specified x,y offset will fit within the device's bounds.
      *
      *  This is explicitly asserted in readPixels(), the public way to call this.
      */
     virtual bool onReadPixels(const SkImageInfo&, void*, size_t, int x, int y);
 
     /**
      *  The caller is responsible for "pre-clipping" the src. The impl can assume that the src
      *  image at the specified x,y offset will fit within the device's bounds.
      *
      *  This is explicitly asserted in writePixelsDirect(), the public way to call this.
      */
     virtual bool onWritePixels(const SkImageInfo&, const void*, size_t, int x, int y);
 
-    /**
-     *  Default impl returns NULL.
-     */
-    virtual void* onAccessPixels(SkImageInfo* info, size_t* rowBytes);
+    virtual bool onAccessPixels(SkPixmap*) { return false; }
 
     /**
      *  Leaky properties are those which the device should be applying but it isn't.
      *  These properties will be applied by the draw, when and as it can.
      *  If the device does handle a property, that property should be set to the identity value
      *  for that property, effectively making it non-leaky.
      */
     const SkDeviceProperties& getLeakyProperties() const {
         return *fLeakyProperties;
     }
@@ skipping 81 matching lines @@
     SkDeviceProperties* fLeakyProperties;   // will always exist.
 
 #ifdef SK_DEBUG
     bool        fAttachedToCanvas;
 #endif
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif