Use SkImageCacherator in SkImages

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 "SkImageCacherator.h"
@@ skipping 35 matching lines @@
     }
 
     return SkNEW_ARGS(SkImageCacherator, (gen,
                                           gen->getInfo().makeWH(subset->width(), subset->height()),
                                           SkIPoint::Make(subset->x(), subset->y()),
                                           uniqueID));
 }
 
 SkImageCacherator::SkImageCacherator(SkImageGenerator* gen, const SkImageInfo& info,
                                      const SkIPoint& origin, uint32_t uniqueID)
-    : fGenerator(gen)
+    : fNotThreadSafeGenerator(gen)
     , fInfo(info)
     , fOrigin(origin)
     , fUniqueID(uniqueID)
 {}
 
 SkImageCacherator::~SkImageCacherator() {
-    SkDELETE(fGenerator);
+    SkDELETE(fNotThreadSafeGenerator);
+}
+
+SkData* SkImageCacherator::refEncoded() {
+    ScopedGenerator generator(this);
+    return generator->refEncodedData();
 }
 
 static bool check_output_bitmap(const SkBitmap& bitmap, uint32_t expectedID) {
     SkASSERT(bitmap.getGenerationID() == expectedID);
     SkASSERT(bitmap.isImmutable());
     SkASSERT(bitmap.getPixels());
     return true;
 }
 
-static bool generate_bitmap(SkBitmap* bitmap, const SkImageInfo& info, const SkIPoint& origin,
-                            SkImageGenerator* generator) {
-    const size_t rowBytes = info.minRowBytes();
-    if (!bitmap->tryAllocPixels(info, rowBytes)) {
+bool SkImageCacherator::generateBitmap(SkBitmap* bitmap) {
+    const size_t rowBytes = fInfo.minRowBytes();
+    if (!bitmap->tryAllocPixels(fInfo, rowBytes)) {
         return false;
     }
     SkASSERT(bitmap->rowBytes() == rowBytes);
 
+    ScopedGenerator generator(this);
     const SkImageInfo& genInfo = generator->getInfo();
-    if (info.dimensions() == genInfo.dimensions()) {
-        SkASSERT(origin.x() == 0 && origin.y() == 0);
+    if (fInfo.dimensions() == genInfo.dimensions()) {
+        SkASSERT(fOrigin.x() == 0 && fOrigin.y() == 0);
         // fast-case, no copy needed
         if (!generator->getPixels(bitmap->info(), bitmap->getPixels(), rowBytes)) {
             bitmap->reset();
             return false;
         }
     } else {
         // need to handle subsetting
         SkBitmap full;
         if (!full.tryAllocPixels(genInfo)) {
             return false;
         }
         if (!generator->getPixels(full.info(), full.getPixels(), full.rowBytes())) {
             bitmap->reset();
             return false;
         }
         full.readPixels(bitmap->info(), bitmap->getPixels(), bitmap->rowBytes(),
-                        origin.x(), origin.y());
+                        fOrigin.x(), fOrigin.y());
     }
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
 bool SkImageCacherator::tryLockAsBitmap(SkBitmap* bitmap) {
     if (SkBitmapCache::Find(fUniqueID, bitmap)) {
         return check_output_bitmap(*bitmap, fUniqueID);
     }
-    if (!generate_bitmap(bitmap, fInfo, fOrigin, fGenerator)) {
+
+    if (!this->generateBitmap(bitmap)) {
         return false;
     }
 
     bitmap->pixelRef()->setImmutableWithID(fUniqueID);
     SkBitmapCache::Add(fUniqueID, *bitmap);
     return true;
 }
 
 bool SkImageCacherator::lockAsBitmap(SkBitmap* bitmap) {
     if (this->tryLockAsBitmap(bitmap)) {
         return check_output_bitmap(*bitmap, fUniqueID);
     }
 
 #if SK_SUPPORT_GPU
     // Try to get a texture and read it back to raster (and then cache that with our ID)
+    SkAutoTUnref<GrTexture> tex;
 
-    SkIRect subset = SkIRect::MakeXYWH(fOrigin.x(), fOrigin.y(), fInfo.width(), fInfo.height());
-    SkAutoTUnref<GrTexture> tex(fGenerator->generateTexture(nullptr, kUntiled_SkImageUsageType,
-                                                            &subset));
+    {
+        ScopedGenerator generator(this);
+        SkIRect subset = SkIRect::MakeXYWH(fOrigin.x(), fOrigin.y(), fInfo.width(), fInfo.height());
+        tex.reset(generator->generateTexture(nullptr, kUntiled_SkImageUsageType, &subset));
+    }
     if (!tex) {
         bitmap->reset();
         return false;
     }
 
     if (!bitmap->tryAllocPixels(fInfo)) {
         bitmap->reset();
         return false;
     }
 
@@ skipping 17 matching lines @@
 GrTexture* SkImageCacherator::tryLockAsTexture(GrContext* ctx, SkImageUsageType usage) {
 #if SK_SUPPORT_GPU
     GrUniqueKey key;
     GrMakeKeyFromImageID(&key, fUniqueID, fInfo.width(), fInfo.height(), SkIPoint::Make(0, 0),
                          *ctx->caps(), usage);
     GrTexture* tex = ctx->textureProvider()->findAndRefTextureByUniqueKey(key);
     if (tex) {
         return tex; // we got a cache hit!
     }
 
-    SkIRect subset = SkIRect::MakeXYWH(fOrigin.x(), fOrigin.y(), fInfo.width(), fInfo.height());
-    tex = fGenerator->generateTexture(ctx, usage, &subset);
+    {
+        ScopedGenerator generator(this);
+        SkIRect subset = SkIRect::MakeXYWH(fOrigin.x(), fOrigin.y(), fInfo.width(), fInfo.height());
+        tex = generator->generateTexture(ctx, usage, &subset);
+    }
     if (tex) {
         tex->resourcePriv().setUniqueKey(key);
     }
     return tex;
 #else
     return nullptr;
 #endif
 }
 
 GrTexture* SkImageCacherator::lockAsTexture(GrContext* ctx, SkImageUsageType usage) {
 #if SK_SUPPORT_GPU
     if (!ctx) {
         return nullptr;
     }
     if (GrTexture* tex = this->tryLockAsTexture(ctx, usage)) {
         return tex;
     }
 
     // Try to get a bitmap and then upload/cache it as a texture
 
     SkBitmap bitmap;
-    if (!generate_bitmap(&bitmap, fInfo, fOrigin, fGenerator)) {
+    if (!this->generateBitmap(&bitmap)) {
         return nullptr;
     }
     return GrRefCachedBitmapTexture(ctx, bitmap, usage);
 #else
     return nullptr;
 #endif
 }