Line data    Source code

       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           0 :     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           0 :     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           0 :     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           0 :     void makeUnbudgeted() { fResource->makeUnbudgeted(); }
      42             : 
      43             :     /**
      44             :      * Does the resource count against the resource budget?
      45             :      */
      46           0 :     SkBudgeted isBudgeted() const {
      47           0 :         bool ret = SkBudgeted::kYes == fResource->fBudgeted;
      48           0 :         SkASSERT(ret || !fResource->getUniqueKey().isValid());
      49           0 :         return SkBudgeted(ret);
      50             :     }
      51             : 
      52             :     /**
      53             :      * Is the resource object wrapping an externally allocated GPU resource?
      54             :      */
      55           0 :     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           0 :     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           0 :     void removeScratchKey() const { fResource->removeScratchKey();  }
      69             : 
      70             : protected:
      71           0 :     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           0 : inline GrGpuResource::ResourcePriv GrGpuResource::resourcePriv() { return ResourcePriv(this); }
      85             : 
      86           0 : inline const GrGpuResource::ResourcePriv GrGpuResource::resourcePriv() const {
      87           0 :     return ResourcePriv(const_cast<GrGpuResource*>(this));
      88             : }
      89             : 
      90             : #endif