Big Cleanup: SkBitmapFactory, SkLazyPixelRef, SkImageCache

tools/LazyDecodeBitmap.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "LazyDecodeBitmap.h"
 
-#include "PictureRenderingFlags.h"  // --deferImageDecoding is defined here.
-#include "SkBitmap.h"
 #include "SkData.h"
-#include "SkImageDecoder.h"
+#include "SkDecodingImageGenerator.h"
+#include "SkDiscardablePixelRef.h"
 #include "SkForceLinking.h"
-#include "SkLruImageCache.h"
-#include "SkPurgeableImageCache.h"
-#include "SkCommandLineFlags.h"
+#include "SkDiscardableMemoryPool.h"
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
-DEFINE_bool(useVolatileCache, false, "Use a volatile cache for deferred image decoding pixels. "

[scroggo, 2013/12/03 23:00:01]

You'll need to modify buildbot/slave/skia_slave_scripts/render_pictures.py to
remove the flag --useVolatileCache.

[hal.canary, 2013/12/04 00:01:36]

Okay.

We may want to keep useVolatileCache for Android testing when my ashmem-backed
DM lands.   

-            "Only meaningful if --deferImageDecoding is set to true and the platform has an "
-            "implementation.");
-
-SkLruImageCache gLruImageCache(1024 * 1024);
-
-namespace sk_tools {
-
-// Simple cache selector to choose between a purgeable cache for large images and the standard one
-// for smaller images.
-//
-class CacheSelector : public SkBitmapFactory::CacheSelector {
-
-public:
-    CacheSelector() {
-        fPurgeableImageCache = SkPurgeableImageCache::Create();
+//  Fits SkPicture::InstallPixelRefProc call signature.
+//  Used in SkPicturePlayback::CreateFromStream
+bool sk_tools::LazyDecodeBitmap(const void* src,
+                                size_t length,
+                                SkBitmap* dst) {
+    SkAutoDataUnref data(SkData::NewWithCopy(src, length));
+    if (NULL == data.get()) {
+        return false;
     }
 
-    ~CacheSelector() {
-        SkSafeUnref(fPurgeableImageCache);
+    SkAutoTDelete<SkImageGenerator> gen(SkNEW_ARGS(SkDecodingImageGenerator,
+                                                   (data)));
+    SkImageInfo info;
+    if (!gen->getInfo(&info)) {
+        return false;
     }
-
-    virtual SkImageCache* selectCache(const SkImageInfo& info) SK_OVERRIDE {
-        if (info.fWidth * info.fHeight > 32 * 1024 && fPurgeableImageCache != NULL) {
-            return fPurgeableImageCache;
-        }
-        return &gLruImageCache;
+    SkDiscardableMemory::Factory* pool = NULL;
+    if (info.fWidth * info.fHeight > 32 * 1024) {
+        // how to do switching with SkDiscardableMemory.
+        pool = SkGetGlobalDiscardableMemoryPool();
     }
-private:
-    SkImageCache* fPurgeableImageCache;
-};
-
-static CacheSelector gCacheSelector;
-static SkBitmapFactory gFactory(&SkImageDecoder::DecodeMemoryToTarget);
-
-bool LazyDecodeBitmap(const void* buffer, size_t size, SkBitmap* bitmap) {
-    void* copiedBuffer = sk_malloc_throw(size);
-    memcpy(copiedBuffer, buffer, size);
-    SkAutoDataUnref data(SkData::NewFromMalloc(copiedBuffer, size));
-
-    static bool gOnce;
-    if (!gOnce) {
-        // Only use the cache selector if there is a purgeable image cache to use for large
-        // images.
-        if (FLAGS_useVolatileCache && SkAutoTUnref<SkImageCache>(
-                SkPurgeableImageCache::Create()).get() != NULL) {
-            gFactory.setCacheSelector(&gCacheSelector);
-        } else {
-            gFactory.setImageCache(&gLruImageCache);
-        }
-        gOnce = true;
-    }
-    return gFactory.installPixelRef(data, bitmap);
+    return SkDiscardablePixelRef::Install(gen.detach(), dst, pool);
 }
-
-}  // namespace sk_tools