Remove SkDEPRECATED_InstallDiscardablePixelRef from SkPictureShader

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"
 #include "SkBitmapProcShader.h"
 #include "SkCanvas.h"
+#include "SkImage.h"
 #include "SkImageGenerator.h"
 #include "SkMatrixUtils.h"
 #include "SkPicture.h"
 #include "SkReadBuffer.h"
 #include "SkResourceCache.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrCaps.h"
 #endif
@@ skipping 187 matching lines @@
     BitmapShaderKey key(fPicture->uniqueID(),
                         fTile,
                         fTmx,
                         fTmy,
                         tileScale,
                         this->getLocalMatrix());
 
     if (!SkResourceCache::Find(key, BitmapShaderRec::Visitor, &tileShader)) {
         SkMatrix tileMatrix;
         tileMatrix.setRectToRect(fTile, SkRect::MakeIWH(tileSize.width(), tileSize.height()),
-                             SkMatrix::kFill_ScaleToFit);
-        SkBitmap bm;
-        if (!SkDEPRECATED_InstallDiscardablePixelRef(
-            SkImageGenerator::NewFromPicture(tileSize, fPicture, &tileMatrix, nullptr), &bm)) {
+                                 SkMatrix::kFill_ScaleToFit);
+
+        SkAutoTDelete<SkImageGenerator> tileGenerator(
+            SkImageGenerator::NewFromPicture(tileSize, fPicture, &tileMatrix, nullptr));
+        if (!tileGenerator) {
+            return nullptr;
+        }
+
+        // Grab this before the generator goes poof!
+        const SkImageInfo tileInfo = tileGenerator->getInfo();

[reed1, 2015/10/16 14:12:19]

Can we replace these to New calls with just

    static SkImage* NewFromPicture(const SkPicture*, const SkISize& dimensions,
                                   const SkMatrix*, const SkPaint*);

+
+        SkAutoTUnref<SkImage> tileImage(SkImage::NewFromGenerator(tileGenerator.detach()));
+        if (!tileImage) {
             return nullptr;
         }
 
         SkMatrix shaderMatrix = this->getLocalMatrix();
         shaderMatrix.preScale(1 / tileScale.width(), 1 / tileScale.height());
-        tileShader.reset(CreateBitmapShader(bm, fTmx, fTmy, &shaderMatrix));
+        tileShader.reset(tileImage->newShader(fTmx, fTmy, &shaderMatrix));
 
-        SkResourceCache::Add(new BitmapShaderRec(key, tileShader.get(), bm.getSize()));
+        SkResourceCache::Add(new BitmapShaderRec(key, tileShader.get(),
+                                                 tileInfo.getSafeSize(tileInfo.minRowBytes())));
     }
 
     return tileShader.detach();
 }
 
 size_t SkPictureShader::contextSize() const {
     return sizeof(PictureShaderContext);
 }
 
 SkShader::Context* SkPictureShader::onCreateContext(const ContextRec& rec, void* storage) const {
@@ skipping 81 matching lines @@
     if (context) {
         maxTextureSize = context->caps()->maxTextureSize();
     }
     SkAutoTUnref<SkShader> bitmapShader(this->refBitmapShader(viewM, localMatrix, maxTextureSize));
     if (!bitmapShader) {
         return nullptr;
     }
     return bitmapShader->asFragmentProcessor(context, viewM, nullptr, fq);
 }
 #endif