diff --git a/bench/BitmapBench.cpp b/bench/BitmapBench.cpp
index 77e7ade..9db4ae3 100644
--- a/bench/BitmapBench.cpp
+++ b/bench/BitmapBench.cpp
@@ -93,13 +93,15 @@
     SkBitmap    fBitmap;
     SkPaint     fPaint;
     bool        fIsOpaque;
+    bool        fForceUpdate; //bitmap marked as dirty before each draw. forces bitmap to be updated on device cache
     int         fTileX, fTileY; // -1 means don't use shader
     SkString    fName;
     enum { N = 300 };
 public:
     BitmapBench(void* param, bool isOpaque, SkBitmap::Config c,
+                bool forceUpdate = false, bool bitmapVolatile = false, 
                 int tx = -1, int ty = -1)
-        : INHERITED(param), fIsOpaque(isOpaque), fTileX(tx), fTileY(ty) {
+        : INHERITED(param), fIsOpaque(isOpaque), fForceUpdate(forceUpdate), fTileX(tx), fTileY(ty) {
         const int w = 128;
         const int h = 128;
         SkBitmap bm;
@@ -124,6 +126,7 @@
             fBitmap.getColorTable()->setIsOpaque(isOpaque);
         }
         fBitmap.setIsOpaque(isOpaque);
+        fBitmap.setIsVolatile(bitmapVolatile);
     }
 
 protected:
@@ -137,6 +140,11 @@
         }
         fName.appendf("_%s%s", gConfigName[fBitmap.config()],
                       fIsOpaque ? "" : "_A");
+        if (fForceUpdate) 
+            fName.append("_update");
+        if (fBitmap.isVolatile())
+            fName.append("_volatile");
+
         return fName.c_str();
     }
 
@@ -154,6 +162,10 @@
         for (int i = 0; i < N; i++) {
             SkScalar x = x0 + rand.nextUScalar1() * dim.fX;
             SkScalar y = y0 + rand.nextUScalar1() * dim.fY;
+
+            if (fForceUpdate)
+                bitmap.notifyPixelsChanged();
+
             canvas->drawBitmap(bitmap, x, y, &paint);
         }
     }
@@ -169,6 +181,8 @@
 static SkBenchmark* Fact4(void* p) { return new BitmapBench(p, true, SkBitmap::kARGB_4444_Config); }
 static SkBenchmark* Fact5(void* p) { return new BitmapBench(p, false, SkBitmap::kIndex8_Config); }
 static SkBenchmark* Fact6(void* p) { return new BitmapBench(p, true, SkBitmap::kIndex8_Config); }
+static SkBenchmark* Fact7(void* p) { return new BitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, true); }
+static SkBenchmark* Fact8(void* p) { return new BitmapBench(p, true, SkBitmap::kARGB_8888_Config, true, false); }
 
 static BenchRegistry gReg0(Fact0);
 static BenchRegistry gReg1(Fact1);
@@ -177,3 +191,5 @@
 static BenchRegistry gReg4(Fact4);
 static BenchRegistry gReg5(Fact5);
 static BenchRegistry gReg6(Fact6);
+static BenchRegistry gReg7(Fact7);
+static BenchRegistry gReg8(Fact8);
diff --git a/gpu/include/GrGLTexture.h b/gpu/include/GrGLTexture.h
index b4713a4..6873b86 100644
--- a/gpu/include/GrGLTexture.h
+++ b/gpu/include/GrGLTexture.h
@@ -169,7 +169,8 @@
                                    int y,
                                    int width,
                                    int height,
-                                   const void* srcData);
+                                   const void* srcData,
+                                   size_t rowBytes);
     virtual intptr_t getTextureHandle();
 
     const TexParams& getTexParams() const { return fTexParams; }
diff --git a/gpu/include/GrTexture.h b/gpu/include/GrTexture.h
index 7815997..d811b35 100644
--- a/gpu/include/GrTexture.h
+++ b/gpu/include/GrTexture.h
@@ -201,18 +201,21 @@
     /**
      * Updates a subrectangle of texels in the texture.
      *
-     * @param x       left edge of rectangle to update
-     * @param y       top edge of rectangle to update
-     * @param width   width of rectangle to update
-     * @param height  height of rectangle to update
-     * @param srcData width*height texels of data in same format that was used
-     *                at texture creation.
+     * @param x         left edge of rectangle to update
+     * @param y         top edge of rectangle to update
+     * @param width     width of rectangle to update
+     * @param height    height of rectangle to update
+     * @param srcData   width*height texels of data in same format that was
+     *                  used at texture creation.
+     * @param rowBytes  number of bytes per row in srcData, 0 means rows are 
+     *                  packed
      */
     virtual void uploadTextureData(int x,
                                    int y,
                                    int width,
                                    int height,
-                                   const void* srcData) = 0;
+                                   const void* srcData,
+                                   size_t rowBytes) = 0;
 
     /**
      * Reads a rectangle of pixels from the texture.
diff --git a/gpu/src/GrAtlas.cpp b/gpu/src/GrAtlas.cpp
index 480a307..c623952 100644
--- a/gpu/src/GrAtlas.cpp
+++ b/gpu/src/GrAtlas.cpp
@@ -117,7 +117,7 @@
         image = storage.get();
     }
     adjustForPlot(loc, fPlot);
-    fTexture->uploadTextureData(loc->fX, loc->fY, dstW, dstH, image);
+    fTexture->uploadTextureData(loc->fX, loc->fY, dstW, dstH, image, 0);
 
     // now tell the caller to skip the top/left BORDER
     loc->fX += BORDER;
diff --git a/gpu/src/GrGLTexture.cpp b/gpu/src/GrGLTexture.cpp
index fec1e74..d36e21b 100644
--- a/gpu/src/GrGLTexture.cpp
+++ b/gpu/src/GrGLTexture.cpp
@@ -17,6 +17,7 @@
 
 #include "GrGLTexture.h"
 #include "GrGpuGL.h"
+#include "GrMemory.h"
 
 #define GPUGL static_cast<GrGpuGL*>(getGpu())
 
@@ -157,7 +158,8 @@
                                     int y,
                                     int width,
                                     int height,
-                                    const void* srcData) {
+                                    const void* srcData,
+                                    size_t rowBytes) {
 
     GPUGL->setSpareTextureUnit();
 
@@ -165,6 +167,37 @@
     // (at least without extensions)
     GrAssert(fUploadFormat != GR_GL_PALETTE8_RGBA8);
 
+    // in case we need a temporary, trimmed copy of the src pixels
+    GrAutoSMalloc<128 * 128> trimStorage;
+
+    /*
+     *  check if our srcData has extra bytes past each row. If so, we need
+     *  to trim those off here, since GL doesn't let us pass the rowBytes as
+     *  a parameter to glTexImage2D
+     */
+
+    if (GR_GL_SUPPORT_DESKTOP) {
+        if (srcData && rowBytes) {
+            GR_GL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH,
+                              rowBytes / fUploadByteCount));
+        }
+    } else {
+        size_t trimRowBytes = width * fUploadByteCount;
+        if (srcData && (trimRowBytes < rowBytes)) {
+            // copy the data into our new storage, skipping the trailing bytes
+            size_t trimSize = height * trimRowBytes;
+            const char* src = (const char*)srcData;
+            char* dst = (char*)trimStorage.realloc(trimSize);
+            for (int y = 0; y < height; y++) {
+                memcpy(dst, src, trimRowBytes);
+                src += rowBytes;
+                dst += trimRowBytes;
+            }
+            // now point srcData to our trimmed version
+            srcData = trimStorage.get();
+        }
+    }
+
     // If we need to update textures that are created upside down
     // then we have to modify this code to flip the srcData
     GrAssert(kTopDown_Orientation == fOrientation);
@@ -173,6 +206,11 @@
     GR_GL(TexSubImage2D(GR_GL_TEXTURE_2D, 0, x, y, width, height,
                         fUploadFormat, fUploadType, srcData));
 
+    if (GR_GL_SUPPORT_DESKTOP) {
+        if (srcData && rowBytes) {
+            GR_GL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, 0));
+        }
+    }
 }
 
 intptr_t GrGLTexture::getTextureHandle() {
diff --git a/include/core/SkBitmap.h b/include/core/SkBitmap.h
index 91143c1..58af571 100644
--- a/include/core/SkBitmap.h
+++ b/include/core/SkBitmap.h
@@ -168,11 +168,25 @@
     /** Returns true if the bitmap is opaque (has no translucent/transparent pixels).
     */
     bool isOpaque() const;
+
     /** Specify if this bitmap's pixels are all opaque or not. Is only meaningful for configs
         that support per-pixel alpha (RGB32, A1, A8).
     */
     void setIsOpaque(bool);
 
+    /** Returns true if the bitmap is volatile (i.e. should not be cached by devices.)
+    */
+    bool isVolatile() const;
+
+    /** Specify whether this bitmap is volatile. Bitmaps are not volatile by 
+        default. Temporary bitmaps that are discarded after use should be
+        marked as volatile. This provides a hint to the device that the bitmap
+        should not be cached. Providing this hint when appropriate can  
+        improve performance by avoiding unnecessary overhead and resource 
+        consumption on the device.
+    */
+    void setIsVolatile(bool);
+
     /** Reset the bitmap to its initial state (see default constructor). If we are a (shared)
         owner of the pixels, that ownership is decremented.
     */
@@ -580,7 +594,8 @@
     mutable int         fRawPixelGenerationID;
 
     enum Flags {
-        kImageIsOpaque_Flag  = 0x01
+        kImageIsOpaque_Flag = 0x01,
+        kImageIsVolatile_Flag     = 0x02
     };
 
     uint32_t    fRowBytes;
diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index 72b6b62..cdb74bb 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -583,6 +583,18 @@
     }
 }
 
+bool SkBitmap::isVolatile() const {
+    return (fFlags & kImageIsVolatile_Flag) != 0;
+}
+
+void SkBitmap::setIsVolatile(bool isVolatile) {
+    if (isVolatile) {
+        fFlags |= kImageIsVolatile_Flag;
+    } else {
+        fFlags &= ~kImageIsVolatile_Flag;
+    }
+}
+
 void* SkBitmap::getAddr(int x, int y) const {
     SkASSERT((unsigned)x < (unsigned)this->width());
     SkASSERT((unsigned)y < (unsigned)this->height());
@@ -1510,7 +1522,7 @@
 void SkBitmap::validate() const {
     SkASSERT(fConfig < kConfigCount);
     SkASSERT(fRowBytes >= (unsigned)ComputeRowBytes((Config)fConfig, fWidth));
-    SkASSERT(fFlags <= kImageIsOpaque_Flag);
+    SkASSERT(fFlags <= (kImageIsOpaque_Flag | kImageIsVolatile_Flag));
     SkASSERT(fPixelLockCount >= 0);
     SkASSERT(NULL == fColorTable || (unsigned)fColorTable->getRefCnt() < 10000);
     SkASSERT((uint8_t)ComputeBytesPerPixel((Config)fConfig) == fBytesPerPixel);
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index b9e7d47..4f2d7c4 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -1459,19 +1459,22 @@
             entry = ctx->lockKeylessTexture(desc);
         }
     } else {
-        uint32_t p0, p1;
-        p0 = bitmap.getGenerationID();
-        p1 = bitmap.pixelRefOffset();
-
-        GrTextureKey key(p0, p1, bitmap.width(), bitmap.height());
-        entry = ctx->findAndLockTexture(&key, sampler);
-
+        if (!bitmap.isVolatile()) {
+            uint32_t p0, p1;
+            p0 = bitmap.getGenerationID();
+            p1 = bitmap.pixelRefOffset();
+            GrTextureKey key(p0, p1, bitmap.width(), bitmap.height());
+        
+            entry = ctx->findAndLockTexture(&key, sampler);
+            if (NULL == entry)
+                entry = sk_gr_create_bitmap_texture(ctx, &key, sampler, 
+                                                    bitmap);
+        } else {
+            entry = sk_gr_create_bitmap_texture(ctx, NULL, sampler, bitmap);
+        }
         if (NULL == entry) {
-            entry = sk_gr_create_bitmap_texture(ctx, &key, sampler, bitmap);
-            if (NULL == entry) {
-                GrPrintf("---- failed to create texture for cache [%d %d]\n",
-                         bitmap.width(), bitmap.height());
-            }
+            GrPrintf("---- failed to create texture for cache [%d %d]\n",
+                     bitmap.width(), bitmap.height());
         }
     }
 
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index 600c336..4f1e6fd 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -97,8 +97,16 @@
 
             // our compressed data will be trimmed, so pass width() for its
             // "rowBytes", since they are the same now.
-            return ctx->createAndLockTexture(key, sampler, desc, storage.get(),
-                                             bitmap->width());
+            
+            if (NULL != key) {
+                return ctx->createAndLockTexture(key, sampler, desc, storage.get(),
+                                                 bitmap->width());
+            } else {
+                GrTextureEntry* entry = ctx->lockKeylessTexture(desc);
+                entry->texture()->uploadTextureData(0, 0, bitmap->width(), 
+                    bitmap->height(), storage.get(), 0);
+                return entry;
+            }
 
         } else {
             origBitmap.copyTo(&tmpBitmap, SkBitmap::kARGB_8888_Config);
@@ -108,8 +116,15 @@
     }
 
     desc.fFormat = SkGr::Bitmap2PixelConfig(*bitmap);
-    return ctx->createAndLockTexture(key, sampler, desc, bitmap->getPixels(),
-                                     bitmap->rowBytes());
+    if (NULL != key) {
+        return ctx->createAndLockTexture(key, sampler, desc, 
+            bitmap->getPixels(), bitmap->rowBytes());
+    } else {
+        GrTextureEntry* entry = ctx->lockKeylessTexture(desc);
+        entry->texture()->uploadTextureData(0, 0, bitmap->width(), 
+            bitmap->height(), bitmap->getPixels(), bitmap->rowBytes());
+        return entry;
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////