Make npot resizing work properly for bmps that are explicitly texture backed.

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 "GrDrawTargetCaps.h"
@@ skipping 474 matching lines @@
             }
         }
         GrTexture* resized = resize_texture(unstretched, stretch, stretchedKey);
         return resized;
     }
 
     return create_unstretched_bitmap_texture(ctx, bmp, unstretchedKey);
 
 }
 
-static GrTexture* get_texture_backing_bmp(const SkBitmap& bitmap, const GrContext* context,
-                                          const GrTextureParams* params) {
-    if (GrTexture* texture = bitmap.getTexture()) {
-        // Our texture-resizing-for-tiling used to upscale NPOT textures for tiling only works with
-        // content-key cached resources. Rather than invest in that legacy code path, we'll just
-        // take the horribly slow route of causing a cache miss which will cause the pixels to be
-        // read and reuploaded to a texture with a content key.
-        if (params && !context->getGpu()->caps()->npotTextureTileSupport() &&
-            (params->isTiled() || GrTextureParams::kMipMap_FilterMode == params->filterMode())) {
-            return NULL;
-        }
-        return texture;
-    }
-    return NULL;
-}
-
 bool GrIsBitmapInCache(const GrContext* ctx,
                        const SkBitmap& bitmap,
                        const GrTextureParams* params) {
-    if (get_texture_backing_bmp(bitmap, ctx, params)) {
-        return true;
+    Stretch stretch = get_stretch_type(ctx, bitmap.width(), bitmap.height(), params);
+
+    // 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();
+        if (!key.isValid()) {
+            return false;
+        }
+        GrContentKey resizedKey;
+        make_resize_key(key, stretch, &resizedKey);
+        return ctx->isResourceInCache(resizedKey);
     }
 
     // We don't cache volatile bitmaps
     if (bitmap.isVolatile()) {
         return false;
     }
 
-    // If it is inherently texture backed, consider it in the cache
-    if (bitmap.getTexture()) {
-        return true;
-    }
-
-    Stretch stretch = get_stretch_type(ctx, bitmap.width(), bitmap.height(), params);
     GrContentKey key, resizedKey;
     generate_bitmap_keys(bitmap, stretch, &key, &resizedKey);
-
-    GrSurfaceDesc desc;
-    generate_bitmap_texture_desc(bitmap, &desc);
     return ctx->isResourceInCache((kNo_Stretch == stretch) ? key : resizedKey);
 }
 
 GrTexture* GrRefCachedBitmapTexture(GrContext* ctx,
                                     const SkBitmap& bitmap,
                                     const GrTextureParams* params) {
-    GrTexture* result = get_texture_backing_bmp(bitmap, ctx, params);
+
+    Stretch stretch = get_stretch_type(ctx, bitmap.width(), bitmap.height(), params);
+
+    GrTexture* result = bitmap.getTexture();
     if (result) {
-        return SkRef(result);
+        if (kNo_Stretch == stretch) {
+            return SkRef(result);
+        }
+        GrContentKey resizedKey;
+        // Don't create a key for the resized version if the bmp is volatile.
+        if (!bitmap.isVolatile()) {
+            const GrContentKey& key = result->getContentKey();
+            if (key.isValid()) {
+                make_resize_key(key, stretch, &resizedKey);
+                GrTexture* stretched = ctx->findAndRefCachedTexture(resizedKey);
+                if (stretched) {
+                    return stretched;
+                }
+            }
+        }
+        return resize_texture(result, stretch, resizedKey);
     }
 
-    Stretch stretch = get_stretch_type(ctx, bitmap.width(), bitmap.height(), params);
     GrContentKey key, resizedKey;
 
     if (!bitmap.isVolatile()) {
         // If the bitmap isn't changing try to find a cached copy first.
         generate_bitmap_keys(bitmap, stretch, &key, &resizedKey);
 
         result = ctx->findAndRefCachedTexture(resizedKey.isValid() ? resizedKey : key);
         if (result) {
             return result;
         }
@@ skipping 161 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, skPaint, paintColor, constantColor, grPaint);
 }