Avoid separate allocation of SkImageCacherator

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"
@@ skipping 14 matching lines @@
 #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
 
-SkImageCacherator* SkImageCacherator::NewFromGenerator(SkImageGenerator* gen,
-                                                       const SkIRect* subset) {
+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.
+    : fGenerator(gen) {
+
     if (!gen) {
-        return nullptr;
+        return;
     }
 
-    // We are required to take ownership of gen, regardless of if we return a cacherator or not
-    SkAutoTDelete<SkImageGenerator> genHolder(gen);
-
     const SkImageInfo& info = gen->getInfo();
     if (info.isEmpty()) {
-        return nullptr;
+        fGenerator.reset();
+        return;
     }
 
-    uint32_t uniqueID = gen->uniqueID();
+    fUniqueID = gen->uniqueID();
     const SkIRect bounds = SkIRect::MakeWH(info.width(), info.height());
     if (subset) {
         if (!bounds.contains(*subset)) {
-            return nullptr;
+            fGenerator.reset();
+            return;
         }
         if (*subset != bounds) {
             // we need a different uniqueID since we really are a subset of the raw generator
-            uniqueID = SkNextID::ImageID();
+            fUniqueID = SkNextID::ImageID();
         }
     } else {
         subset = &bounds;
     }
 
-    // Now that we know we can hand-off the generator (to be owned by the cacherator) we can
-    // release our holder. (we DONT want to delete it here anymore)
-    genHolder.release();
-
-    return new SkImageCacherator(gen, gen->getInfo().makeWH(subset->width(), subset->height()),
-                                 SkIPoint::Make(subset->x(), subset->y()), uniqueID);
+    fInfo   = info.makeWH(subset->width(), subset->height());
+    fOrigin = SkIPoint::Make(subset->x(), subset->y());
 }
 
-SkImageCacherator::SkImageCacherator(SkImageGenerator* gen, const SkImageInfo& info,
-                                     const SkIPoint& origin, uint32_t uniqueID)
-    : fNotThreadSafeGenerator(gen)
-    , fInfo(info)
-    , fOrigin(origin)
-    , fUniqueID(uniqueID)
-{}
+SkImageCacherator* SkImageCacherator::NewFromGenerator(SkImageGenerator* gen,
+                                                       const SkIRect* subset) {
+    Validator validator(gen, subset);
+
+    return validator ? new SkImageCacherator(&validator) : nullptr;
+}
+
+SkImageCacherator::SkImageCacherator(Validator* validator)
+    : fNotThreadSafeGenerator(validator->fGenerator.release()) // we take ownership
+    , fInfo(validator->fInfo)
+    , fOrigin(validator->fOrigin)
+    , fUniqueID(validator->fUniqueID)
+{
+    SkASSERT(fNotThreadSafeGenerator);
+}
 
 SkData* SkImageCacherator::refEncoded(GrContext* ctx) {
     ScopedGenerator generator(this);
     return generator->refEncodedData(ctx);
 }
 
 static bool check_output_bitmap(const SkBitmap& bitmap, uint32_t expectedID) {
     SkASSERT(bitmap.getGenerationID() == expectedID);
     SkASSERT(bitmap.isImmutable());
     SkASSERT(bitmap.getPixels());
@@ skipping 259 matching lines @@
 
 #else
 
 GrTexture* SkImageCacherator::lockAsTexture(GrContext* ctx, const GrTextureParams&,
                                             SkSourceGammaTreatment gammaTreatment,
                                             const SkImage* client, SkImage::CachingHint) {
     return nullptr;
 }
 
 #endif