Shared image generator

src/core/SkImageCacherator.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkImageCacherator_DEFINED
 #define SkImageCacherator_DEFINED
 
 #include "SkImageGenerator.h"
-#include "SkMutex.h"
 #include "SkTemplates.h"
 
 class GrContext;
 class GrTextureParams;
 class GrUniqueKey;
 class SkBitmap;
 class SkImage;
 
 /*
  *  Internal class to manage caching the output of an ImageGenerator.
  */
 class SkImageCacherator {
 public:
     // Takes ownership of the generator
     static SkImageCacherator* NewFromGenerator(SkImageGenerator*, const SkIRect* subset = nullptr);
 
+    ~SkImageCacherator();
+
     const SkImageInfo& info() const { return fInfo; }
     uint32_t uniqueID() const { return fUniqueID; }
 
     /**
      *  On success (true), bitmap will point to the pixels for this generator. If this returns
      *  false, the bitmap will be reset to empty.
      *
      *  If not NULL, the client will be notified (->notifyAddedToCache()) when resources are
      *  added to the cache on its behalf.
      */
@@ skipping 22 matching lines @@
      */
     SkData* refEncoded(GrContext*);
 
     // Only return true if the generate has already been cached.
     bool lockAsBitmapOnlyIfAlreadyCached(SkBitmap*);
     // Call the underlying generator directly
     bool directGeneratePixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB,
                               int srcX, int srcY);
 
 private:
+    class SharedGenerator;
+    class ScopedGenerator;
+
     struct Validator {
         Validator(SkImageGenerator*, const SkIRect* subset);
+        ~Validator();
 
-        operator bool() const { return fGenerator.get(); }
+        operator bool() const { return fSharedGenerator.get(); }
 
-        std::unique_ptr<SkImageGenerator> fGenerator;
-        SkImageInfo                       fInfo;
-        SkIPoint                          fOrigin;
-        uint32_t                          fUniqueID;
+        sk_sp<SharedGenerator> fSharedGenerator;
+        SkImageInfo            fInfo;
+        SkIPoint               fOrigin;
+        uint32_t               fUniqueID;
     };
 
     SkImageCacherator(Validator*);
 
     bool generateBitmap(SkBitmap*);
     bool tryLockAsBitmap(SkBitmap*, const SkImage*, SkImage::CachingHint);
 #if SK_SUPPORT_GPU
     // Returns the texture. If the cacherator is generating the texture and wants to cache it,
     // it should use the passed in key (if the key is valid).
     GrTexture* lockTexture(GrContext*, const GrUniqueKey& key, const SkImage* client,
                            SkImage::CachingHint, bool willBeMipped, SkSourceGammaTreatment);
 #endif
 
-    class ScopedGenerator {
-        SkImageCacherator* fCacher;
-    public:
-        ScopedGenerator(SkImageCacherator* cacher) : fCacher(cacher) {
-            fCacher->fMutexForGenerator.acquire();
-        }
-        ~ScopedGenerator() {
-            fCacher->fMutexForGenerator.release();
-        }
-        SkImageGenerator* operator->() const { return fCacher->fNotThreadSafeGenerator; }
-        operator SkImageGenerator*() const { return fCacher->fNotThreadSafeGenerator; }
-    };
-
-    SkMutex                         fMutexForGenerator;
-    SkAutoTDelete<SkImageGenerator> fNotThreadSafeGenerator;
-
-    const SkImageInfo   fInfo;
-    const SkIPoint      fOrigin;
-    const uint32_t      fUniqueID;
+    sk_sp<SharedGenerator> fSharedGenerator;
+    const SkImageInfo      fInfo;
+    const SkIPoint         fOrigin;
+    const uint32_t         fUniqueID;
 
     friend class GrImageTextureMaker;
     friend class SkImage;
     friend class SkImage_Generator;
 };
 
 #endif