No more caching volatile bitmaps

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 297 matching lines @@
         desc.fConfig = kETC1_GrPixelConfig;
     } else {
         return NULL;
     }
 
     return create_texture_for_bmp(ctx, optionalKey, desc, bytes, 0);
 }
 #endif   // SK_IGNORE_ETC1_SUPPORT
 
 static GrTexture* load_yuv_texture(GrContext* ctx, const GrContentKey& optionalKey,
-                                   const SkBitmap& bm, const GrSurfaceDesc& desc) {
+                                   const SkBitmap& bm, const GrSurfaceDesc& desc, bool cache) {

[bsalomon, 2015/02/04 17:19:33]

We don't need the cache bool. optionalKey should already be invalid if the
bitmap is not to be cached (setup in GrRefCachedBitmapTexture)

[sugoi1, 2015/02/04 17:59:51]

Done.

     // 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;
     }
 
     SkYUVPlanesCache::Info yuvInfo;
-    SkAutoTUnref<SkCachedData> cachedData(
-        SkYUVPlanesCache::FindAndRef(pixelRef->getGenerationID(), &yuvInfo));
+    SkAutoTUnref<SkCachedData> cachedData;
+    SkAutoMalloc storage;
+    if (cache) {
+        cachedData.reset(SkYUVPlanesCache::FindAndRef(pixelRef->getGenerationID(), &yuvInfo));
+    }
 
     void* planes[3];
-    if (cachedData && cachedData->data()) {
+    if (cachedData.get()) {
         planes[0] = (void*)cachedData->data();
         planes[1] = (uint8_t*)planes[0] + yuvInfo.fSizeInMemory[0];
         planes[2] = (uint8_t*)planes[1] + yuvInfo.fSizeInMemory[1];
     } else {
         // Fetch yuv plane sizes for memory allocation. Here, width and height can be
         // rounded up to JPEG block size and be larger than the image's width and height.
         if (!pixelRef->getYUV8Planes(yuvInfo.fSize, NULL, NULL, NULL)) {
             return NULL;
         }
 
         // Allocate the memory for YUV
         size_t totalSize(0);
         for (int i = 0; i < 3; ++i) {
             yuvInfo.fRowBytes[i] = yuvInfo.fSize[i].fWidth;
             yuvInfo.fSizeInMemory[i] = yuvInfo.fRowBytes[i] * yuvInfo.fSize[i].fHeight;
             totalSize += yuvInfo.fSizeInMemory[i];
         }
-        cachedData.reset(SkResourceCache::NewCachedData(totalSize));
-        planes[0] = cachedData->writable_data();
+        if (cache) {
+            cachedData.reset(SkResourceCache::NewCachedData(totalSize));
+            planes[0] = cachedData->writable_data();
+        } else {
+            storage.reset(totalSize);
+            planes[0] = storage.get();
+        }
         planes[1] = (uint8_t*)planes[0] + yuvInfo.fSizeInMemory[0];
         planes[2] = (uint8_t*)planes[1] + yuvInfo.fSizeInMemory[1];
 
         // Get the YUV planes and update plane sizes to actual image size
         if (!pixelRef->getYUV8Planes(yuvInfo.fSize, planes, yuvInfo.fRowBytes,
                                      &yuvInfo.fColorSpace)) {
             return NULL;
         }
 
-        // Decoding is done, cache the resulting YUV planes
-        SkYUVPlanesCache::Add(pixelRef->getGenerationID(), cachedData, &yuvInfo);
+        if (cache) {
+            // Decoding is done, cache the resulting YUV planes
+            SkYUVPlanesCache::Add(pixelRef->getGenerationID(), cachedData, &yuvInfo);
+        }
     }
 
     GrSurfaceDesc yuvDesc;
     yuvDesc.fConfig = kAlpha_8_GrPixelConfig;
     SkAutoTUnref<GrTexture> yuvTextures[3];
     for (int i = 0; i < 3; ++i) {
         yuvDesc.fWidth  = yuvInfo.fSize[i].fWidth;
         yuvDesc.fHeight = yuvInfo.fSize[i].fHeight;
         yuvTextures[i].reset(
             ctx->refScratchTexture(yuvDesc, GrContext::kApprox_ScratchTexMatch));
@@ skipping 74 matching lines @@
         // data is.
         && !(bitmap->readyToDraw())) {
         GrTexture *texture = load_etc1_texture(ctx, optionalKey, *bitmap, desc);
         if (texture) {
             return texture;
         }
     }
 #endif   // SK_IGNORE_ETC1_SUPPORT
 
     else {
-        GrTexture *texture = load_yuv_texture(ctx, optionalKey, *bitmap, desc);
+        GrTexture *texture = load_yuv_texture(ctx, optionalKey, *bitmap, desc,
+                                              !origBitmap.isVolatile());
         if (texture) {
             return texture;
         }
     }
     SkAutoLockPixels alp(*bitmap);
     if (!bitmap->readyToDraw()) {
         return NULL;
     }
 
     return create_texture_for_bmp(ctx, optionalKey, desc, bitmap->getPixels(), bitmap->rowBytes());
@@ skipping 249 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);
 }