Use shared memory to update the renderer's view of the command buffer state.

content/common/gpu/gpu_command_buffer_stub.cc

  // 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.
 
 #if defined(ENABLE_GPU)
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 80 matching lines @@
   }
 
   // Always use IPC_MESSAGE_HANDLER_DELAY_REPLY for synchronous message handlers
   // here. This is so the reply can be delayed if the scheduler is unscheduled.
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuCommandBufferStub, message)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_Initialize,
                                     OnInitialize);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_SetGetBuffer,
                                     OnSetGetBuffer);
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_SetSharedStateBuffer,
+                                    OnSetSharedStateBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_SetParent,
                                     OnSetParent);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_GetState, OnGetState);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_GetStateFast,
                                     OnGetStateFast);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncFlush, OnAsyncFlush);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Rescheduled, OnRescheduled);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_CreateTransferBuffer,
                                     OnCreateTransferBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_RegisterTransferBuffer,
@@ skipping 176 matching lines @@
     int32 shm_id, IPC::Message* reply_message) {
   if (command_buffer_.get()) {
     command_buffer_->SetGetBuffer(shm_id);
   } else {
     DLOG(ERROR) << "no command_buffer.";
     reply_message->set_reply_error();
   }
   Send(reply_message);
 }
 
+void GpuCommandBufferStub::OnSetSharedStateBuffer(
+    int32 shm_id, IPC::Message* reply_message) {
+  if (command_buffer_.get()) {
+    command_buffer_->SetSharedStateBuffer(shm_id);
+  } else {
+    DLOG(ERROR) << "no command_buffer.";
+    reply_message->set_reply_error();
+  }
+  Send(reply_message);
+}
+
 void GpuCommandBufferStub::OnSetParent(int32 parent_route_id,
                                        uint32 parent_texture_id,
                                        IPC::Message* reply_message) {
   GpuCommandBufferStub* parent_stub = NULL;
   if (parent_route_id != MSG_ROUTING_NONE) {
     parent_stub = channel_->LookupCommandBuffer(parent_route_id);
   }
 
   bool result = true;
   if (scheduler_.get()) {
@@ skipping 162 matching lines @@
   if (watchdog_)
     watchdog_->CheckArmed();
 }
 
 void GpuCommandBufferStub::ReportState() {
   gpu::CommandBuffer::State state = command_buffer_->GetState();
   if (state.error == gpu::error::kLostContext &&
       gfx::GLContext::LosesAllContextsOnContextLost()) {
     channel_->LoseAllContexts();
   } else {
-    IPC::Message* msg = new GpuCommandBufferMsg_UpdateState(route_id_, state);
-    msg->set_unblock(true);
-    Send(msg);
+    command_buffer_->UpdateState();
   }
 }
 
 void GpuCommandBufferStub::OnCreateVideoDecoder(
     media::VideoDecodeAccelerator::Profile profile,
     IPC::Message* reply_message) {
   int decoder_route_id = channel_->GenerateRouteID();
   GpuCommandBufferMsg_CreateVideoDecoder::WriteReplyParams(
       reply_message, decoder_route_id);
   GpuVideoDecodeAccelerator* decoder =
@@ skipping 67 matching lines @@
     return;
   if (allocation.has_frontbuffer && allocation.has_backbuffer)
     surface_->SetVisibility(gfx::GLSurface::VISIBILITY_STATE_FOREGROUND);
   else if (allocation.has_frontbuffer)
     surface_->SetVisibility(gfx::GLSurface::VISIBILITY_STATE_BACKGROUND);
   else
     surface_->SetVisibility(gfx::GLSurface::VISIBILITY_STATE_HIBERNATED);
 }
 
 #endif  // defined(ENABLE_GPU)