Cache render targets that render to wrapped textures

src/gpu/gl/GrGLGpu.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLGpu.h"
 #include "GrGLBuffer.h"
 #include "GrGLGLSL.h"
@@ skipping 680 matching lines @@
     desc.fConfig = wrapDesc.fConfig;
     desc.fFlags = kCheckAllocation_GrSurfaceFlag | kRenderTarget_GrSurfaceFlag;
     desc.fWidth = wrapDesc.fWidth;
     desc.fHeight = wrapDesc.fHeight;
     desc.fSampleCnt = SkTMin(wrapDesc.fSampleCnt, this->caps()->maxSampleCount());
     desc.fOrigin = resolve_origin(wrapDesc.fOrigin, true);
 
     return GrGLRenderTarget::CreateWrapped(this, desc, idDesc, wrapDesc.fStencilBits);
 }
 
-GrRenderTarget* GrGLGpu::onWrapBackendTextureAsRenderTarget(const GrBackendTextureDesc& desc) {
+static bool backend_texture_to_tex_info(const GrBackendTextureDesc& desc,
+                                        GrGLTextureInfo* outInfo) {
 #ifdef SK_IGNORE_GL_TEXTURE_TARGET
     if (!desc.fTextureHandle) {
-        return nullptr;
+        return false;
     }
 #else
     const GrGLTextureInfo* info = reinterpret_cast<const GrGLTextureInfo*>(desc.fTextureHandle);
     if (!info || !info->fID) {
-        return nullptr;
+        return false;
     }
 #endif
-
     GrGLTextureInfo texInfo;
-    GrSurfaceDesc surfDesc;
-
 #ifdef SK_IGNORE_GL_TEXTURE_TARGET
     texInfo.fID = static_cast<GrGLuint>(desc.fTextureHandle);
     // We only support GL_TEXTURE_2D at the moment.
     texInfo.fTarget = GR_GL_TEXTURE_2D;
 #else
     texInfo = *info;
 #endif
 
     if (GR_GL_TEXTURE_RECTANGLE != texInfo.fTarget &&
         GR_GL_TEXTURE_2D != texInfo.fTarget) {
         // Only texture rectangle and texture 2d are supported. We do not check whether texture
         // rectangle is supported by Skia - if the caller provided us with a texture rectangle,
         // we assume the necessary support exists.
+        return false;
+    }
+    *outInfo = texInfo;
+    return true;
+}
+
+static void compute_backend_texture_key_for_wrap_as_render_target(const GrBackendTextureDesc& desc,
+                                                              GrUniqueKey* key) {
+    GrGLTextureInfo texInfo;
+    if (!backend_texture_to_tex_info(desc, &texInfo)) {
+        return;
+    }
+    static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
+    GrUniqueKey::Builder builder(key, kDomain, 3);
+    builder[0] = desc.fWidth;
+    builder[1] = desc.fHeight;
+    builder[2] = desc.fConfig | (desc.fFlags << 5) | (desc.fSampleCnt << 6) | (desc.fOrigin << 14)
+            | ((texInfo.fTarget == GR_GL_TEXTURE_2D) << 16);
+    builder.finish();
+}
+
+void GrGLGpu::onComputeBackendTextureKeyForWrapAsRenderTarget(const GrBackendTextureDesc& desc,
+                                                              GrUniqueKey* key) {
+    compute_backend_texture_key_for_wrap_as_render_target(desc, key);
+}
+
+bool GrGLGpu::onRewrapRenderTargetWithBackendTexture(const GrBackendTextureDesc& desc,
+                                                     GrRenderTarget* rt) {
+    GrGLTextureInfo texInfo;
+    SkAssertResult(backend_texture_to_tex_info(desc, &texInfo));
+
+
+    GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(rt);
+    SkASSERT(glRT);
+    fStats.incRenderTargetBinds();
+    GL_CALL(BindFramebuffer(GR_GL_FRAMEBUFFER, glRT->textureFBOID()));
+    if (this->glCaps().usesImplicitMSAAResolve() && desc.fSampleCnt > 0) {
+        GL_CALL(FramebufferTexture2DMultisample(GR_GL_FRAMEBUFFER,
+                                                GR_GL_COLOR_ATTACHMENT0,
+                                                texInfo.fTarget,
+                                                texInfo.fID, 0, desc.fSampleCnt));
+    } else {
+        GL_CALL(FramebufferTexture2D(GR_GL_FRAMEBUFFER,
+                                     GR_GL_COLOR_ATTACHMENT0,
+                                     texInfo.fTarget,
+                                     texInfo.fID, 0));
+    }
+    return true;
+}
+
+GrRenderTarget* GrGLGpu::onWrapBackendTextureAsRenderTarget(const GrBackendTextureDesc& desc) {
+    GrGLTextureInfo texInfo;
+    if (!backend_texture_to_tex_info(desc, &texInfo)) {
         return nullptr;
     }
 
+    GrSurfaceDesc surfDesc;
     surfDesc.fFlags = (GrSurfaceFlags) desc.fFlags;
     surfDesc.fWidth = desc.fWidth;
     surfDesc.fHeight = desc.fHeight;
     surfDesc.fConfig = desc.fConfig;
     surfDesc.fSampleCnt = SkTMin(desc.fSampleCnt, this->caps()->maxSampleCount());
     // FIXME:  this should be calling resolve_origin(), but Chrome code is currently
     // assuming the old behaviour, which is that backend textures are always
     // BottomLeft, even for non-RT's.  Once Chrome is fixed, change this to:
     // glTexDesc.fOrigin = resolve_origin(desc.fOrigin, renderTarget);
     if (kDefault_GrSurfaceOrigin == desc.fOrigin) {
         surfDesc.fOrigin = kBottomLeft_GrSurfaceOrigin;
     } else {
         surfDesc.fOrigin = desc.fOrigin;
     }
 
     GrGLRenderTarget::IDDesc rtIDDesc;
     if (!this->createRenderTargetObjects(surfDesc, texInfo, &rtIDDesc)) {
         return nullptr;
     }
-    return GrGLRenderTarget::CreateWrapped(this, surfDesc, rtIDDesc, 0);
+    GrGLRenderTarget* rt = GrGLRenderTarget::CreateWrapped(this, surfDesc, rtIDDesc, 0);
+    GrUniqueKey key;
+    compute_backend_texture_key_for_wrap_as_render_target(desc, &key);
+    rt->resourcePriv().setUniqueKey(key);
+    return rt;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrGLGpu::onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
                                    GrPixelConfig srcConfig,
                                    DrawPreference* drawPreference,
                                    WritePixelTempDrawInfo* tempDrawInfo) {
     if (kIndex_8_GrPixelConfig == srcConfig || GrPixelConfigIsCompressed(dstSurface->config())) {
         return false;
@@ skipping 3492 matching lines @@
         if (GR_GL_TEXTURE_EXTERNAL == glTexture->target() ||
             GR_GL_TEXTURE_RECTANGLE == glTexture->target()) {
             copyParams->fFilter = GrTextureParams::kNone_FilterMode;
             copyParams->fWidth = texture->width();
             copyParams->fHeight = texture->height();
             return true;
         }
     }
     return false;
 }