1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/bind.h"
6 #include "base/bind_helpers.h"
7 #include "base/command_line.h"
8 #include "base/debug/trace_event.h"
9 #include "base/hash.h"
10 #include "base/memory/shared_memory.h"
11 #include "base/time/time.h"
12 #include "build/build_config.h"
13 #include "content/common/gpu/devtools_gpu_instrumentation.h"
14 #include "content/common/gpu/gpu_channel.h"
15 #include "content/common/gpu/gpu_channel_manager.h"
16 #include "content/common/gpu/gpu_command_buffer_stub.h"
17 #include "content/common/gpu/gpu_memory_manager.h"
18 #include "content/common/gpu/gpu_memory_tracking.h"
19 #include "content/common/gpu/gpu_messages.h"
20 #include "content/common/gpu/gpu_watchdog.h"
21 #include "content/common/gpu/image_transport_surface.h"
22 #include "content/common/gpu/media/gpu_video_decode_accelerator.h"
23 #include "content/common/gpu/sync_point_manager.h"
24 #include "content/public/common/content_client.h"
25 #include "gpu/command_buffer/common/constants.h"
26 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
27 #include "gpu/command_buffer/common/mailbox.h"
28 #include "gpu/command_buffer/service/gl_context_virtual.h"
29 #include "gpu/command_buffer/service/gl_state_restorer_impl.h"
30 #include "gpu/command_buffer/service/gpu_control_service.h"
31 #include "gpu/command_buffer/service/image_manager.h"
32 #include "gpu/command_buffer/service/logger.h"
33 #include "gpu/command_buffer/service/mailbox_manager.h"
34 #include "gpu/command_buffer/service/memory_tracking.h"
35 #include "gpu/command_buffer/service/query_manager.h"
36 #include "ui/gl/gl_bindings.h"
37 #include "ui/gl/gl_switches.h"
38
39 #if defined(OS_WIN)
40 #include "content/public/common/sandbox_init.h"
41 #endif
42
43 #if defined(OS_ANDROID)
44 #include "content/common/gpu/stream_texture_manager_android.h"
45 #endif
46
47 namespace content {
48 namespace {
49
50 // The GpuCommandBufferMemoryTracker class provides a bridge between the
51 // ContextGroup's memory type managers and the GpuMemoryManager class.
52 class GpuCommandBufferMemoryTracker : public gpu::gles2::MemoryTracker {
53 public:
GpuCommandBufferMemoryTracker(GpuChannel * channel)54 explicit GpuCommandBufferMemoryTracker(GpuChannel* channel) :
55 tracking_group_(channel->gpu_channel_manager()->gpu_memory_manager()->
56 CreateTrackingGroup(channel->renderer_pid(), this)) {
57 }
58
TrackMemoryAllocatedChange(size_t old_size,size_t new_size,gpu::gles2::MemoryTracker::Pool pool)59 virtual void TrackMemoryAllocatedChange(
60 size_t old_size,
61 size_t new_size,
62 gpu::gles2::MemoryTracker::Pool pool) OVERRIDE {
63 tracking_group_->TrackMemoryAllocatedChange(
64 old_size, new_size, pool);
65 }
66
EnsureGPUMemoryAvailable(size_t size_needed)67 virtual bool EnsureGPUMemoryAvailable(size_t size_needed) OVERRIDE {
68 return tracking_group_->EnsureGPUMemoryAvailable(size_needed);
69 };
70
71 private:
~GpuCommandBufferMemoryTracker()72 virtual ~GpuCommandBufferMemoryTracker() {
73 }
74 scoped_ptr<GpuMemoryTrackingGroup> tracking_group_;
75
76 DISALLOW_COPY_AND_ASSIGN(GpuCommandBufferMemoryTracker);
77 };
78
79 // FastSetActiveURL will shortcut the expensive call to SetActiveURL when the
80 // url_hash matches.
FastSetActiveURL(const GURL & url,size_t url_hash)81 void FastSetActiveURL(const GURL& url, size_t url_hash) {
82 // Leave the previously set URL in the empty case -- empty URLs are given by
83 // WebKitPlatformSupportImpl::createOffscreenGraphicsContext3D. Hopefully the
84 // onscreen context URL was set previously and will show up even when a crash
85 // occurs during offscreen command processing.
86 if (url.is_empty())
87 return;
88 static size_t g_last_url_hash = 0;
89 if (url_hash != g_last_url_hash) {
90 g_last_url_hash = url_hash;
91 GetContentClient()->SetActiveURL(url);
92 }
93 }
94
95 // The first time polling a fence, delay some extra time to allow other
96 // stubs to process some work, or else the timing of the fences could
97 // allow a pattern of alternating fast and slow frames to occur.
98 const int64 kHandleMoreWorkPeriodMs = 2;
99 const int64 kHandleMoreWorkPeriodBusyMs = 1;
100
101 // Prevents idle work from being starved.
102 const int64 kMaxTimeSinceIdleMs = 10;
103
104 } // namespace
105
GpuCommandBufferStub(GpuChannel * channel,GpuCommandBufferStub * share_group,const gfx::GLSurfaceHandle & handle,gpu::gles2::MailboxManager * mailbox_manager,gpu::gles2::ImageManager * image_manager,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)106 GpuCommandBufferStub::GpuCommandBufferStub(
107 GpuChannel* channel,
108 GpuCommandBufferStub* share_group,
109 const gfx::GLSurfaceHandle& handle,
110 gpu::gles2::MailboxManager* mailbox_manager,
111 gpu::gles2::ImageManager* image_manager,
112 const gfx::Size& size,
113 const gpu::gles2::DisallowedFeatures& disallowed_features,
114 const std::vector<int32>& attribs,
115 gfx::GpuPreference gpu_preference,
116 bool use_virtualized_gl_context,
117 int32 route_id,
118 int32 surface_id,
119 GpuWatchdog* watchdog,
120 bool software,
121 const GURL& active_url)
122 : channel_(channel),
123 handle_(handle),
124 initial_size_(size),
125 disallowed_features_(disallowed_features),
126 requested_attribs_(attribs),
127 gpu_preference_(gpu_preference),
128 use_virtualized_gl_context_(use_virtualized_gl_context),
129 route_id_(route_id),
130 surface_id_(surface_id),
131 software_(software),
132 last_flush_count_(0),
133 last_memory_allocation_valid_(false),
134 watchdog_(watchdog),
135 sync_point_wait_count_(0),
136 delayed_work_scheduled_(false),
137 previous_messages_processed_(0),
138 active_url_(active_url),
139 total_gpu_memory_(0) {
140 active_url_hash_ = base::Hash(active_url.possibly_invalid_spec());
141 FastSetActiveURL(active_url_, active_url_hash_);
142 if (share_group) {
143 context_group_ = share_group->context_group_;
144 } else {
145 gpu::StreamTextureManager* stream_texture_manager = NULL;
146 #if defined(OS_ANDROID)
147 stream_texture_manager = channel_->stream_texture_manager();
148 #endif
149 context_group_ = new gpu::gles2::ContextGroup(
150 mailbox_manager,
151 image_manager,
152 new GpuCommandBufferMemoryTracker(channel),
153 stream_texture_manager,
154 NULL,
155 true);
156 }
157
158 use_virtualized_gl_context_ |=
159 context_group_->feature_info()->workarounds().use_virtualized_gl_contexts;
160 }
161
~GpuCommandBufferStub()162 GpuCommandBufferStub::~GpuCommandBufferStub() {
163 Destroy();
164
165 GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
166 gpu_channel_manager->Send(new GpuHostMsg_DestroyCommandBuffer(surface_id()));
167 }
168
GetMemoryManager() const169 GpuMemoryManager* GpuCommandBufferStub::GetMemoryManager() const {
170 return channel()->gpu_channel_manager()->gpu_memory_manager();
171 }
172
OnMessageReceived(const IPC::Message & message)173 bool GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
174 devtools_gpu_instrumentation::ScopedGpuTask task(this);
175 FastSetActiveURL(active_url_, active_url_hash_);
176
177 // Ensure the appropriate GL context is current before handling any IPC
178 // messages directed at the command buffer. This ensures that the message
179 // handler can assume that the context is current (not necessary for
180 // Echo, RetireSyncPoint, or WaitSyncPoint).
181 if (decoder_.get() &&
182 message.type() != GpuCommandBufferMsg_Echo::ID &&
183 message.type() != GpuCommandBufferMsg_GetStateFast::ID &&
184 message.type() != GpuCommandBufferMsg_RetireSyncPoint::ID &&
185 message.type() != GpuCommandBufferMsg_SetLatencyInfo::ID) {
186 if (!MakeCurrent())
187 return false;
188 }
189
190 // Always use IPC_MESSAGE_HANDLER_DELAY_REPLY for synchronous message handlers
191 // here. This is so the reply can be delayed if the scheduler is unscheduled.
192 bool handled = true;
193 IPC_BEGIN_MESSAGE_MAP(GpuCommandBufferStub, message)
194 IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_Initialize,
195 OnInitialize);
196 IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_SetGetBuffer,
197 OnSetGetBuffer);
198 IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_ProduceFrontBuffer,
199 OnProduceFrontBuffer);
200 IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Echo, OnEcho);
201 IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_GetState, OnGetState);
202 IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_GetStateFast,
203 OnGetStateFast);
204 IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncFlush, OnAsyncFlush);
205 IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SetLatencyInfo, OnSetLatencyInfo);
206 IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Rescheduled, OnRescheduled);
207 IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RegisterTransferBuffer,
208 OnRegisterTransferBuffer);
209 IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyTransferBuffer,
210 OnDestroyTransferBuffer);
211 IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_GetTransferBuffer,
212 OnGetTransferBuffer);
213 IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_CreateVideoDecoder,
214 OnCreateVideoDecoder)
215 IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SetSurfaceVisible,
216 OnSetSurfaceVisible)
217 IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RetireSyncPoint,
218 OnRetireSyncPoint)
219 IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalSyncPoint,
220 OnSignalSyncPoint)
221 IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalQuery,
222 OnSignalQuery)
223 IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SendClientManagedMemoryStats,
224 OnReceivedClientManagedMemoryStats)
225 IPC_MESSAGE_HANDLER(
226 GpuCommandBufferMsg_SetClientHasMemoryAllocationChangedCallback,
227 OnSetClientHasMemoryAllocationChangedCallback)
228 IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RegisterGpuMemoryBuffer,
229 OnRegisterGpuMemoryBuffer);
230 IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyGpuMemoryBuffer,
231 OnDestroyGpuMemoryBuffer);
232 IPC_MESSAGE_UNHANDLED(handled = false)
233 IPC_END_MESSAGE_MAP()
234
235 // Ensure that any delayed work that was created will be handled.
236 ScheduleDelayedWork(kHandleMoreWorkPeriodMs);
237
238 DCHECK(handled);
239 return handled;
240 }
241
Send(IPC::Message * message)242 bool GpuCommandBufferStub::Send(IPC::Message* message) {
243 return channel_->Send(message);
244 }
245
IsScheduled()246 bool GpuCommandBufferStub::IsScheduled() {
247 return (!scheduler_.get() || scheduler_->IsScheduled());
248 }
249
HasMoreWork()250 bool GpuCommandBufferStub::HasMoreWork() {
251 return scheduler_.get() && scheduler_->HasMoreWork();
252 }
253
PollWork()254 void GpuCommandBufferStub::PollWork() {
255 TRACE_EVENT0("gpu", "GpuCommandBufferStub::PollWork");
256 delayed_work_scheduled_ = false;
257 FastSetActiveURL(active_url_, active_url_hash_);
258 if (decoder_.get() && !MakeCurrent())
259 return;
260
261 if (scheduler_) {
262 bool fences_complete = scheduler_->PollUnscheduleFences();
263 // Perform idle work if all fences are complete.
264 if (fences_complete) {
265 uint64 current_messages_processed =
266 channel()->gpu_channel_manager()->MessagesProcessed();
267 // We're idle when no messages were processed or scheduled.
268 bool is_idle =
269 (previous_messages_processed_ == current_messages_processed) &&
270 !channel()->gpu_channel_manager()->HandleMessagesScheduled();
271 if (!is_idle && !last_idle_time_.is_null()) {
272 base::TimeDelta time_since_idle = base::TimeTicks::Now() -
273 last_idle_time_;
274 base::TimeDelta max_time_since_idle =
275 base::TimeDelta::FromMilliseconds(kMaxTimeSinceIdleMs);
276
277 // Force idle when it's been too long since last time we were idle.
278 if (time_since_idle > max_time_since_idle)
279 is_idle = true;
280 }
281
282 if (is_idle) {
283 last_idle_time_ = base::TimeTicks::Now();
284 scheduler_->PerformIdleWork();
285 }
286 }
287 }
288 ScheduleDelayedWork(kHandleMoreWorkPeriodBusyMs);
289 }
290
HasUnprocessedCommands()291 bool GpuCommandBufferStub::HasUnprocessedCommands() {
292 if (command_buffer_) {
293 gpu::CommandBuffer::State state = command_buffer_->GetLastState();
294 return state.put_offset != state.get_offset &&
295 !gpu::error::IsError(state.error);
296 }
297 return false;
298 }
299
ScheduleDelayedWork(int64 delay)300 void GpuCommandBufferStub::ScheduleDelayedWork(int64 delay) {
301 if (!HasMoreWork()) {
302 last_idle_time_ = base::TimeTicks();
303 return;
304 }
305
306 if (delayed_work_scheduled_)
307 return;
308 delayed_work_scheduled_ = true;
309
310 // Idle when no messages are processed between now and when
311 // PollWork is called.
312 previous_messages_processed_ =
313 channel()->gpu_channel_manager()->MessagesProcessed();
314 if (last_idle_time_.is_null())
315 last_idle_time_ = base::TimeTicks::Now();
316
317 // IsScheduled() returns true after passing all unschedule fences
318 // and this is when we can start performing idle work. Idle work
319 // is done synchronously so we can set delay to 0 and instead poll
320 // for more work at the rate idle work is performed. This also ensures
321 // that idle work is done as efficiently as possible without any
322 // unnecessary delays.
323 if (scheduler_.get() &&
324 scheduler_->IsScheduled() &&
325 scheduler_->HasMoreIdleWork()) {
326 delay = 0;
327 }
328
329 base::MessageLoop::current()->PostDelayedTask(
330 FROM_HERE,
331 base::Bind(&GpuCommandBufferStub::PollWork, AsWeakPtr()),
332 base::TimeDelta::FromMilliseconds(delay));
333 }
334
OnEcho(const IPC::Message & message)335 void GpuCommandBufferStub::OnEcho(const IPC::Message& message) {
336 TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnEcho");
337 Send(new IPC::Message(message));
338 }
339
MakeCurrent()340 bool GpuCommandBufferStub::MakeCurrent() {
341 if (decoder_->MakeCurrent())
342 return true;
343 DLOG(ERROR) << "Context lost because MakeCurrent failed.";
344 command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
345 command_buffer_->SetParseError(gpu::error::kLostContext);
346 CheckContextLost();
347 return false;
348 }
349
Destroy()350 void GpuCommandBufferStub::Destroy() {
351 if (handle_.is_null() && !active_url_.is_empty()) {
352 GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
353 gpu_channel_manager->Send(new GpuHostMsg_DidDestroyOffscreenContext(
354 active_url_));
355 }
356
357 memory_manager_client_state_.reset();
358
359 while (!sync_points_.empty())
360 OnRetireSyncPoint(sync_points_.front());
361
362 if (decoder_)
363 decoder_->set_engine(NULL);
364
365 // The scheduler has raw references to the decoder and the command buffer so
366 // destroy it before those.
367 scheduler_.reset();
368
369 bool have_context = false;
370 if (decoder_ && command_buffer_ &&
371 command_buffer_->GetState().error != gpu::error::kLostContext)
372 have_context = decoder_->MakeCurrent();
373 FOR_EACH_OBSERVER(DestructionObserver,
374 destruction_observers_,
375 OnWillDestroyStub());
376
377 if (decoder_) {
378 decoder_->Destroy(have_context);
379 decoder_.reset();
380 }
381
382 command_buffer_.reset();
383
384 // Remove this after crbug.com/248395 is sorted out.
385 surface_ = NULL;
386 }
387
OnInitializeFailed(IPC::Message * reply_message)388 void GpuCommandBufferStub::OnInitializeFailed(IPC::Message* reply_message) {
389 Destroy();
390 GpuCommandBufferMsg_Initialize::WriteReplyParams(
391 reply_message, false, gpu::Capabilities());
392 Send(reply_message);
393 }
394
OnInitialize(base::SharedMemoryHandle shared_state_handle,IPC::Message * reply_message)395 void GpuCommandBufferStub::OnInitialize(
396 base::SharedMemoryHandle shared_state_handle,
397 IPC::Message* reply_message) {
398 TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnInitialize");
399 DCHECK(!command_buffer_.get());
400
401 scoped_ptr<base::SharedMemory> shared_state_shm(
402 new base::SharedMemory(shared_state_handle, false));
403
404 command_buffer_.reset(new gpu::CommandBufferService(
405 context_group_->transfer_buffer_manager()));
406
407 if (!command_buffer_->Initialize()) {
408 DLOG(ERROR) << "CommandBufferService failed to initialize.\n";
409 OnInitializeFailed(reply_message);
410 return;
411 }
412
413 decoder_.reset(::gpu::gles2::GLES2Decoder::Create(context_group_.get()));
414
415 scheduler_.reset(new gpu::GpuScheduler(command_buffer_.get(),
416 decoder_.get(),
417 decoder_.get()));
418 if (preemption_flag_.get())
419 scheduler_->SetPreemptByFlag(preemption_flag_);
420
421 decoder_->set_engine(scheduler_.get());
422
423 if (!handle_.is_null()) {
424 #if defined(OS_MACOSX) || defined(UI_COMPOSITOR_IMAGE_TRANSPORT)
425 if (software_) {
426 DLOG(ERROR) << "No software support.\n";
427 OnInitializeFailed(reply_message);
428 return;
429 }
430 #endif
431
432 surface_ = ImageTransportSurface::CreateSurface(
433 channel_->gpu_channel_manager(),
434 this,
435 handle_);
436 } else {
437 GpuChannelManager* manager = channel_->gpu_channel_manager();
438 surface_ = manager->GetDefaultOffscreenSurface();
439 }
440
441 if (!surface_.get()) {
442 DLOG(ERROR) << "Failed to create surface.\n";
443 OnInitializeFailed(reply_message);
444 return;
445 }
446
447 scoped_refptr<gfx::GLContext> context;
448 if (use_virtualized_gl_context_ && channel_->share_group()) {
449 context = channel_->share_group()->GetSharedContext();
450 if (!context.get()) {
451 context = gfx::GLContext::CreateGLContext(
452 channel_->share_group(),
453 channel_->gpu_channel_manager()->GetDefaultOffscreenSurface(),
454 gpu_preference_);
455 channel_->share_group()->SetSharedContext(context.get());
456 }
457 // This should be a non-virtual GL context.
458 DCHECK(context->GetHandle());
459 context = new gpu::GLContextVirtual(
460 channel_->share_group(), context.get(), decoder_->AsWeakPtr());
461 if (!context->Initialize(surface_.get(), gpu_preference_)) {
462 // TODO(sievers): The real context created above for the default
463 // offscreen surface might not be compatible with this surface.
464 // Need to adjust at least GLX to be able to create the initial context
465 // with a config that is compatible with onscreen and offscreen surfaces.
466 context = NULL;
467
468 DLOG(ERROR) << "Failed to initialize virtual GL context.";
469 OnInitializeFailed(reply_message);
470 return;
471 }
472 }
473 if (!context.get()) {
474 context = gfx::GLContext::CreateGLContext(
475 channel_->share_group(), surface_.get(), gpu_preference_);
476 }
477 if (!context.get()) {
478 DLOG(ERROR) << "Failed to create context.\n";
479 OnInitializeFailed(reply_message);
480 return;
481 }
482
483 if (!context->MakeCurrent(surface_.get())) {
484 LOG(ERROR) << "Failed to make context current.";
485 OnInitializeFailed(reply_message);
486 return;
487 }
488
489 if (!context->GetGLStateRestorer()) {
490 context->SetGLStateRestorer(
491 new gpu::GLStateRestorerImpl(decoder_->AsWeakPtr()));
492 }
493
494 if (!context->GetTotalGpuMemory(&total_gpu_memory_))
495 total_gpu_memory_ = 0;
496
497 if (!context_group_->has_program_cache()) {
498 context_group_->set_program_cache(
499 channel_->gpu_channel_manager()->program_cache());
500 }
501
502 // Initialize the decoder with either the view or pbuffer GLContext.
503 if (!decoder_->Initialize(surface_,
504 context,
505 !surface_id(),
506 initial_size_,
507 disallowed_features_,
508 requested_attribs_)) {
509 DLOG(ERROR) << "Failed to initialize decoder.";
510 OnInitializeFailed(reply_message);
511 return;
512 }
513
514 gpu_control_.reset(
515 new gpu::GpuControlService(context_group_->image_manager(),
516 NULL,
517 context_group_->mailbox_manager(),
518 NULL,
519 decoder_->GetCapabilities()));
520
521 if (CommandLine::ForCurrentProcess()->HasSwitch(
522 switches::kEnableGPUServiceLogging)) {
523 decoder_->set_log_commands(true);
524 }
525
526 decoder_->GetLogger()->SetMsgCallback(
527 base::Bind(&GpuCommandBufferStub::SendConsoleMessage,
528 base::Unretained(this)));
529 decoder_->SetShaderCacheCallback(
530 base::Bind(&GpuCommandBufferStub::SendCachedShader,
531 base::Unretained(this)));
532 decoder_->SetWaitSyncPointCallback(
533 base::Bind(&GpuCommandBufferStub::OnWaitSyncPoint,
534 base::Unretained(this)));
535
536 command_buffer_->SetPutOffsetChangeCallback(
537 base::Bind(&GpuCommandBufferStub::PutChanged, base::Unretained(this)));
538 command_buffer_->SetGetBufferChangeCallback(
539 base::Bind(&gpu::GpuScheduler::SetGetBuffer,
540 base::Unretained(scheduler_.get())));
541 command_buffer_->SetParseErrorCallback(
542 base::Bind(&GpuCommandBufferStub::OnParseError, base::Unretained(this)));
543 scheduler_->SetSchedulingChangedCallback(
544 base::Bind(&GpuChannel::StubSchedulingChanged,
545 base::Unretained(channel_)));
546
547 if (watchdog_) {
548 scheduler_->SetCommandProcessedCallback(
549 base::Bind(&GpuCommandBufferStub::OnCommandProcessed,
550 base::Unretained(this)));
551 }
552
553 if (!command_buffer_->SetSharedStateBuffer(shared_state_shm.Pass())) {
554 DLOG(ERROR) << "Failed to map shared stae buffer.";
555 OnInitializeFailed(reply_message);
556 return;
557 }
558
559 GpuCommandBufferMsg_Initialize::WriteReplyParams(
560 reply_message, true, gpu_control_->GetCapabilities());
561 Send(reply_message);
562
563 if (handle_.is_null() && !active_url_.is_empty()) {
564 GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
565 gpu_channel_manager->Send(new GpuHostMsg_DidCreateOffscreenContext(
566 active_url_));
567 }
568 }
569
OnSetLatencyInfo(const ui::LatencyInfo & latency_info)570 void GpuCommandBufferStub::OnSetLatencyInfo(
571 const ui::LatencyInfo& latency_info) {
572 if (!latency_info_callback_.is_null())
573 latency_info_callback_.Run(latency_info);
574 }
575
SetLatencyInfoCallback(const LatencyInfoCallback & callback)576 void GpuCommandBufferStub::SetLatencyInfoCallback(
577 const LatencyInfoCallback& callback) {
578 latency_info_callback_ = callback;
579 }
580
GetRequestedAttribute(int attr) const581 int32 GpuCommandBufferStub::GetRequestedAttribute(int attr) const {
582 // The command buffer is pairs of enum, value
583 // search for the requested attribute, return the value.
584 for (std::vector<int32>::const_iterator it = requested_attribs_.begin();
585 it != requested_attribs_.end(); ++it) {
586 if (*it++ == attr) {
587 return *it;
588 }
589 }
590 return -1;
591 }
592
OnSetGetBuffer(int32 shm_id,IPC::Message * reply_message)593 void GpuCommandBufferStub::OnSetGetBuffer(int32 shm_id,
594 IPC::Message* reply_message) {
595 TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnSetGetBuffer");
596 if (command_buffer_)
597 command_buffer_->SetGetBuffer(shm_id);
598 Send(reply_message);
599 }
600
OnProduceFrontBuffer(const gpu::Mailbox & mailbox)601 void GpuCommandBufferStub::OnProduceFrontBuffer(const gpu::Mailbox& mailbox) {
602 TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnProduceFrontBuffer");
603 if (!decoder_) {
604 LOG(ERROR) << "Can't produce front buffer before initialization.";
605 return;
606 }
607
608 decoder_->ProduceFrontBuffer(mailbox);
609 }
610
OnGetState(IPC::Message * reply_message)611 void GpuCommandBufferStub::OnGetState(IPC::Message* reply_message) {
612 TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnGetState");
613 if (command_buffer_) {
614 gpu::CommandBuffer::State state = command_buffer_->GetState();
615 CheckContextLost();
616 GpuCommandBufferMsg_GetState::WriteReplyParams(reply_message, state);
617 } else {
618 DLOG(ERROR) << "no command_buffer.";
619 reply_message->set_reply_error();
620 }
621 Send(reply_message);
622 }
623
OnParseError()624 void GpuCommandBufferStub::OnParseError() {
625 TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnParseError");
626 DCHECK(command_buffer_.get());
627 gpu::CommandBuffer::State state = command_buffer_->GetState();
628 IPC::Message* msg = new GpuCommandBufferMsg_Destroyed(
629 route_id_, state.context_lost_reason);
630 msg->set_unblock(true);
631 Send(msg);
632
633 // Tell the browser about this context loss as well, so it can
634 // determine whether client APIs like WebGL need to be immediately
635 // blocked from automatically running.
636 GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
637 gpu_channel_manager->Send(new GpuHostMsg_DidLoseContext(
638 handle_.is_null(), state.context_lost_reason, active_url_));
639
640 CheckContextLost();
641 }
642
OnGetStateFast(IPC::Message * reply_message)643 void GpuCommandBufferStub::OnGetStateFast(IPC::Message* reply_message) {
644 TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnGetStateFast");
645 DCHECK(command_buffer_.get());
646 CheckContextLost();
647 gpu::CommandBuffer::State state = command_buffer_->GetState();
648 GpuCommandBufferMsg_GetStateFast::WriteReplyParams(reply_message, state);
649 Send(reply_message);
650 }
651
OnAsyncFlush(int32 put_offset,uint32 flush_count)652 void GpuCommandBufferStub::OnAsyncFlush(int32 put_offset,
653 uint32 flush_count) {
654 TRACE_EVENT1("gpu", "GpuCommandBufferStub::OnAsyncFlush",
655 "put_offset", put_offset);
656 DCHECK(command_buffer_.get());
657 if (flush_count - last_flush_count_ < 0x8000000U) {
658 last_flush_count_ = flush_count;
659 command_buffer_->Flush(put_offset);
660 } else {
661 // We received this message out-of-order. This should not happen but is here
662 // to catch regressions. Ignore the message.
663 NOTREACHED() << "Received a Flush message out-of-order";
664 }
665
666 ReportState();
667 }
668
OnRescheduled()669 void GpuCommandBufferStub::OnRescheduled() {
670 gpu::CommandBuffer::State pre_state = command_buffer_->GetLastState();
671 command_buffer_->Flush(pre_state.put_offset);
672 gpu::CommandBuffer::State post_state = command_buffer_->GetLastState();
673
674 if (pre_state.get_offset != post_state.get_offset)
675 ReportState();
676 }
677
OnRegisterTransferBuffer(int32 id,base::SharedMemoryHandle transfer_buffer,uint32 size)678 void GpuCommandBufferStub::OnRegisterTransferBuffer(
679 int32 id,
680 base::SharedMemoryHandle transfer_buffer,
681 uint32 size) {
682 TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnRegisterTransferBuffer");
683 base::SharedMemory shared_memory(transfer_buffer, false);
684
685 if (command_buffer_)
686 command_buffer_->RegisterTransferBuffer(id, &shared_memory, size);
687 }
688
OnDestroyTransferBuffer(int32 id)689 void GpuCommandBufferStub::OnDestroyTransferBuffer(int32 id) {
690 TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnDestroyTransferBuffer");
691
692 if (command_buffer_)
693 command_buffer_->DestroyTransferBuffer(id);
694 }
695
OnGetTransferBuffer(int32 id,IPC::Message * reply_message)696 void GpuCommandBufferStub::OnGetTransferBuffer(
697 int32 id,
698 IPC::Message* reply_message) {
699 TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnGetTransferBuffer");
700 if (command_buffer_) {
701 base::SharedMemoryHandle transfer_buffer = base::SharedMemoryHandle();
702 uint32 size = 0;
703
704 gpu::Buffer buffer = command_buffer_->GetTransferBuffer(id);
705 if (buffer.shared_memory) {
706 #if defined(OS_WIN)
707 transfer_buffer = NULL;
708 BrokerDuplicateHandle(buffer.shared_memory->handle(),
709 channel_->renderer_pid(), &transfer_buffer, FILE_MAP_READ |
710 FILE_MAP_WRITE, 0);
711 DCHECK(transfer_buffer != NULL);
712 #else
713 buffer.shared_memory->ShareToProcess(channel_->renderer_pid(),
714 &transfer_buffer);
715 #endif
716 size = buffer.size;
717 }
718
719 GpuCommandBufferMsg_GetTransferBuffer::WriteReplyParams(reply_message,
720 transfer_buffer,
721 size);
722 } else {
723 reply_message->set_reply_error();
724 }
725 Send(reply_message);
726 }
727
OnCommandProcessed()728 void GpuCommandBufferStub::OnCommandProcessed() {
729 if (watchdog_)
730 watchdog_->CheckArmed();
731 }
732
ReportState()733 void GpuCommandBufferStub::ReportState() {
734 if (!CheckContextLost())
735 command_buffer_->UpdateState();
736 }
737
PutChanged()738 void GpuCommandBufferStub::PutChanged() {
739 FastSetActiveURL(active_url_, active_url_hash_);
740 scheduler_->PutChanged();
741 }
742
OnCreateVideoDecoder(media::VideoCodecProfile profile,IPC::Message * reply_message)743 void GpuCommandBufferStub::OnCreateVideoDecoder(
744 media::VideoCodecProfile profile,
745 IPC::Message* reply_message) {
746 TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnCreateVideoDecoder");
747 int decoder_route_id = channel_->GenerateRouteID();
748 GpuVideoDecodeAccelerator* decoder = new GpuVideoDecodeAccelerator(
749 decoder_route_id, this, channel_->io_message_loop());
750 decoder->Initialize(profile, reply_message);
751 // decoder is registered as a DestructionObserver of this stub and will
752 // self-delete during destruction of this stub.
753 }
754
OnSetSurfaceVisible(bool visible)755 void GpuCommandBufferStub::OnSetSurfaceVisible(bool visible) {
756 TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnSetSurfaceVisible");
757 if (memory_manager_client_state_)
758 memory_manager_client_state_->SetVisible(visible);
759 }
760
AddSyncPoint(uint32 sync_point)761 void GpuCommandBufferStub::AddSyncPoint(uint32 sync_point) {
762 sync_points_.push_back(sync_point);
763 }
764
OnRetireSyncPoint(uint32 sync_point)765 void GpuCommandBufferStub::OnRetireSyncPoint(uint32 sync_point) {
766 DCHECK(!sync_points_.empty() && sync_points_.front() == sync_point);
767 sync_points_.pop_front();
768 if (context_group_->mailbox_manager()->UsesSync() && MakeCurrent())
769 context_group_->mailbox_manager()->PushTextureUpdates();
770 GpuChannelManager* manager = channel_->gpu_channel_manager();
771 manager->sync_point_manager()->RetireSyncPoint(sync_point);
772 }
773
OnWaitSyncPoint(uint32 sync_point)774 bool GpuCommandBufferStub::OnWaitSyncPoint(uint32 sync_point) {
775 if (sync_point_wait_count_ == 0) {
776 TRACE_EVENT_ASYNC_BEGIN1("gpu", "WaitSyncPoint", this,
777 "GpuCommandBufferStub", this);
778 }
779 scheduler_->SetScheduled(false);
780 ++sync_point_wait_count_;
781 GpuChannelManager* manager = channel_->gpu_channel_manager();
782 manager->sync_point_manager()->AddSyncPointCallback(
783 sync_point,
784 base::Bind(&GpuCommandBufferStub::OnSyncPointRetired,
785 this->AsWeakPtr()));
786 return scheduler_->IsScheduled();
787 }
788
OnSyncPointRetired()789 void GpuCommandBufferStub::OnSyncPointRetired() {
790 --sync_point_wait_count_;
791 if (sync_point_wait_count_ == 0) {
792 TRACE_EVENT_ASYNC_END1("gpu", "WaitSyncPoint", this,
793 "GpuCommandBufferStub", this);
794 }
795 scheduler_->SetScheduled(true);
796 }
797
OnSignalSyncPoint(uint32 sync_point,uint32 id)798 void GpuCommandBufferStub::OnSignalSyncPoint(uint32 sync_point, uint32 id) {
799 GpuChannelManager* manager = channel_->gpu_channel_manager();
800 manager->sync_point_manager()->AddSyncPointCallback(
801 sync_point,
802 base::Bind(&GpuCommandBufferStub::OnSignalSyncPointAck,
803 this->AsWeakPtr(),
804 id));
805 }
806
OnSignalSyncPointAck(uint32 id)807 void GpuCommandBufferStub::OnSignalSyncPointAck(uint32 id) {
808 Send(new GpuCommandBufferMsg_SignalSyncPointAck(route_id_, id));
809 }
810
OnSignalQuery(uint32 query_id,uint32 id)811 void GpuCommandBufferStub::OnSignalQuery(uint32 query_id, uint32 id) {
812 if (decoder_) {
813 gpu::gles2::QueryManager* query_manager = decoder_->GetQueryManager();
814 if (query_manager) {
815 gpu::gles2::QueryManager::Query* query =
816 query_manager->GetQuery(query_id);
817 if (query) {
818 query->AddCallback(
819 base::Bind(&GpuCommandBufferStub::OnSignalSyncPointAck,
820 this->AsWeakPtr(),
821 id));
822 return;
823 }
824 }
825 }
826 // Something went wrong, run callback immediately.
827 OnSignalSyncPointAck(id);
828 }
829
830
OnReceivedClientManagedMemoryStats(const gpu::ManagedMemoryStats & stats)831 void GpuCommandBufferStub::OnReceivedClientManagedMemoryStats(
832 const gpu::ManagedMemoryStats& stats) {
833 TRACE_EVENT0(
834 "gpu",
835 "GpuCommandBufferStub::OnReceivedClientManagedMemoryStats");
836 if (memory_manager_client_state_)
837 memory_manager_client_state_->SetManagedMemoryStats(stats);
838 }
839
OnSetClientHasMemoryAllocationChangedCallback(bool has_callback)840 void GpuCommandBufferStub::OnSetClientHasMemoryAllocationChangedCallback(
841 bool has_callback) {
842 TRACE_EVENT0(
843 "gpu",
844 "GpuCommandBufferStub::OnSetClientHasMemoryAllocationChangedCallback");
845 if (has_callback) {
846 if (!memory_manager_client_state_) {
847 memory_manager_client_state_.reset(GetMemoryManager()->CreateClientState(
848 this, surface_id_ != 0, true));
849 }
850 } else {
851 memory_manager_client_state_.reset();
852 }
853 }
854
OnRegisterGpuMemoryBuffer(int32 id,gfx::GpuMemoryBufferHandle gpu_memory_buffer,uint32 width,uint32 height,uint32 internalformat)855 void GpuCommandBufferStub::OnRegisterGpuMemoryBuffer(
856 int32 id,
857 gfx::GpuMemoryBufferHandle gpu_memory_buffer,
858 uint32 width,
859 uint32 height,
860 uint32 internalformat) {
861 TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnRegisterGpuMemoryBuffer");
862 if (gpu_control_) {
863 gpu_control_->RegisterGpuMemoryBuffer(id,
864 gpu_memory_buffer,
865 width,
866 height,
867 internalformat);
868 }
869 }
870
OnDestroyGpuMemoryBuffer(int32 id)871 void GpuCommandBufferStub::OnDestroyGpuMemoryBuffer(int32 id) {
872 TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnDestroyGpuMemoryBuffer");
873 if (gpu_control_)
874 gpu_control_->DestroyGpuMemoryBuffer(id);
875 }
876
SendConsoleMessage(int32 id,const std::string & message)877 void GpuCommandBufferStub::SendConsoleMessage(
878 int32 id,
879 const std::string& message) {
880 GPUCommandBufferConsoleMessage console_message;
881 console_message.id = id;
882 console_message.message = message;
883 IPC::Message* msg = new GpuCommandBufferMsg_ConsoleMsg(
884 route_id_, console_message);
885 msg->set_unblock(true);
886 Send(msg);
887 }
888
SendCachedShader(const std::string & key,const std::string & shader)889 void GpuCommandBufferStub::SendCachedShader(
890 const std::string& key, const std::string& shader) {
891 channel_->CacheShader(key, shader);
892 }
893
AddDestructionObserver(DestructionObserver * observer)894 void GpuCommandBufferStub::AddDestructionObserver(
895 DestructionObserver* observer) {
896 destruction_observers_.AddObserver(observer);
897 }
898
RemoveDestructionObserver(DestructionObserver * observer)899 void GpuCommandBufferStub::RemoveDestructionObserver(
900 DestructionObserver* observer) {
901 destruction_observers_.RemoveObserver(observer);
902 }
903
SetPreemptByFlag(scoped_refptr<gpu::PreemptionFlag> flag)904 void GpuCommandBufferStub::SetPreemptByFlag(
905 scoped_refptr<gpu::PreemptionFlag> flag) {
906 preemption_flag_ = flag;
907 if (scheduler_)
908 scheduler_->SetPreemptByFlag(preemption_flag_);
909 }
910
GetTotalGpuMemory(uint64 * bytes)911 bool GpuCommandBufferStub::GetTotalGpuMemory(uint64* bytes) {
912 *bytes = total_gpu_memory_;
913 return !!total_gpu_memory_;
914 }
915
GetSurfaceSize() const916 gfx::Size GpuCommandBufferStub::GetSurfaceSize() const {
917 if (!surface_.get())
918 return gfx::Size();
919 return surface_->GetSize();
920 }
921
GetMemoryTracker() const922 gpu::gles2::MemoryTracker* GpuCommandBufferStub::GetMemoryTracker() const {
923 return context_group_->memory_tracker();
924 }
925
SetMemoryAllocation(const gpu::MemoryAllocation & allocation)926 void GpuCommandBufferStub::SetMemoryAllocation(
927 const gpu::MemoryAllocation& allocation) {
928 if (!last_memory_allocation_valid_ ||
929 !allocation.Equals(last_memory_allocation_)) {
930 Send(new GpuCommandBufferMsg_SetMemoryAllocation(
931 route_id_, allocation));
932 }
933
934 last_memory_allocation_valid_ = true;
935 last_memory_allocation_ = allocation;
936 }
937
SuggestHaveFrontBuffer(bool suggest_have_frontbuffer)938 void GpuCommandBufferStub::SuggestHaveFrontBuffer(
939 bool suggest_have_frontbuffer) {
940 // This can be called outside of OnMessageReceived, so the context needs
941 // to be made current before calling methods on the surface.
942 if (surface_.get() && MakeCurrent())
943 surface_->SetFrontbufferAllocation(suggest_have_frontbuffer);
944 }
945
CheckContextLost()946 bool GpuCommandBufferStub::CheckContextLost() {
947 DCHECK(command_buffer_);
948 gpu::CommandBuffer::State state = command_buffer_->GetState();
949 bool was_lost = state.error == gpu::error::kLostContext;
950 // Lose all other contexts if the reset was triggered by the robustness
951 // extension instead of being synthetic.
952 if (was_lost && decoder_ && decoder_->WasContextLostByRobustnessExtension() &&
953 (gfx::GLContext::LosesAllContextsOnContextLost() ||
954 use_virtualized_gl_context_))
955 channel_->LoseAllContexts();
956 return was_lost;
957 }
958
MarkContextLost()959 void GpuCommandBufferStub::MarkContextLost() {
960 if (!command_buffer_ ||
961 command_buffer_->GetState().error == gpu::error::kLostContext)
962 return;
963
964 command_buffer_->SetContextLostReason(gpu::error::kUnknown);
965 if (decoder_)
966 decoder_->LoseContext(GL_UNKNOWN_CONTEXT_RESET_ARB);
967 command_buffer_->SetParseError(gpu::error::kLostContext);
968 }
969
GetMemoryUsage() const970 uint64 GpuCommandBufferStub::GetMemoryUsage() const {
971 return GetMemoryManager()->GetClientMemoryUsage(this);
972 }
973
974 } // namespace content
975