Split out methods in GrGpuResource::CacheAccess that can be called outside of the cache.

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"
 
 #include "GrAARectRenderer.h"
 #include "GrBufferAllocPool.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrFontCache.h"
 #include "GrGpuResource.h"
-#include "GrGpuResourceCacheAccess.h"
+#include "GrGpuResourcePriv.h"
 #include "GrDistanceFieldTextContext.h"
 #include "GrDrawTargetCaps.h"
 #include "GrGpu.h"
 #include "GrIndexBuffer.h"
 #include "GrInOrderDrawBuffer.h"
 #include "GrLayerCache.h"
 #include "GrOvalRenderer.h"
 #include "GrPathRenderer.h"
 #include "GrPathUtils.h"
 #include "GrResourceCache.h"
@@ skipping 215 matching lines @@
         !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();
+                    texture->resourcePriv().makeUnbudgeted();
                 }
                 return texture;
             }
             texture->unref();
         }
     }
     return fGpu->createTexture(desc, budgeted, srcData, rowBytes);
 }
 
 GrTexture* GrContext::refScratchTexture(const GrSurfaceDesc& desc, ScratchTexMatch match,
@@ skipping 65 matching lines @@
             } else {
                 break;
             }
 
         } while (true);
 
         desc.writable()->fFlags = origFlags;
     }
 
     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;
+        return fGpu->createTexture(*desc, true, NULL, 0);
     }
 
     return NULL;
 }
 
 void GrContext::OverBudgetCB(void* data) {
     SkASSERT(data);
 
     GrContext* context = reinterpret_cast<GrContext*>(data);
 
@@ skipping 1221 matching lines @@
 
 void GrContext::setResourceCacheLimits(int maxTextures, size_t maxTextureBytes) {
     fResourceCache->setLimits(maxTextures, maxTextureBytes);
 }
 
 bool GrContext::addResourceToCache(const GrContentKey& key, GrGpuResource* resource) {
     ASSERT_OWNED_RESOURCE(resource);
     if (!resource || resource->wasDestroyed()) {
         return false;
     }
-    return resource->cacheAccess().setContentKey(key);
+    return resource->resourcePriv().setContentKey(key);
 }
 
 bool GrContext::isResourceInCache(const GrContentKey& key) const {
     return fResourceCache->hasContentKey(key);
 }
 
 GrGpuResource* GrContext::findAndRefCachedResource(const GrContentKey& key) {
     return fResourceCache->findAndRefContentResource(key);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::addGpuTraceMarker(const GrGpuTraceMarker* marker) {
     fGpu->addGpuTraceMarker(marker);
     if (fDrawBuffer) {
         fDrawBuffer->addGpuTraceMarker(marker);
     }
 }
 
 void GrContext::removeGpuTraceMarker(const GrGpuTraceMarker* marker) {
     fGpu->removeGpuTraceMarker(marker);
     if (fDrawBuffer) {
         fDrawBuffer->removeGpuTraceMarker(marker);
     }
 }