Cache render targets that render to wrapped textures

src/gpu/GrTexture.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 "GrContext.h"
 #include "GrCaps.h"
@@ skipping 33 matching lines @@
     } else {
         textureSize = (size_t) fDesc.fWidth * fDesc.fHeight * GrBytesPerPixel(fDesc.fConfig);
     }
 
     if (this->texturePriv().hasMipMaps()) {
         // We don't have to worry about the mipmaps being a different size than
         // we'd expect because we never change fDesc.fWidth/fHeight.
         textureSize += textureSize/3;
     }
 
-    SkASSERT(!SkToBool(fDesc.fFlags & kRenderTarget_GrSurfaceFlag));
     SkASSERT(textureSize <= WorseCaseSize(fDesc));
 
     return textureSize;
 }
 
 void GrTexture::validateDesc() const {
     if (this->asRenderTarget()) {
         // This texture has a render target
         SkASSERT(0 != (fDesc.fFlags & kRenderTarget_GrSurfaceFlag));
         SkASSERT(fDesc.fSampleCnt == this->asRenderTarget()->numColorSamples());
@@ skipping 15 matching lines @@
     bool renderTarget = 0 != (desc.fFlags & kRenderTarget_GrSurfaceFlag);
     if (kDefault_GrSurfaceOrigin == desc.fOrigin) {
         return renderTarget ? kBottomLeft_GrSurfaceOrigin : kTopLeft_GrSurfaceOrigin;
     } else {
         return desc.fOrigin;
     }
 }
 }
 
 //////////////////////////////////////////////////////////////////////////////
-GrTexture::GrTexture(GrGpu* gpu, LifeCycle lifeCycle, const GrSurfaceDesc& desc,
+GrTexture::GrTexture(GrGpu* gpu, SkBudgeted budgeted, const GrSurfaceDesc& desc,
                      GrSLType samplerType, bool wasMipMapDataProvided)
-    : INHERITED(gpu, lifeCycle, desc)
+    : INHERITED(gpu, budgeted, desc)
     , fSamplerType(samplerType) {
-    if (!this->isExternal() && !GrPixelConfigIsCompressed(desc.fConfig) &&
-        !desc.fTextureStorageAllocator.fAllocateTextureStorage) {
-        GrScratchKey key;
-        GrTexturePriv::ComputeScratchKey(desc, &key);
-        this->setScratchKey(key);
-    }
-
     if (wasMipMapDataProvided) {
         fMipMapsStatus = kValid_MipMapsStatus;
         fMaxMipMapLevel = SkMipMap::ComputeLevelCount(fDesc.fWidth, fDesc.fHeight);
     } else {
         fMipMapsStatus = kNotAllocated_MipMapsStatus;
         fMaxMipMapLevel = 0;
     }
 }
 
+void GrTexture::initScratchKeyIfNeeded() {
+    if (!this->refsWrappedResources() && !GrPixelConfigIsCompressed(fDesc.fConfig) &&
+        !fDesc.fTextureStorageAllocator.fAllocateTextureStorage) {
+        GrScratchKey key;
+        GrTexturePriv::ComputeScratchKey(fDesc, &key);
+        this->setScratchKey(key);
+    }
+}
+
 void GrTexturePriv::ComputeScratchKey(const GrSurfaceDesc& desc, GrScratchKey* key) {
     static const GrScratchKey::ResourceType kType = GrScratchKey::GenerateResourceType();
 
     GrSurfaceOrigin origin = resolve_origin(desc);
     uint32_t flags = desc.fFlags & ~kCheckAllocation_GrSurfaceFlag;
 
     // make sure desc.fConfig fits in 5 bits
     SkASSERT(sk_float_log2(kLast_GrPixelConfig) <= 5);
     SkASSERT(static_cast<int>(desc.fConfig) < (1 << 5));
     SkASSERT(desc.fSampleCnt < (1 << 8));
     SkASSERT(flags < (1 << 10));
     SkASSERT(static_cast<int>(origin) < (1 << 8));
 
     GrScratchKey::Builder builder(key, kType, 3);
     builder[0] = desc.fWidth;
     builder[1] = desc.fHeight;
     builder[2] = desc.fConfig | (desc.fIsMipMapped << 5) | (desc.fSampleCnt << 6) | (flags << 14)
                  | (origin << 24);
 }