src/core/SkBitmapCache.cpp - skia - Git at Google

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "SkBitmapCache.h"
 #include "SkImage.h"
 #include "SkResourceCache.h"
 #include "SkMipMap.h"
 #include "SkPixelRef.h"
 #include "SkRect.h"

 /**
  *  Use this for bitmapcache and mipmapcache entries.
  */
 uint64_t SkMakeResourceCacheSharedIDForBitmap(uint32_t bitmapGenID) {
     uint64_t sharedID = SkSetFourByteTag('b', 'm', 'a', 'p');
     return (sharedID << 32) | bitmapGenID;
 }

 void SkNotifyBitmapGenIDIsStale(uint32_t bitmapGenID) {
     SkResourceCache::PostPurgeSharedID(SkMakeResourceCacheSharedIDForBitmap(bitmapGenID));
 }

 ///////////////////////////////////////////////////////////////////////////////////////////////////

 /**
  This function finds the bounds of the bitmap *within its pixelRef*.
  If the bitmap lacks a pixelRef, it will return an empty rect, since
  that doesn't make sense.  This may be a useful enough function that
  it should be somewhere else (in SkBitmap?).
  */
 static SkIRect get_bounds_from_bitmap(const SkBitmap& bm) {
     if (!(bm.pixelRef())) {
         return SkIRect::MakeEmpty();
     }
     SkIPoint origin = bm.pixelRefOrigin();
     return SkIRect::MakeXYWH(origin.fX, origin.fY, bm.width(), bm.height());
 }

 /**
  *  This function finds the bounds of the image. Today this is just the entire bounds,
  *  but in the future we may support subsets within an image, in which case this should
  *  return that subset (see get_bounds_from_bitmap).
  */
 static SkIRect get_bounds_from_image(const SkImage* image) {
     SkASSERT(image->width() > 0 && image->height() > 0);
     return SkIRect::MakeWH(image->width(), image->height());
 }

 SkBitmapCacheDesc SkBitmapCacheDesc::Make(uint32_t imageID, int origWidth, int origHeight) {
     SkASSERT(imageID);
     SkASSERT(origWidth > 0 && origHeight > 0);
     return { imageID, 0, 0, {0, 0, origWidth, origHeight} };
 }

 SkBitmapCacheDesc SkBitmapCacheDesc::Make(const SkBitmap& bm, int scaledWidth, int scaledHeight) {
     SkASSERT(bm.width() > 0 && bm.height() > 0);
     SkASSERT(scaledWidth > 0 && scaledHeight > 0);
     SkASSERT(scaledWidth != bm.width() || scaledHeight != bm.height());

     return { bm.getGenerationID(), scaledWidth, scaledHeight, get_bounds_from_bitmap(bm) };
 }

 SkBitmapCacheDesc SkBitmapCacheDesc::Make(const SkBitmap& bm) {
     SkASSERT(bm.width() > 0 && bm.height() > 0);
     SkASSERT(bm.pixelRefOrigin() == SkIPoint::Make(0, 0));

     return { bm.getGenerationID(), 0, 0, get_bounds_from_bitmap(bm) };
 }

 SkBitmapCacheDesc SkBitmapCacheDesc::Make(const SkImage* image, int scaledWidth, int scaledHeight) {
     SkASSERT(image->width() > 0 && image->height() > 0);
     SkASSERT(scaledWidth > 0 && scaledHeight > 0);

     // If the dimensions are the same, should we set them to 0,0?
     //SkASSERT(scaledWidth != image->width() || scaledHeight != image->height());

     return { image->uniqueID(), scaledWidth, scaledHeight, get_bounds_from_image(image) };
 }

 SkBitmapCacheDesc SkBitmapCacheDesc::Make(const SkImage* image) {
     SkASSERT(image->width() > 0 && image->height() > 0);

     return { image->uniqueID(), 0, 0, get_bounds_from_image(image) };
 }

 namespace {
 static unsigned gBitmapKeyNamespaceLabel;

 struct BitmapKey : public SkResourceCache::Key {
 public:
     BitmapKey(const SkBitmapCacheDesc& desc) : fDesc(desc) {
         this->init(&gBitmapKeyNamespaceLabel, SkMakeResourceCacheSharedIDForBitmap(fDesc.fImageID),
                    sizeof(fDesc));
     }

     void dump() const {
         SkDebugf("-- add [%d %d] %d [%d %d %d %d]\n",
                  fDesc.fScaledWidth, fDesc.fScaledHeight, fDesc.fImageID,
              fDesc.fSubset.x(), fDesc.fSubset.y(), fDesc.fSubset.width(), fDesc.fSubset.height());
     }

     const SkBitmapCacheDesc fDesc;
 };
 }

 //////////////////////
 #include "SkDiscardableMemory.h"
 #include "SkNextID.h"

 void SkBitmapCache_setImmutableWithID(SkPixelRef* pr, uint32_t id) {
     pr->setImmutableWithID(id);
 }

 //#define REC_TRACE   SkDebugf
 static void REC_TRACE(const char format[], ...) {}

 // for diagnostics
 static int32_t gRecCounter;

 class SkBitmapCache::Rec : public SkResourceCache::Rec {
 public:
     Rec(const SkBitmapCacheDesc& desc, const SkImageInfo& info, size_t rowBytes,
         std::unique_ptr<SkDiscardableMemory> dm, void* block)
         : fKey(desc)
         , fDM(std::move(dm))
         , fMalloc(block)
         , fInfo(info)
         , fRowBytes(rowBytes)
         , fExternalCounter(kBeforeFirstInstall_ExternalCounter)
     {
         SkASSERT(!(fDM && fMalloc));    // can't have both

         // We need an ID to return with the bitmap/pixelref.
         // If they are not scaling, we can return the same ID as the key/desc
         // If they are scaling, we need a new ID
         if (desc.fScaledWidth == 0 && desc.fScaledHeight == 0) {
             fPrUniqueID = desc.fImageID;
         } else {
             fPrUniqueID = SkNextID::ImageID();
         }
         REC_TRACE(" Rec(%d): [%d %d] %d\n",
                   sk_atomic_inc(&gRecCounter), fInfo.width(), fInfo.height(), fPrUniqueID);
     }

     ~Rec() override {
         SkASSERT(0 == fExternalCounter || kBeforeFirstInstall_ExternalCounter == fExternalCounter);
         if (fDM && kBeforeFirstInstall_ExternalCounter == fExternalCounter) {
             // we never installed, so we need to unlock before we destroy the DM
             SkASSERT(fDM->data());
             fDM->unlock();
         }
         REC_TRACE("~Rec(%d): [%d %d] %d\n",
                   sk_atomic_dec(&gRecCounter) - 1, fInfo.width(), fInfo.height(), fPrUniqueID);
         sk_free(fMalloc);   // may be null
     }

     const Key& getKey() const override { return fKey; }
     size_t bytesUsed() const override {
         return sizeof(fKey) + fInfo.computeByteSize(fRowBytes);
     }
     bool canBePurged() override {
         SkAutoMutexAcquire ama(fMutex);
         return fExternalCounter == 0;
     }
     void postAddInstall(void* payload) override {
         SkAssertResult(this->install(static_cast<SkBitmap*>(payload)));
     }

     const char* getCategory() const override { return "bitmap"; }
     SkDiscardableMemory* diagnostic_only_getDiscardable() const override {
         return fDM.get();
     }

     static void ReleaseProc(void* addr, void* ctx) {
         Rec* rec = static_cast<Rec*>(ctx);
         SkAutoMutexAcquire ama(rec->fMutex);

         REC_TRACE(" Rec: [%d] releaseproc\n", rec->fPrUniqueID);

         SkASSERT(rec->fExternalCounter > 0);
         rec->fExternalCounter -= 1;
         if (rec->fDM) {
             SkASSERT(rec->fMalloc == nullptr);
             if (rec->fExternalCounter == 0) {
                 REC_TRACE(" Rec [%d] unlock\n", rec->fPrUniqueID);
                 rec->fDM->unlock();
             }
         } else {
             SkASSERT(rec->fMalloc != nullptr);
         }
     }

     bool install(SkBitmap* bitmap) {
         SkAutoMutexAcquire ama(fMutex);

         // are we still valid
         if (!fDM && !fMalloc) {
             REC_TRACE(" Rec: [%d] invalid\n", fPrUniqueID);
             return false;
         }

         /*
             constructor      fExternalCount < 0     fDM->data()
             after install    fExternalCount > 0     fDM->data()
             after Release    fExternalCount == 0    !fDM->data()
         */
         if (fDM) {
             if (kBeforeFirstInstall_ExternalCounter == fExternalCounter) {
                 SkASSERT(fDM->data());
             } else if (fExternalCounter > 0) {
                 SkASSERT(fDM->data());
             } else {
                 SkASSERT(fExternalCounter == 0);
                 if (!fDM->lock()) {
                     REC_TRACE(" Rec [%d] re-lock failed\n", fPrUniqueID);
                     fDM.reset(nullptr);
                     return false;
                 }
                 REC_TRACE(" Rec [%d] re-lock succeeded\n", fPrUniqueID);
             }
             SkASSERT(fDM->data());
         }

         bitmap->installPixels(fInfo, fDM ? fDM->data() : fMalloc, fRowBytes, ReleaseProc, this);
         SkBitmapCache_setImmutableWithID(bitmap->pixelRef(), fPrUniqueID);

         REC_TRACE(" Rec: [%d] install new pr\n", fPrUniqueID);

         if (kBeforeFirstInstall_ExternalCounter == fExternalCounter) {
             fExternalCounter = 1;
         } else {
             fExternalCounter += 1;
         }
         SkASSERT(fExternalCounter > 0);
         return true;
     }

     static bool Finder(const SkResourceCache::Rec& baseRec, void* contextBitmap) {
         Rec* rec = (Rec*)&baseRec;
         SkBitmap* result = (SkBitmap*)contextBitmap;
         REC_TRACE(" Rec: [%d] found\n", rec->fPrUniqueID);
         return rec->install(result);
     }

 private:
     BitmapKey   fKey;

     SkMutex     fMutex;

     // either fDM or fMalloc can be non-null, but not both
     std::unique_ptr<SkDiscardableMemory> fDM;
     void*       fMalloc;

     SkImageInfo fInfo;
     size_t      fRowBytes;
     uint32_t    fPrUniqueID;

     // This field counts the number of external pixelrefs we have created. They notify us when
     // they are destroyed so we can decrement this.
     //
     //  > 0     we have outstanding pixelrefs
     // == 0     we have no outstanding pixelrefs, and can be safely purged
     //  < 0     we have been created, but not yet "installed" the first time.
     //
     int         fExternalCounter;

     enum {
         kBeforeFirstInstall_ExternalCounter = -1
     };
 };

 void SkBitmapCache::PrivateDeleteRec(Rec* rec) { delete rec; }

 SkBitmapCache::RecPtr SkBitmapCache::Alloc(const SkBitmapCacheDesc& desc, const SkImageInfo& info,
                                            SkPixmap* pmap) {
     // Ensure that the caller is self-consistent:
     //  - if they are scaling, the info matches the scaled size
     //  - if they are not, the info matches the subset (i.e. the subset is the entire image)
     if (desc.fScaledWidth == 0 && desc.fScaledHeight == 0) {
         SkASSERT(info.width() == desc.fSubset.width());
         SkASSERT(info.height() == desc.fSubset.height());
     } else {
         SkASSERT(info.width() == desc.fScaledWidth);
         SkASSERT(info.height() == desc.fScaledHeight);
     }

     const size_t rb = info.minRowBytes();
     size_t size = info.computeByteSize(rb);
     if (SkImageInfo::ByteSizeOverflowed(size)) {
         return nullptr;
     }

     std::unique_ptr<SkDiscardableMemory> dm;
     void* block = nullptr;

     auto factory = SkResourceCache::GetDiscardableFactory();
     if (factory) {
         dm.reset(factory(size));
     } else {
         block = sk_malloc_canfail(size);
     }
     if (!dm && !block) {
         return nullptr;
     }
     *pmap = SkPixmap(info, dm ? dm->data() : block, rb);
     return RecPtr(new Rec(desc, info, rb, std::move(dm), block));
 }

 void SkBitmapCache::Add(RecPtr rec, SkBitmap* bitmap) {
     SkResourceCache::Add(rec.release(), bitmap);
 }

 bool SkBitmapCache::Find(const SkBitmapCacheDesc& desc, SkBitmap* result) {
     desc.validate();
     return SkResourceCache::Find(BitmapKey(desc), SkBitmapCache::Rec::Finder, result);
 }

 //////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////

 #define CHECK_LOCAL(localCache, localName, globalName, ...) \
     ((localCache) ? localCache->localName(__VA_ARGS__) : SkResourceCache::globalName(__VA_ARGS__))

 namespace {
 static unsigned gMipMapKeyNamespaceLabel;

 struct MipMapKey : public SkResourceCache::Key {
 public:
     MipMapKey(uint32_t imageID, const SkIRect& subset, SkDestinationSurfaceColorMode colorMode)
         : fImageID(imageID)
         , fColorMode(static_cast<uint32_t>(colorMode))
         , fSubset(subset)
     {
         SkASSERT(fImageID);
         SkASSERT(!subset.isEmpty());
         this->init(&gMipMapKeyNamespaceLabel, SkMakeResourceCacheSharedIDForBitmap(fImageID),
                    sizeof(fImageID) + sizeof(fColorMode) + sizeof(fSubset));
     }

     uint32_t    fImageID;
     uint32_t    fColorMode;
     SkIRect     fSubset;
 };

 struct MipMapRec : public SkResourceCache::Rec {
     MipMapRec(uint32_t imageID, const SkIRect& subset, SkDestinationSurfaceColorMode colorMode,
               const SkMipMap* result)
         : fKey(imageID, subset, colorMode)
         , fMipMap(result)
     {
         fMipMap->attachToCacheAndRef();
     }

     ~MipMapRec() override {
         fMipMap->detachFromCacheAndUnref();
     }

     const Key& getKey() const override { return fKey; }
     size_t bytesUsed() const override { return sizeof(fKey) + fMipMap->size(); }
     const char* getCategory() const override { return "mipmap"; }
     SkDiscardableMemory* diagnostic_only_getDiscardable() const override {
         return fMipMap->diagnostic_only_getDiscardable();
     }

     static bool Finder(const SkResourceCache::Rec& baseRec, void* contextMip) {
         const MipMapRec& rec = static_cast<const MipMapRec&>(baseRec);
         const SkMipMap* mm = SkRef(rec.fMipMap);
         // the call to ref() above triggers a "lock" in the case of discardable memory,
         // which means we can now check for null (in case the lock failed).
         if (nullptr == mm->data()) {
             mm->unref();    // balance our call to ref()
             return false;
         }
         // the call must call unref() when they are done.
         *(const SkMipMap**)contextMip = mm;
         return true;
     }

 private:
     MipMapKey       fKey;
     const SkMipMap* fMipMap;
 };
 }

 const SkMipMap* SkMipMapCache::FindAndRef(const SkBitmapCacheDesc& desc,
                                           SkDestinationSurfaceColorMode colorMode,
                                           SkResourceCache* localCache) {
     SkASSERT(desc.fScaledWidth == 0);
     SkASSERT(desc.fScaledHeight == 0);
     MipMapKey key(desc.fImageID, desc.fSubset, colorMode);
     const SkMipMap* result;

     if (!CHECK_LOCAL(localCache, find, Find, key, MipMapRec::Finder, &result)) {
         result = nullptr;
     }
     return result;
 }

 static SkResourceCache::DiscardableFactory get_fact(SkResourceCache* localCache) {
     return localCache ? localCache->GetDiscardableFactory()
                       : SkResourceCache::GetDiscardableFactory();
 }

 const SkMipMap* SkMipMapCache::AddAndRef(const SkBitmap& src,
                                          SkDestinationSurfaceColorMode colorMode,
                                          SkResourceCache* localCache) {
     SkMipMap* mipmap = SkMipMap::Build(src, colorMode, get_fact(localCache));
     if (mipmap) {
         MipMapRec* rec = new MipMapRec(src.getGenerationID(), get_bounds_from_bitmap(src),
                                        colorMode, mipmap);
         CHECK_LOCAL(localCache, add, Add, rec);
         src.pixelRef()->notifyAddedToCache();
     }
     return mipmap;
 }
	/*
	* Copyright 2014 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "SkBitmapCache.h"
	#include "SkImage.h"
	#include "SkResourceCache.h"
	#include "SkMipMap.h"
	#include "SkPixelRef.h"
	#include "SkRect.h"

	/**
	* Use this for bitmapcache and mipmapcache entries.
	*/
	uint64_t SkMakeResourceCacheSharedIDForBitmap(uint32_t bitmapGenID) {
	uint64_t sharedID = SkSetFourByteTag('b', 'm', 'a', 'p');
	return (sharedID << 32) \| bitmapGenID;
	}

	void SkNotifyBitmapGenIDIsStale(uint32_t bitmapGenID) {
	SkResourceCache::PostPurgeSharedID(SkMakeResourceCacheSharedIDForBitmap(bitmapGenID));
	}

	///////////////////////////////////////////////////////////////////////////////////////////////////

	/**
	This function finds the bounds of the bitmap within its pixelRef.
	If the bitmap lacks a pixelRef, it will return an empty rect, since
	that doesn't make sense. This may be a useful enough function that
	it should be somewhere else (in SkBitmap?).
	*/
	static SkIRect get_bounds_from_bitmap(const SkBitmap& bm) {
	if (!(bm.pixelRef())) {
	return SkIRect::MakeEmpty();
	}
	SkIPoint origin = bm.pixelRefOrigin();
	return SkIRect::MakeXYWH(origin.fX, origin.fY, bm.width(), bm.height());
	}

	/**
	* This function finds the bounds of the image. Today this is just the entire bounds,
	* but in the future we may support subsets within an image, in which case this should
	* return that subset (see get_bounds_from_bitmap).
	*/
	static SkIRect get_bounds_from_image(const SkImage* image) {
	SkASSERT(image->width() > 0 && image->height() > 0);
	return SkIRect::MakeWH(image->width(), image->height());
	}

	SkBitmapCacheDesc SkBitmapCacheDesc::Make(uint32_t imageID, int origWidth, int origHeight) {
	SkASSERT(imageID);
	SkASSERT(origWidth > 0 && origHeight > 0);
	return { imageID, 0, 0, {0, 0, origWidth, origHeight} };
	}

	SkBitmapCacheDesc SkBitmapCacheDesc::Make(const SkBitmap& bm, int scaledWidth, int scaledHeight) {
	SkASSERT(bm.width() > 0 && bm.height() > 0);
	SkASSERT(scaledWidth > 0 && scaledHeight > 0);
	SkASSERT(scaledWidth != bm.width() \|\| scaledHeight != bm.height());

	return { bm.getGenerationID(), scaledWidth, scaledHeight, get_bounds_from_bitmap(bm) };
	}

	SkBitmapCacheDesc SkBitmapCacheDesc::Make(const SkBitmap& bm) {
	SkASSERT(bm.width() > 0 && bm.height() > 0);
	SkASSERT(bm.pixelRefOrigin() == SkIPoint::Make(0, 0));

	return { bm.getGenerationID(), 0, 0, get_bounds_from_bitmap(bm) };
	}

	SkBitmapCacheDesc SkBitmapCacheDesc::Make(const SkImage* image, int scaledWidth, int scaledHeight) {
	SkASSERT(image->width() > 0 && image->height() > 0);
	SkASSERT(scaledWidth > 0 && scaledHeight > 0);

	// If the dimensions are the same, should we set them to 0,0?
	//SkASSERT(scaledWidth != image->width() \|\| scaledHeight != image->height());

	return { image->uniqueID(), scaledWidth, scaledHeight, get_bounds_from_image(image) };
	}

	SkBitmapCacheDesc SkBitmapCacheDesc::Make(const SkImage* image) {
	SkASSERT(image->width() > 0 && image->height() > 0);

	return { image->uniqueID(), 0, 0, get_bounds_from_image(image) };
	}

	namespace {
	static unsigned gBitmapKeyNamespaceLabel;

	struct BitmapKey : public SkResourceCache::Key {
	public:
	BitmapKey(const SkBitmapCacheDesc& desc) : fDesc(desc) {
	this->init(&gBitmapKeyNamespaceLabel, SkMakeResourceCacheSharedIDForBitmap(fDesc.fImageID),
	sizeof(fDesc));
	}

	void dump() const {
	SkDebugf("-- add [%d %d] %d [%d %d %d %d]\n",
	fDesc.fScaledWidth, fDesc.fScaledHeight, fDesc.fImageID,
	fDesc.fSubset.x(), fDesc.fSubset.y(), fDesc.fSubset.width(), fDesc.fSubset.height());
	}

	const SkBitmapCacheDesc fDesc;
	};
	}

	//////////////////////
	#include "SkDiscardableMemory.h"
	#include "SkNextID.h"

	void SkBitmapCache_setImmutableWithID(SkPixelRef* pr, uint32_t id) {
	pr->setImmutableWithID(id);
	}

	//#define REC_TRACE SkDebugf
	static void REC_TRACE(const char format[], ...) {}

	// for diagnostics
	static int32_t gRecCounter;

	class SkBitmapCache::Rec : public SkResourceCache::Rec {
	public:
	Rec(const SkBitmapCacheDesc& desc, const SkImageInfo& info, size_t rowBytes,
	std::unique_ptr<SkDiscardableMemory> dm, void* block)
	: fKey(desc)
	, fDM(std::move(dm))
	, fMalloc(block)
	, fInfo(info)
	, fRowBytes(rowBytes)
	, fExternalCounter(kBeforeFirstInstall_ExternalCounter)
	{
	SkASSERT(!(fDM && fMalloc)); // can't have both

	// We need an ID to return with the bitmap/pixelref.
	// If they are not scaling, we can return the same ID as the key/desc
	// If they are scaling, we need a new ID
	if (desc.fScaledWidth == 0 && desc.fScaledHeight == 0) {
	fPrUniqueID = desc.fImageID;
	} else {
	fPrUniqueID = SkNextID::ImageID();
	}
	REC_TRACE(" Rec(%d): [%d %d] %d\n",
	sk_atomic_inc(&gRecCounter), fInfo.width(), fInfo.height(), fPrUniqueID);
	}

	~Rec() override {
	SkASSERT(0 == fExternalCounter \|\| kBeforeFirstInstall_ExternalCounter == fExternalCounter);
	if (fDM && kBeforeFirstInstall_ExternalCounter == fExternalCounter) {
	// we never installed, so we need to unlock before we destroy the DM
	SkASSERT(fDM->data());
	fDM->unlock();
	}
	REC_TRACE("~Rec(%d): [%d %d] %d\n",
	sk_atomic_dec(&gRecCounter) - 1, fInfo.width(), fInfo.height(), fPrUniqueID);
	sk_free(fMalloc); // may be null
	}

	const Key& getKey() const override { return fKey; }
	size_t bytesUsed() const override {
	return sizeof(fKey) + fInfo.computeByteSize(fRowBytes);
	}
	bool canBePurged() override {
	SkAutoMutexAcquire ama(fMutex);
	return fExternalCounter == 0;
	}
	void postAddInstall(void* payload) override {
	SkAssertResult(this->install(static_cast<SkBitmap*>(payload)));
	}

	const char* getCategory() const override { return "bitmap"; }
	SkDiscardableMemory* diagnostic_only_getDiscardable() const override {
	return fDM.get();
	}

	static void ReleaseProc(void* addr, void* ctx) {
	Rec* rec = static_cast<Rec*>(ctx);
	SkAutoMutexAcquire ama(rec->fMutex);

	REC_TRACE(" Rec: [%d] releaseproc\n", rec->fPrUniqueID);

	SkASSERT(rec->fExternalCounter > 0);
	rec->fExternalCounter -= 1;
	if (rec->fDM) {
	SkASSERT(rec->fMalloc == nullptr);
	if (rec->fExternalCounter == 0) {
	REC_TRACE(" Rec [%d] unlock\n", rec->fPrUniqueID);
	rec->fDM->unlock();
	}
	} else {
	SkASSERT(rec->fMalloc != nullptr);
	}
	}

	bool install(SkBitmap* bitmap) {
	SkAutoMutexAcquire ama(fMutex);

	// are we still valid
	if (!fDM && !fMalloc) {
	REC_TRACE(" Rec: [%d] invalid\n", fPrUniqueID);
	return false;
	}

	/*
	constructor fExternalCount < 0 fDM->data()
	after install fExternalCount > 0 fDM->data()
	after Release fExternalCount == 0 !fDM->data()
	*/
	if (fDM) {
	if (kBeforeFirstInstall_ExternalCounter == fExternalCounter) {
	SkASSERT(fDM->data());
	} else if (fExternalCounter > 0) {
	SkASSERT(fDM->data());
	} else {
	SkASSERT(fExternalCounter == 0);
	if (!fDM->lock()) {
	REC_TRACE(" Rec [%d] re-lock failed\n", fPrUniqueID);
	fDM.reset(nullptr);
	return false;
	}
	REC_TRACE(" Rec [%d] re-lock succeeded\n", fPrUniqueID);
	}
	SkASSERT(fDM->data());
	}

	bitmap->installPixels(fInfo, fDM ? fDM->data() : fMalloc, fRowBytes, ReleaseProc, this);
	SkBitmapCache_setImmutableWithID(bitmap->pixelRef(), fPrUniqueID);

	REC_TRACE(" Rec: [%d] install new pr\n", fPrUniqueID);

	if (kBeforeFirstInstall_ExternalCounter == fExternalCounter) {
	fExternalCounter = 1;
	} else {
	fExternalCounter += 1;
	}
	SkASSERT(fExternalCounter > 0);
	return true;
	}

	static bool Finder(const SkResourceCache::Rec& baseRec, void* contextBitmap) {
	Rec* rec = (Rec*)&baseRec;
	SkBitmap* result = (SkBitmap*)contextBitmap;
	REC_TRACE(" Rec: [%d] found\n", rec->fPrUniqueID);
	return rec->install(result);
	}

	private:
	BitmapKey fKey;

	SkMutex fMutex;

	// either fDM or fMalloc can be non-null, but not both
	std::unique_ptr<SkDiscardableMemory> fDM;
	void* fMalloc;

	SkImageInfo fInfo;
	size_t fRowBytes;
	uint32_t fPrUniqueID;

	// This field counts the number of external pixelrefs we have created. They notify us when
	// they are destroyed so we can decrement this.
	//
	// > 0 we have outstanding pixelrefs
	// == 0 we have no outstanding pixelrefs, and can be safely purged
	// < 0 we have been created, but not yet "installed" the first time.
	//
	int fExternalCounter;

	enum {
	kBeforeFirstInstall_ExternalCounter = -1
	};
	};

	void SkBitmapCache::PrivateDeleteRec(Rec* rec) { delete rec; }

	SkBitmapCache::RecPtr SkBitmapCache::Alloc(const SkBitmapCacheDesc& desc, const SkImageInfo& info,
	SkPixmap* pmap) {
	// Ensure that the caller is self-consistent:
	// - if they are scaling, the info matches the scaled size
	// - if they are not, the info matches the subset (i.e. the subset is the entire image)
	if (desc.fScaledWidth == 0 && desc.fScaledHeight == 0) {
	SkASSERT(info.width() == desc.fSubset.width());
	SkASSERT(info.height() == desc.fSubset.height());
	} else {
	SkASSERT(info.width() == desc.fScaledWidth);
	SkASSERT(info.height() == desc.fScaledHeight);
	}

	const size_t rb = info.minRowBytes();
	size_t size = info.computeByteSize(rb);
	if (SkImageInfo::ByteSizeOverflowed(size)) {
	return nullptr;
	}

	std::unique_ptr<SkDiscardableMemory> dm;
	void* block = nullptr;

	auto factory = SkResourceCache::GetDiscardableFactory();
	if (factory) {
	dm.reset(factory(size));
	} else {
	block = sk_malloc_canfail(size);
	}
	if (!dm && !block) {
	return nullptr;
	}
	*pmap = SkPixmap(info, dm ? dm->data() : block, rb);
	return RecPtr(new Rec(desc, info, rb, std::move(dm), block));
	}

	void SkBitmapCache::Add(RecPtr rec, SkBitmap* bitmap) {
	SkResourceCache::Add(rec.release(), bitmap);
	}

	bool SkBitmapCache::Find(const SkBitmapCacheDesc& desc, SkBitmap* result) {
	desc.validate();
	return SkResourceCache::Find(BitmapKey(desc), SkBitmapCache::Rec::Finder, result);
	}

	//////////////////////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////////////////////

	#define CHECK_LOCAL(localCache, localName, globalName, ...) \
	((localCache) ? localCache->localName(__VA_ARGS__) : SkResourceCache::globalName(__VA_ARGS__))

	namespace {
	static unsigned gMipMapKeyNamespaceLabel;

	struct MipMapKey : public SkResourceCache::Key {
	public:
	MipMapKey(uint32_t imageID, const SkIRect& subset, SkDestinationSurfaceColorMode colorMode)
	: fImageID(imageID)
	, fColorMode(static_cast<uint32_t>(colorMode))
	, fSubset(subset)
	{
	SkASSERT(fImageID);
	SkASSERT(!subset.isEmpty());
	this->init(&gMipMapKeyNamespaceLabel, SkMakeResourceCacheSharedIDForBitmap(fImageID),
	sizeof(fImageID) + sizeof(fColorMode) + sizeof(fSubset));
	}

	uint32_t fImageID;
	uint32_t fColorMode;
	SkIRect fSubset;
	};

	struct MipMapRec : public SkResourceCache::Rec {
	MipMapRec(uint32_t imageID, const SkIRect& subset, SkDestinationSurfaceColorMode colorMode,
	const SkMipMap* result)
	: fKey(imageID, subset, colorMode)
	, fMipMap(result)
	{
	fMipMap->attachToCacheAndRef();
	}

	~MipMapRec() override {
	fMipMap->detachFromCacheAndUnref();
	}

	const Key& getKey() const override { return fKey; }
	size_t bytesUsed() const override { return sizeof(fKey) + fMipMap->size(); }
	const char* getCategory() const override { return "mipmap"; }
	SkDiscardableMemory* diagnostic_only_getDiscardable() const override {
	return fMipMap->diagnostic_only_getDiscardable();
	}

	static bool Finder(const SkResourceCache::Rec& baseRec, void* contextMip) {
	const MipMapRec& rec = static_cast<const MipMapRec&>(baseRec);
	const SkMipMap* mm = SkRef(rec.fMipMap);
	// the call to ref() above triggers a "lock" in the case of discardable memory,
	// which means we can now check for null (in case the lock failed).
	if (nullptr == mm->data()) {
	mm->unref(); // balance our call to ref()
	return false;
	}
	// the call must call unref() when they are done.
	(const SkMipMap*)contextMip = mm;
	return true;
	}

	private:
	MipMapKey fKey;
	const SkMipMap* fMipMap;
	};
	}

	const SkMipMap* SkMipMapCache::FindAndRef(const SkBitmapCacheDesc& desc,
	SkDestinationSurfaceColorMode colorMode,
	SkResourceCache* localCache) {
	SkASSERT(desc.fScaledWidth == 0);
	SkASSERT(desc.fScaledHeight == 0);
	MipMapKey key(desc.fImageID, desc.fSubset, colorMode);
	const SkMipMap* result;

	if (!CHECK_LOCAL(localCache, find, Find, key, MipMapRec::Finder, &result)) {
	result = nullptr;
	}
	return result;
	}

	static SkResourceCache::DiscardableFactory get_fact(SkResourceCache* localCache) {
	return localCache ? localCache->GetDiscardableFactory()
	: SkResourceCache::GetDiscardableFactory();
	}

	const SkMipMap* SkMipMapCache::AddAndRef(const SkBitmap& src,
	SkDestinationSurfaceColorMode colorMode,
	SkResourceCache* localCache) {
	SkMipMap* mipmap = SkMipMap::Build(src, colorMode, get_fact(localCache));
	if (mipmap) {
	MipMapRec* rec = new MipMapRec(src.getGenerationID(), get_bounds_from_bitmap(src),
	colorMode, mipmap);
	CHECK_LOCAL(localCache, add, Add, rec);
	src.pixelRef()->notifyAddedToCache();
	}
	return mipmap;
	}