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