Some cleanup in GrTextureProvider and GrResourceProvider

src/gpu/GrTextureProvider.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTextureProvider.h"
 #include "GrTexturePriv.h"
@@ skipping 11 matching lines @@
     if (this->isAbandoned()) {
         return NULL;
     }
     if ((desc.fFlags & kRenderTarget_GrSurfaceFlag) &&
         !fGpu->caps()->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 (GrTexture* texture = this->refScratchTexture(desc, kFlags)) {
             if (!srcData || texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
                                                  srcData, rowBytes)) {
                 if (!budgeted) {
                     texture->resourcePriv().makeUnbudgeted();
                 }
                 return texture;
             }
             texture->unref();
         }
     }
     return fGpu->createTexture(desc, budgeted, srcData, rowBytes);
 }
 
-GrTexture* GrTextureProvider::refScratchTexture(const GrSurfaceDesc& desc, ScratchTexMatch match,
-                                                bool calledDuringFlush) {
+GrTexture* GrTextureProvider::createApproxTexture(const GrSurfaceDesc& desc) {
+    return this->internalCreateApproxTexture(desc, 0);
+}
+
+GrTexture* GrTextureProvider::internalCreateApproxTexture(const GrSurfaceDesc& desc,
+                                                          uint32_t scratchFlags) {
     if (this->isAbandoned()) {
         return NULL;
     }
     // Currently we don't recycle compressed textures as scratch.
     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);
+        return this->refScratchTexture(desc, scratchFlags);
     }
 }
 
-GrTexture* GrTextureProvider::internalRefScratchTexture(const GrSurfaceDesc& inDesc,
-                                                        uint32_t flags) {
+GrTexture* GrTextureProvider::refScratchTexture(const GrSurfaceDesc& inDesc,
+                                                uint32_t scratchFlags) {
     SkASSERT(!this->isAbandoned());
     SkASSERT(!GrPixelConfigIsCompressed(inDesc.fConfig));
 
     SkTCopyOnFirstWrite<GrSurfaceDesc> desc(inDesc);
 
     if (fGpu->caps()->reuseScratchTextures() || (desc->fFlags & kRenderTarget_GrSurfaceFlag)) {
-        if (!(kExact_ScratchTextureFlag & flags)) {
+        if (!(kExact_ScratchTextureFlag & scratchFlags)) {
             // bin by pow2 with a reasonable min
             const int minSize = SkTMin(16, fGpu->caps()->minTextureSize());
             GrSurfaceDesc* wdesc = desc.writable();
             wdesc->fWidth  = SkTMax(minSize, GrNextPow2(desc->fWidth));
             wdesc->fHeight = SkTMax(minSize, GrNextPow2(desc->fHeight));
         }
 
         GrScratchKey key;
         GrTexturePriv::ComputeScratchKey(*desc, &key);
         uint32_t scratchFlags = 0;
-        if (kNoPendingIO_ScratchTextureFlag & flags) {
+        if (kNoPendingIO_ScratchTextureFlag & scratchFlags) {

[brucedawson, 2015/08/05 17:41:19]

This use of scratchFlags now refers to the local variable declared on the line
above, which is incorrect. The parameter should be renamed, perhaps back to
'flags'.

Currently the 'if' block will always be skipped.

I opened bug https://code.google.com/p/skia/issues/detail?id=4169 to track this.

             scratchFlags = GrResourceCache::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 = GrResourceCache::kPreferNoPendingIO_ScratchFlag;
         }
         GrGpuResource* resource = fCache->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 (!(kNoCreate_ScratchTextureFlag & flags)) {
+    if (!(kNoCreate_ScratchTextureFlag & scratchFlags)) {
         return fGpu->createTexture(*desc, true, NULL, 0);
     }
 
     return NULL;
 }
 
 GrTexture* GrTextureProvider::wrapBackendTexture(const GrBackendTextureDesc& desc,
                                                  GrWrapOwnership ownership) {
     if (this->isAbandoned()) {
         return NULL;
@@ skipping 13 matching lines @@
     resource->resourcePriv().setUniqueKey(key);
 }
 
 bool GrTextureProvider::existsResourceWithUniqueKey(const GrUniqueKey& key) const {
     return this->isAbandoned() ? false : fCache->hasUniqueKey(key);
 }
 
 GrGpuResource* GrTextureProvider::findAndRefResourceByUniqueKey(const GrUniqueKey& key) {
     return this->isAbandoned() ? NULL : fCache->findAndRefUniqueResource(key);
 }