Use an image generator to back SkPictureShader tiles.

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 "SkImageGenerator.h"
 #include "SkMatrixUtils.h"
 #include "SkPicture.h"
 #include "SkReadBuffer.h"
 #include "SkResourceCache.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #endif
 
 namespace {
 static unsigned gBitmapSkaderKeyNamespaceLabel;
 
+class PictureImageGenerator : public SkImageGenerator {
+public:
+    PictureImageGenerator(const SkPicture* picture,
+                          const SkRect& pictureTile,
+                          const SkISize& tileSize)
+        : fPicture(SkRef(picture))
+        , fPictureTile(pictureTile)
+        , fRasterTileInfo(SkImageInfo::MakeN32Premul(tileSize)) {}
+
+    virtual ~PictureImageGenerator() {}
+
+protected:
+    virtual bool onGetInfo(SkImageInfo *info) SK_OVERRIDE {
+        *info = fRasterTileInfo;
+        return true;
+    }
+
+    virtual bool onGetPixels(const SkImageInfo& info, void *pixels, size_t rowBytes,
+                             SkPMColor ctable[], int *ctableCount) SK_OVERRIDE {
+        if (info != fRasterTileInfo || SkToBool(ctable) || SkToBool(ctableCount)) {
+            return false;
+        }
+
+        SkSize tileScale = SkSize::Make(SkIntToScalar(info.width()) / fPictureTile.width(),
+                                        SkIntToScalar(info.height()) / fPictureTile.height());
+        SkBitmap tileBitmap;
+        if (!tileBitmap.installPixels(info, pixels, rowBytes)) {
+            return false;
+        }
+        tileBitmap.eraseColor(SK_ColorTRANSPARENT);
+
+        SkCanvas tileCanvas(tileBitmap);
+        tileCanvas.scale(tileScale.width(), tileScale.height());
+        tileCanvas.translate(-fPictureTile.x(), -fPictureTile.y());
+        tileCanvas.drawPicture(fPicture);
+
+        return true;
+    }
+
+private:
+    SkAutoTUnref<const SkPicture> fPicture;
+    const SkRect                  fPictureTile;
+    const SkImageInfo             fRasterTileInfo;
+};
+
 struct BitmapShaderKey : public SkResourceCache::Key {
 public:
     BitmapShaderKey(uint32_t pictureID,
                     const SkRect& tile,
                     SkShader::TileMode tmx,
                     SkShader::TileMode tmy,
                     const SkSize& scale,
                     const SkMatrix& localMatrix)
         : fPictureID(pictureID)
         , fTile(tile)
@@ skipping 30 matching lines @@
         : fKey(key)
         , fShader(SkRef(tileShader))
         , fBitmapBytes(bitmapBytes) {}
 
     BitmapShaderKey        fKey;
     SkAutoTUnref<SkShader> fShader;
     size_t                 fBitmapBytes;
 
     const Key& getKey() const SK_OVERRIDE { return fKey; }
     size_t bytesUsed() const SK_OVERRIDE {
         return sizeof(fKey) + sizeof(SkShader) + fBitmapBytes;

[f(malita), 2015/01/22 15:46:00]

Is this a lie now? Since we use discardable pixel refs, accounting for that
memory here doesn't feel quite right.

     }
 
     static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextShader) {
         const BitmapShaderRec& rec = static_cast<const BitmapShaderRec&>(baseRec);
         SkAutoTUnref<SkShader>* result = reinterpret_cast<SkAutoTUnref<SkShader>*>(contextShader);
 
         result->reset(SkRef(rec.fShader.get()));
 
-        SkBitmap tile;
-        rec.fShader.get()->asABitmap(&tile, NULL, NULL);
-        // FIXME: this doesn't protect the pixels from being discarded as soon as we unlock.
-        // Should be handled via a pixel ref generator instead
-        // (https://code.google.com/p/skia/issues/detail?id=3220).
-        SkAutoLockPixels alp(tile, true);
-        return tile.getPixels() != NULL;
+        // The bitmap shader is backed by an image generator, thus it can always re-generate its
+        // pixels if discarded.
+        return true;
     }
 };
 
-static bool cache_try_alloc_pixels(SkBitmap* bitmap) {
-    SkBitmap::Allocator* allocator = SkResourceCache::GetAllocator();
-
-    return NULL != allocator
-        ? allocator->allocPixelRef(bitmap, NULL)
-        : bitmap->tryAllocPixels();
-}
-
 } // namespace
 
 SkPictureShader::SkPictureShader(const SkPicture* picture, TileMode tmx, TileMode tmy,
                                  const SkMatrix* localMatrix, const SkRect* tile)
     : INHERITED(localMatrix)
     , fPicture(SkRef(picture))
     , fTile(tile ? *tile : picture->cullRect())
     , fTmx(tmx)
     , fTmy(tmy) {
 }
 
-SkPictureShader::~SkPictureShader() {
-    fPicture->unref();
-}
-
 SkPictureShader* SkPictureShader::Create(const SkPicture* picture, TileMode tmx, TileMode tmy,
                                          const SkMatrix* localMatrix, const SkRect* tile) {
     if (!picture || picture->cullRect().isEmpty() || (tile && tile->isEmpty())) {
         return NULL;
     }
     return SkNEW_ARGS(SkPictureShader, (picture, tmx, tmy, localMatrix, tile));
 }
 
 SkFlattenable* SkPictureShader::CreateProc(SkReadBuffer& buffer) {
     SkMatrix lm;
@@ skipping 54 matching lines @@
     SkAutoTUnref<SkShader> tileShader;
     BitmapShaderKey key(fPicture->uniqueID(),
                         fTile,
                         fTmx,
                         fTmy,
                         tileScale,
                         this->getLocalMatrix());
 
     if (!SkResourceCache::Find(key, BitmapShaderRec::Visitor, &tileShader)) {
         SkBitmap bm;
-        bm.setInfo(SkImageInfo::MakeN32Premul(tileSize));
-        if (!cache_try_alloc_pixels(&bm)) {
+        if (!SkInstallDiscardablePixelRef(SkNEW_ARGS(PictureImageGenerator,
+                                                     (fPicture, fTile, tileSize)), &bm)) {
             return NULL;
         }
-        bm.eraseColor(SK_ColorTRANSPARENT);
-
-        SkCanvas canvas(bm);
-        canvas.scale(tileScale.width(), tileScale.height());
-        canvas.translate(-fTile.x(), -fTile.y());
-        canvas.drawPicture(fPicture);
 
         SkMatrix shaderMatrix = this->getLocalMatrix();
         shaderMatrix.preScale(1 / tileScale.width(), 1 / tileScale.height());
         tileShader.reset(CreateBitmapShader(bm, fTmx, fTmy, &shaderMatrix));
 
         SkResourceCache::Add(SkNEW_ARGS(BitmapShaderRec, (key, tileShader.get(), bm.getSize())));
     }
 
     return tileShader.detach();
 }
@@ skipping 60 matching lines @@
     fBitmapShaderContext->shadeSpan16(x, y, dstC, count);
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkPictureShader::toString(SkString* str) const {
     static const char* gTileModeName[SkShader::kTileModeCount] = {
         "clamp", "repeat", "mirror"
     };
 
     str->appendf("PictureShader: [%f:%f:%f:%f] ",
-                 fPicture ? fPicture->cullRect().fLeft : 0,
-                 fPicture ? fPicture->cullRect().fTop : 0,
-                 fPicture ? fPicture->cullRect().fRight : 0,
-                 fPicture ? fPicture->cullRect().fBottom : 0);
+                 fPicture->cullRect().fLeft,
+                 fPicture->cullRect().fTop,
+                 fPicture->cullRect().fRight,
+                 fPicture->cullRect().fBottom);
 
     str->appendf("(%s, %s)", gTileModeName[fTmx], gTileModeName[fTmy]);
 
     this->INHERITED::toString(str);
 }
 #endif
 
 #if SK_SUPPORT_GPU
 bool SkPictureShader::asFragmentProcessor(GrContext* context, const SkPaint& paint,
                                           const SkMatrix& viewM, const SkMatrix* localMatrix,
                                           GrColor* paintColor,
                                           GrFragmentProcessor** fp) const {
     SkAutoTUnref<SkShader> bitmapShader(this->refBitmapShader(viewM, localMatrix));
     if (!bitmapShader) {
         return false;
     }
     return bitmapShader->asFragmentProcessor(context, paint, viewM, NULL, paintColor, fp);
 }
 #else
 bool SkPictureShader::asFragmentProcessor(GrContext*, const SkPaint&, const SkMatrix&,
                                           const SkMatrix*, GrColor*,
                                           GrFragmentProcessor**) const {
     SkDEBUGFAIL("Should not call in GPU-less build");
     return false;
 }
 #endif