GrResourceCache2 manages scratch texture.

src/gpu/SkGpuDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuDevice.h"
 
 #include "effects/GrBicubicEffect.h"
@@ skipping 57 matching lines @@
             this->clear(SK_ColorTRANSPARENT); \
         }                               \
     } while (false)                     \
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #define CHECK_FOR_ANNOTATION(paint) \
     do { if (paint.getAnnotation()) { return; } } while (0)
 
 ///////////////////////////////////////////////////////////////////////////////
 

[robertphillips, 2014/09/29 15:25:08]

// If 'bitmap' is GrTexture backed, return the backing GrTexture. Otherwise,
// create a scratch texture based copy.

?

[bsalomon, 2014/09/29 19:58:14]

Done.

+class AutoBitmapTexture : public SkNoncopyable {
+public:
+    AutoBitmapTexture() {}
 
-class SkGpuDevice::SkAutoCachedTexture : public ::SkNoncopyable {
-public:
-    SkAutoCachedTexture()
-        : fDevice(NULL)
-        , fTexture(NULL) {
+    AutoBitmapTexture(GrContext* context,
+                      const SkBitmap& bitmap,
+                      const GrTextureParams* params,
+                      GrTexture** texture) {
+        SkASSERT(texture);
+        *texture = this->set(context, bitmap, params);
     }
 
-    SkAutoCachedTexture(SkGpuDevice* device,
-                        const SkBitmap& bitmap,
-                        const GrTextureParams* params,
-                        GrTexture** texture)
-        : fDevice(NULL)
-        , fTexture(NULL) {
-        SkASSERT(texture);
-        *texture = this->set(device, bitmap, params);
-    }
-
-    ~SkAutoCachedTexture() {
-        if (fTexture) {
-            GrUnlockAndUnrefCachedBitmapTexture(fTexture);
+    GrTexture* set(GrContext* context,
+                   const SkBitmap& bitmap,
+                   const GrTextureParams* params) {
+        // Either get the texture directly from the bitmap, or else use the cache and
+        // remember to unref it.
+        if (GrTexture* bmpTexture = bitmap.getTexture()) {
+            fTexture.reset(NULL);
+            return bmpTexture;
+        } else {
+            fTexture.reset(GrRefCachedBitmapTexture(context, bitmap, params));
+            return fTexture.get();
         }
     }
 
-    GrTexture* set(SkGpuDevice* device,
-                   const SkBitmap& bitmap,
-                   const GrTextureParams* params) {
-        if (fTexture) {
-            GrUnlockAndUnrefCachedBitmapTexture(fTexture);
-            fTexture = NULL;
-        }
-        fDevice = device;
-        GrTexture* result = (GrTexture*)bitmap.getTexture();
-        if (NULL == result) {
-            // Cannot return the native texture so look it up in our cache
-            fTexture = GrLockAndRefCachedBitmapTexture(device->context(), bitmap, params);
-            result = fTexture;
-        }
-        return result;
-    }
-
 private:
-    SkGpuDevice* fDevice;
-    GrTexture*   fTexture;
+    SkAutoTUnref<GrTexture> fTexture;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 struct GrSkDrawProcs : public SkDrawProcs {
 public:
     GrContext* fContext;
     GrTextContext* fTextContext;
     GrFontScaler* fFontScaler;  // cached in the skia glyphcache
 };
@@ skipping 12 matching lines @@
 
     fDrawProcs = NULL;
 
     fContext = SkRef(surface->getContext());
 
     fNeedClear = flags & kNeedClear_Flag;
 
     fRenderTarget = SkRef(surface->asRenderTarget());
 
     SkImageInfo info = surface->surfacePriv().info();
-    SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef,
-                                (info, surface, SkToBool(flags & kCached_Flag)));
+    SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (info, surface));
     fLegacyBitmap.setInfo(info);
     fLegacyBitmap.setPixelRef(pr)->unref();
 
     this->setPixelGeometry(props.pixelGeometry());
 
     bool useDFFonts = !!(flags & kDFFonts_Flag);
     fMainTextContext = fContext->createTextContext(fRenderTarget, this->getLeakyProperties(), useDFFonts);
     fFallbackTextContext = SkNEW_ARGS(GrBitmapTextContext, (fContext, this->getLeakyProperties()));
 }
 
@@ skipping 1120 matching lines @@
                                      const SkRect& srcRect,
                                      const GrTextureParams& params,
                                      const SkPaint& paint,
                                      SkCanvas::DrawBitmapRectFlags flags,
                                      bool bicubic,
                                      bool needsTextureDomain) {
     SkASSERT(bitmap.width() <= fContext->getMaxTextureSize() &&
              bitmap.height() <= fContext->getMaxTextureSize());
 
     GrTexture* texture;
-    SkAutoCachedTexture act(this, bitmap, &params, &texture);
+    AutoBitmapTexture abt(fContext, bitmap, &params, &texture);
     if (NULL == texture) {
         return;
     }
 
     SkRect dstRect = {0, 0, srcRect.width(), srcRect.height() };
     SkRect paintRect;
     SkScalar wInv = SkScalarInvert(SkIntToScalar(texture->width()));
     SkScalar hInv = SkScalarInvert(SkIntToScalar(texture->height()));
     paintRect.setLTRB(SkScalarMul(srcRect.fLeft,   wInv),
                       SkScalarMul(srcRect.fTop,    hInv),
@@ skipping 74 matching lines @@
     SkAutoLockPixels alp(bitmap, !bitmap.getTexture());
     if (!bitmap.getTexture() && !bitmap.readyToDraw()) {
         return;
     }
 
     int w = bitmap.width();
     int h = bitmap.height();
 
     GrTexture* texture;
     // draw sprite uses the default texture params
-    SkAutoCachedTexture act(this, bitmap, NULL, &texture);
+    AutoBitmapTexture abt(fContext, bitmap, NULL, &texture);
 
     SkImageFilter* filter = paint.getImageFilter();
     // This bitmap will own the filtered result as a texture.
     SkBitmap filteredBitmap;
 
     if (filter) {
         SkIPoint offset = SkIPoint::Make(0, 0);
         SkMatrix matrix(*draw.fMatrix);
         matrix.postTranslate(SkIntToScalar(-left), SkIntToScalar(-top));
         SkIRect clipBounds = SkIRect::MakeWH(bitmap.width(), bitmap.height());
@@ skipping 156 matching lines @@
     }
 
     SkAutoLockPixels alp(src, !src.getTexture());
     if (!src.getTexture() && !src.readyToDraw()) {
         return false;
     }
 
     GrTexture* texture;
     // We assume here that the filter will not attempt to tile the src. Otherwise, this cache lookup
     // must be pushed upstack.
-    SkAutoCachedTexture act(this, src, NULL, &texture);
+    AutoBitmapTexture abt(fContext, src, NULL, &texture);
 
     return filter_texture(this, fContext, texture, filter, src.width(), src.height(), ctx,
                           result, offset);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // must be in SkCanvas::VertexMode order
 static const GrPrimitiveType gVertexMode2PrimitiveType[] = {
     kTriangles_GrPrimitiveType,
@@ skipping 210 matching lines @@
     desc.fHeight = info.height();
     desc.fSampleCnt = fRenderTarget->numSamples();
 
     SkAutoTUnref<GrTexture> texture;
     // Skia's convention is to only clear a device if it is non-opaque.
     unsigned flags = info.isOpaque() ? 0 : kNeedClear_Flag;
 
 #if CACHE_COMPATIBLE_DEVICE_TEXTURES
     // layers are never draw in repeat modes, so we can request an approx
     // match and ignore any padding.
-    flags |= kCached_Flag;
     const GrContext::ScratchTexMatch match = (kSaveLayer_Usage == usage) ?
                                                 GrContext::kApprox_ScratchTexMatch :
                                                 GrContext::kExact_ScratchTexMatch;
     texture.reset(fContext->lockAndRefScratchTexture(desc, match));
 #else
     texture.reset(fContext->createUncachedTexture(desc, NULL, 0));
 #endif
     if (texture.get()) {
         return SkGpuDevice::Create(texture, SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType), flags);
     } else {
@@ skipping 58 matching lines @@
     GrLayerHoister::UnlockLayers(fContext->getLayerCache(), atlased, nonAtlased);
 
     return true;
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }