1 /* 2 * Copyright 2015 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef GrGpuResourcePriv_DEFINED 9 #define GrGpuResourcePriv_DEFINED 10 11 #include "GrGpuResource.h" 12 13 /** 14 * This class allows code internal to Skia privileged access to manage the cache keys and budget 15 * status of a GrGpuResource object. 16 */ 17 class GrGpuResource::ResourcePriv { 18 public: SkDEBUGCODE(bool hasPendingIO_debugOnly ()const{ return fResource->internalHasPendingIO(); })19 SkDEBUGCODE(bool hasPendingIO_debugOnly() const { return fResource->internalHasPendingIO(); }) 20 21 /** 22 * Sets a unique key for the resource. If the resource was previously cached as scratch it will 23 * be converted to a uniquely-keyed resource. If the key is invalid then this is equivalent to 24 * removeUniqueKey(). If another resource is using the key then its unique key is removed and 25 * this resource takes over the key. 26 */ 27 void setUniqueKey(const GrUniqueKey& key) { fResource->setUniqueKey(key); } 28 29 /** Removes the unique key from a resource. If the resource has a scratch key, it may be 30 preserved for recycling as scratch. */ removeUniqueKey()31 void removeUniqueKey() { fResource->removeUniqueKey(); } 32 33 /** 34 * If the resource is uncached make it cached. Has no effect on resources that are wrapped or 35 * already cached. 36 */ makeBudgeted()37 void makeBudgeted() { fResource->makeBudgeted(); } 38 39 /** 40 * If the resource is cached make it uncached. Has no effect on resources that are wrapped or 41 * already uncached. Furthermore, resources with unique keys cannot be made unbudgeted. 42 */ makeUnbudgeted()43 void makeUnbudgeted() { fResource->makeUnbudgeted(); } 44 45 /** 46 * Get the resource's budgeted-type which indicates whether it counts against the resource cache 47 * budget and if not whether it is allowed to be cached. 48 */ budgetedType()49 GrBudgetedType budgetedType() const { 50 SkASSERT(GrBudgetedType::kBudgeted == fResource->fBudgetedType || 51 !fResource->getUniqueKey().isValid() || fResource->fRefsWrappedObjects); 52 return fResource->fBudgetedType; 53 } 54 55 /** 56 * Is the resource object wrapping an externally allocated GPU resource? 57 */ refsWrappedObjects()58 bool refsWrappedObjects() const { return fResource->fRefsWrappedObjects; } 59 60 /** 61 * If this resource can be used as a scratch resource this returns a valid scratch key. 62 * Otherwise it returns a key for which isNullScratch is true. The resource may currently be 63 * used as a uniquely keyed resource rather than scratch. Check isScratch(). 64 */ getScratchKey()65 const GrScratchKey& getScratchKey() const { return fResource->fScratchKey; } 66 67 /** 68 * If the resource has a scratch key, the key will be removed. Since scratch keys are installed 69 * at resource creation time, this means the resource will never again be used as scratch. 70 */ removeScratchKey()71 void removeScratchKey() const { fResource->removeScratchKey(); } 72 isPurgeable()73 bool isPurgeable() const { return fResource->isPurgeable(); } 74 hasRefOrPendingIO()75 bool hasRefOrPendingIO() const { return fResource->hasRefOrPendingIO(); } 76 77 protected: ResourcePriv(GrGpuResource * resource)78 ResourcePriv(GrGpuResource* resource) : fResource(resource) { } ResourcePriv(const ResourcePriv & that)79 ResourcePriv(const ResourcePriv& that) : fResource(that.fResource) {} 80 ResourcePriv& operator=(const CacheAccess&); // unimpl 81 82 // No taking addresses of this type. 83 const ResourcePriv* operator&() const; 84 ResourcePriv* operator&(); 85 86 GrGpuResource* fResource; 87 88 friend class GrGpuResource; // to construct/copy this type. 89 }; 90 resourcePriv()91inline GrGpuResource::ResourcePriv GrGpuResource::resourcePriv() { return ResourcePriv(this); } 92 resourcePriv()93inline const GrGpuResource::ResourcePriv GrGpuResource::resourcePriv() const { 94 return ResourcePriv(const_cast<GrGpuResource*>(this)); 95 } 96 97 #endif 98