SkResourceCache::Key namespace support.

src/core/SkPictureShader.cpp

 /*
  * 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 "SkPictureShader.h"
 
 #include "SkBitmap.h"
 #include "SkBitmapProcShader.h"
 #include "SkCanvas.h"
-#include "SkDiscardableMemory.h"
 #include "SkMatrixUtils.h"
 #include "SkPicture.h"
 #include "SkReadBuffer.h"
 #include "SkResourceCache.h"
-#include "SkThread.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #endif
 
+namespace {
+static unsigned gBitmapSkaderKeyNamespaceLabel;
+
 struct BitmapShaderKey : public SkResourceCache::Key {
 public:
     BitmapShaderKey(uint32_t pictureID,
                     const SkRect& tile,
                     SkShader::TileMode tmx,
                     SkShader::TileMode tmy,
                     const SkSize& scale,
                     const SkMatrix& localMatrix)
         : fPictureID(pictureID)
         , fTile(tile)
         , fTmx(tmx)
         , fTmy(tmy)
         , fScale(scale)
         , fLocalMatrix(localMatrix) {
 
         static const size_t keySize = sizeof(fPictureID) +
                                       sizeof(fTile) +
                                       sizeof(fTmx) + sizeof(fTmy) +
                                       sizeof(fScale) +
                                       sizeof(fLocalMatrix);
         // This better be packed.
         SkASSERT(sizeof(uint32_t) * (&fEndOfStruct - &fPictureID) == keySize);
-        this->init(keySize);
+        this->init(&gBitmapSkaderKeyNamespaceLabel, keySize);
     }
 
 private:
     uint32_t           fPictureID;
     SkRect             fTile;
     SkShader::TileMode fTmx, fTmy;
     SkSize             fScale;
     SkMatrix           fLocalMatrix;
 
     SkDEBUGCODE(uint32_t fEndOfStruct;)
@@ skipping 16 matching lines @@
 
     static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextShader) {
         const BitmapShaderRec& rec = static_cast<const BitmapShaderRec&>(baseRec);
         SkAutoTUnref<SkShader>* result = reinterpret_cast<SkAutoTUnref<SkShader>*>(contextShader);
 
         result->reset(SkRef(rec.fShader.get()));
         return true;
     }
 };
 
-// FIXME: there's considerable boilerplate/duplication here vs. the global resource cache.
-SK_DECLARE_STATIC_MUTEX(gBitmapShaderCacheMutex);
-static SkResourceCache* gBitmapShaderCache = NULL;
+static bool cache_try_alloc_pixels(SkBitmap* bitmap) {
+    SkBitmap::Allocator* allocator = SkResourceCache::GetAllocator();
 
-#ifndef SK_DEFAULT_TILE_CACHE_LIMIT
-    #define SK_DEFAULT_TILE_CACHE_LIMIT     (2 * 1024 * 1024)
-#endif
-
-static void cleanup_cache() {
-    // We'll clean this up in our own tests, but disable for clients.
-    // Chrome seems to have funky multi-process things going on in unit tests that
-    // makes this unsafe to delete when the main process atexit()s.
-    // SkLazyPtr does the same sort of thing.
-#if SK_DEVELOPER
-    SkDELETE(gBitmapShaderCache);
-#endif
+    return NULL != allocator
+        ? allocator->allocPixelRef(bitmap, NULL)
+        : bitmap->tryAllocPixels();
 }
 
-/** Must hold gBitmapShaderCacheMutex when calling. */
-static SkResourceCache* cache() {
-    // gTileCacheMutex is always held when this is called, so we don't need to be fancy in here.
-    gBitmapShaderCacheMutex.assertHeld();
-    if (NULL == gBitmapShaderCache) {
-#ifdef SK_USE_DISCARDABLE_SCALEDIMAGECACHE
-        gBitmapShaderCache = SkNEW_ARGS(SkResourceCache, (SkDiscardableMemory::Create));
-#else
-        gBitmapShaderCache = SkNEW_ARGS(SkResourceCache, (SK_DEFAULT_TILE_CACHE_LIMIT));
-#endif
-        atexit(cleanup_cache);
-    }
-    return gBitmapShaderCache;
-}
-
-static bool cache_find(const BitmapShaderKey& key, SkAutoTUnref<SkShader>* result) {
-    SkAutoMutexAcquire am(gBitmapShaderCacheMutex);
-    return cache()->find(key, BitmapShaderRec::Visitor, result);
-}
-
-static void cache_add(BitmapShaderRec* rec) {
-    SkAutoMutexAcquire am(gBitmapShaderCacheMutex);
-    cache()->add(rec);
-}
-
-static bool cache_try_alloc_pixels(SkBitmap* bitmap) {
-    SkAutoMutexAcquire am(gBitmapShaderCacheMutex);
-    SkBitmap::Allocator* allocator = cache()->allocator();
-
-    if (NULL != allocator) {
-        return allocator->allocPixelRef(bitmap, NULL);
-    } else {
-        return bitmap->tryAllocPixels();
-    }
-}
+} // namespace
 
 SkPictureShader::SkPictureShader(const SkPicture* picture, TileMode tmx, TileMode tmy,
                                  const SkMatrix* localMatrix, const SkRect* tile)
     : INHERITED(localMatrix)
     , fPicture(SkRef(picture))
     , fTile(tile ? *tile : picture->cullRect())
     , fTmx(tmx)
     , fTmy(tmy) {
 }
 
@@ skipping 74 matching lines @@
                                     SkIntToScalar(tileSize.height()) / fTile.height());
 
     SkAutoTUnref<SkShader> tileShader;
     BitmapShaderKey key(fPicture->uniqueID(),
                         fTile,
                         fTmx,
                         fTmy,
                         tileScale,
                         this->getLocalMatrix());
 
-    if (!cache_find(key, &tileShader)) {
+    if (!SkResourceCache::Find(key, BitmapShaderRec::Visitor, &tileShader)) {
         SkBitmap bm;
         bm.setInfo(SkImageInfo::MakeN32Premul(tileSize));
         if (!cache_try_alloc_pixels(&bm)) {
             return NULL;
         }
         bm.eraseColor(SK_ColorTRANSPARENT);
 
         SkCanvas canvas(bm);
         canvas.scale(tileScale.width(), tileScale.height());
         canvas.translate(fTile.x(), fTile.y());
         canvas.drawPicture(fPicture);
 
         SkMatrix shaderMatrix = this->getLocalMatrix();
         shaderMatrix.preScale(1 / tileScale.width(), 1 / tileScale.height());
         tileShader.reset(CreateBitmapShader(bm, fTmx, fTmy, &shaderMatrix));
 
-        cache_add(SkNEW_ARGS(BitmapShaderRec, (key, tileShader.get(), bm.getSize())));
+        SkResourceCache::Add(SkNEW_ARGS(BitmapShaderRec, (key, tileShader.get(), bm.getSize())));
     }
 
     return tileShader.detach();
 }
 
 size_t SkPictureShader::contextSize() const {
     return sizeof(PictureShaderContext);
 }
 
 SkShader::Context* SkPictureShader::onCreateContext(const ContextRec& rec, void* storage) const {
@@ skipping 82 matching lines @@
     }
     return bitmapShader->asFragmentProcessor(context, paint, NULL, paintColor, fp);
 }
 #else
 bool SkPictureShader::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix*, GrColor*,
                                           GrFragmentProcessor**) const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
 #endif