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

content/common/gpu/client/command_buffer_proxy.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.
 
 #include "content/common/gpu/client/command_buffer_proxy.h"
 
 #include "base/callback.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "base/stl_util.h"
 #include "content/common/child_process_messages.h"
 #include "content/common/child_thread.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/plugin_messages.h"
 #include "content/common/view_messages.h"
 #include "gpu/command_buffer/common/cmd_buffer_common.h"
+#include "gpu/command_buffer/common/command_buffer_shared.h"
 #include "ui/gfx/size.h"
 
 using gpu::Buffer;
 
 CommandBufferProxy::CommandBufferProxy(
     GpuChannelHost* channel,
     int route_id)
     : channel_(channel),
       route_id_(route_id),
       flush_count_(0) {
 }
 
 CommandBufferProxy::~CommandBufferProxy() {
   // Delete all the locally cached shared memory objects, closing the handle
   // in this process.
   for (TransferBufferMap::iterator it = transfer_buffers_.begin();
        it != transfer_buffers_.end();
        ++it) {
     delete it->second.shared_memory;
     it->second.shared_memory = NULL;
   }
 }
 
 bool CommandBufferProxy::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(CommandBufferProxy, message)
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_UpdateState, OnUpdateState);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Destroyed, OnDestroyed);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_NotifyRepaint,
                         OnNotifyRepaint);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_EchoAck, OnEchoAck);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_ConsoleMsg, OnConsoleMessage);
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   DCHECK(handled);
   return handled;
@@ skipping 47 matching lines @@
   if (!Send(new GpuCommandBufferMsg_Initialize(route_id_, &result))) {
     LOG(ERROR) << "Could not send GpuCommandBufferMsg_Initialize.";
     return false;
   }
 
   if (!result) {
     LOG(ERROR) << "Failed to initialize command buffer service.";
     return false;
   }
 
+  int32 state_buffer = CreateTransferBuffer(sizeof *shared_state_, -1);

[greggman, 2012/02/11 04:17:21]

Just asking but does this need to be a separate piece of shared memory? Maybe it
does because it's being setup before GLES2Implemenation but I thought I'd ask.

The GLES2Implementation allocations a chunk of shared memory and currently
reserves the first 64 bytes for "results". That is defined by
GLES2Implemetation:kStartingOffset, from 0 to starting offset is the results
buffer, after that is the command buffer.

Would it be possible to just increase that size for these values?

Allocating separate shared memory means another file descriptor in linux which
we ran out of once before. It also means all this extra setup and 2 more sync
IPCs to startup where as if you can just use the existing memory you don't need
this extra setup.

If that's possible, I believe you can just increase
GLES2Implementation:kStartingOffset.  You can either put the state at 64 bytes
in, or you can put it at 0 bytes in and make
GLES2Implementation::GetResultOffset return enough of an offset to skip the
state.

If not no biggy.

+
+  if (state_buffer == -1) {
+    LOG(ERROR) << "Failed to create shared state transfer buffer.";
+    return false;
+  }
+
+  gpu::Buffer buffer = GetTransferBuffer(state_buffer);
+  if (!buffer.ptr) {
+    LOG(ERROR) << "Failed to get shared state transfer buffer";
+    return false;
+  }
+
+  shared_state_ = reinterpret_cast<gpu::CommandBufferSharedState*>(buffer.ptr);
+  shared_state_->Initialize();
+
+  if (!Send(new GpuCommandBufferMsg_SetSharedStateBuffer(route_id_,

[apatrick_chromium, 2012/02/13 20:50:58]

Could this be sent over as another argument to GpuCommandBufferMsg_Initialize?

+                                                         state_buffer))) {
+    LOG(ERROR) << "Failed to initialize shared command buffer state.";
+    return false;
+  }
+
   return true;
 }
 
 gpu::CommandBuffer::State CommandBufferProxy::GetState() {
   // Send will flag state with lost context if IPC fails.
   if (last_state_.error == gpu::error::kNoError) {
     gpu::CommandBuffer::State state;
     if (Send(new GpuCommandBufferMsg_GetState(route_id_, &state)))
       OnUpdateState(state);
   }
 
+  TryUpdateState();
   return last_state_;
 }
 
 gpu::CommandBuffer::State CommandBufferProxy::GetLastState() {
   return last_state_;
 }
 
 void CommandBufferProxy::Flush(int32 put_offset) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   TRACE_EVENT1("gpu", "CommandBufferProxy::Flush", "put_offset", put_offset);
 
   Send(new GpuCommandBufferMsg_AsyncFlush(route_id_,
                                           put_offset,
                                           ++flush_count_));
 }
 
 gpu::CommandBuffer::State CommandBufferProxy::FlushSync(int32 put_offset,
                                                         int32 last_known_get) {
   TRACE_EVENT1("gpu", "CommandBufferProxy::FlushSync", "put_offset",
                put_offset);
   Flush(put_offset);
+  TryUpdateState();
   if (last_known_get == last_state_.get_offset) {
     // Send will flag state with lost context if IPC fails.
     if (last_state_.error == gpu::error::kNoError) {
       gpu::CommandBuffer::State state;
       if (Send(new GpuCommandBufferMsg_GetStateFast(route_id_,
                                                     &state)))
         OnUpdateState(state);
     }
+    TryUpdateState();
   }
 
   return last_state_;
 }
 
 void CommandBufferProxy::SetGetBuffer(int32 shm_id) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   Send(new GpuCommandBufferMsg_SetGetBuffer(route_id_, shm_id));
@@ skipping 240 matching lines @@
   // updates in flight across which reordering occurs.
   if (state.generation - last_state_.generation < 0x80000000U)
     last_state_ = state;
 }
 
 void CommandBufferProxy::SetOnConsoleMessageCallback(
     const GpuConsoleMessageCallback& callback) {
   console_message_callback_ = callback;
 }
 
+void CommandBufferProxy::TryUpdateState() {
+  shared_state_->Read(&last_state_);
+}