add new readPixels with direct memory parameters

src/core/SkDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDevice.h"
 #include "SkMetaData.h"
 
@@ skipping 94 matching lines @@
 }
 
 const SkBitmap& SkBaseDevice::accessBitmap(bool changePixels) {
     const SkBitmap& bitmap = this->onAccessBitmap();
     if (changePixels) {
         bitmap.notifyPixelsChanged();
     }
     return bitmap;
 }
 
+#ifdef SK_SUPPORT_LEGACY_READPIXELSCONFIG
 bool SkBaseDevice::readPixels(SkBitmap* bitmap, int x, int y,
                               SkCanvas::Config8888 config8888) {
     if (SkBitmap::kARGB_8888_Config != bitmap->config() ||
         NULL != bitmap->getTexture()) {
         return false;
     }
 
     const SkBitmap& src = this->accessBitmap(false);
 
     SkIRect srcRect = SkIRect::MakeXYWH(x, y, bitmap->width(),
@@ skipping 22 matching lines @@
 
     bool result = this->onReadPixels(bmpSubset,
                                      srcRect.fLeft,
                                      srcRect.fTop,
                                      config8888);
     if (result && bmp == &tmp) {
         tmp.swap(*bitmap);
     }
     return result;
 }
+bool SkBaseDevice::onReadPixels(const SkBitmap&, int x, int y, SkCanvas::Config8888) {
+    return false;
+}
+#endif
 
 SkSurface* SkBaseDevice::newSurface(const SkImageInfo&) { return NULL; }
 
 const void* SkBaseDevice::peekPixels(SkImageInfo*, size_t*) { return NULL; }
 
 void SkBaseDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer,
                               const SkRRect& inner, const SkPaint& paint) {
     SkPath path;
     path.addRRect(outer);
     path.addRRect(inner);
     path.setFillType(SkPath::kEvenOdd_FillType);
 
     const SkMatrix* preMatrix = NULL;
     const bool pathIsMutable = true;
     this->drawPath(draw, path, paint, preMatrix, pathIsMutable);
 }
 
+bool SkBaseDevice::readPixels(const SkImageInfo& info, void* dstP, size_t rowBytes, int x, int y) {
+#ifdef SK_DEBUG
+    SkASSERT(info.width() > 0 && info.height() > 0);
+    SkASSERT(dstP);
+    SkASSERT(rowBytes >= info.minRowBytes());
+    SkASSERT(x >= 0 && y >= 0);
+    
+    const SkImageInfo& srcInfo = this->imageInfo();
+    SkASSERT(x + info.width() <= srcInfo.width());
+    SkASSERT(y + info.height() <= srcInfo.height());
+#endif
+    return this->onReadPixels(info, dstP, rowBytes, x, y);
+}
+
 bool SkBaseDevice::writePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes,
                                int x, int y) {
 #ifdef SK_DEBUG
     SkASSERT(info.width() > 0 && info.height() > 0);
     SkASSERT(pixels);
     SkASSERT(rowBytes >= info.minRowBytes());
     SkASSERT(x >= 0 && y >= 0);
 
     const SkImageInfo& dstInfo = this->imageInfo();
     SkASSERT(x + info.width() <= dstInfo.width());
     SkASSERT(y + info.height() <= dstInfo.height());
 #endif
     return this->onWritePixels(info, pixels, rowBytes, x, y);
 }
 
 bool SkBaseDevice::onWritePixels(const SkImageInfo&, const void*, size_t, int, int) {
     return false;
 }
 
-bool SkBaseDevice::onReadPixels(const SkBitmap&, int x, int y, SkCanvas::Config8888) {
+bool SkBaseDevice::onReadPixels(const SkImageInfo&, void*, size_t, int x, int y) {
     return false;
 }
 
 void* SkBaseDevice::accessPixels(SkImageInfo* info, size_t* rowBytes) {
     SkImageInfo tmpInfo;
     size_t tmpRowBytes;
     if (NULL == info) {
         info = &tmpInfo;
     }
     if (NULL == rowBytes) {
         rowBytes = &tmpRowBytes;
     }
     return this->onAccessPixels(info, rowBytes);
 }
 
 void* SkBaseDevice::onAccessPixels(SkImageInfo* info, size_t* rowBytes) {
     return NULL;
 }
 
 void SkBaseDevice::EXPERIMENTAL_optimize(SkPicture* picture) {
     // The base class doesn't perform any analysis but derived classes may
 }
 
 bool SkBaseDevice::EXPERIMENTAL_drawPicture(const SkPicture& picture) {
     // The base class doesn't perform any accelerated picture rendering
     return false;
 }