Update SkSpecialImage to be able to create tight SkImages and SkSurfaces

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"
@@ skipping 17 matching lines @@
 
     virtual bool onPeekPixels(SkPixmap*) const { return false; }
 
     virtual GrTexture* onPeekTexture() const { return nullptr; }
 
     virtual bool testingOnlyOnGetROPixels(SkBitmap*) 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<SkSpecialImage> onMakeSubset(const SkIRect& subset) const = 0;
+    virtual sk_sp<SkImage> onMakeTightSubset(const SkIRect& subset) const = 0;
+
+    virtual SkSurface* onMakeTightSurface(const SkImageInfo& info) const = 0;
 
 private:
     typedef SkSpecialImage INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 static inline const SkSpecialImage_Base* as_SIB(const SkSpecialImage* image) {
     return static_cast<const SkSpecialImage_Base*>(image);
 }
 
@@ skipping 42 matching lines @@
 }
 
 bool SkSpecialImage::testingOnlyGetROPixels(SkBitmap* result) const {
     return as_SIB(this)->testingOnlyOnGetROPixels(result);
 }
 
 sk_sp<SkSpecialSurface> SkSpecialImage::makeSurface(const SkImageInfo& info) const {
     return as_SIB(this)->onMakeSurface(info);
 }
 
+sk_sp<SkSurface> SkSpecialImage::makeTightSurface(const SkImageInfo& info) const {
+    sk_sp<SkSurface> tmp(SkRef(as_SIB(this)->onMakeTightSurface(info)));
+    return tmp;
+}
+
 sk_sp<SkSpecialImage> SkSpecialImage::makeSubset(const SkIRect& subset) const {
     return as_SIB(this)->onMakeSubset(subset);
 }
 
+sk_sp<SkImage> SkSpecialImage::makeTightSubset(const SkIRect& subset) const {
+    return as_SIB(this)->onMakeTightSubset(subset);
+}
+
 #if SK_SUPPORT_GPU
 #include "SkGr.h"
 #include "SkGrPixelRef.h"
 #endif
 
 sk_sp<SkSpecialImage> SkSpecialImage::internal_fromBM(SkImageFilter::Proxy* proxy,
                                                        const SkBitmap& src) {
     // Need to test offset case! (see skbug.com/4967)
     if (src.getTexture()) {
         return SkSpecialImage::MakeFromGpu(proxy,
@@ skipping 103 matching lines @@
         sk_sp<SkImage> subsetImg(fImage->makeSubset(subset));
         if (!subsetImg) {
             return nullptr;
         }
 
         return SkSpecialImage::MakeFromImage(this->internal_getProxy(),
                                              SkIRect::MakeWH(subset.width(), subset.height()),
                                              subsetImg);
     }
 
+    sk_sp<SkImage> onMakeTightSubset(const SkIRect& subset) const override {
+        return fImage->makeSubset(subset);
+    }
+
+    SkSurface* onMakeTightSurface(const SkImageInfo& info) const override {
+#if SK_SUPPORT_GPU
+        GrTexture* texture = as_IB(fImage.get())->peekTexture();
+        if (texture) {
+            return SkSurface::NewRenderTarget(texture->getContext(), SkBudgeted::kYes, info, 0);
+        }
+#endif
+        return SkSurface::NewRaster(info, nullptr);
+    }
+
 private:
     sk_sp<SkImage> fImage;
 
     typedef SkSpecialImage_Base INHERITED;
 };
 
 #ifdef SK_DEBUG
 static bool rect_fits(const SkIRect& rect, int width, int height) {
     if (0 == width && 0 == height) {
         SkASSERT(0 == rect.fLeft && 0 == rect.fRight && 0 == rect.fTop && 0 == rect.fBottom);
@@ skipping 85 matching lines @@
         
         if (!fBitmap.extractSubset(&subsetBM, subset)) {
             return nullptr;
         }
 
         return SkSpecialImage::MakeFromRaster(this->internal_getProxy(),
                                               SkIRect::MakeWH(subset.width(), subset.height()),
                                               subsetBM);
     }
 
+    sk_sp<SkImage> onMakeTightSubset(const SkIRect& subset) const override {
+        SkBitmap subsetBM;
+
+        if (!fBitmap.extractSubset(&subsetBM, subset)) {
+            return nullptr;
+        }
+
+        return SkImage::MakeFromBitmap(subsetBM);
+    }
+
+    SkSurface* onMakeTightSurface(const SkImageInfo& info) const override {
+        return SkSurface::NewRaster(info);
+    }
+
 private:
     SkBitmap fBitmap;
 
     typedef SkSpecialImage_Base INHERITED;
 };
 
 sk_sp<SkSpecialImage> SkSpecialImage::MakeFromRaster(SkImageFilter::Proxy* proxy,
                                                      const SkIRect& subset,
                                                      const SkBitmap& bm) {
     SkASSERT(nullptr == bm.getTexture());
@@ skipping 11 matching lines @@
         return nullptr;
     }
 
     return sk_make_sp<SkSpecialImage_Raster>(proxy, subset, src, releaseProc, context);
 }
 
 
 #if SK_SUPPORT_GPU
 ///////////////////////////////////////////////////////////////////////////////
 #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)
         : INHERITED(proxy, subset, uniqueID)
         , fTexture(SkRef(tex))
         , fAlphaType(at) {
     }
 
@@ skipping 62 matching lines @@
     }
 
     sk_sp<SkSpecialImage> onMakeSubset(const SkIRect& subset) const override {
         return SkSpecialImage::MakeFromGpu(this->internal_getProxy(),
                                            subset,
                                            this->uniqueID(),
                                            fTexture, 
                                            fAlphaType);
     }
 
+    sk_sp<SkImage> onMakeTightSubset(const SkIRect& subset) const override {
+        if (0 == subset.fLeft && 0 == subset.fTop &&
+            fTexture->width() == subset.width() &&
+            fTexture->height() == subset.height()) {
+            // The existing GrTexture is already tight so reuse it in the SkImage
+            return sk_make_sp<SkImage_Gpu>(fTexture->width(), fTexture->height(),
+                                           kNeedNewImageUniqueID,
+                                           fAlphaType, fTexture, SkBudgeted::kYes);
+        }
+
+        GrContext* ctx = fTexture->getContext();
+        GrSurfaceDesc desc = fTexture->desc();
+        desc.fWidth = subset.width();
+        desc.fHeight = subset.height();
+
+        GrTexture* subTx = ctx->textureProvider()->createTexture(desc, SkBudgeted::kYes);
+        if (!subTx) {
+            return nullptr;
+        }
+        ctx->copySurface(subTx, fTexture, subset, SkIPoint::Make(0, 0));
+        return sk_make_sp<SkImage_Gpu>(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID,
+                                       fAlphaType, subTx, SkBudgeted::kYes);
+    }
+
+    SkSurface* onMakeTightSurface(const SkImageInfo& info) const override {
+        return SkSurface::NewRenderTarget(fTexture->getContext(), SkBudgeted::kYes, info);
+    }
+
 private:
     SkAutoTUnref<GrTexture> fTexture;
     const SkAlphaType       fAlphaType;
 
     typedef SkSpecialImage_Base INHERITED;
 };
 
 sk_sp<SkSpecialImage> SkSpecialImage::MakeFromGpu(SkImageFilter::Proxy* proxy,
                                                   const SkIRect& subset, 
                                                   uint32_t uniqueID,
                                                   GrTexture* tex,
                                                   SkAlphaType at) {
     SkASSERT(rect_fits(subset, tex->width(), tex->height()));
     return sk_make_sp<SkSpecialImage_Gpu>(proxy, subset, uniqueID, tex, at);
 }
 
 #else
 
 sk_sp<SkSpecialImage> SkSpecialImage::MakeFromGpu(SkImageFilter::Proxy* proxy,
                                                   const SkIRect& subset,
                                                   uint32_t uniqueID,
                                                   GrTexture* tex,
                                                   SkAlphaType at) {
     return nullptr;
 }
 
 #endif