Add SkCachedData and use it for SkMipMap

src/core/SkMipMap.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 "SkMipMap.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
@@ skipping 91 matching lines @@
     }
     c += expand4444(*p);
     if (x < src.width() - 1) {
         p += 1;
     }
     c += expand4444(*p);
 
     *dst->getAddr16(x >> 1, y >> 1) = (uint16_t)collaps4444(c >> 2);
 }
 
-SkMipMap::Level* SkMipMap::AllocLevels(int levelCount, size_t pixelSize) {
+size_t SkMipMap::AllocLevelsSize(int levelCount, size_t pixelSize) {
     if (levelCount < 0) {
-        return NULL;
+        return 0;
     }
     int64_t size = sk_64_mul(levelCount + 1, sizeof(Level)) + pixelSize;
     if (!sk_64_isS32(size)) {
-        return NULL;
+        return 0;
     }
-    return (Level*)sk_malloc_throw(sk_64_asS32(size));
+    return sk_64_asS32(size);
 }
 
-SkMipMap* SkMipMap::Build(const SkBitmap& src) {
+SkMipMap* SkMipMap::Build(const SkBitmap& src, SkDiscardableFactoryProc fact) {
     void (*proc)(SkBitmap* dst, int x, int y, const SkBitmap& src);
 
     const SkColorType ct = src.colorType();
     const SkAlphaType at = src.alphaType();
     switch (ct) {
         case kRGBA_8888_SkColorType:
         case kBGRA_8888_SkColorType:
             proc = downsampleby2_proc32;
             break;
         case kRGB_565_SkColorType:
@@ skipping 24 matching lines @@
                 break;
             }
             size += SkColorTypeMinRowBytes(ct, width) * height;
             countLevels += 1;
         }
     }
     if (0 == countLevels) {
         return NULL;
     }
 
-    Level* levels = SkMipMap::AllocLevels(countLevels, size);
-    if (NULL == levels) {
+    size_t storageSize = SkMipMap::AllocLevelsSize(countLevels, size);
+    if (0 == storageSize) {
         return NULL;
     }
 
+    SkMipMap* mipmap;
+    if (fact) {
+        SkDiscardableMemory* dm = fact(storageSize);
+        if (NULL == dm) {
+            return NULL;
+        }
+        mipmap = SkNEW_ARGS(SkMipMap, (storageSize, dm));
+    } else {
+        mipmap = SkNEW_ARGS(SkMipMap, (sk_malloc_throw(storageSize), storageSize));
+    }
+
+    // init
+    mipmap->fCount = countLevels;
+    mipmap->fLevels = (Level*)mipmap->writable_data();
+
+    Level* levels = mipmap->fLevels;
     uint8_t*    baseAddr = (uint8_t*)&levels[countLevels];
     uint8_t*    addr = baseAddr;
     int         width = src.width();
     int         height = src.height();
     uint32_t    rowBytes;
     SkBitmap    srcBM(src);
 
     for (int i = 0; i < countLevels; ++i) {
         width >>= 1;
         height >>= 1;
@@ skipping 14 matching lines @@
                 proc(&dstBM, x, y, srcBM);
             }
         }
         srcBM.unlockPixels();
 
         srcBM = dstBM;
         addr += height * rowBytes;
     }
     SkASSERT(addr == baseAddr + size);
 
-    return SkNEW_ARGS(SkMipMap, (levels, countLevels, size));
+    return mipmap;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 //static int gCounter;
 
-SkMipMap::SkMipMap(Level* levels, int count, size_t size)
-    : fSize(size), fLevels(levels), fCount(count) {
-    SkASSERT(levels);
-    SkASSERT(count > 0);
-//    SkDebugf("mips %d\n", ++gCounter);
-}
-
-SkMipMap::~SkMipMap() {
-    sk_free(fLevels);
-//    SkDebugf("mips %d\n", --gCounter);
-}
-
 static SkFixed compute_level(SkScalar scale) {
     SkFixed s = SkAbs32(SkScalarToFixed(SkScalarInvert(scale)));
 
     if (s < SK_Fixed1) {
         return 0;
     }
     int clz = SkCLZ(s);
     SkASSERT(clz >= 1 && clz <= 15);
     return SkIntToFixed(15 - clz) + ((unsigned)(s << (clz + 1)) >> 16);
 }
 
 bool SkMipMap::extractLevel(SkScalar scale, Level* levelPtr) const {
+    if (NULL == fLevels) {
+        return false;
+    }
+
     if (scale >= SK_Scalar1) {
         return false;
     }
 
     int level = compute_level(scale) >> 16;
     SkASSERT(level >= 0);
     if (level <= 0) {
         return false;
     }
 
     if (level > fCount) {
         level = fCount;
     }
     if (levelPtr) {
         *levelPtr = fLevels[level - 1];
     }
     return true;
 }