Deferred image generator subsetting

src/core/SkImageCacherator.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkBitmapCache.h"
 #include "SkImage_Base.h"
 #include "SkImageCacherator.h"
 #include "SkMallocPixelRef.h"
-#include "SkMutex.h"
 #include "SkNextID.h"
 #include "SkPixelRef.h"
 #include "SkResourceCache.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrGpuResourcePriv.h"
 #include "GrImageIDTextureAdjuster.h"
 #include "GrResourceKey.h"
 #include "GrTextureParams.h"
 #include "GrYUVProvider.h"
 #include "SkGr.h"
 #include "SkGrPriv.h"
 #endif
 
 // Until we actually have codecs/etc. that can contain/support a GPU texture format
 // skip this step, since for some generators, returning their encoded data as a SkData
 // can be somewhat expensive, and this call doesn't indicate to the generator that we're
 // only interested in GPU datas...
 // see skbug.com/ 4971, 5128, ...
 //#define SK_SUPPORT_COMPRESSED_TEXTURES_IN_CACHERATOR
 
-// Ref-counted tuple(SkImageGenerator, SkMutex) which allows sharing of one generator
-// among several cacherators.
-class SkImageCacherator::SharedGenerator final : public SkNVRefCnt<SharedGenerator> {
-public:
-    static sk_sp<SharedGenerator> Make(SkImageGenerator* gen) {
-        return gen ? sk_sp<SharedGenerator>(new SharedGenerator(gen)) : nullptr;
-    }
-
-private:
-    explicit SharedGenerator(SkImageGenerator* gen) : fGenerator(gen) { SkASSERT(gen); }
-
-    friend class ScopedGenerator;
-
-    std::unique_ptr<SkImageGenerator> fGenerator;
-    SkMutex                           fMutex;
-};
-
-
 // Helper for exclusive access to a shared generator.
 class SkImageCacherator::ScopedGenerator {
 public:
     ScopedGenerator(const sk_sp<SharedGenerator>& gen)
       : fSharedGenerator(gen)
       , fAutoAquire(gen->fMutex) {}
 
     SkImageGenerator* operator->() const {
         fSharedGenerator->fMutex.assertHeld();
         return fSharedGenerator->fGenerator.get();
     }
 
     operator SkImageGenerator*() const {
         fSharedGenerator->fMutex.assertHeld();
         return fSharedGenerator->fGenerator.get();
     }
 
 private:
     const sk_sp<SharedGenerator>& fSharedGenerator;
     SkAutoExclusive               fAutoAquire;
 };
 
-SkImageCacherator::Validator::Validator(SkImageGenerator* gen, const SkIRect* subset)
-    // We are required to take ownership of gen, regardless of whether we instantiate a cacherator
-    // or not.  On instantiation, the client is responsible for transferring ownership.
-    : fSharedGenerator(SkImageCacherator::SharedGenerator::Make(gen)) {
+SkImageCacherator::Validator::Validator(sk_sp<SharedGenerator> gen, const SkIRect* subset)
+    : fSharedGenerator(std::move(gen)) {
 
     if (!fSharedGenerator) {
         return;
     }
 
-    const SkImageInfo& info = gen->getInfo();
+    const SkImageInfo& info = fSharedGenerator->fGenerator->getInfo();

[reed1, 2016/11/04 17:55:29]

I presume its "safe" to access the generator w/o grabbing the shared mutex?

[f(malita), 2016/11/04 18:10:16]

Added comment, will follow up with cleanup CL.

     if (info.isEmpty()) {
         fSharedGenerator.reset();
         return;
     }
 
-    fUniqueID = gen->uniqueID();
+    fUniqueID = fSharedGenerator->fGenerator->uniqueID();
     const SkIRect bounds = SkIRect::MakeWH(info.width(), info.height());
     if (subset) {
         if (!bounds.contains(*subset)) {
             fSharedGenerator.reset();
             return;
         }
         if (*subset != bounds) {
             // we need a different uniqueID since we really are a subset of the raw generator
             fUniqueID = SkNextID::ImageID();
         }
     } else {
         subset = &bounds;
     }
 
     fInfo   = info.makeWH(subset->width(), subset->height());
     fOrigin = SkIPoint::Make(subset->x(), subset->y());
 }
 
-SkImageCacherator::Validator::~Validator() {}
-
 SkImageCacherator* SkImageCacherator::NewFromGenerator(SkImageGenerator* gen,
                                                        const SkIRect* subset) {
-    Validator validator(gen, subset);
+    Validator validator(SharedGenerator::Make(gen), subset);
 
     return validator ? new SkImageCacherator(&validator) : nullptr;
 }
 
 SkImageCacherator::SkImageCacherator(Validator* validator)
     : fSharedGenerator(std::move(validator->fSharedGenerator)) // we take ownership
     , fInfo(validator->fInfo)
     , fOrigin(validator->fOrigin)
     , fUniqueID(validator->fUniqueID)
 {
@@ skipping 273 matching lines @@
 
 #else
 
 GrTexture* SkImageCacherator::lockAsTexture(GrContext* ctx, const GrTextureParams&,
                                             SkSourceGammaTreatment gammaTreatment,
                                             const SkImage* client, SkImage::CachingHint) {
     return nullptr;
 }
 
 #endif