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
|
// Copyright (c) 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 CONTENT_COMMON_GPU_GPU_COMMAND_BUFFER_STUB_H_
#define CONTENT_COMMON_GPU_GPU_COMMAND_BUFFER_STUB_H_
#include <deque>
#include <string>
#include <vector>
#include "base/memory/scoped_vector.h"
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "content/common/content_export.h"
#include "content/common/gpu/gpu_memory_manager.h"
#include "content/common/gpu/gpu_memory_manager_client.h"
#include "gpu/command_buffer/common/constants.h"
#include "gpu/command_buffer/common/gpu_memory_allocation.h"
#include "gpu/command_buffer/service/command_buffer_service.h"
#include "gpu/command_buffer/service/context_group.h"
#include "gpu/command_buffer/service/gpu_scheduler.h"
#include "ipc/ipc_listener.h"
#include "ipc/ipc_sender.h"
#include "media/base/video_decoder_config.h"
#include "ui/events/latency_info.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/gpu_memory_buffer.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/gfx/swap_result.h"
#include "ui/gl/gl_surface.h"
#include "ui/gl/gpu_preference.h"
#include "url/gurl.h"
namespace gpu {
struct Mailbox;
class ValueStateMap;
namespace gles2 {
class MailboxManager;
class SubscriptionRefSet;
}
}
namespace content {
class GpuChannel;
class GpuVideoDecodeAccelerator;
class GpuVideoEncodeAccelerator;
class GpuWatchdog;
struct WaitForCommandState;
class GpuCommandBufferStub
: public GpuMemoryManagerClient,
public IPC::Listener,
public IPC::Sender,
public base::SupportsWeakPtr<GpuCommandBufferStub> {
public:
class DestructionObserver {
public:
// Called in Destroy(), before the context/surface are released.
virtual void OnWillDestroyStub() = 0;
protected:
virtual ~DestructionObserver() {}
};
typedef base::Callback<void(const std::vector<ui::LatencyInfo>&)>
LatencyInfoCallback;
GpuCommandBufferStub(
GpuChannel* channel,
GpuCommandBufferStub* share_group,
const gfx::GLSurfaceHandle& handle,
gpu::gles2::MailboxManager* mailbox_manager,
gpu::gles2::SubscriptionRefSet* subscription_ref_set,
gpu::ValueStateMap* pending_valuebuffer_state,
const gfx::Size& size,
const gpu::gles2::DisallowedFeatures& disallowed_features,
const std::vector<int32>& attribs,
gfx::GpuPreference gpu_preference,
bool use_virtualized_gl_context,
int32 route_id,
int32 surface_id,
GpuWatchdog* watchdog,
bool software,
const GURL& active_url);
~GpuCommandBufferStub() override;
// IPC::Listener implementation:
bool OnMessageReceived(const IPC::Message& message) override;
// IPC::Sender implementation:
bool Send(IPC::Message* msg) override;
// GpuMemoryManagerClient implementation:
gfx::Size GetSurfaceSize() const override;
gpu::gles2::MemoryTracker* GetMemoryTracker() const override;
void SetMemoryAllocation(const gpu::MemoryAllocation& allocation) override;
void SuggestHaveFrontBuffer(bool suggest_have_frontbuffer) override;
bool GetTotalGpuMemory(uint64* bytes) override;
// Whether this command buffer can currently handle IPC messages.
bool IsScheduled();
// If the command buffer is pre-empted and cannot process commands.
bool IsPreempted() const {
return scheduler_.get() && scheduler_->IsPreempted();
}
// Whether there are commands in the buffer that haven't been processed.
bool HasUnprocessedCommands();
gpu::gles2::GLES2Decoder* decoder() const { return decoder_.get(); }
gpu::GpuScheduler* scheduler() const { return scheduler_.get(); }
GpuChannel* channel() const { return channel_; }
// Identifies the target surface.
int32 surface_id() const { return surface_id_; }
// Identifies the various GpuCommandBufferStubs in the GPU process belonging
// to the same renderer process.
int32 route_id() const { return route_id_; }
gfx::GpuPreference gpu_preference() { return gpu_preference_; }
int32 GetRequestedAttribute(int attr) const;
// Sends a message to the console.
void SendConsoleMessage(int32 id, const std::string& message);
void SendCachedShader(const std::string& key, const std::string& shader);
gfx::GLSurface* surface() const { return surface_.get(); }
void AddDestructionObserver(DestructionObserver* observer);
void RemoveDestructionObserver(DestructionObserver* observer);
// Associates a sync point to this stub. When the stub is destroyed, it will
// retire all sync points that haven't been previously retired.
void AddSyncPoint(uint32 sync_point);
void SetPreemptByFlag(scoped_refptr<gpu::PreemptionFlag> flag);
void SetLatencyInfoCallback(const LatencyInfoCallback& callback);
void MarkContextLost();
const gpu::gles2::FeatureInfo* GetFeatureInfo() const;
uint64 GetMemoryUsage() const;
void SendSwapBuffersCompleted(
const std::vector<ui::LatencyInfo>& latency_info,
gfx::SwapResult result);
void SendUpdateVSyncParameters(base::TimeTicks timebase,
base::TimeDelta interval);
private:
GpuMemoryManager* GetMemoryManager() const;
bool MakeCurrent();
void Destroy();
// Cleans up and sends reply if OnInitialize failed.
void OnInitializeFailed(IPC::Message* reply_message);
// Message handlers:
void OnInitialize(base::SharedMemoryHandle shared_state_shm,
IPC::Message* reply_message);
void OnSetGetBuffer(int32 shm_id, IPC::Message* reply_message);
void OnProduceFrontBuffer(const gpu::Mailbox& mailbox);
void OnGetState(IPC::Message* reply_message);
void OnWaitForTokenInRange(int32 start,
int32 end,
IPC::Message* reply_message);
void OnWaitForGetOffsetInRange(int32 start,
int32 end,
IPC::Message* reply_message);
void OnAsyncFlush(int32 put_offset, uint32 flush_count,
const std::vector<ui::LatencyInfo>& latency_info);
void OnRescheduled();
void OnRegisterTransferBuffer(int32 id,
base::SharedMemoryHandle transfer_buffer,
uint32 size);
void OnDestroyTransferBuffer(int32 id);
void OnGetTransferBuffer(int32 id, IPC::Message* reply_message);
void OnCreateVideoDecoder(media::VideoCodecProfile profile,
int32 route_id,
IPC::Message* reply_message);
void OnCreateVideoEncoder(media::VideoFrame::Format input_format,
const gfx::Size& input_visible_size,
media::VideoCodecProfile output_profile,
uint32 initial_bitrate,
int32 route_id,
IPC::Message* reply_message);
void OnSetSurfaceVisible(bool visible);
void OnEnsureBackbuffer();
void OnRetireSyncPoint(uint32 sync_point);
bool OnWaitSyncPoint(uint32 sync_point);
void OnSyncPointRetired();
void OnSignalSyncPoint(uint32 sync_point, uint32 id);
void OnSignalSyncPointAck(uint32 id);
void OnSignalQuery(uint32 query, uint32 id);
void OnSetClientHasMemoryAllocationChangedCallback(bool has_callback);
void OnCreateImage(int32 id,
gfx::GpuMemoryBufferHandle handle,
gfx::Size size,
gfx::GpuMemoryBuffer::Format format,
uint32 internalformat);
void OnDestroyImage(int32 id);
void OnCommandProcessed();
void OnParseError();
void OnCreateStreamTexture(
uint32 texture_id, int32 stream_id, bool* succeeded);
void ReportState();
// Wrapper for GpuScheduler::PutChanged that sets the crash report URL.
void PutChanged();
// Poll the command buffer to execute work.
void PollWork();
// Whether this command buffer needs to be polled again in the future.
bool HasMoreWork();
void ScheduleDelayedWork(int64 delay);
bool CheckContextLost();
void CheckCompleteWaits();
// The lifetime of objects of this class is managed by a GpuChannel. The
// GpuChannels destroy all the GpuCommandBufferStubs that they own when they
// are destroyed. So a raw pointer is safe.
GpuChannel* channel_;
// The group of contexts that share namespaces with this context.
scoped_refptr<gpu::gles2::ContextGroup> context_group_;
gfx::GLSurfaceHandle handle_;
gfx::Size initial_size_;
gpu::gles2::DisallowedFeatures disallowed_features_;
std::vector<int32> requested_attribs_;
gfx::GpuPreference gpu_preference_;
bool use_virtualized_gl_context_;
int32 route_id_;
int32 surface_id_;
bool software_;
uint32 last_flush_count_;
scoped_ptr<gpu::CommandBufferService> command_buffer_;
scoped_ptr<gpu::gles2::GLES2Decoder> decoder_;
scoped_ptr<gpu::GpuScheduler> scheduler_;
scoped_refptr<gfx::GLSurface> surface_;
scoped_ptr<GpuMemoryManagerClientState> memory_manager_client_state_;
// The last memory allocation received from the GpuMemoryManager (used to
// elide redundant work).
bool last_memory_allocation_valid_;
gpu::MemoryAllocation last_memory_allocation_;
GpuWatchdog* watchdog_;
base::ObserverList<DestructionObserver> destruction_observers_;
// A queue of sync points associated with this stub.
std::deque<uint32> sync_points_;
int sync_point_wait_count_;
bool delayed_work_scheduled_;
uint64 previous_messages_processed_;
base::TimeTicks last_idle_time_;
scoped_refptr<gpu::PreemptionFlag> preemption_flag_;
LatencyInfoCallback latency_info_callback_;
GURL active_url_;
size_t active_url_hash_;
size_t total_gpu_memory_;
scoped_ptr<WaitForCommandState> wait_for_token_;
scoped_ptr<WaitForCommandState> wait_for_get_offset_;
DISALLOW_COPY_AND_ASSIGN(GpuCommandBufferStub);
};
} // namespace content
#endif // CONTENT_COMMON_GPU_GPU_COMMAND_BUFFER_STUB_H_
|