Rename GrContentKey to GrUniqueKey

src/gpu/SkGr.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGr.h"
 
 #include "GrXferProcessor.h"
@@ skipping 88 matching lines @@
                     return kNearest_Stretch;
                 case GrTextureParams::kBilerp_FilterMode:
                 case GrTextureParams::kMipMap_FilterMode:
                     return kBilerp_Stretch;
             }
         }
     }
     return kNo_Stretch;
 }
 
-static bool make_stretched_key(const GrContentKey& origKey, Stretch stretch,
-                               GrContentKey* stretchedKey) {
+static bool make_stretched_key(const GrUniqueKey& origKey, Stretch stretch,
+                               GrUniqueKey* stretchedKey) {
     if (origKey.isValid() && kNo_Stretch != stretch) {
-        static const GrContentKey::Domain kDomain = GrContentKey::GenerateDomain();
-        GrContentKey::Builder builder(stretchedKey, origKey, kDomain, 1);
+        static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
+        GrUniqueKey::Builder builder(stretchedKey, origKey, kDomain, 1);
         builder[0] = stretch;
         builder.finish();
         return true;
     }
     SkASSERT(!stretchedKey->isValid());
     return false;
 }
 
-static void make_unstretched_key(const SkBitmap& bitmap, GrContentKey* key) {
+static void make_unstretched_key(const SkBitmap& bitmap, GrUniqueKey* key) {
     // Our id includes the offset, width, and height so that bitmaps created by extractSubset()
     // are unique.
     uint32_t genID = bitmap.getGenerationID();
     SkIPoint origin = bitmap.pixelRefOrigin();
     uint32_t width = SkToU16(bitmap.width());
     uint32_t height = SkToU16(bitmap.height());
 
-    static const GrContentKey::Domain kDomain = GrContentKey::GenerateDomain();
-    GrContentKey::Builder builder(key, kDomain, 4);
+    static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
+    GrUniqueKey::Builder builder(key, kDomain, 4);
     builder[0] = genID;
     builder[1] = origin.fX;
     builder[2] = origin.fY;
     builder[3] = width | (height << 16);
 }
 
 static void make_bitmap_keys(const SkBitmap& bitmap,
                              Stretch stretch,
-                             GrContentKey* key,
-                             GrContentKey* stretchedKey) {
+                             GrUniqueKey* key,
+                             GrUniqueKey* stretchedKey) {
     make_unstretched_key(bitmap, key);
     if (kNo_Stretch != stretch) {
         make_stretched_key(*key, stretch, stretchedKey);
     }
 }
 
 static void generate_bitmap_texture_desc(const SkBitmap& bitmap, GrSurfaceDesc* desc) {
     desc->fFlags = kNone_GrSurfaceFlags;
     desc->fWidth = bitmap.width();
     desc->fHeight = bitmap.height();
     desc->fConfig = SkImageInfo2GrPixelConfig(bitmap.info());
     desc->fSampleCnt = 0;
 }
 
 namespace {
 
 // When the SkPixelRef genID changes, invalidate a corresponding GrResource described by key.
 class BitmapInvalidator : public SkPixelRef::GenIDChangeListener {
 public:
-    explicit BitmapInvalidator(const GrContentKey& key) : fMsg(key) {}
+    explicit BitmapInvalidator(const GrUniqueKey& key) : fMsg(key) {}
 private:
-    GrContentKeyInvalidatedMessage fMsg;
+    GrUniqueKeyInvalidatedMessage fMsg;
 
     void onChange() SK_OVERRIDE {
-        SkMessageBus<GrContentKeyInvalidatedMessage>::Post(fMsg);
+        SkMessageBus<GrUniqueKeyInvalidatedMessage>::Post(fMsg);
     }
 };
 
 }  // namespace
 
 
 static GrTexture* create_texture_for_bmp(GrContext* ctx,
-                                         const GrContentKey& optionalKey,
+                                         const GrUniqueKey& optionalKey,
                                          GrSurfaceDesc desc,
                                          SkPixelRef* pixelRefForInvalidationNotification,
                                          const void* pixels,
                                          size_t rowBytes) {
     GrTexture* result = ctx->createTexture(desc, true, pixels, rowBytes);
     if (result && optionalKey.isValid()) {
         BitmapInvalidator* listener = SkNEW_ARGS(BitmapInvalidator, (optionalKey));
         pixelRefForInvalidationNotification->addGenIDChangeListener(listener);
         SkAssertResult(ctx->addResourceToCache(optionalKey, result));
     }
     return result;
 }
 
 // creates a new texture that is the input texture scaled up to the next power of two in
 // width or height. If optionalKey is valid it will be set on the new texture. stretch
 // controls whether the scaling is done using nearest or bilerp filtering.
 GrTexture* stretch_texture_to_next_pot(GrTexture* inputTexture, Stretch stretch,
                                        SkPixelRef* pixelRef,
-                                       const GrContentKey& optionalKey) {
+                                       const GrUniqueKey& optionalKey) {
     SkASSERT(kNo_Stretch != stretch);
 
     GrContext* context = inputTexture->getContext();
     SkASSERT(context);
 
     // Either it's a cache miss or the original wasn't cached to begin with.
     GrSurfaceDesc rtDesc = inputTexture->desc();
     rtDesc.fFlags =  rtDesc.fFlags |
                      kRenderTarget_GrSurfaceFlag |
                      kNoStencil_GrSurfaceFlag;
@@ skipping 42 matching lines @@
     SkRect localRect = SkRect::MakeWH(1.f, 1.f);
 
     GrContext::AutoClip ac(context, GrContext::AutoClip::kWideOpen_InitialClip);
     context->drawNonAARectToRect(stretched->asRenderTarget(), paint, SkMatrix::I(), rect,
                                  localRect);
 
     return stretched;
 }
 
 #ifndef SK_IGNORE_ETC1_SUPPORT
-static GrTexture *load_etc1_texture(GrContext* ctx, const GrContentKey& optionalKey,
+static GrTexture *load_etc1_texture(GrContext* ctx, const GrUniqueKey& optionalKey,
                                     const SkBitmap &bm, GrSurfaceDesc desc) {
     SkAutoTUnref<SkData> data(bm.pixelRef()->refEncodedData());
 
     // Is this even encoded data?
     if (NULL == data) {
         return NULL;
     }
 
     // Is this a valid PKM encoded data?
     const uint8_t *bytes = data->bytes();
@@ skipping 28 matching lines @@
         bytes = ktx.pixelData();
         desc.fConfig = kETC1_GrPixelConfig;
     } else {
         return NULL;
     }
 
     return create_texture_for_bmp(ctx, optionalKey, desc, bm.pixelRef(), bytes, 0);
 }
 #endif   // SK_IGNORE_ETC1_SUPPORT
 
-static GrTexture* load_yuv_texture(GrContext* ctx, const GrContentKey& optionalKey,
+static GrTexture* load_yuv_texture(GrContext* ctx, const GrUniqueKey& optionalKey,
                                    const SkBitmap& bm, const GrSurfaceDesc& desc) {
     // Subsets are not supported, the whole pixelRef is loaded when using YUV decoding
     SkPixelRef* pixelRef = bm.pixelRef();
     if ((NULL == pixelRef) || 
         (pixelRef->info().width()  != bm.info().width()) ||
         (pixelRef->info().height() != bm.info().height())) {
         return NULL;
     }
 
     const bool useCache = optionalKey.isValid();
@@ skipping 81 matching lines @@
     SkRect r = SkRect::MakeWH(SkIntToScalar(yuvInfo.fSize[0].fWidth),
                               SkIntToScalar(yuvInfo.fSize[0].fHeight));
     GrContext::AutoClip ac(ctx, GrContext::AutoClip::kWideOpen_InitialClip);
     ctx->drawRect(renderTarget, paint, SkMatrix::I(), r);
 
     return result;
 }
 
 static GrTexture* create_unstretched_bitmap_texture(GrContext* ctx,
                                                     const SkBitmap& origBitmap,
-                                                    const GrContentKey& optionalKey) {
+                                                    const GrUniqueKey& optionalKey) {
     SkBitmap tmpBitmap;
 
     const SkBitmap* bitmap = &origBitmap;
 
     GrSurfaceDesc desc;
     generate_bitmap_texture_desc(*bitmap, &desc);
 
     if (kIndex_8_SkColorType == bitmap->colorType()) {
         if (ctx->isConfigTexturable(kIndex_8_GrPixelConfig)) {
             size_t imageSize = GrCompressedFormatDataSize(kIndex_8_GrPixelConfig,
@@ skipping 40 matching lines @@
         return NULL;
     }
 
     return create_texture_for_bmp(ctx, optionalKey, desc, origBitmap.pixelRef(),
                                   bitmap->getPixels(), bitmap->rowBytes());
 }
 
 static GrTexture* create_bitmap_texture(GrContext* ctx,
                                         const SkBitmap& bmp,
                                         Stretch stretch,
-                                        const GrContentKey& unstretchedKey,
-                                        const GrContentKey& stretchedKey) {
+                                        const GrUniqueKey& unstretchedKey,
+                                        const GrUniqueKey& stretchedKey) {
     if (kNo_Stretch != stretch) {
         SkAutoTUnref<GrTexture> unstretched;
         // Check if we have the unstretched version in the cache, if not create it.
         if (unstretchedKey.isValid()) {
             unstretched.reset(ctx->findAndRefCachedTexture(unstretchedKey));
         }
         if (!unstretched) {
             unstretched.reset(create_unstretched_bitmap_texture(ctx, bmp, unstretchedKey));
             if (!unstretched) {
                 return NULL;
@@ skipping 16 matching lines @@
     // Handle the case where the bitmap is explicitly texture backed.
     GrTexture* texture = bitmap.getTexture();
     if (texture) {
         if (kNo_Stretch == stretch) {
             return true;
         }
         // No keys for volatile bitmaps.
         if (bitmap.isVolatile()) {
             return false;
         }
-        const GrContentKey& key = texture->getContentKey();
+        const GrUniqueKey& key = texture->getUniqueKey();
         if (!key.isValid()) {
             return false;
         }
-        GrContentKey stretchedKey;
+        GrUniqueKey stretchedKey;
         make_stretched_key(key, stretch, &stretchedKey);
         return ctx->isResourceInCache(stretchedKey);
     }
 
     // We don't cache volatile bitmaps
     if (bitmap.isVolatile()) {
         return false;
     }
 
-    GrContentKey key, stretchedKey;
+    GrUniqueKey key, stretchedKey;
     make_bitmap_keys(bitmap, stretch, &key, &stretchedKey);
     return ctx->isResourceInCache((kNo_Stretch == stretch) ? key : stretchedKey);
 }
 
 GrTexture* GrRefCachedBitmapTexture(GrContext* ctx,
                                     const SkBitmap& bitmap,
                                     const GrTextureParams* params) {
 
     Stretch stretch = get_stretch_type(ctx, bitmap.width(), bitmap.height(), params);
 
     GrTexture* result = bitmap.getTexture();
     if (result) {
         if (kNo_Stretch == stretch) {
             return SkRef(result);
         }
-        GrContentKey stretchedKey;
+        GrUniqueKey stretchedKey;
         // Don't create a key for the resized version if the bmp is volatile.
         if (!bitmap.isVolatile()) {
-            const GrContentKey& key = result->getContentKey();
+            const GrUniqueKey& key = result->getUniqueKey();
             if (key.isValid()) {
                 make_stretched_key(key, stretch, &stretchedKey);
                 GrTexture* stretched = ctx->findAndRefCachedTexture(stretchedKey);
                 if (stretched) {
                     return stretched;
                 }
             }
         }
         return stretch_texture_to_next_pot(result, stretch, bitmap.pixelRef(), stretchedKey);
     }
 
-    GrContentKey key, resizedKey;
+    GrUniqueKey key, resizedKey;
 
     if (!bitmap.isVolatile()) {
         // If the bitmap isn't changing try to find a cached copy first.
         make_bitmap_keys(bitmap, stretch, &key, &resizedKey);
 
         result = ctx->findAndRefCachedTexture(resizedKey.isValid() ? resizedKey : key);
         if (result) {
             return result;
         }
     }
@@ skipping 156 matching lines @@
         if (shader->asFragmentProcessor(context, skPaint, viewM, NULL, &paintColor, &fp) && fp) {
             grPaint->addColorProcessor(fp)->unref();
             constantColor = false;
         }
     }
 
     // The grcolor is automatically set when calling asFragmentProcessor.
     // If the shader can be seen as an effect it returns true and adds its effect to the grpaint.
     SkPaint2GrPaintNoShader(context, rt, skPaint, paintColor, constantColor, grPaint);
 }