Home | History | Annotate | Download | only in gpu 
      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:
     19     /**
     20      * Sets a unique key for the resource. If the resource was previously cached as scratch it will
     21      * be converted to a uniquely-keyed resource. If the key is invalid then this is equivalent to
     22      * removeUniqueKey(). If another resource is using the key then its unique key is removed and
     23      * this resource takes over the key.
     24      */
     25     void setUniqueKey(const GrUniqueKey& key) { fResource->setUniqueKey(key); }
     26 
     27     /** Removes the unique key from a resource. If the resource has a scratch key, it may be
     28         preserved for recycling as scratch. */
     29     void removeUniqueKey() { fResource->removeUniqueKey(); }
     30 
     31     /**
     32      * If the resource is uncached make it cached. Has no effect on resources that are wrapped or
     33      * already cached.
     34      */
     35     void makeBudgeted() { fResource->makeBudgeted(); }
     36 
     37     /**
     38      * If the resource is cached make it uncached. Has no effect on resources that are wrapped or
     39      * already uncached. Furthermore, resources with unique keys cannot be made unbudgeted.
     40      */
     41     void makeUnbudgeted() { fResource->makeUnbudgeted(); }
     42 
     43     /**
     44      * Does the resource count against the resource budget?
     45      */
     46     SkBudgeted isBudgeted() const {
     47         bool ret = SkBudgeted::kYes == fResource->fBudgeted;
     48         SkASSERT(ret || !fResource->getUniqueKey().isValid());
     49         return SkBudgeted(ret);
     50     }
     51 
     52     /**
     53      * Is the resource object wrapping an externally allocated GPU resource?
     54      */
     55     bool refsWrappedObjects() const { return fResource->fRefsWrappedObjects; }
     56 
     57     /**
     58      * If this resource can be used as a scratch resource this returns a valid scratch key.
     59      * Otherwise it returns a key for which isNullScratch is true. The resource may currently be
     60      * used as a uniquely keyed resource rather than scratch. Check isScratch().
     61      */
     62     const GrScratchKey& getScratchKey() const { return fResource->fScratchKey; }
     63 
     64     /**
     65      * If the resource has a scratch key, the key will be removed. Since scratch keys are installed
     66      * at resource creation time, this means the resource will never again be used as scratch.
     67      */
     68     void removeScratchKey() const { fResource->removeScratchKey();  }
     69 
     70 protected:
     71     ResourcePriv(GrGpuResource* resource) : fResource(resource) {   }
     72     ResourcePriv(const ResourcePriv& that) : fResource(that.fResource) {}
     73     ResourcePriv& operator=(const CacheAccess&); // unimpl
     74 
     75     // No taking addresses of this type.
     76     const ResourcePriv* operator&() const;
     77     ResourcePriv* operator&();
     78 
     79     GrGpuResource* fResource;
     80 
     81     friend class GrGpuResource; // to construct/copy this type.
     82 };
     83 
     84 inline GrGpuResource::ResourcePriv GrGpuResource::resourcePriv() { return ResourcePriv(this); }
     85 
     86 inline const GrGpuResource::ResourcePriv GrGpuResource::resourcePriv() const {
     87     return ResourcePriv(const_cast<GrGpuResource*>(this));
     88 }
     89 
     90 #endif
     91