Remove SkSpecialImage's GrTexture-based ctors

Change-Id: Id71b8ab0477cd1d459089d97af27d63f9f08d21b
Reviewed-on: https://skia-review.googlesource.com/7889
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Robert Phillips <robertphillips@google.com>

2 files changed, 54 insertions, 33 deletions

diff --git a/tests/ImageFilterCacheTest.cpp b/tests/ImageFilterCacheTest.cpp
index 393269adf6..d2d543c1f9 100644
--- a/tests/ImageFilterCacheTest.cpp
+++ b/tests/ImageFilterCacheTest.cpp
@@ -192,6 +192,24 @@ static GrTexture* create_texture(GrContext* context) {
     return context->textureProvider()->createTexture(desc, SkBudgeted::kNo, srcBM.getPixels(), 0);
 }
 
+static sk_sp<GrTextureProxy> create_proxy(GrContext* context) {
+    SkBitmap srcBM = create_bm();
+
+    GrSurfaceDesc desc;
+    desc.fConfig = kRGBA_8888_GrPixelConfig;
+    desc.fFlags  = kNone_GrSurfaceFlags;
+    desc.fWidth  = kFullSize;
+    desc.fHeight = kFullSize;
+
+    sk_sp<GrSurfaceProxy> proxy = GrSurfaceProxy::MakeDeferred(*context->caps(),
+                                                               context->textureProvider(),
+                                                               desc, SkBudgeted::kYes,
+                                                               srcBM.getPixels(),
+                                                               srcBM.rowBytes());
+    return sk_ref_sp(proxy->asTextureProxy());
+}
+
+
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, ctxInfo) {
     sk_sp<GrTexture> srcTexture(create_texture(ctxInfo.grContext()));
     if (!srcTexture) {
@@ -234,23 +252,26 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, ct
 }
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_GPUBacked, reporter, ctxInfo) {
+    GrContext* context = ctxInfo.grContext();
 
-    sk_sp<GrTexture> srcTexture(create_texture(ctxInfo.grContext()));
-    if (!srcTexture) {
+    sk_sp<GrTextureProxy> srcProxy(create_proxy(context));
+    if (!srcProxy) {
         return;
     }
 
     const SkIRect& full = SkIRect::MakeWH(kFullSize, kFullSize);
 
-    sk_sp<SkSpecialImage> fullImg(SkSpecialImage::MakeFromGpu(full,
+    sk_sp<SkSpecialImage> fullImg(SkSpecialImage::MakeDeferredFromGpu(
+                                                              context, full,
                                                               kNeedNewImageUniqueID_SpecialImage,
-                                                              srcTexture, nullptr));
+                                                              srcProxy, nullptr));
 
     const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
 
-    sk_sp<SkSpecialImage> subsetImg(SkSpecialImage::MakeFromGpu(subset,
+    sk_sp<SkSpecialImage> subsetImg(SkSpecialImage::MakeDeferredFromGpu(
+                                                                context, subset,
                                                                 kNeedNewImageUniqueID_SpecialImage,
-                                                                srcTexture, nullptr));
+                                                                srcProxy, nullptr));
 
     test_find_existing(reporter, fullImg, subsetImg);
     test_dont_find_if_diff_key(reporter, fullImg, subsetImg);
diff --git a/tests/SpecialImageTest.cpp b/tests/SpecialImageTest.cpp
index 80cacde960..77015c4aa2 100644
--- a/tests/SpecialImageTest.cpp
+++ b/tests/SpecialImageTest.cpp
@@ -18,6 +18,7 @@
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrSurfaceProxy.h"
+#include "SkGrPriv.h"
 #endif
 
 
@@ -60,7 +61,7 @@ static void test_image(const sk_sp<SkSpecialImage>& img, skiatest::Reporter* rep
     REPORTER_ASSERT(reporter, kSmallerSize == subset.height());
 
     //--------------
-    // Test that peekTexture reports the correct backing type
+    // Test that isTextureBacked reports the correct backing type
     REPORTER_ASSERT(reporter, isGPUBacked == img->isTextureBacked());
 
 #if SK_SUPPORT_GPU
@@ -230,25 +231,23 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_MakeTexture, reporter, ctxInfo)
 
     {
         // gpu
-        GrSurfaceDesc desc;
-        desc.fConfig = kSkia8888_GrPixelConfig;
-        desc.fFlags = kNone_GrSurfaceFlags;
-        desc.fWidth = kFullSize;
-        desc.fHeight = kFullSize;
-
-        sk_sp<GrTexture> texture(context->textureProvider()->createTexture(desc,
-                                                                           SkBudgeted::kNo,
-                                                                           bm.getPixels(),
-                                                                           0));
-        if (!texture) {
+        const GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bm.info(), *context->caps());
+
+        sk_sp<GrSurfaceProxy> proxy(GrSurfaceProxy::MakeDeferred(*context->caps(),
+                                                                 context->textureProvider(),
+                                                                 desc, SkBudgeted::kNo,
+                                                                 bm.getPixels(), bm.rowBytes()));
+        if (!proxy || !proxy->asTextureProxy()) {
             return;
         }
 
-        sk_sp<SkSpecialImage> gpuImage(SkSpecialImage::MakeFromGpu(
+        sk_sp<SkSpecialImage> gpuImage(SkSpecialImage::MakeDeferredFromGpu(
+                                                                context,
                                                                 SkIRect::MakeWH(kFullSize,
                                                                                 kFullSize),
                                                                 kNeedNewImageUniqueID_SpecialImage,
-                                                                std::move(texture), nullptr));
+                                                                sk_ref_sp(proxy->asTextureProxy()),
+                                                                nullptr));
 
         {
             sk_sp<SkSpecialImage> fromGPU(gpuImage->makeTextureImage(context));
@@ -268,31 +267,32 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_Gpu, reporter, ctxInfo) {
     GrContext* context = ctxInfo.grContext();
     SkBitmap bm = create_bm();
 
-    GrSurfaceDesc desc;
-    desc.fConfig = kSkia8888_GrPixelConfig;
-    desc.fFlags  = kNone_GrSurfaceFlags;
-    desc.fWidth  = kFullSize;
-    desc.fHeight = kFullSize;
+    const GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bm.info(), *context->caps());
 
-    sk_sp<GrTexture> texture(context->textureProvider()->createTexture(desc,
-                                                                       SkBudgeted::kNo,
-                                                                       bm.getPixels(), 0));
-    if (!texture) {
+    sk_sp<GrSurfaceProxy> proxy(GrSurfaceProxy::MakeDeferred(*context->caps(),
+                                                             context->textureProvider(),
+                                                             desc, SkBudgeted::kNo,
+                                                             bm.getPixels(), bm.rowBytes()));
+    if (!proxy || !proxy->asTextureProxy()) {
         return;
     }
 
-    sk_sp<SkSpecialImage> fullSImg(SkSpecialImage::MakeFromGpu(
+    sk_sp<SkSpecialImage> fullSImg(SkSpecialImage::MakeDeferredFromGpu(
+                                                            context,
                                                             SkIRect::MakeWH(kFullSize, kFullSize),
                                                             kNeedNewImageUniqueID_SpecialImage,
-                                                            texture, nullptr));
+                                                            sk_ref_sp(proxy->asTextureProxy()),
+                                                            nullptr));
 
     const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
 
     {
-        sk_sp<SkSpecialImage> subSImg1(SkSpecialImage::MakeFromGpu(
+        sk_sp<SkSpecialImage> subSImg1(SkSpecialImage::MakeDeferredFromGpu(
+                                                               context,
                                                                subset,
                                                                kNeedNewImageUniqueID_SpecialImage,
-                                                               texture, nullptr));
+                                                               sk_ref_sp(proxy->asTextureProxy()),
+                                                               nullptr));
         test_image(subSImg1, reporter, context, true, kPad, kFullSize);
     }