Remove createUncachedTexture function, attempt to recycle scratch in createTexture.

src/gpu/GrContext.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"
 
@@ skipping 204 matching lines @@
                                             bool enableDistanceFieldFonts) {
     if (fGpu->caps()->pathRenderingSupport() && renderTarget->getStencilBuffer() && 
                                                 renderTarget->isMultisampled()) {
         return GrStencilAndCoverTextContext::Create(this, leakyProperties);
     } 
 
     return GrDistanceFieldTextContext::Create(this, leakyProperties, enableDistanceFieldFonts);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+enum ScratchTextureFlags {
+    kExact_ScratchTextureFlag           = 0x1,
+    kNoPendingIO_ScratchTextureFlag     = 0x2,
+    kNoCreate_ScratchTextureFlag        = 0x4,
+};
 
 bool GrContext::isConfigTexturable(GrPixelConfig config) const {
     return fGpu->caps()->isConfigTexturable(config);
 }
 
 bool GrContext::npotTextureTileSupport() const {
     return fGpu->caps()->npotTextureTileSupport();
 }
 
-GrTexture* GrContext::createTexture(const GrSurfaceDesc& desc, const void* srcData,
+GrTexture* GrContext::createTexture(const GrSurfaceDesc& desc, bool budgeted, const void* srcData,
                                     size_t rowBytes) {
-    return fGpu->createTexture(desc, true, srcData, rowBytes);
+    if ((desc.fFlags & kRenderTarget_GrSurfaceFlag) &&
+        !this->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
+        return NULL;
+    }
+    if (!GrPixelConfigIsCompressed(desc.fConfig)) {
+        static const uint32_t kFlags = kExact_ScratchTextureFlag |
+                                       kNoCreate_ScratchTextureFlag;
+        if (GrTexture* texture = this->internalRefScratchTexture(desc, kFlags)) {
+            if (!srcData || texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
+                                                 srcData, rowBytes)) {
+                if (!budgeted) {
+                    texture->cacheAccess().makeUnbudgeted();
+                }
+                return texture;
+            }
+            texture->unref();
+        }
+    }
+    return fGpu->createTexture(desc, budgeted, srcData, rowBytes);
 }
 
-GrTexture* GrContext::refScratchTexture(const GrSurfaceDesc& inDesc, ScratchTexMatch match,
+GrTexture* GrContext::refScratchTexture(const GrSurfaceDesc& desc, ScratchTexMatch match,
                                         bool calledDuringFlush) {
     // Currently we don't recycle compressed textures as scratch.
-    if (GrPixelConfigIsCompressed(inDesc.fConfig)) {
+    if (GrPixelConfigIsCompressed(desc.fConfig)) {
         return NULL;
+    } else {
+        uint32_t flags = 0;
+        if (kExact_ScratchTexMatch == match) {
+            flags |= kExact_ScratchTextureFlag;
+        }
+        if (calledDuringFlush) {
+            flags |= kNoPendingIO_ScratchTextureFlag;
+        }
+        return this->internalRefScratchTexture(desc, flags);
     }
+}
 
+GrTexture* GrContext::internalRefScratchTexture(const GrSurfaceDesc& inDesc, uint32_t flags) {
+    SkASSERT(!GrPixelConfigIsCompressed(inDesc.fConfig));
     // kNoStencil has no meaning if kRT isn't set.
     SkASSERT((inDesc.fFlags & kRenderTarget_GrSurfaceFlag) ||
              !(inDesc.fFlags & kNoStencil_GrSurfaceFlag));
 
-    // Make sure caller has checked for renderability if kRT is set.
-    SkASSERT(!(inDesc.fFlags & kRenderTarget_GrSurfaceFlag) ||
-             this->isConfigRenderable(inDesc.fConfig, inDesc.fSampleCnt > 0));
-
     SkTCopyOnFirstWrite<GrSurfaceDesc> desc(inDesc);
 
     if (fGpu->caps()->reuseScratchTextures() || (desc->fFlags & kRenderTarget_GrSurfaceFlag)) {
         GrSurfaceFlags origFlags = desc->fFlags;
-        if (kApprox_ScratchTexMatch == match) {
+        if (!(kExact_ScratchTextureFlag & flags)) {
             // bin by pow2 with a reasonable min
             static const int MIN_SIZE = 16;
             GrSurfaceDesc* wdesc = desc.writable();
             wdesc->fWidth  = SkTMax(MIN_SIZE, GrNextPow2(desc->fWidth));
             wdesc->fHeight = SkTMax(MIN_SIZE, GrNextPow2(desc->fHeight));
         }
 
         do {
             GrScratchKey key;
             GrTexturePriv::ComputeScratchKey(*desc, &key);
             uint32_t scratchFlags = 0;
-            if (calledDuringFlush) {
+            if (kNoPendingIO_ScratchTextureFlag & flags) {
                 scratchFlags = GrResourceCache2::kRequireNoPendingIO_ScratchFlag;
             } else  if (!(desc->fFlags & kRenderTarget_GrSurfaceFlag)) {
                 // If it is not a render target then it will most likely be populated by
                 // writePixels() which will trigger a flush if the texture has pending IO.
                 scratchFlags = GrResourceCache2::kPreferNoPendingIO_ScratchFlag;
             }
             GrGpuResource* resource = fResourceCache2->findAndRefScratchResource(key, scratchFlags);
             if (resource) {
                 GrSurface* surface = static_cast<GrSurface*>(resource);
                 GrRenderTarget* rt = surface->asRenderTarget();
                 if (rt && fGpu->caps()->discardRenderTargetSupport()) {
                     rt->discard();
                 }
                 return surface->asTexture();
             }
 
-            if (kExact_ScratchTexMatch == match) {
+            if (kExact_ScratchTextureFlag & flags) {
                 break;
             }
             // We had a cache miss and we are in approx mode, relax the fit of the flags.
 
             // We no longer try to reuse textures that were previously used as render targets in
             // situations where no RT is needed; doing otherwise can confuse the video driver and
             // cause significant performance problems in some cases.
             if (desc->fFlags & kNoStencil_GrSurfaceFlag) {
                 desc.writable()->fFlags = desc->fFlags & ~kNoStencil_GrSurfaceFlag;
             } else {
                 break;
             }
 
         } while (true);
 
         desc.writable()->fFlags = origFlags;
     }
 
-    GrTexture* texture = fGpu->createTexture(*desc, true, NULL, 0);
-#ifdef SK_DEBUG
-    if (fGpu->caps()->reuseScratchTextures() || (desc->fFlags & kRenderTarget_GrSurfaceFlag)) {
-        GrScratchKey key;
-        GrTexturePriv::ComputeScratchKey(*desc, &key);
-        SkASSERT(NULL == texture || texture->cacheAccess().getScratchKey() == key);
+    if (!(kNoCreate_ScratchTextureFlag & flags)) {
+        GrTexture* texture = fGpu->createTexture(*desc, true, NULL, 0);
+    #ifdef SK_DEBUG
+        if (fGpu->caps()->reuseScratchTextures() || (desc->fFlags & kRenderTarget_GrSurfaceFlag)) {
+            GrScratchKey key;
+            GrTexturePriv::ComputeScratchKey(*desc, &key);
+            SkASSERT(NULL == texture || texture->cacheAccess().getScratchKey() == key);
+        }
+    #endif
+        return texture;
     }
-#endif
-    return texture;
+
+    return NULL;
 }
 
 void GrContext::OverBudgetCB(void* data) {
     SkASSERT(data);
 
     GrContext* context = reinterpret_cast<GrContext*>(data);
 
     // Flush the InOrderDrawBuffer to possibly free up some textures
     context->fFlushToReduceCacheSize = true;
 }
 
-GrTexture* GrContext::createUncachedTexture(const GrSurfaceDesc& desc,
-                                            void* srcData,
-                                            size_t rowBytes) {
-    return fGpu->createTexture(desc, false, srcData, rowBytes);
-}
-
 int GrContext::getMaxTextureSize() const {
     return SkTMin(fGpu->caps()->maxTextureSize(), fMaxTextureSizeOverride);
 }
 
 int GrContext::getMaxRenderTargetSize() const {
     return fGpu->caps()->maxRenderTargetSize();
 }
 
 int GrContext::getMaxSampleCount() const {
     return fGpu->caps()->maxSampleCount();
@@ skipping 1234 matching lines @@
     }
 }
 
 void GrContext::removeGpuTraceMarker(const GrGpuTraceMarker* marker) {
     fGpu->removeGpuTraceMarker(marker);
     if (fDrawBuffer) {
         fDrawBuffer->removeGpuTraceMarker(marker);
     }
 }