Revert of 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)) {}
-
-protected:
-    virtual bool onGetInfo(SkImageInfo *info) SK_OVERRIDE {
-        *info = fRasterTileInfo;
-        return true;
-    }
-
-    virtual Result onGetPixels(const SkImageInfo& info, void *pixels, size_t rowBytes,
-                             SkPMColor ctable[], int *ctableCount) SK_OVERRIDE {
-        if (info != fRasterTileInfo || SkToBool(ctable) || SkToBool(ctableCount)) {
-            return kInvalidConversion;
-        }
-
-        SkSize tileScale = SkSize::Make(SkIntToScalar(info.width()) / fPictureTile.width(),
-                                        SkIntToScalar(info.height()) / fPictureTile.height());
-        SkBitmap tileBitmap;
-        if (!tileBitmap.installPixels(info, pixels, rowBytes)) {
-            return kInvalidParameters;
-        }
-        tileBitmap.eraseColor(SK_ColorTRANSPARENT);
-
-        // Always disable LCD text, since we can't assume our image will be opaque.
-        SkCanvas tileCanvas(tileBitmap, SkSurfaceProps(0, kUnknown_SkPixelGeometry));
-        tileCanvas.scale(tileScale.width(), tileScale.height());
-        tileCanvas.translate(-fPictureTile.x(), -fPictureTile.y());
-        tileCanvas.drawPicture(fPicture);
-
-        return kSuccess;
-    }
-
-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 39 matching lines @@
     size_t bytesUsed() const SK_OVERRIDE {
         return sizeof(fKey) + sizeof(SkShader) + fBitmapBytes;
     }
 
     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()));
 
-        // The bitmap shader is backed by an image generator, thus it can always re-generate its
-        // pixels if discarded.
-        return true;
+        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;
     }
 };
 
+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;
-        if (!SkInstallDiscardablePixelRef(SkNEW_ARGS(PictureImageGenerator,
-                                                     (fPicture, fTile, tileSize)), &bm)) {
+        bm.setInfo(SkImageInfo::MakeN32Premul(tileSize));
+        if (!cache_try_alloc_pixels(&bm)) {
             return NULL;
         }
+        bm.eraseColor(SK_ColorTRANSPARENT);
+
+        // Always disable LCD text, since we can't assume our image will be opaque.
+        SkCanvas canvas(bm, SkSurfaceProps(0, kUnknown_SkPixelGeometry));
+
+        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->cullRect().fLeft,
-                 fPicture->cullRect().fTop,
-                 fPicture->cullRect().fRight,
-                 fPicture->cullRect().fBottom);
+                 fPicture ? fPicture->cullRect().fLeft : 0,
+                 fPicture ? fPicture->cullRect().fTop : 0,
+                 fPicture ? fPicture->cullRect().fRight : 0,
+                 fPicture ? fPicture->cullRect().fBottom : 0);
 
     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