Implement SkBaseDevice snapshot support

src/image/SkSurface_Raster.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkSurface_Base.h"
+#include "SkBitmapDevice.h"
+#include "SkCanvas.h"
+#include "SkDeviceProperties.h"
+#include "SkImage_Base.h"
 #include "SkImagePriv.h"
-#include "SkCanvas.h"
-#include "SkDevice.h"
 #include "SkMallocPixelRef.h"
 
 static const size_t kIgnoreRowBytesValue = (size_t)~0;
+class SkRasterDevice;
 
 class SkSurface_Raster : public SkSurface_Base {
 public:
     static bool Valid(const SkImageInfo&, size_t rb = kIgnoreRowBytesValue);
 
     SkSurface_Raster(const SkImageInfo&, void*, size_t rb,
                      void (*releaseProc)(void* pixels, void* context), void* context,
                      const SkSurfaceProps*);
     SkSurface_Raster(SkPixelRef*, const SkSurfaceProps*);
-
+    ~SkSurface_Raster();
     SkCanvas* onNewCanvas() SK_OVERRIDE;
     SkSurface* onNewSurface(const SkImageInfo&) SK_OVERRIDE;
     SkImage* onNewImageSnapshot(Budgeted) SK_OVERRIDE;
-    virtual void onDraw(SkCanvas*, SkScalar x, SkScalar y,
-                        const SkPaint*) SK_OVERRIDE;
-    void onCopyOnWrite(ContentChangeMode) SK_OVERRIDE;
+    uint32_t generationID() SK_OVERRIDE;
 
 private:
-    SkBitmap    fBitmap;
+    SkRasterDevice* fDevice;
+    uint32_t fLastDeviceGenerationID;
+    uint32_t fGenerationID;
 
     typedef SkSurface_Base INHERITED;
 };
 
+/** A bitmap device that is used by SkSurface_Raster. */
+class SkRasterDevice : public SkBitmapDevice {
+public:
+    SkRasterDevice(const SkBitmap& bitmap);
+
+    void setSurface(SkSurface_Raster* surface) {
+        fSurface = surface;
+        if (NULL != fSurface) {
+            fSurfaceProps = fSurface->props();
+        }
+    }
+
+    uint32_t generationID() { return this->getBackendBitmap().getGenerationID(); }
+
+private:
+    SkImage* onNewImageSnapshot() SK_OVERRIDE;
+
+    SkBitmap& getBackendBitmap() {
+        return fBitmap; // Note: accessing private SkBitmapDevice::fBitmap
+    }
+
+    SkSurface_Raster* fSurface;
+    SkSurfaceProps fSurfaceProps;
+
+    typedef SkBitmapDevice INHERITED;
+};
+
+SkRasterDevice::SkRasterDevice(const SkBitmap& bitmap)
+    : INHERITED(bitmap)
+    , fSurface(NULL)
+    , fSurfaceProps(0, kUnknown_SkPixelGeometry) {
+}
+
+SkImage* SkRasterDevice::onNewImageSnapshot() {
+    // Override the SkImage creation to set the correct surface properties.
+    return SkNewImageFromBitmap(fBitmap, &fSurfaceProps);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkSurface_Raster::Valid(const SkImageInfo& info, size_t rowBytes) {
     if (info.isEmpty()) {
         return false;
     }
 
     static const size_t kMaxTotalSize = SK_MaxS32;
 
     int shift = 0;
@@ skipping 31 matching lines @@
     }
 
     return true;
 }
 
 SkSurface_Raster::SkSurface_Raster(const SkImageInfo& info, void* pixels, size_t rb,
                                    void (*releaseProc)(void* pixels, void* context), void* context,
                                    const SkSurfaceProps* props)
     : INHERITED(info, props)
 {
-    fBitmap.installPixels(info, pixels, rb, NULL, releaseProc, context);
+    SkBitmap bitmap;
+    bitmap.installPixels(info, pixels, rb, NULL, releaseProc, context);
+    fDevice = SkNEW_ARGS(SkRasterDevice, (bitmap));
+    fDevice->setSurface(this);
+    fLastDeviceGenerationID = fDevice->generationID();
+    fGenerationID = this->newGenerationID();
 }
 
 SkSurface_Raster::SkSurface_Raster(SkPixelRef* pr, const SkSurfaceProps* props)
     : INHERITED(pr->info().width(), pr->info().height(), props)
 {
     const SkImageInfo& info = pr->info();
+    SkBitmap bitmap;
+    bitmap.setInfo(info, info.minRowBytes());
+    bitmap.setPixelRef(pr);
+    if (!info.isOpaque()) {
+        bitmap.eraseColor(SK_ColorTRANSPARENT);
+    }
+    fDevice = SkNEW_ARGS(SkRasterDevice, (bitmap));
+    fDevice->setSurface(this);
+    fLastDeviceGenerationID = fDevice->generationID();
+    fGenerationID = this->newGenerationID();
+}
 
-    fBitmap.setInfo(info, info.minRowBytes());
-    fBitmap.setPixelRef(pr);
-
-    if (!info.isOpaque()) {
-        fBitmap.eraseColor(SK_ColorTRANSPARENT);
-    }
+SkSurface_Raster::~SkSurface_Raster() {
+    fDevice->setSurface(NULL);
+    fDevice->unref();
 }
 
 SkCanvas* SkSurface_Raster::onNewCanvas() {
-    return SkNEW_ARGS(SkCanvas, (fBitmap, this->props()));
+    return SkNEW_ARGS(SkCanvas, (fDevice, &this->props(), SkCanvas::kDefault_InitFlags));
 }
 
 SkSurface* SkSurface_Raster::onNewSurface(const SkImageInfo& info) {
     return SkSurface::NewRaster(info);
 }
 
-void SkSurface_Raster::onDraw(SkCanvas* canvas, SkScalar x, SkScalar y,
-                              const SkPaint* paint) {
-    canvas->drawBitmap(fBitmap, x, y, paint);
+SkImage* SkSurface_Raster::onNewImageSnapshot(Budgeted) {
+    return fDevice->newImageSnapshot();
 }
 
-SkImage* SkSurface_Raster::onNewImageSnapshot(Budgeted) {
-    return SkNewImageFromBitmap(fBitmap, &this->props());
+uint32_t SkSurface_Raster::generationID() {
+    uint32_t deviceGenerationID = fDevice->generationID();
+    if (fLastDeviceGenerationID != deviceGenerationID) {
+        fLastDeviceGenerationID = deviceGenerationID;
+        // We do not return the device generation id, as that might clash with another
+        // SkSurface::generationID() generated by other SkSurface subclass.
+        fGenerationID = this->newGenerationID();
+    }
+    // The SkSurface API mandates that empty surfaces return zero. However, those are not valid by
+    // SkSurface_Raster::Valid, so currently this is not taken into account.
+    return fGenerationID;
 }
-
-void SkSurface_Raster::onCopyOnWrite(ContentChangeMode mode) {
-    // are we sharing pixelrefs with the image?
-    SkASSERT(this->getCachedImage(kNo_Budgeted));
-    if (SkBitmapImageGetPixelRef(this->getCachedImage(kNo_Budgeted)) == fBitmap.pixelRef()) {
-        if (kDiscard_ContentChangeMode == mode) {
-            fBitmap.setPixelRef(NULL);
-            fBitmap.allocPixels();
-        } else {
-            SkBitmap prev(fBitmap);
-            prev.deepCopyTo(&fBitmap);
-        }
-        // Now fBitmap is a deep copy of itself (and therefore different from
-        // what is being used by the image. Next we update the canvas to use
-        // this as its backend, so we can't modify the image's pixels anymore.
-        SkASSERT(this->getCachedCanvas());
-        this->getCachedCanvas()->getDevice()->replaceBitmapBackendForRasterSurface(fBitmap);
-    }
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 SkSurface* SkSurface::NewRasterDirectReleaseProc(const SkImageInfo& info, void* pixels, size_t rb,
                                                  void (*releaseProc)(void* pixels, void* context),
                                                  void* context, const SkSurfaceProps* props) {
     if (NULL == releaseProc) {
         context = NULL;
     }
     if (!SkSurface_Raster::Valid(info, rb)) {
         return NULL;
@@ skipping 14 matching lines @@
     if (!SkSurface_Raster::Valid(info)) {
         return NULL;
     }
 
     SkAutoTUnref<SkPixelRef> pr(SkMallocPixelRef::NewAllocate(info, 0, NULL));
     if (NULL == pr.get()) {
         return NULL;
     }
     return SkNEW_ARGS(SkSurface_Raster, (pr, props));
 }