Upgrade SkSpecialImage to have getTextureRef & getROPixels entry points

src/core/SkSpecialImage.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file
  */
 #include "SkSpecialImage.h"
 
 #if SK_SUPPORT_GPU
 #include "GrTexture.h"
 #include "GrTextureParams.h"
 #include "SkGr.h"
 #endif
 
+#include "SkBitmapCache.h"
 #include "SkCanvas.h"
 #include "SkImage_Base.h"
 #include "SkSpecialSurface.h"
 #include "SkSurfacePriv.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 class SkSpecialImage_Base : public SkSpecialImage {
 public:
     SkSpecialImage_Base(SkImageFilter::Proxy* proxy, const SkIRect& subset, uint32_t uniqueID,
                         const SkSurfaceProps* props)
         : INHERITED(proxy, subset, uniqueID, props) {
     }
     virtual ~SkSpecialImage_Base() { }
 
     virtual void onDraw(SkCanvas*, SkScalar x, SkScalar y, const SkPaint*) const = 0;
 
-    virtual bool onPeekPixels(SkPixmap*) const { return false; }
+    virtual bool onGetROPixels(SkBitmap*) const = 0;
 
     virtual GrTexture* onPeekTexture() const { return nullptr; }
 
-    virtual bool testingOnlyOnGetROPixels(SkBitmap*) const = 0;
+    virtual GrTexture* onAsTextureRef(GrContext* context) const = 0;
 
     // Delete this entry point ASAP (see skbug.com/4965)
     virtual bool getBitmapDeprecated(SkBitmap* result) const = 0;
 
     virtual sk_sp<SkSpecialImage> onMakeSubset(const SkIRect& subset) const = 0;
 
     virtual sk_sp<SkSpecialSurface> onMakeSurface(const SkImageInfo& info) const = 0;
 
     virtual sk_sp<SkImage> onMakeTightSubset(const SkIRect& subset) const = 0;
 
@@ skipping 17 matching lines @@
     , fUniqueID(kNeedNewImageUniqueID_SpecialImage == uniqueID ? SkNextID::ImageID() : uniqueID)
     , fProxy(proxy) {
 }
 
 sk_sp<SkSpecialImage> SkSpecialImage::makeTextureImage(SkImageFilter::Proxy* proxy,
                                                        GrContext* context) {
 #if SK_SUPPORT_GPU
     if (!context) {
         return nullptr;
     }
-    if (GrTexture* peek = as_SIB(this)->peekTexture()) {
+    if (GrTexture* peek = as_SIB(this)->onPeekTexture()) {
         return peek->getContext() == context ? sk_sp<SkSpecialImage>(SkRef(this)) : nullptr;
     }
 
     SkBitmap bmp;
     if (!this->internal_getBM(&bmp)) {
         return nullptr;
     }
 
     if (bmp.empty()) {
         return SkSpecialImage::MakeFromRaster(proxy, SkIRect::MakeEmpty(), bmp, &this->props());
@@ skipping 13 matching lines @@
                                        resultTex, &this->props(), at);
 #else
     return nullptr;
 #endif
 }
 
 void SkSpecialImage::draw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const {
     return as_SIB(this)->onDraw(canvas, x, y, paint);
 }
 
-bool SkSpecialImage::peekPixels(SkPixmap* pixmap) const {
-    return as_SIB(this)->onPeekPixels(pixmap);
+bool SkSpecialImage::getROPixels(SkBitmap* bm) const {
+    return as_SIB(this)->onGetROPixels(bm);
 }
 
-GrTexture* SkSpecialImage::peekTexture() const {
-    return as_SIB(this)->onPeekTexture();
+bool SkSpecialImage::isTextureBacked() const {
+#if SK_SUPPORT_GPU
+    return as_SIB(this)->onPeekTexture() && as_SIB(this)->onPeekTexture()->getContext();
+#else
+    return false;
+#endif
 }
 
-bool SkSpecialImage::testingOnlyGetROPixels(SkBitmap* result) const {
-    return as_SIB(this)->testingOnlyOnGetROPixels(result);
+GrContext* SkSpecialImage::getContext() const {
+#if SK_SUPPORT_GPU
+    GrTexture* texture = as_SIB(this)->onPeekTexture();
+    
+    if (texture) {
+        return texture->getContext();
+    }
+#endif
+    return nullptr;
+}
+
+
+GrTexture* SkSpecialImage::asTextureRef(GrContext* context) const {
+    return as_SIB(this)->onAsTextureRef(context);
 }
 
 sk_sp<SkSpecialSurface> SkSpecialImage::makeSurface(const SkImageInfo& info) const {
     return as_SIB(this)->onMakeSurface(info);
 }
 
 sk_sp<SkSurface> SkSpecialImage::makeTightSurface(const SkImageInfo& info) const {
     return as_SIB(this)->onMakeTightSurface(info);
 }
 
@@ skipping 72 matching lines @@
         return 0;
     }
 
     void onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const override {
         SkRect dst = SkRect::MakeXYWH(x, y, this->subset().width(), this->subset().height());
 
         canvas->drawImageRect(fImage.get(), this->subset(),
                               dst, paint, SkCanvas::kStrict_SrcRectConstraint);
     }
 
-    bool onPeekPixels(SkPixmap* pixmap) const override {
-        return fImage->peekPixels(pixmap);
+    bool onGetROPixels(SkBitmap* bm) const override {
+        return as_IB(fImage)->getROPixels(bm);
     }
 
-    GrTexture* onPeekTexture() const override { return as_IB(fImage.get())->peekTexture(); }
+    GrTexture* onPeekTexture() const override { return as_IB(fImage)->peekTexture(); }
+
+    GrTexture* onAsTextureRef(GrContext* context) const override {
+#if SK_SUPPORT_GPU
+        return as_IB(fImage)->asTextureRef(context, GrTextureParams::ClampNoFilter());
+#else
+        return nullptr;
+#endif
+    }
 
     bool getBitmapDeprecated(SkBitmap* result) const override {
 #if SK_SUPPORT_GPU
         if (GrTexture* texture = as_IB(fImage.get())->peekTexture()) {
             const SkImageInfo info = GrMakeInfoFromTexture(texture,
                                                            fImage->width(), fImage->height(),
                                                            fImage->isOpaque());
             if (!result->setInfo(info)) {
                 return false;
             }
 
             result->setPixelRef(new SkGrPixelRef(info, texture))->unref();
             return true;
         }
 #endif
 
         return as_IB(fImage.get())->asBitmapForImageFilters(result);
     }
 
-    bool testingOnlyOnGetROPixels(SkBitmap* result) const override {
-        return fImage->asLegacyBitmap(result, SkImage::kRO_LegacyBitmapMode);
-    }
-
     sk_sp<SkSpecialSurface> onMakeSurface(const SkImageInfo& info) const override {
 #if SK_SUPPORT_GPU
         GrTexture* texture = as_IB(fImage.get())->peekTexture();
         if (texture) {
             GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(info, *texture->getContext()->caps());
             desc.fFlags = kRenderTarget_GrSurfaceFlag;
 
             return SkSpecialSurface::MakeRenderTarget(this->proxy(), texture->getContext(), desc);
         }
 #endif
@@ skipping 92 matching lines @@
     size_t getSize() const override { return fBitmap.getSize(); }
 
     void onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const override {
         SkRect dst = SkRect::MakeXYWH(x, y,
                                       this->subset().width(), this->subset().height());
 
         canvas->drawBitmapRect(fBitmap, this->subset(),
                                dst, paint, SkCanvas::kStrict_SrcRectConstraint);
     }
 
-    bool onPeekPixels(SkPixmap* pixmap) const override {
-        const SkImageInfo info = fBitmap.info();
+    bool onGetROPixels(SkBitmap* bm) const override {
+        *bm = fBitmap;
+        return true;
+    }
 
-        if (kUnknown_SkColorType == info.colorType()) {
-            return false;
+    GrTexture* onAsTextureRef(GrContext* context) const override {
+#if SK_SUPPORT_GPU
+        if (context) {
+            return GrRefCachedBitmapTexture(context, fBitmap, GrTextureParams::ClampNoFilter());
         }
+#endif
 
-        if (!fBitmap.peekPixels(pixmap)) {
-            fBitmap.lockPixels();
-        }
-
-        return fBitmap.peekPixels(pixmap);
+        return nullptr;
     }
 
     bool getBitmapDeprecated(SkBitmap* result) const override {
         *result = fBitmap;
         return true;
     }
 
-    bool testingOnlyOnGetROPixels(SkBitmap* result) const override {
-        *result = fBitmap;
-        return true;
-    }
-
     sk_sp<SkSpecialSurface> onMakeSurface(const SkImageInfo& info) const override {
         return SkSpecialSurface::MakeRaster(this->proxy(), info, nullptr);
     }
 
     sk_sp<SkSpecialImage> onMakeSubset(const SkIRect& subset) const override {
         SkBitmap subsetBM;
 
         if (!fBitmap.extractSubset(&subsetBM, subset)) {
             return nullptr;
         }
@@ skipping 53 matching lines @@
 #include "GrTexture.h"
 #include "SkImage_Gpu.h"
 
 class SkSpecialImage_Gpu : public SkSpecialImage_Base {
 public:
     SkSpecialImage_Gpu(SkImageFilter::Proxy* proxy, const SkIRect& subset,
                        uint32_t uniqueID, GrTexture* tex, SkAlphaType at,
                        const SkSurfaceProps* props)
         : INHERITED(proxy, subset, uniqueID, props)
         , fTexture(SkRef(tex))
-        , fAlphaType(at) {
+        , fAlphaType(at)
+        , fAddedRasterVersionToCache(false) {
     }
 
-    ~SkSpecialImage_Gpu() override { }
+    ~SkSpecialImage_Gpu() override {
+        if (fAddedRasterVersionToCache.load()) {
+            SkNotifyBitmapGenIDIsStale(this->uniqueID());
+        }
+    }
 
     bool isOpaque() const override {
         return GrPixelConfigIsOpaque(fTexture->config()) || fAlphaType == kOpaque_SkAlphaType;
     }
 
     size_t getSize() const override { return fTexture->gpuMemorySize(); }
 
     void onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const override {
         SkRect dst = SkRect::MakeXYWH(x, y,
                                       this->subset().width(), this->subset().height());
 
         SkBitmap bm;
 
         GrWrapTextureInBitmap(fTexture,
                               fTexture->width(), fTexture->height(), this->isOpaque(), &bm);
 
         canvas->drawBitmapRect(bm, this->subset(),
                                dst, paint, SkCanvas::kStrict_SrcRectConstraint);
     }
 
     GrTexture* onPeekTexture() const override { return fTexture; }
 
+    GrTexture* onAsTextureRef(GrContext*) const override { return SkRef(fTexture.get()); }
+
+    bool onGetROPixels(SkBitmap* dst) const override {
+        if (SkBitmapCache::Find(this->uniqueID(), dst)) {
+            SkASSERT(dst->getGenerationID() == this->uniqueID());
+            SkASSERT(dst->isImmutable());
+            SkASSERT(dst->getPixels());
+            return true;
+        }
+
+        SkImageInfo info = SkImageInfo::MakeN32(this->width(), this->height(),
+                                                this->isOpaque() ? kOpaque_SkAlphaType
+                                                                 : kPremul_SkAlphaType);
+
+        if (!dst->tryAllocPixels(info)) {
+            return false;
+        }
+
+        if (!fTexture->readPixels(0, 0, dst->width(), dst->height(), kSkia8888_GrPixelConfig,
+                                  dst->getPixels(), dst->rowBytes())) {
+            return false;
+        }
+
+        dst->pixelRef()->setImmutableWithID(this->uniqueID());
+        SkBitmapCache::Add(this->uniqueID(), *dst);
+        fAddedRasterVersionToCache.store(true);
+        return true;
+    }
+
     bool getBitmapDeprecated(SkBitmap* result) const override {
         const SkImageInfo info = GrMakeInfoFromTexture(fTexture,
                                                        this->width(), this->height(),
                                                        this->isOpaque());
         if (!result->setInfo(info)) {
             return false;
         }
 
         const SkImageInfo prInfo = info.makeWH(fTexture->width(), fTexture->height());
 
         SkAutoTUnref<SkGrPixelRef> pixelRef(new SkGrPixelRef(prInfo, fTexture));
         result->setPixelRef(pixelRef, this->subset().fLeft, this->subset().fTop);
         return true;
     }
 
-    bool testingOnlyOnGetROPixels(SkBitmap* result) const override {
-
-        const SkImageInfo info = SkImageInfo::MakeN32(this->width(),
-                                                      this->height(),
-                                                      this->isOpaque() ? kOpaque_SkAlphaType
-                                                                       : kPremul_SkAlphaType);
-        if (!result->tryAllocPixels(info)) {
-            return false;
-        }
-
-        if (!fTexture->readPixels(0, 0, result->width(), result->height(), kSkia8888_GrPixelConfig,
-                                  result->getPixels(), result->rowBytes())) {
-            return false;
-        }
-
-        result->pixelRef()->setImmutable();
-        return true;
-    }
-
     sk_sp<SkSpecialSurface> onMakeSurface(const SkImageInfo& info) const override {
         if (!fTexture->getContext()) {
             return nullptr;
         }
 
         GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(info, *fTexture->getContext()->caps());
         desc.fFlags = kRenderTarget_GrSurfaceFlag;
 
         return SkSpecialSurface::MakeRenderTarget(this->proxy(), fTexture->getContext(), desc);
     }
@@ skipping 32 matching lines @@
                                        fAlphaType, subTx, SkBudgeted::kYes);
     }
 
     sk_sp<SkSurface> onMakeTightSurface(const SkImageInfo& info) const override {
         return SkSurface::MakeRenderTarget(fTexture->getContext(), SkBudgeted::kYes, info);
     }
 
 private:
     SkAutoTUnref<GrTexture> fTexture;
     const SkAlphaType       fAlphaType;
+    mutable SkAtomic<bool>  fAddedRasterVersionToCache;
 
     typedef SkSpecialImage_Base INHERITED;
 };
 
 sk_sp<SkSpecialImage> SkSpecialImage::MakeFromGpu(SkImageFilter::Proxy* proxy,
                                                   const SkIRect& subset,
                                                   uint32_t uniqueID,
                                                   GrTexture* tex,
                                                   const SkSurfaceProps* props,
                                                   SkAlphaType at) {
     SkASSERT(rect_fits(subset, tex->width(), tex->height()));
     return sk_make_sp<SkSpecialImage_Gpu>(proxy, subset, uniqueID, tex, at, props);
 }
 
 #else
 
 sk_sp<SkSpecialImage> SkSpecialImage::MakeFromGpu(SkImageFilter::Proxy* proxy,
                                                   const SkIRect& subset,
                                                   uint32_t uniqueID,
                                                   GrTexture* tex,
                                                   const SkSurfaceProps* props,
                                                   SkAlphaType at) {
     return nullptr;
 }
 
 #endif