create SkBitmapProvider to abstract images and bitmaps

tests/SkResourceCacheTest.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 "Test.h"
 #include "SkBitmapCache.h"
 #include "SkCanvas.h"
 #include "SkDiscardableMemoryPool.h"
 #include "SkGraphics.h"
 #include "SkResourceCache.h"
 #include "SkSurface.h"
 
 static const int kCanvasSize = 1;
 static const int kBitmapSize = 16;
 static const int kScale = 8;
 
 static bool is_in_scaled_image_cache(const SkBitmap& orig,
                                      SkScalar xScale,
                                      SkScalar yScale) {
     SkBitmap scaled;
     int width = SkScalarRoundToInt(orig.width() * xScale);
     int height = SkScalarRoundToInt(orig.height() * yScale);
-    return SkBitmapCache::FindWH(orig, width, height, &scaled);
+    return SkBitmapCache::FindWH(SkBitmapCacheDesc::Make(orig, width, height), &scaled);
 }
 
 // Draw a scaled bitmap, then return true if it has been cached.
 static bool test_scaled_image_cache_usage() {
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(kCanvasSize, kCanvasSize));
     SkCanvas* canvas = surface->getCanvas();
     SkBitmap bitmap;
     bitmap.allocN32Pixels(kBitmapSize, kBitmapSize);
     bitmap.eraseColor(0xFFFFFFFF);
     SkScalar xScale = SkIntToScalar(kScale);
@@ skipping 109 matching lines @@
     REPORTER_ASSERT(reporter, isLocked == (lockedState == kLocked));
 }
 
 static void test_mipmapcache(skiatest::Reporter* reporter, SkResourceCache* cache) {
     cache->purgeAll();
 
     SkBitmap src;
     src.allocN32Pixels(5, 5);
     src.setImmutable();
 
-    const SkMipMap* mipmap = SkMipMapCache::FindAndRef(src, cache);
+    const SkMipMap* mipmap = SkMipMapCache::FindAndRef(SkBitmapCacheDesc::Make(src), cache);
     REPORTER_ASSERT(reporter, nullptr == mipmap);
 
     mipmap = SkMipMapCache::AddAndRef(src, cache);
     REPORTER_ASSERT(reporter, mipmap);
 
     {
-        const SkMipMap* mm = SkMipMapCache::FindAndRef(src, cache);
+        const SkMipMap* mm = SkMipMapCache::FindAndRef(SkBitmapCacheDesc::Make(src), cache);
         REPORTER_ASSERT(reporter, mm);
         REPORTER_ASSERT(reporter, mm == mipmap);
         mm->unref();
     }
 
     check_data(reporter, mipmap, 2, kInCache, kLocked);
 
     mipmap->unref();
     // tricky, since technically after this I'm no longer an owner, but since the cache is
     // local, I know it won't get purged behind my back
     check_data(reporter, mipmap, 1, kInCache, kNotLocked);
 
     // find us again
-    mipmap = SkMipMapCache::FindAndRef(src, cache);
+    mipmap = SkMipMapCache::FindAndRef(SkBitmapCacheDesc::Make(src), cache);
     check_data(reporter, mipmap, 2, kInCache, kLocked);
 
     cache->purgeAll();
     check_data(reporter, mipmap, 1, kNotInCache, kLocked);
 
     mipmap->unref();
 }
 
 static void test_mipmap_notify(skiatest::Reporter* reporter, SkResourceCache* cache) {
     const int N = 3;
     SkBitmap src[N];
     for (int i = 0; i < N; ++i) {
         src[i].allocN32Pixels(5, 5);
         src[i].setImmutable();
         SkMipMapCache::AddAndRef(src[i], cache)->unref();
     }
 
     for (int i = 0; i < N; ++i) {
-        const SkMipMap* mipmap = SkMipMapCache::FindAndRef(src[i], cache);
+        const SkMipMap* mipmap = SkMipMapCache::FindAndRef(SkBitmapCacheDesc::Make(src[i]), cache);
         if (cache) {
             // if cache is null, we're working on the global cache, and other threads might purge
             // it, making this check fragile.
             REPORTER_ASSERT(reporter, mipmap);
         }
         SkSafeUnref(mipmap);
 
         src[i].reset(); // delete the underlying pixelref, which *should* remove us from the cache
 
-        mipmap = SkMipMapCache::FindAndRef(src[i], cache);
+        mipmap = SkMipMapCache::FindAndRef(SkBitmapCacheDesc::Make(src[i]), cache);
         REPORTER_ASSERT(reporter, !mipmap);
     }
 }
 
 static void test_bitmap_notify(skiatest::Reporter* reporter, SkResourceCache* cache) {
     const SkIRect subset = SkIRect::MakeWH(5, 5);
     const int N = 3;
     SkBitmap src[N], dst[N];
     for (int i = 0; i < N; ++i) {
         src[i].allocN32Pixels(5, 5);
@@ skipping 62 matching lines @@
     cachedBitmap.unlockPixels();
 
     // We can add the bitmap back to the cache and find it again.
     REPORTER_ASSERT(reporter, SkBitmapCache::Add(cachedBitmap.pixelRef(), rect, cachedBitmap, cache));
     REPORTER_ASSERT(reporter, SkBitmapCache::Find(cachedBitmap.getGenerationID(), rect, &bm, cache));
 
     test_mipmapcache(reporter, cache);
     test_bitmap_notify(reporter, cache);
     test_mipmap_notify(reporter, cache);
 }