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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
gpu / command_buffer / service / context_group.h [blame]
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef GPU_COMMAND_BUFFER_SERVICE_CONTEXT_GROUP_H_
#define GPU_COMMAND_BUFFER_SERVICE_CONTEXT_GROUP_H_
#include <stdint.h>
#include <memory>
#include <unordered_map>
#include <vector>
#include "base/memory/raw_ptr.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "gpu/command_buffer/common/constants.h"
#include "gpu/command_buffer/common/gles2_cmd_format.h"
#include "gpu/command_buffer/common/gles2_cmd_utils.h"
#include "gpu/command_buffer/service/feature_info.h"
#include "gpu/command_buffer/service/framebuffer_completeness_cache.h"
#include "gpu/command_buffer/service/shader_translator_cache.h"
#include "gpu/config/gpu_feature_info.h"
#include "gpu/config/gpu_preferences.h"
#include "gpu/gpu_gles2_export.h"
namespace gl {
class ProgressReporter;
}
namespace gpu {
struct GpuPreferences;
class SharedImageManager;
class SharedImageRepresentationFactory;
class ServiceDiscardableManager;
class PassthroughDiscardableManager;
class DecoderContext;
class MemoryTracker;
namespace gles2 {
class ProgramCache;
class BufferManager;
class RenderbufferManager;
class ProgramManager;
class SamplerManager;
class ShaderManager;
class TextureManager;
struct DisallowedFeatures;
struct PassthroughResources;
DisallowedFeatures AdjustDisallowedFeatures(
ContextType context_type,
const DisallowedFeatures& disallowed_features);
// A Context Group helps manage multiple DecoderContexts that share
// resources.
class GPU_GLES2_EXPORT ContextGroup : public base::RefCounted<ContextGroup> {
public:
ContextGroup(const GpuPreferences& gpu_preferences,
bool supports_passthrough_command_decoders,
std::unique_ptr<MemoryTracker> memory_tracker,
ShaderTranslatorCache* shader_translator_cache,
FramebufferCompletenessCache* framebuffer_completeness_cache,
const scoped_refptr<FeatureInfo>& feature_info,
bool bind_generates_resource,
gl::ProgressReporter* progress_reporter,
const GpuFeatureInfo& gpu_feature_info,
ServiceDiscardableManager* discardable_manager,
PassthroughDiscardableManager* passthrough_discardable_manager,
SharedImageManager* shared_image_manager);
ContextGroup(const ContextGroup&) = delete;
ContextGroup& operator=(const ContextGroup&) = delete;
// This should only be called by a DecoderContext. This must be paired with a
// call to destroy if it succeeds.
gpu::ContextResult Initialize(DecoderContext* decoder,
ContextType context_type,
const DisallowedFeatures& disallowed_features);
// Destroys all the resources when called for the last context in the group.
// It should only be called by DecoderContext.
void Destroy(DecoderContext* decoder, bool have_context);
gpu::SharedImageManager* shared_image_manager() const {
return shared_image_manager_;
}
MemoryTracker* memory_tracker() const { return memory_tracker_.get(); }
ShaderTranslatorCache* shader_translator_cache() const {
return shader_translator_cache_;
}
FramebufferCompletenessCache* framebuffer_completeness_cache() const {
return framebuffer_completeness_cache_;
}
bool bind_generates_resource() {
return bind_generates_resource_;
}
uint32_t max_vertex_attribs() const { return max_vertex_attribs_; }
uint32_t max_texture_units() const { return max_texture_units_; }
uint32_t max_texture_image_units() const { return max_texture_image_units_; }
uint32_t max_vertex_texture_image_units() const {
return max_vertex_texture_image_units_;
}
uint32_t max_fragment_uniform_vectors() const {
return max_fragment_uniform_vectors_;
}
uint32_t max_varying_vectors() const { return max_varying_vectors_; }
uint32_t max_vertex_uniform_vectors() const {
return max_vertex_uniform_vectors_;
}
uint32_t max_color_attachments() const { return max_color_attachments_; }
uint32_t max_draw_buffers() const { return max_draw_buffers_; }
uint32_t max_dual_source_draw_buffers() const {
return max_dual_source_draw_buffers_;
}
uint32_t max_vertex_output_components() const {
return max_vertex_output_components_;
}
uint32_t max_fragment_input_components() const {
return max_fragment_input_components_;
}
int32_t min_program_texel_offset() const { return min_program_texel_offset_; }
int32_t max_program_texel_offset() const { return max_program_texel_offset_; }
uint32_t max_transform_feedback_separate_attribs() const {
return max_transform_feedback_separate_attribs_;
}
uint32_t max_uniform_buffer_bindings() const {
return max_uniform_buffer_bindings_;
}
uint32_t uniform_buffer_offset_alignment() const {
return uniform_buffer_offset_alignment_;
}
FeatureInfo* feature_info() {
return feature_info_.get();
}
const GpuPreferences& gpu_preferences() const {
return gpu_preferences_;
}
BufferManager* buffer_manager() const {
return buffer_manager_.get();
}
RenderbufferManager* renderbuffer_manager() const {
return renderbuffer_manager_.get();
}
TextureManager* texture_manager() const {
return texture_manager_.get();
}
ProgramManager* program_manager() const {
return program_manager_.get();
}
bool has_program_cache() const { return program_cache_ != nullptr; }
void set_program_cache(ProgramCache* program_cache) {
program_cache_ = program_cache;
}
ProgramCache* get_program_cache() { return program_cache_; }
ShaderManager* shader_manager() const {
return shader_manager_.get();
}
SamplerManager* sampler_manager() const {
return sampler_manager_.get();
}
ServiceDiscardableManager* discardable_manager() const {
return discardable_manager_;
}
SharedImageRepresentationFactory* shared_image_representation_factory()
const {
return shared_image_representation_factory_.get();
}
uint32_t GetMemRepresented() const;
// Loses all the context associated with this group.
void LoseContexts(error::ContextLostReason reason);
bool GetBufferServiceId(GLuint client_id, GLuint* service_id) const;
void AddSyncId(GLuint client_id, GLsync service_id) {
syncs_id_map_[client_id] = service_id;
}
bool GetSyncServiceId(GLuint client_id, GLsync* service_id) const {
std::unordered_map<GLuint, GLsync>::const_iterator iter =
syncs_id_map_.find(client_id);
if (iter == syncs_id_map_.end())
return false;
if (service_id)
*service_id = iter->second;
return true;
}
void RemoveSyncId(GLuint client_id) {
syncs_id_map_.erase(client_id);
}
bool use_passthrough_cmd_decoder() const {
return use_passthrough_cmd_decoder_;
}
PassthroughResources* passthrough_resources() const {
return passthrough_resources_.get();
}
PassthroughDiscardableManager* passthrough_discardable_manager() const {
return passthrough_discardable_manager_;
}
const GpuFeatureInfo& gpu_feature_info() const { return gpu_feature_info_; }
void ReportProgress();
private:
friend class base::RefCounted<ContextGroup>;
~ContextGroup();
bool CheckGLFeature(GLint min_required, GLint* v);
bool CheckGLFeatureU(GLint min_required, uint32_t* v);
bool QueryGLFeature(GLenum pname, GLint min_required, GLint* v);
bool QueryGLFeatureU(GLenum pname, GLint min_required, uint32_t* v);
bool HaveContexts();
// It's safer to make a copy of the GpuPreferences struct rather
// than refer to the one passed in to the constructor.
const GpuPreferences gpu_preferences_;
std::unique_ptr<MemoryTracker> memory_tracker_;
raw_ptr<ShaderTranslatorCache> shader_translator_cache_;
raw_ptr<FramebufferCompletenessCache> framebuffer_completeness_cache_;
bool enforce_gl_minimums_;
bool bind_generates_resource_;
uint32_t max_vertex_attribs_;
uint32_t max_texture_units_;
uint32_t max_texture_image_units_;
uint32_t max_vertex_texture_image_units_;
uint32_t max_fragment_uniform_vectors_;
uint32_t max_varying_vectors_;
uint32_t max_vertex_uniform_vectors_;
uint32_t max_color_attachments_;
uint32_t max_draw_buffers_;
uint32_t max_dual_source_draw_buffers_;
uint32_t max_vertex_output_components_;
uint32_t max_fragment_input_components_;
int32_t min_program_texel_offset_;
int32_t max_program_texel_offset_;
uint32_t max_transform_feedback_separate_attribs_;
uint32_t max_uniform_buffer_bindings_;
uint32_t uniform_buffer_offset_alignment_;
raw_ptr<ProgramCache> program_cache_;
std::unique_ptr<BufferManager> buffer_manager_;
std::unique_ptr<RenderbufferManager> renderbuffer_manager_;
std::unique_ptr<TextureManager> texture_manager_;
std::unique_ptr<ProgramManager> program_manager_;
std::unique_ptr<ShaderManager> shader_manager_;
std::unique_ptr<SamplerManager> sampler_manager_;
scoped_refptr<FeatureInfo> feature_info_;
std::vector<base::WeakPtr<DecoderContext>> decoders_;
// Mappings from client side IDs to service side IDs.
std::unordered_map<GLuint, GLsync> syncs_id_map_;
bool use_passthrough_cmd_decoder_;
std::unique_ptr<PassthroughResources> passthrough_resources_;
raw_ptr<PassthroughDiscardableManager> passthrough_discardable_manager_;
// Used to notify the watchdog thread of progress during destruction,
// preventing time-outs when destruction takes a long time. May be null when
// using in-process command buffer.
raw_ptr<gl::ProgressReporter> progress_reporter_;
GpuFeatureInfo gpu_feature_info_;
raw_ptr<ServiceDiscardableManager> discardable_manager_;
std::unique_ptr<SharedImageRepresentationFactory>
shared_image_representation_factory_;
raw_ptr<gpu::SharedImageManager> shared_image_manager_ = nullptr;
};
} // namespace gles2
} // namespace gpu
#endif // GPU_COMMAND_BUFFER_SERVICE_CONTEXT_GROUP_H_