diff --git a/include/gpu/GrContext.h b/include/gpu/GrContext.h
index 8768528..adceb77 100644
--- a/include/gpu/GrContext.h
+++ b/include/gpu/GrContext.h
@@ -109,13 +109,6 @@
     };
 
     /**
-     * Key generated by client. Should be a unique key on the texture data.
-     * Does not need to consider that width and height of the texture. Two
-     * textures with the same TextureKey but different bounds will not collide.
-     */
-    typedef uint64_t TextureKey;
-
-    /**
      *  Create a new entry, based on the specified key and texture, and return
      *  its "locked" entry. Must call be balanced with an unlockTexture() call.
      *
@@ -133,7 +126,7 @@
      * @param rowBytes  The number of bytes between rows of the texture. Zero
      *                  implies tightly packed rows.
      */
-    TextureCacheEntry createAndLockTexture(TextureKey key,
+    TextureCacheEntry createAndLockTexture(GrTexture::TextureKey key,
                                            const GrSamplerState* sampler,
                                            const GrTextureDesc& desc,
                                            void* srcData, size_t rowBytes);
@@ -158,18 +151,16 @@
      *                  filter fields are used. NULL implies clamp wrap modes
      *                  and nearest filtering.
      */
-    TextureCacheEntry findAndLockTexture(TextureKey key,
-                                         int width,
-                                         int height,
+    TextureCacheEntry findAndLockTexture(GrTexture::TextureKey key,
+                                         const GrTextureDesc& desc,
                                          const GrSamplerState* sampler);
     /**
      * Determines whether a texture is in the cache. If the texture is found it
      * will not be locked or returned. This call does not affect the priority of
      * the texture for deletion.
      */
-    bool isTextureInCache(TextureKey key,
-                          int width,
-                          int height,
+    bool isTextureInCache(GrTexture::TextureKey key,
+                          const GrTextureDesc& desc,
                           const GrSamplerState*) const;
 
     /**
diff --git a/include/gpu/GrTexture.h b/include/gpu/GrTexture.h
index e5c67d6..c3e2946 100644
--- a/include/gpu/GrTexture.h
+++ b/include/gpu/GrTexture.h
@@ -14,11 +14,20 @@
 #include "GrResource.h"
 
 class GrRenderTarget;
+class GrResourceKey;
+class GrSamplerState;
 
 class GrTexture : public GrResource {
 
 public:
     /**
+     * Key generated by client. Should be a unique key on the texture data.
+     * Does not need to consider that width and height of the texture. Two
+     * textures with the same TextureKey but different bounds will not collide.
+     */
+    typedef uint64_t TextureKey;
+
+    /**
      * Retrieves the width of the texture.
      *
      * @return the width in texels
@@ -130,6 +139,16 @@
     void validate() const {}
 #endif
 
+    static GrResourceKey ComputeKey(const GrGpu* gpu,
+                                    const GrSamplerState* sampler,
+                                    TextureKey clientKey,
+                                    const GrTextureDesc& desc,
+                                    bool scratch);
+
+    static bool NeedsResizing(const GrResourceKey& key);
+    static bool IsScratchTexture(const GrResourceKey& key);
+    static bool NeedsFiltering(const GrResourceKey& key);
+
 protected:
     GrRenderTarget* fRenderTarget; // texture refs its rt representation
                                    // base class cons sets to NULL
diff --git a/include/gpu/SkGr.h b/include/gpu/SkGr.h
index 74dc2cf..9e6d83e 100644
--- a/include/gpu/SkGr.h
+++ b/include/gpu/SkGr.h
@@ -74,12 +74,7 @@
      *  Convert the SkBitmap::Config to the corresponding PixelConfig, or
      *  kUnknown_PixelConfig if the conversion cannot be done.
      */
-    static GrPixelConfig BitmapConfig2PixelConfig(SkBitmap::Config,
-                                                  bool isOpaque);
-
-    static GrPixelConfig Bitmap2PixelConfig(const SkBitmap& bm) {
-        return BitmapConfig2PixelConfig(bm.config(), bm.isOpaque());
-    }
+    static GrPixelConfig BitmapConfig2PixelConfig(SkBitmap::Config);
 
     static GrColor SkColor2GrColor(SkColor c) {
         SkPMColor pm = SkPreMultiplyColor(c);
@@ -157,9 +152,9 @@
 ////////////////////////////////////////////////////////////////////////////////
 // Helper functions
 
-static const GrContext::TextureKey gUNCACHED_KEY = ~0;
+static const GrTexture::TextureKey gUNCACHED_KEY = ~0;
 GrContext::TextureCacheEntry sk_gr_create_bitmap_texture(GrContext* ctx,
-                                                GrContext::TextureKey key,
+                                                GrTexture::TextureKey key,
                                                 const GrSamplerState* sampler,
                                                 const SkBitmap& bitmap);
 
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index b7ada61..072bc47 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -163,17 +163,6 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
-enum {
-    // flags for textures
-    kNPOTBit            = 0x1,
-    kFilterBit          = 0x2,
-    kScratchBit         = 0x4,
-
-    // resource type
-    kTextureBit         = 0x8,
-    kStencilBufferBit   = 0x10
-};
-
 GrTexture* GrContext::TextureCacheEntry::texture() const {
     if (NULL == fEntry) {
         return NULL; 
@@ -183,50 +172,6 @@
 }
 
 namespace {
-// returns true if this is a "special" texture because of gpu NPOT limitations
-bool gen_texture_key_values(const GrGpu* gpu,
-                            const GrSamplerState* sampler,
-                            GrContext::TextureKey clientKey,
-                            int width,
-                            int height,
-                            int sampleCnt,
-                            bool scratch,
-                            uint32_t v[4]) {
-    GR_STATIC_ASSERT(sizeof(GrContext::TextureKey) == sizeof(uint64_t));
-    // we assume we only need 16 bits of width and height
-    // assert that texture creation will fail anyway if this assumption
-    // would cause key collisions.
-    GrAssert(gpu->getCaps().fMaxTextureSize <= SK_MaxU16);
-    v[0] = clientKey & 0xffffffffUL;
-    v[1] = (clientKey >> 32) & 0xffffffffUL;
-    v[2] = width | (height << 16);
-
-    v[3] = (sampleCnt << 24);
-    GrAssert(sampleCnt >= 0 && sampleCnt < 256);
-
-    if (!gpu->getCaps().fNPOTTextureTileSupport) {
-        bool isPow2 = GrIsPow2(width) && GrIsPow2(height);
-
-        bool tiled = NULL != sampler &&
-                     ((sampler->getWrapX() != GrSamplerState::kClamp_WrapMode) ||
-                      (sampler->getWrapY() != GrSamplerState::kClamp_WrapMode));
-
-        if (tiled && !isPow2) {
-            v[3] |= kNPOTBit;
-            if (GrSamplerState::kNearest_Filter != sampler->getFilter()) {
-                v[3] |= kFilterBit;
-            }
-        }
-    }
-
-    if (scratch) {
-        v[3] |= kScratchBit;
-    }
-
-    v[3] |= kTextureBit;
-
-    return v[3] & kNPOTBit;
-}
 
 // we should never have more than one stencil buffer with same combo of
 // (width,height,samplecount)
@@ -235,7 +180,7 @@
     v[0] = width;
     v[1] = height;
     v[2] = sampleCnt;
-    v[3] = kStencilBufferBit;
+    v[3] = GrResourceKey::kStencilBuffer_TypeBit;
 }
 
 void gen_stencil_key_values(const GrStencilBuffer* sb,
@@ -307,24 +252,18 @@
 }
 
 GrContext::TextureCacheEntry GrContext::findAndLockTexture(
-        TextureKey key,
-        int width,
-        int height,
+        GrTexture::TextureKey key,
+        const GrTextureDesc& desc,
         const GrSamplerState* sampler) {
-    uint32_t v[4];
-    gen_texture_key_values(fGpu, sampler, key, width, height, 0, false, v);
-    GrResourceKey resourceKey(v);
+    GrResourceKey resourceKey = GrTexture::ComputeKey(fGpu, sampler, key, desc, false);
     return TextureCacheEntry(fTextureCache->findAndLock(resourceKey,
                                             GrResourceCache::kNested_LockType));
 }
 
-bool GrContext::isTextureInCache(TextureKey key,
-                                 int width,
-                                 int height,
+bool GrContext::isTextureInCache(GrTexture::TextureKey key,
+                                 const GrTextureDesc& desc,
                                  const GrSamplerState* sampler) const {
-    uint32_t v[4];
-    gen_texture_key_values(fGpu, sampler, key, width, height, 0, false, v);
-    GrResourceKey resourceKey(v);
+    GrResourceKey resourceKey = GrTexture::ComputeKey(fGpu, sampler, key, desc, false);
     return fTextureCache->hasKey(resourceKey);
 }
 
@@ -384,7 +323,7 @@
 }
 
 GrContext::TextureCacheEntry GrContext::createAndLockTexture(
-        TextureKey key,
+        GrTexture::TextureKey key,
         const GrSamplerState* sampler,
         const GrTextureDesc& desc,
         void* srcData,
@@ -396,17 +335,16 @@
 #endif
 
     TextureCacheEntry entry;
-    uint32_t v[4];
-    bool special = gen_texture_key_values(fGpu, sampler, key,
-                                          desc.fWidth, desc.fHeight,
-                                          desc.fSampleCnt, false, v);
-    GrResourceKey resourceKey(v);
 
-    if (special) {
+    GrResourceKey resourceKey = GrTexture::ComputeKey(fGpu, sampler, key,
+                                                      desc, false);
+
+    if (GrTexture::NeedsResizing(resourceKey)) {
+        // The desired texture is NPOT and tiled but that isn't supported by 
+        // the current hardware. Resize the texture to be a POT
         GrAssert(NULL != sampler);
         TextureCacheEntry clampEntry = this->findAndLockTexture(key,
-                                                                desc.fWidth,
-                                                                desc.fHeight,
+                                                                desc,
                                                                 NULL);
 
         if (NULL == clampEntry.texture()) {
@@ -437,10 +375,10 @@
             // if filtering is not desired then we want to ensure all
             // texels in the resampled image are copies of texels from
             // the original.
-            if (GrSamplerState::kNearest_Filter == sampler->getFilter()) {
-                filter = GrSamplerState::kNearest_Filter;
-            } else {
+            if (GrTexture::NeedsFiltering(resourceKey)) {
                 filter = GrSamplerState::kBilinear_Filter;
+            } else {
+                filter = GrSamplerState::kNearest_Filter;
             }
             drawState->sampler(0)->reset(GrSamplerState::kClamp_WrapMode,
                                          filter);
@@ -497,21 +435,6 @@
     return entry;
 }
 
-namespace {
-inline void gen_scratch_tex_key_values(const GrGpu* gpu, 
-                                       const GrTextureDesc& desc,
-                                       uint32_t v[4]) {
-    // Instead of a client-provided key of the texture contents
-    // we create a key of from the descriptor.
-    GrContext::TextureKey descKey = (desc.fFlags << 8) |
-                                    ((uint64_t) desc.fConfig << 32);
-    // this code path isn't friendly to tiling with NPOT restricitons
-    // We just pass ClampNoFilter()
-    gen_texture_key_values(gpu, NULL, descKey, desc.fWidth,
-                           desc.fHeight, desc.fSampleCnt, true, v);
-}
-}
-
 GrContext::TextureCacheEntry GrContext::lockScratchTexture(
                                                 const GrTextureDesc& inDesc,
                                                 ScratchTexMatch match) {
@@ -531,9 +454,7 @@
     bool doubledH = false;
 
     do {
-        uint32_t v[4];
-        gen_scratch_tex_key_values(fGpu, desc, v);
-        GrResourceKey key(v);
+        GrResourceKey key = GrTexture::ComputeKey(fGpu, NULL, 0, desc, true);
         entry = fTextureCache->findAndLock(key,
                                            GrResourceCache::kNested_LockType);
         // if we miss, relax the fit of the flags...
@@ -566,9 +487,9 @@
         desc.fHeight = origHeight;
         GrTexture* texture = fGpu->createTexture(desc, NULL, 0);
         if (NULL != texture) {
-            uint32_t v[4];
-            gen_scratch_tex_key_values(fGpu, desc, v);
-            GrResourceKey key(v);
+            GrResourceKey key = GrTexture::ComputeKey(fGpu, NULL, 0,
+                                                      texture->desc(),
+                                                      true);
             entry = fTextureCache->createAndLock(key, texture);
         }
     }
@@ -587,7 +508,7 @@
     // If this is a scratch texture we detached it from the cache
     // while it was locked (to avoid two callers simultaneously getting
     // the same texture).
-    if (kScratchBit & entry.cacheEntry()->key().getValue32(3)) {
+    if (GrTexture::IsScratchTexture(entry.cacheEntry()->key())) {
         fTextureCache->reattachAndUnlock(entry.cacheEntry());
     } else {
         fTextureCache->unlock(entry.cacheEntry());
diff --git a/src/gpu/GrResourceCache.h b/src/gpu/GrResourceCache.h
index f86fcd2..b83e8ec 100644
--- a/src/gpu/GrResourceCache.h
+++ b/src/gpu/GrResourceCache.h
@@ -41,6 +41,16 @@
         kHashMask   = kHashCount - 1
     };
 
+    enum TypeBits {
+        // resource types
+        kTexture_TypeBit         = 0x01,
+        kStencilBuffer_TypeBit   = 0x02,
+
+        // Derived classes may add additional bits
+        kDummy_TypeBit,
+        kLastPublic_TypeBit = kDummy_TypeBit-1,
+    };
+
     GrResourceKey(uint32_t p0, uint32_t p1, uint32_t p2, uint32_t p3) {
         fP[0] = p0;
         fP[1] = p1;
diff --git a/src/gpu/GrTexture.cpp b/src/gpu/GrTexture.cpp
index 00ae8d0..e05b62b 100644
--- a/src/gpu/GrTexture.cpp
+++ b/src/gpu/GrTexture.cpp
@@ -12,6 +12,7 @@
 #include "GrContext.h"
 #include "GrGpu.h"
 #include "GrRenderTarget.h"
+#include "GrResourceCache.h"
 
 bool GrTexture::readPixels(int left, int top, int width, int height,
                            GrPixelConfig config, void* buffer,
@@ -80,3 +81,97 @@
         GrAssert(0 == fDesc.fSampleCnt);
     }
 }
+
+enum TextureBits {
+    kFirst_TextureBit = (GrResourceKey::kLastPublic_TypeBit << 1),
+
+    /*
+     * The kNPOT bit is set when the texture is NPOT and is being repeated
+     * but the hardware doesn't support that feature. 
+     */
+    kNPOT_TextureBit            = kFirst_TextureBit,
+    /*
+     * The kFilter bit can only be set when the kNPOT flag is set and indicates
+     * whether the resizing of the texture should use filtering. This is
+     * to handle cases where the original texture is indexed to disable
+     * filtering.
+     */
+    kFilter_TextureBit          = kNPOT_TextureBit << 1,
+    /*
+     * The kScratch bit is set if the texture is being used as a scratch
+     * texture.
+     */
+    kScratch_TextureBit         = kFilter_TextureBit << 1,
+};
+
+namespace {
+void gen_texture_key_values(const GrGpu* gpu,
+                            const GrSamplerState* sampler,
+                            GrTexture::TextureKey clientKey,
+                            const GrTextureDesc& desc,
+                            bool scratch,
+                            uint32_t v[4]) {
+    GR_STATIC_ASSERT(sizeof(GrTexture::TextureKey) == sizeof(uint64_t));
+
+    if (scratch) {
+        // Instead of a client-provided key of the texture contents
+        // we create a key of from the descriptor.
+        GrAssert(0 == clientKey);
+        clientKey = (desc.fFlags << 8) | ((uint64_t) desc.fConfig << 32);
+    }
+
+    // we assume we only need 16 bits of width and height
+    // assert that texture creation will fail anyway if this assumption
+    // would cause key collisions.
+    GrAssert(gpu->getCaps().fMaxTextureSize <= SK_MaxU16);
+    v[0] = clientKey & 0xffffffffUL;
+    v[1] = (clientKey >> 32) & 0xffffffffUL;
+    v[2] = desc.fWidth | (desc.fHeight << 16);
+
+    v[3] = (desc.fSampleCnt << 24);
+    GrAssert(desc.fSampleCnt >= 0 && desc.fSampleCnt < 256);
+
+    if (!gpu->getCaps().fNPOTTextureTileSupport) {
+        bool isPow2 = GrIsPow2(desc.fWidth) && GrIsPow2(desc.fHeight);
+
+        bool tiled = NULL != sampler &&
+                   ((sampler->getWrapX() != GrSamplerState::kClamp_WrapMode) ||
+                    (sampler->getWrapY() != GrSamplerState::kClamp_WrapMode));
+
+        if (tiled && !isPow2) {
+            v[3] |= kNPOT_TextureBit;
+            if (GrSamplerState::kNearest_Filter != sampler->getFilter()) {
+                v[3] |= kFilter_TextureBit;
+            }
+        }
+    }
+
+    if (scratch) {
+        v[3] |= kScratch_TextureBit;
+    }
+
+    v[3] |= GrResourceKey::kTexture_TypeBit;
+}
+}
+
+GrResourceKey GrTexture::ComputeKey(const GrGpu* gpu,
+                                    const GrSamplerState* sampler,
+                                    TextureKey clientKey,
+                                    const GrTextureDesc& desc,
+                                    bool scratch) {
+    uint32_t v[4];
+    gen_texture_key_values(gpu, sampler, clientKey, desc, scratch, v);
+    return GrResourceKey(v);
+}
+
+bool GrTexture::NeedsResizing(const GrResourceKey& key) {
+    return 0 != (key.getValue32(3) & kNPOT_TextureBit);
+}
+
+bool GrTexture::IsScratchTexture(const GrResourceKey& key) {
+    return 0 != (key.getValue32(3) & kScratch_TextureBit);
+}
+
+bool GrTexture::NeedsFiltering(const GrResourceKey& key) {
+    return 0 != (key.getValue32(3) & kFilter_TextureBit);
+}
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 056c5d8..d9d2349 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -230,7 +230,7 @@
         kRenderTarget_GrTextureFlagBit,
         width,
         height,
-        SkGr::Bitmap2PixelConfig(bm),
+        SkGr::BitmapConfig2PixelConfig(bm.config()),
         0 // samples
     };
 
@@ -337,8 +337,7 @@
     if (SkBitmap::kARGB_8888_Config == bitmap.config()) {
         config = config8888_to_gr_config(config8888);
     } else {
-        config= SkGr::BitmapConfig2PixelConfig(bitmap.config(),
-                                               bitmap.isOpaque());
+        config= SkGr::BitmapConfig2PixelConfig(bitmap.config());
     }
 
     fRenderTarget->writePixels(x, y, bitmap.width(), bitmap.height(),
@@ -1831,11 +1830,18 @@
     GrContext* ctx = this->context();
 
     if (!bitmap.isVolatile()) {
-        GrContext::TextureKey key = bitmap.getGenerationID();
+        GrTexture::TextureKey key = bitmap.getGenerationID();
         key |= ((uint64_t) bitmap.pixelRefOffset()) << 32;
 
-        entry = ctx->findAndLockTexture(key, bitmap.width(),
-                                        bitmap.height(), sampler);
+        GrTextureDesc desc = {
+            kNone_GrTextureFlags,
+            bitmap.width(),
+            bitmap.height(),
+            SkGr::BitmapConfig2PixelConfig(bitmap.config()),
+            0 // samples
+        };
+
+        entry = ctx->findAndLockTexture(key, desc, sampler);
         if (NULL == entry.texture()) {
             entry = sk_gr_create_bitmap_texture(ctx, key, sampler,
                                                 bitmap);
@@ -1857,11 +1863,18 @@
 
 bool SkGpuDevice::isBitmapInTextureCache(const SkBitmap& bitmap,
                                          const GrSamplerState& sampler) const {
-    GrContext::TextureKey key = bitmap.getGenerationID();
+    GrTexture::TextureKey key = bitmap.getGenerationID();
     key |= ((uint64_t) bitmap.pixelRefOffset()) << 32;
-    return this->context()->isTextureInCache(key, bitmap.width(),
-                                             bitmap.height(), &sampler);
 
+    GrTextureDesc desc = {
+        kNone_GrTextureFlags,
+        bitmap.width(),
+        bitmap.height(),
+        SkGr::BitmapConfig2PixelConfig(bitmap.config()),
+        0 // samples
+    };
+
+    return this->context()->isTextureInCache(key, desc, &sampler);
 }
 
 
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index 12967e2..92a3aff 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -57,7 +57,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 GrContext::TextureCacheEntry sk_gr_create_bitmap_texture(GrContext* ctx,
-                                                GrContext::TextureKey key,
+                                                GrTexture::TextureKey key,
                                                 const GrSamplerState* sampler,
                                                 const SkBitmap& origBitmap) {
     SkAutoLockPixels alp(origBitmap);
@@ -75,7 +75,7 @@
         kNone_GrTextureFlags,
         bitmap->width(),
         bitmap->height(),
-        SkGr::Bitmap2PixelConfig(*bitmap),
+        SkGr::BitmapConfig2PixelConfig(bitmap->config()),
         0 // samples
     };
 
@@ -112,7 +112,7 @@
         }
     }
 
-    desc.fConfig = SkGr::Bitmap2PixelConfig(*bitmap);
+    desc.fConfig = SkGr::BitmapConfig2PixelConfig(bitmap->config());
     if (gUNCACHED_KEY != key) {
         return ctx->createAndLockTexture(key, sampler, desc,
                                          bitmap->getPixels(),
@@ -194,8 +194,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrPixelConfig SkGr::BitmapConfig2PixelConfig(SkBitmap::Config config,
-                                                    bool isOpaque) {
+GrPixelConfig SkGr::BitmapConfig2PixelConfig(SkBitmap::Config config) {
     switch (config) {
         case SkBitmap::kA8_Config:
             return kAlpha_8_GrPixelConfig;
@@ -208,6 +207,7 @@
         case SkBitmap::kARGB_8888_Config:
             return kSkia8888_PM_GrPixelConfig;
         default:
+            // kNo_Config, kA1_Config missing, and kRLE_Index8_Config
             return kUnknown_GrPixelConfig;
     }
 }
diff --git a/src/gpu/SkGrTexturePixelRef.cpp b/src/gpu/SkGrTexturePixelRef.cpp
index c81e9c0..485d572 100644
--- a/src/gpu/SkGrTexturePixelRef.cpp
+++ b/src/gpu/SkGrTexturePixelRef.cpp
@@ -62,7 +62,7 @@
     desc.fWidth  = texture->width();
     desc.fHeight = texture->height();
     desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
-    desc.fConfig = SkGr::BitmapConfig2PixelConfig(dstConfig, false);
+    desc.fConfig = SkGr::BitmapConfig2PixelConfig(dstConfig);
     desc.fSampleCnt = 0;
 
     GrTexture* dst = context->createUncachedTexture(desc, NULL, 0);