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 */
17class GrGpuResource::ResourcePriv {
18public:
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. */
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     */
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     */
43    void makeUnbudgeted() { fResource->makeUnbudgeted(); }
44
45    /**
46     * Does the resource count against the resource budget?
47     */
48    SkBudgeted isBudgeted() const {
49        bool ret = SkBudgeted::kYes == fResource->fBudgeted;
50        SkASSERT(ret || !fResource->getUniqueKey().isValid() || fResource->fRefsWrappedObjects);
51        return SkBudgeted(ret);
52    }
53
54    /**
55     * Is the resource object wrapping an externally allocated GPU resource?
56     */
57    bool refsWrappedObjects() const { return fResource->fRefsWrappedObjects; }
58
59    /**
60     * If this resource can be used as a scratch resource this returns a valid scratch key.
61     * Otherwise it returns a key for which isNullScratch is true. The resource may currently be
62     * used as a uniquely keyed resource rather than scratch. Check isScratch().
63     */
64    const GrScratchKey& getScratchKey() const { return fResource->fScratchKey; }
65
66    /**
67     * If the resource has a scratch key, the key will be removed. Since scratch keys are installed
68     * at resource creation time, this means the resource will never again be used as scratch.
69     */
70    void removeScratchKey() const { fResource->removeScratchKey();  }
71
72protected:
73    ResourcePriv(GrGpuResource* resource) : fResource(resource) {   }
74    ResourcePriv(const ResourcePriv& that) : fResource(that.fResource) {}
75    ResourcePriv& operator=(const CacheAccess&); // unimpl
76
77    // No taking addresses of this type.
78    const ResourcePriv* operator&() const;
79    ResourcePriv* operator&();
80
81    GrGpuResource* fResource;
82
83    friend class GrGpuResource; // to construct/copy this type.
84};
85
86inline GrGpuResource::ResourcePriv GrGpuResource::resourcePriv() { return ResourcePriv(this); }
87
88inline const GrGpuResource::ResourcePriv GrGpuResource::resourcePriv() const {
89    return ResourcePriv(const_cast<GrGpuResource*>(this));
90}
91
92#endif
93