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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
// Copyright 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CCPrioritizedTexture_h
#define CCPrioritizedTexture_h
#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "CCPriorityCalculator.h"
#include "CCResourceProvider.h"
#include "CCTexture.h"
#include "GraphicsContext3D.h"
#include "IntRect.h"
#include "IntSize.h"
namespace cc {
class CCPrioritizedTextureManager;
class CCPrioritizedTexture {
public:
static scoped_ptr<CCPrioritizedTexture> create(CCPrioritizedTextureManager* manager, IntSize size, GC3Denum format)
{
return make_scoped_ptr(new CCPrioritizedTexture(manager, size, format));
}
static scoped_ptr<CCPrioritizedTexture> create(CCPrioritizedTextureManager* manager)
{
return make_scoped_ptr(new CCPrioritizedTexture(manager, IntSize(), 0));
}
~CCPrioritizedTexture();
// Texture properties. Changing these causes the backing texture to be lost.
// Setting these to the same value is a no-op.
void setTextureManager(CCPrioritizedTextureManager*);
CCPrioritizedTextureManager* textureManager() { return m_manager; }
void setDimensions(IntSize, GC3Denum format);
GC3Denum format() const { return m_format; }
IntSize size() const { return m_size; }
size_t bytes() const { return m_bytes; }
// Set priority for the requested texture.
void setRequestPriority(int priority) { m_priority = priority; }
int requestPriority() const { return m_priority; }
// After CCPrioritizedTexture::prioritizeTextures() is called, this returns
// if the the request succeeded and this texture can be acquired for use.
bool canAcquireBackingTexture() const { return m_isAbovePriorityCutoff; }
// This returns whether we still have a backing texture. This can continue
// to be true even after canAcquireBackingTexture() becomes false. In this
// case the texture can be used but shouldn't be updated since it will get
// taken away "soon".
bool haveBackingTexture() const { return !!backing(); }
bool backingResourceWasEvicted() const;
// If canAcquireBackingTexture() is true acquireBackingTexture() will acquire
// a backing texture for use. Call this whenever the texture is actually needed.
void acquireBackingTexture(CCResourceProvider*);
// FIXME: Request late is really a hack for when we are totally out of memory
// (all textures are visible) but we can still squeeze into the limit
// by not painting occluded textures. In this case the manager
// refuses all visible textures and requestLate() will enable
// canAcquireBackingTexture() on a call-order basis. We might want to
// just remove this in the future (carefully) and just make sure we don't
// regress OOMs situations.
bool requestLate();
// Uploads pixels into the backing resource. This functions will aquire the backing if needed.
void upload(CCResourceProvider*, const uint8_t* image, const IntRect& imageRect, const IntRect& sourceRect, const IntSize& destOffset);
CCResourceProvider::ResourceId resourceId() const;
// Self-managed textures are accounted for when prioritizing other textures,
// but they are not allocated/recycled/deleted, so this needs to be done
// externally. canAcquireBackingTexture() indicates if the texture would have
// been allowed given its priority.
void setIsSelfManaged(bool isSelfManaged) { m_isSelfManaged = isSelfManaged; }
bool isSelfManaged() { return m_isSelfManaged; }
void setToSelfManagedMemoryPlaceholder(size_t bytes);
private:
friend class CCPrioritizedTextureManager;
friend class CCPrioritizedTextureTest;
class Backing : public CCTexture {
public:
Backing(unsigned id, CCResourceProvider*, IntSize, GC3Denum format);
~Backing();
void updatePriority();
void updateInDrawingImplTree();
CCPrioritizedTexture* owner() { return m_owner; }
bool canBeRecycled() const;
int requestPriorityAtLastPriorityUpdate() const { return m_priorityAtLastPriorityUpdate; }
bool wasAbovePriorityCutoffAtLastPriorityUpdate() const { return m_wasAbovePriorityCutoffAtLastPriorityUpdate; }
bool inDrawingImplTree() const { return m_inDrawingImplTree; }
void deleteResource(CCResourceProvider*);
bool resourceHasBeenDeleted() const;
private:
friend class CCPrioritizedTexture;
CCPrioritizedTexture* m_owner;
int m_priorityAtLastPriorityUpdate;
bool m_wasAbovePriorityCutoffAtLastPriorityUpdate;
// Set if this is currently-drawing impl tree.
bool m_inDrawingImplTree;
bool m_resourceHasBeenDeleted;
#ifndef NDEBUG
CCResourceProvider* m_resourceProvider;
#endif
DISALLOW_COPY_AND_ASSIGN(Backing);
};
CCPrioritizedTexture(CCPrioritizedTextureManager*, IntSize, GC3Denum format);
bool isAbovePriorityCutoff() { return m_isAbovePriorityCutoff; }
void setAbovePriorityCutoff(bool isAbovePriorityCutoff) { m_isAbovePriorityCutoff = isAbovePriorityCutoff; }
void setManagerInternal(CCPrioritizedTextureManager* manager) { m_manager = manager; }
Backing* backing() const { return m_backing; }
void link(Backing*);
void unlink();
IntSize m_size;
GC3Denum m_format;
size_t m_bytes;
int m_priority;
bool m_isAbovePriorityCutoff;
bool m_isSelfManaged;
Backing* m_backing;
CCPrioritizedTextureManager* m_manager;
DISALLOW_COPY_AND_ASSIGN(CCPrioritizedTexture);
};
} // namespace cc
#endif
|
