Add GrTextureRenderTargetProxy and support switching between RT & Tex Proxies

GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=4427

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

3 files changed, 163 insertions, 9 deletions

diff --git a/tests/ProxyConversionTest.cpp b/tests/ProxyConversionTest.cpp
new file mode 100644
index 0000000000..8a799f7859
--- /dev/null
+++ b/tests/ProxyConversionTest.cpp
@@ -0,0 +1,158 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// This is a GPU-backend specific test.
+
+#include "Test.h"
+
+#if SK_SUPPORT_GPU
+#include "GrSurfaceProxy.h"
+#include "GrTextureProxy.h"
+#include "GrRenderTargetProxy.h"
+
+static sk_sp<GrRenderTargetProxy> make_wrapped_FBO0(GrTextureProvider* provider,
+                                                    skiatest::Reporter* reporter,
+                                                    const GrSurfaceDesc& desc) {
+    GrBackendRenderTargetDesc backendDesc;
+    backendDesc.fWidth = desc.fWidth;
+    backendDesc.fHeight = desc.fHeight;
+    backendDesc.fConfig = desc.fConfig;
+    backendDesc.fOrigin = desc.fOrigin;
+    backendDesc.fSampleCnt = desc.fSampleCnt;
+    backendDesc.fStencilBits = 8;
+    backendDesc.fRenderTargetHandle = 0;
+
+    sk_sp<GrRenderTarget> defaultFBO(provider->wrapBackendRenderTarget(backendDesc));
+    SkASSERT(!defaultFBO->asTexture());
+
+    return GrRenderTargetProxy::Make(std::move(defaultFBO));
+}
+
+static sk_sp<GrRenderTargetProxy> make_wrapped_offscreen_rt(GrTextureProvider* provider, 
+                                                            skiatest::Reporter* reporter,
+                                                            const GrSurfaceDesc& desc,
+                                                            SkBudgeted budgeted) {
+    SkASSERT(kRenderTarget_GrSurfaceFlag == desc.fFlags);
+
+    sk_sp<GrTexture> tex(provider->createTexture(desc, budgeted));
+    sk_sp<GrRenderTarget> rt(sk_ref_sp(tex->asRenderTarget()));
+
+    return GrRenderTargetProxy::Make(std::move(rt));
+}
+
+static sk_sp<GrTextureProxy> make_wrapped_texture(GrTextureProvider* provider, 
+                                                  const GrSurfaceDesc& desc,
+                                                  SkBudgeted budgeted) {
+    sk_sp<GrTexture> tex(provider->createTexture(desc, budgeted));
+
+    return GrTextureProxy::Make(std::move(tex));
+}
+
+// Test converting between RenderTargetProxies and TextureProxies for wrapped
+// Proxies
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WrappedProxyConversionTest, reporter, ctxInfo) {
+    GrTextureProvider* provider = ctxInfo.grContext()->textureProvider();
+
+    GrSurfaceDesc desc;
+    desc.fFlags = kRenderTarget_GrSurfaceFlag;
+    desc.fWidth = 64;
+    desc.fHeight = 64;
+    desc.fConfig = kRGBA_8888_GrPixelConfig;
+
+    if (kOpenGL_GrBackend == ctxInfo.backend()) {
+        // External on-screen render target.
+        sk_sp<GrRenderTargetProxy> rtProxy(make_wrapped_FBO0(provider, reporter, desc));
+
+        // RenderTarget-only
+        REPORTER_ASSERT(reporter, !rtProxy->asTextureProxy());
+        REPORTER_ASSERT(reporter, rtProxy->asRenderTargetProxy() == rtProxy.get());
+    }
+
+    {
+        // Internal offscreen render target.
+        sk_sp<GrRenderTargetProxy> rtProxy(make_wrapped_offscreen_rt(provider,
+                                                                     reporter, desc,
+                                                                     SkBudgeted::kYes));
+
+        // Both RenderTarget and Texture
+        GrTextureProxy* tProxy = rtProxy->asTextureProxy();
+        REPORTER_ASSERT(reporter, tProxy);
+        REPORTER_ASSERT(reporter, tProxy->asRenderTargetProxy() == rtProxy.get());
+        REPORTER_ASSERT(reporter, rtProxy->asRenderTargetProxy() == rtProxy.get());
+    }
+
+    {
+        // Internal offscreen render target - but through GrTextureProxy
+        sk_sp<GrTextureProxy> tProxy(make_wrapped_texture(provider,  desc, SkBudgeted::kYes));
+
+        // Both RenderTarget and Texture
+        GrRenderTargetProxy* rtProxy = tProxy->asRenderTargetProxy();
+        REPORTER_ASSERT(reporter, rtProxy);
+        REPORTER_ASSERT(reporter, rtProxy->asTextureProxy() == tProxy.get());
+        REPORTER_ASSERT(reporter, tProxy->asTextureProxy() == tProxy.get());        
+    }
+
+    {
+        desc.fFlags = kNone_GrSurfaceFlags; // force no-RT
+
+        sk_sp<GrTextureProxy> tProxy(make_wrapped_texture(provider,  desc, SkBudgeted::kYes));
+
+        // Texture-only
+        REPORTER_ASSERT(reporter, tProxy->asTextureProxy() == tProxy.get());
+        REPORTER_ASSERT(reporter, !tProxy->asRenderTargetProxy());
+    }
+}
+
+// Test converting between RenderTargetProxies and TextureProxies for deferred
+// Proxies
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DefferredProxyConversionTest, reporter, ctxInfo) {
+    GrTextureProvider* provider = ctxInfo.grContext()->textureProvider();
+    const GrCaps& caps = *ctxInfo.grContext()->caps();
+
+    GrSurfaceDesc desc;
+    desc.fFlags = kRenderTarget_GrSurfaceFlag;
+    desc.fWidth = 64;
+    desc.fHeight = 64;
+    desc.fConfig = kRGBA_8888_GrPixelConfig;
+
+    {
+        sk_sp<GrRenderTargetProxy> rtProxy(GrRenderTargetProxy::Make(caps, desc,
+                                                                     SkBackingFit::kApprox,
+                                                                     SkBudgeted::kYes));
+
+        // Both RenderTarget and Texture
+        GrTextureProxy* tProxy = rtProxy->asTextureProxy();
+        REPORTER_ASSERT(reporter, tProxy);
+        REPORTER_ASSERT(reporter, tProxy->asRenderTargetProxy() == rtProxy.get());
+        REPORTER_ASSERT(reporter, rtProxy->asRenderTargetProxy() == rtProxy.get());
+    }
+    
+    {
+        sk_sp<GrTextureProxy> tProxy(GrTextureProxy::Make(caps, provider, desc,
+                                                          SkBackingFit::kApprox,
+                                                          SkBudgeted::kYes));
+
+        // Both RenderTarget and Texture - but via GrTextureProxy
+        GrRenderTargetProxy* rtProxy = tProxy->asRenderTargetProxy();
+        REPORTER_ASSERT(reporter, rtProxy);
+        REPORTER_ASSERT(reporter, rtProxy->asTextureProxy() == tProxy.get());
+        REPORTER_ASSERT(reporter, tProxy->asTextureProxy() == tProxy.get());
+    }
+
+    {
+        desc.fFlags = kNone_GrSurfaceFlags; // force no-RT
+
+        sk_sp<GrTextureProxy> tProxy(GrTextureProxy::Make(caps, provider, desc,
+                                                          SkBackingFit::kApprox,
+                                                          SkBudgeted::kYes));
+
+        // Texture-only
+        REPORTER_ASSERT(reporter, tProxy->asTextureProxy() == tProxy.get());
+        REPORTER_ASSERT(reporter, !tProxy->asRenderTargetProxy());
+    }
+}
+#endif
diff --git a/tests/ProxyTest.cpp b/tests/ProxyTest.cpp
index 6b7ab25a3f..270f7873ab 100644
--- a/tests/ProxyTest.cpp
+++ b/tests/ProxyTest.cpp
@@ -40,9 +40,6 @@ static void check_rendertarget(skiatest::Reporter* reporter,
                                SkBackingFit fit) {
     REPORTER_ASSERT(reporter, rtProxy->numStencilSamples() == numSamples);
 
-    REPORTER_ASSERT(reporter, rtProxy->asTextureProxy() == nullptr); // for now
-    REPORTER_ASSERT(reporter, rtProxy->asRenderTargetProxy() == rtProxy);
-
     GrRenderTarget* rt = rtProxy->instantiate(provider);
     REPORTER_ASSERT(reporter, rt);
 
@@ -69,9 +66,6 @@ static void check_texture(skiatest::Reporter* reporter,
                           GrTextureProvider* provider,
                           GrTextureProxy* texProxy,
                           SkBackingFit fit) {
-    REPORTER_ASSERT(reporter, texProxy->asTextureProxy() == texProxy);
-    REPORTER_ASSERT(reporter, texProxy->asRenderTargetProxy() == nullptr); // for now
-
     GrTexture* tex = texProxy->instantiate(provider);
     REPORTER_ASSERT(reporter, tex);
 
@@ -102,6 +96,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) {
                                   numSamples <= ctxInfo.grContext()->caps()->maxColorSampleCount();
 
                             GrSurfaceDesc desc;
+                            desc.fFlags = kRenderTarget_GrSurfaceFlag;
                             desc.fOrigin = origin;
                             desc.fWidth = widthHeight;
                             desc.fHeight = widthHeight;
@@ -119,9 +114,10 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredProxyTest, reporter, ctxInfo) {
                                                    numSamples, fit);
                             }
 
+                            desc.fFlags = kNone_GrSurfaceFlags;
                             desc.fSampleCnt = 0;
 
-                            sk_sp<GrTextureProxy> texProxy(GrTextureProxy::Make(provider,
+                            sk_sp<GrTextureProxy> texProxy(GrTextureProxy::Make(caps, provider,
                                                                                 desc,
                                                                                 fit,
                                                                                 budgeted));
diff --git a/tests/SpecialImageTest.cpp b/tests/SpecialImageTest.cpp
index 23e8d5b7e3..abadb303cb 100644
--- a/tests/SpecialImageTest.cpp
+++ b/tests/SpecialImageTest.cpp
@@ -301,8 +301,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_DeferredGpu, reporter, ctxInfo)
     desc.fWidth  = kFullSize;
     desc.fHeight = kFullSize;
 
-    sk_sp<GrTextureProxy> proxy(GrTextureProxy::Make(context->textureProvider(), desc,
-                                                     SkBackingFit::kExact, SkBudgeted::kNo,
+    sk_sp<GrTextureProxy> proxy(GrTextureProxy::Make(*context->caps(), context->textureProvider(),
+                                                     desc, SkBackingFit::kExact, SkBudgeted::kNo,
                                                      bm.getPixels(), 0));
     if (!proxy) {
         return;