expose generalized imagecache key

src/core/SkBitmapProcState.cpp

-
 /*
  * Copyright 2011 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 "SkBitmapProcState.h"
 #include "SkColorPriv.h"
 #include "SkFilterProc.h"
 #include "SkPaint.h"
 #include "SkShader.h"   // for tilemodes
 #include "SkUtilsArm.h"
 #include "SkBitmapScaler.h"
 #include "SkMipMap.h"
 #include "SkPixelRef.h"
-#include "SkScaledImageCache.h"
 #include "SkImageEncoder.h"
 
 #if !SK_ARM_NEON_IS_NONE
 // These are defined in src/opts/SkBitmapProcState_arm_neon.cpp
 extern const SkBitmapProcState::SampleProc16 gSkBitmapProcStateSample16_neon[];
 extern const SkBitmapProcState::SampleProc32 gSkBitmapProcStateSample32_neon[];
 extern void  S16_D16_filter_DX_neon(const SkBitmapProcState&, const uint32_t*, int, uint16_t*);
 extern void  Clamp_S16_D16_filter_DX_shaderproc_neon(const SkBitmapProcState&, int, int, uint16_t*, int);
 extern void  Repeat_S16_D16_filter_DX_shaderproc_neon(const SkBitmapProcState&, int, int, uint16_t*, int);
 extern void  SI8_opaque_D32_filter_DX_neon(const SkBitmapProcState&, const uint32_t*, int, SkPMColor*);
@@ skipping 148 matching lines @@
             // are close to -1 as well, since the flip doesn't require
             // any fancy re-sampling...
 
             // Set our filter level to low -- the only post-filtering this
             // image might require is some interpolation if the translation
             // is fractional.
             fFilterLevel = SkPaint::kLow_FilterLevel;
             return false;
         }
 
-        fScaledCacheID = SkScaledImageCache::FindAndLock(fOrigBitmap,
-                                                         invScaleX, invScaleY,
-                                                         &fScaledBitmap);
+        fScaledCacheID = SkBitmapCache::FindAndLock(fOrigBitmap, invScaleX, invScaleY,
+                                                    &fScaledBitmap);
         if (fScaledCacheID) {
             fScaledBitmap.lockPixels();
             if (!fScaledBitmap.getPixels()) {
                 fScaledBitmap.unlockPixels();
                 // found a purged entry (discardablememory?), release it
                 SkScaledImageCache::Unlock(fScaledCacheID);
                 fScaledCacheID = NULL;
                 // fall through to rebuild
             }
         }
@@ skipping 10 matching lines @@
                                         dest_width,
                                         dest_height,
                                         SkScaledImageCache::GetAllocator())) {
                 // we failed to create fScaledBitmap, so just return and let
                 // the scanline proc handle it.
                 return false;
 
             }
 
             SkASSERT(NULL != fScaledBitmap.getPixels());
-            fScaledCacheID = SkScaledImageCache::AddAndLock(fOrigBitmap,
-                                                            invScaleX,
-                                                            invScaleY,
-                                                            fScaledBitmap);
+            fScaledCacheID = SkBitmapCache::AddAndLock(fOrigBitmap, invScaleX, invScaleY,
+                                                       fScaledBitmap);
             if (!fScaledCacheID) {
                 fScaledBitmap.reset();
                 return false;
             }
             SkASSERT(NULL != fScaledBitmap.getPixels());
         }
 
         SkASSERT(NULL != fScaledBitmap.getPixels());
         fBitmap = &fScaledBitmap;
 
@@ skipping 46 matching lines @@
 
     /**
      *  Medium quality means use a mipmap for down-scaling, and just bilper
      *  for upscaling. Since we're examining the inverse matrix, we look for
      *  a scale > 1 to indicate down scaling by the CTM.
      */
     if (scaleSqd > SK_Scalar1) {
         const SkMipMap* mip = NULL;
 
         SkASSERT(NULL == fScaledCacheID);
-        fScaledCacheID = SkScaledImageCache::FindAndLockMip(fOrigBitmap, &mip);
+        fScaledCacheID = SkMipMapCache::FindAndLock(fOrigBitmap, &mip);
         if (!fScaledCacheID) {
             SkASSERT(NULL == mip);
             mip = SkMipMap::Build(fOrigBitmap);
             if (mip) {
-                fScaledCacheID = SkScaledImageCache::AddAndLockMip(fOrigBitmap,
-                                                                   mip);
+                fScaledCacheID = SkMipMapCache::AddAndLock(fOrigBitmap, mip);
                 SkASSERT(mip->getRefCnt() > 1);
                 mip->unref();   // the cache took a ref
                 SkASSERT(fScaledCacheID);
             }
         } else {
             SkASSERT(mip);
         }
 
         if (mip) {
             SkScalar levelScale = SkScalarInvert(SkScalarSqrt(scaleSqd));
@@ skipping 41 matching lines @@
     SkASSERT(NULL == fScaledCacheID);
 
     if (pr->isLocked() || !pr->implementsDecodeInto()) {
         // fast-case, no need to look in our cache
         fScaledBitmap = fOrigBitmap;
         fScaledBitmap.lockPixels();
         if (NULL == fScaledBitmap.getPixels()) {
             return false;
         }
     } else {
-        fScaledCacheID = SkScaledImageCache::FindAndLock(fOrigBitmap,
-                                                         SK_Scalar1, SK_Scalar1,
-                                                         &fScaledBitmap);
+        fScaledCacheID = SkBitmapCache::FindAndLock(fOrigBitmap, 1, 1, &fScaledBitmap);
         if (fScaledCacheID) {
             fScaledBitmap.lockPixels();
             if (!fScaledBitmap.getPixels()) {
                 fScaledBitmap.unlockPixels();
                 // found a purged entry (discardablememory?), release it
                 SkScaledImageCache::Unlock(fScaledCacheID);
                 fScaledCacheID = NULL;
                 // fall through to rebuild
             }
         }
 
         if (NULL == fScaledCacheID) {
             if (!get_locked_pixels(fOrigBitmap, 0, &fScaledBitmap)) {
                 return false;
             }
 
             // TODO: if fScaled comes back at a different width/height than fOrig,
             // we need to update the matrix we are using to sample from this guy.
 
-            fScaledCacheID = SkScaledImageCache::AddAndLock(fOrigBitmap,
-                                                            SK_Scalar1, SK_Scalar1,
-                                                            fScaledBitmap);
+            fScaledCacheID = SkBitmapCache::AddAndLock(fOrigBitmap, 1, 1, fScaledBitmap);
             if (!fScaledCacheID) {
                 fScaledBitmap.reset();
                 return false;
             }
         }
     }
     fBitmap = &fScaledBitmap;
     unlocker.release();
     return true;
 }
@@ skipping 681 matching lines @@
     } else {
         size >>= 2;
     }
 
     if (fFilterLevel != SkPaint::kNone_FilterLevel) {
         size >>= 1;
     }
 
     return size;
 }