Allow client to force an SkImage snapshot to be unique (and uniquely own its backing store).

src/image/SkSurface_Base.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkSurface_Base_DEFINED
 #define SkSurface_Base_DEFINED
 
 #include "SkCanvas.h"
+#include "SkImagePriv.h"
 #include "SkSurface.h"
 #include "SkSurfacePriv.h"
 
 class SkSurface_Base : public SkSurface {
 public:
     SkSurface_Base(int width, int height, const SkSurfaceProps*);
     SkSurface_Base(const SkImageInfo&, const SkSurfaceProps*);
     virtual ~SkSurface_Base();
 
     virtual GrBackendObject onGetTextureHandle(BackendHandleAccess) {
@@ skipping 13 matching lines @@
     virtual SkCanvas* onNewCanvas() = 0;
 
     virtual SkSurface* onNewSurface(const SkImageInfo&) = 0;
 
     /**
      *  Allocate an SkImage that represents the current contents of the surface.
      *  This needs to be able to outlive the surface itself (if need be), and
      *  must faithfully represent the current contents, even if the surface
      *  is changed after this called (e.g. it is drawn to via its canvas).
      */
-    virtual SkImage* onNewImageSnapshot(Budgeted) = 0;
+    virtual SkImage* onNewImageSnapshot(Budgeted, ForceCopyMode) = 0;
 
     /**
      *  Default implementation:
      *
      *  image = this->newImageSnapshot();
      *  if (image) {
      *      image->draw(canvas, ...);
      *      image->unref();
      *  }
      */
@@ skipping 12 matching lines @@
      */
     virtual void onCopyOnWrite(ContentChangeMode) = 0;
 
     /**
      *  Signal the surface to remind its backing store that it's mutable again.
      *  Called only when we _didn't_ copy-on-write; we assume the copies start mutable.
      */
     virtual void onRestoreBackingMutability() {}
 
     inline SkCanvas* getCachedCanvas();
-    inline SkImage* getCachedImage(Budgeted);
+    inline SkImage* refCachedImage(Budgeted, ForceUnique);
 
     bool hasCachedImage() const { return fCachedImage != nullptr; }
 
     // called by SkSurface to compute a new genID
     uint32_t newGenerationID();
 
 private:
     SkCanvas*   fCachedCanvas;
     SkImage*    fCachedImage;
 
@@ skipping 12 matching lines @@
 SkCanvas* SkSurface_Base::getCachedCanvas() {
     if (nullptr == fCachedCanvas) {
         fCachedCanvas = this->onNewCanvas();
         if (fCachedCanvas) {
             fCachedCanvas->setSurfaceBase(this);
         }
     }
     return fCachedCanvas;
 }
 
-SkImage* SkSurface_Base::getCachedImage(Budgeted budgeted) {
-    if (nullptr == fCachedImage) {
-        fCachedImage = this->onNewImageSnapshot(budgeted);
-        SkASSERT(!fCachedCanvas || fCachedCanvas->getSurfaceBase() == this);
+SkImage* SkSurface_Base::refCachedImage(Budgeted budgeted, ForceUnique unique) {
+    SkImage* snap = fCachedImage;
+    if (kYes_ForceUnique == unique && snap && !snap->unique()) {
+        snap = nullptr;
     }
-    return fCachedImage;
+    if (snap) {
+        return SkRef(snap);
+    }
+    ForceCopyMode fcm = (kYes_ForceUnique == unique) ? kYes_ForceCopyMode :
+                                                       kNo_ForceCopyMode;
+    snap = this->onNewImageSnapshot(budgeted, fcm);
+    if (kNo_ForceUnique == unique) {
+        SkASSERT(!fCachedImage);
+        fCachedImage = SkSafeRef(snap);
+    }
+    SkASSERT(!fCachedCanvas || fCachedCanvas->getSurfaceBase() == this);
+    return snap;
 }
 
 #endif