Fix ref-cnting bug in GrContext::readRenderTargetPixels

src/gpu/GrContext.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 "GrContext.h"
 
@@ skipping 1410 matching lines @@
         swapRAndB = true;
     }
 
     bool unpremul = SkToBool(kUnpremul_PixelOpsFlag & flags);
 
     if (unpremul && !GrPixelConfigIs8888(dstConfig)) {
         // The unpremul flag is only allowed for these two configs.
         return false;
     }
 
+    SkAutoTUnref<GrTexture> tempTexture;
+
     // If the src is a texture and we would have to do conversions after read pixels, we instead
     // do the conversions by drawing the src to a scratch texture. If we handle any of the
     // conversions in the draw we set the corresponding bool to false so that we don't reapply it
     // on the read back pixels.
     GrTexture* src = target->asTexture();
     if (src && (swapRAndB || unpremul || flipY)) {
         // Make the scratch a render so we can read its pixels.
         GrSurfaceDesc desc;
         desc.fFlags = kRenderTarget_GrSurfaceFlag;
         desc.fWidth = width;
         desc.fHeight = height;
         desc.fConfig = readConfig;
         desc.fOrigin = kTopLeft_GrSurfaceOrigin;
 
         // When a full read back is faster than a partial we could always make the scratch exactly
         // match the passed rect. However, if we see many different size rectangles we will trash
         // our texture cache and pay the cost of creating and destroying many textures. So, we only
         // request an exact match when the caller is reading an entire RT.
         ScratchTexMatch match = kApprox_ScratchTexMatch;
         if (0 == left &&
             0 == top &&
             target->width() == width &&
             target->height() == height &&
             fGpu->fullReadPixelsIsFasterThanPartial()) {
             match = kExact_ScratchTexMatch;
         }
-        SkAutoTUnref<GrTexture> texture(this->refScratchTexture(desc, match));
-        if (texture) {
+        tempTexture.reset(this->refScratchTexture(desc, match));
+        if (tempTexture) {
             // compute a matrix to perform the draw
             SkMatrix textureMatrix;
             textureMatrix.setTranslate(SK_Scalar1 *left, SK_Scalar1 *top);
             textureMatrix.postIDiv(src->width(), src->height());
 
             SkAutoTUnref<const GrFragmentProcessor> fp;
             if (unpremul) {
                 fp.reset(this->createPMToUPMEffect(src, swapRAndB, textureMatrix));
                 if (fp) {
                     unpremul = false; // we no longer need to do this on CPU after the read back.
@@ skipping 12 matching lines @@
                 // We protect the existing geometry here since it may not be
                 // clear to the caller that a draw operation (i.e., drawSimpleRect)
                 // can be invoked in this method
                 {
                     GrDrawTarget::AutoGeometryAndStatePush agasp(fDrawBuffer,
                                                                  GrDrawTarget::kReset_ASRInit);
                     GrDrawState* drawState = fDrawBuffer->drawState();
                     SkASSERT(fp);
                     drawState->addColorProcessor(fp);
 
-                    drawState->setRenderTarget(texture->asRenderTarget());
+                    drawState->setRenderTarget(tempTexture->asRenderTarget());
                     SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
                     fDrawBuffer->drawSimpleRect(rect);
                     // we want to read back from the scratch's origin
                     left = 0;
                     top = 0;
-                    target = texture->asRenderTarget();
+                    target = tempTexture->asRenderTarget();
                 }
                 this->flushSurfaceWrites(target);
             }
         }
     }
 
     if (!fGpu->readPixels(target,
                           left, top, width, height,
                           readConfig, buffer, rowBytes)) {
         return false;
@@ skipping 269 matching lines @@
     fResourceCache->printStats();
 }
 #endif
 
 #if GR_GPU_STATS
 const GrContext::GPUStats* GrContext::gpuStats() const {
     return fGpu->gpuStats();
 }
 #endif