Revert of Fix memory leak in SkGradientShader.

src/core/SkPictureShader.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPictureShader.h"
 
 #include "SkBitmap.h"
@@ skipping 37 matching lines @@
     this->INHERITED::flatten(buffer);
 
     buffer.write32(fTmx);
     buffer.write32(fTmy);
     buffer.writeBool(NULL != fPicture);
     if (fPicture) {
         fPicture->flatten(buffer);
     }
 }
 
-SkShader* SkPictureShader::refBitmapShader(const SkMatrix& matrix) const {
+SkShader* SkPictureShader::buildBitmapShader(const SkMatrix& matrix) const {
     if (!fPicture || (0 == fPicture->width() && 0 == fPicture->height())) {
         return NULL;
     }
 
     SkMatrix m;
     if (this->hasLocalMatrix()) {
         m.setConcat(matrix, this->getLocalMatrix());
     } else {
         m = matrix;
     }
@@ skipping 45 matching lines @@
     fCachedBitmapShader.get()->ref();
     return fCachedBitmapShader;
 }
 
 SkShader* SkPictureShader::validInternal(const SkBitmap& device, const SkPaint& paint,
                                          const SkMatrix& matrix, SkMatrix* totalInverse) const {
     if (!this->INHERITED::validContext(device, paint, matrix, totalInverse)) {
         return NULL;
     }
 
-    SkAutoTUnref<SkShader> bitmapShader(this->refBitmapShader(matrix));
-    if (!bitmapShader || !bitmapShader->validContext(device, paint, matrix)) {
+    SkShader* bitmapShader = this->buildBitmapShader(matrix);
+    if (!bitmapShader) {
         return NULL;
     }
 
-    return bitmapShader.detach();
+    if (!bitmapShader->validContext(device, paint, matrix)) {
+        bitmapShader->unref();
+        return NULL;
+    }
+
+    return bitmapShader;
 }
 
 bool SkPictureShader::validContext(const SkBitmap& device, const SkPaint& paint,
                                    const SkMatrix& matrix, SkMatrix* totalInverse) const {
     SkAutoTUnref<SkShader> shader(this->validInternal(device, paint, matrix, totalInverse));
     return shader != NULL;
 }
 
 SkShader::Context* SkPictureShader::createContext(const SkBitmap& device, const SkPaint& paint,
                                                   const SkMatrix& matrix, void* storage) const {
-    SkAutoTUnref<SkShader> bitmapShader(this->validInternal(device, paint, matrix, NULL));
+    SkShader* bitmapShader = this->validInternal(device, paint, matrix, NULL);
     if (!bitmapShader) {
         return NULL;
     }
 
     return SkNEW_PLACEMENT_ARGS(storage, PictureShaderContext,
-                                (*this, device, paint, matrix, bitmapShader.detach()));
+                                (*this, device, paint, matrix, bitmapShader));
 }
 
 size_t SkPictureShader::contextSize() const {
     return sizeof(PictureShaderContext);
 }
 
 SkPictureShader::PictureShaderContext::PictureShaderContext(
         const SkPictureShader& shader, const SkBitmap& device,
         const SkPaint& paint, const SkMatrix& matrix, SkShader* bitmapShader)
     : INHERITED(shader, device, paint, matrix)
@@ skipping 40 matching lines @@
                  fPicture ? fPicture->height() : 0);
 
     str->appendf("(%s, %s)", gTileModeName[fTmx], gTileModeName[fTmy]);
 
     this->INHERITED::toString(str);
 }
 #endif
 
 #if SK_SUPPORT_GPU
 GrEffectRef* SkPictureShader::asNewEffect(GrContext* context, const SkPaint& paint) const {
-    SkAutoTUnref<SkShader> bitmapShader(this->refBitmapShader(context->getMatrix()));
+    SkAutoTUnref<SkShader> bitmapShader(this->buildBitmapShader(context->getMatrix()));
     if (!bitmapShader) {
         return NULL;
     }
     return bitmapShader->asNewEffect(context, paint);
 }
 #endif