[NOT FOR COMMIT] Hacks to merge render compositor thread with UI thread

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.
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/hash.h"
 #include "base/shared_memory.h"
@@ skipping 19 matching lines @@
 #include "ui/gl/gl_switches.h"
 
 #if defined(OS_WIN)
 #include "content/public/common/sandbox_init.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include "content/common/gpu/stream_texture_manager_android.h"
 #endif
 
+#include "base/threading/thread_restrictions.h"

[boliu, 2013/03/01 00:19:12]

oops, no needed

+
 namespace content {
 namespace {
 
 // The GpuCommandBufferMemoryTracker class provides a bridge between the
 // ContextGroup's memory type managers and the GpuMemoryManager class.
 class GpuCommandBufferMemoryTracker : public gpu::gles2::MemoryTracker {
  public:
   explicit GpuCommandBufferMemoryTracker(GpuChannel* channel) :
       tracking_group_(channel->gpu_channel_manager()->gpu_memory_manager()->
           CreateTrackingGroup(channel->renderer_pid(), this)) {
@@ skipping 115 matching lines @@
     if (!MakeCurrent())
       return false;
   }
 
   // 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(GpuCommandBufferMsg_SetGetBuffer,
+                        OnSetGetBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_SetParent,
                                     OnSetParent);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Echo, OnEcho);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_GetState, OnGetState);
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_GetStateFast,
-                                    OnGetStateFast);
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_GetStateFast,
+                        OnGetStateFast);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncFlush, OnAsyncFlush);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Rescheduled, OnRescheduled);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RegisterTransferBuffer,
                         OnRegisterTransferBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyTransferBuffer,
                         OnDestroyTransferBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_GetTransferBuffer,
                                     OnGetTransferBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_CreateVideoDecoder,
                                     OnCreateVideoDecoder)
@@ skipping 134 matching lines @@
   if (context)
     context->ReleaseCurrent(NULL);
 }
 
 void GpuCommandBufferStub::OnInitializeFailed(IPC::Message* reply_message) {
   Destroy();
   GpuCommandBufferMsg_Initialize::WriteReplyParams(reply_message, false);
   Send(reply_message);
 }
 
 void GpuCommandBufferStub::OnInitialize(

[boliu, 2013/03/01 00:19:12]

This doesn't really need flexibility of DELAYED_RESPONSE

     base::SharedMemoryHandle shared_state_handle,
     IPC::Message* reply_message) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnInitialize");
   DCHECK(!command_buffer_.get());
 
   scoped_ptr<base::SharedMemory> shared_state_shm(
       new base::SharedMemory(shared_state_handle, false));
 
   command_buffer_.reset(new gpu::CommandBufferService(
       context_group_->transfer_buffer_manager()));
@@ skipping 166 matching lines @@
   GpuCommandBufferMsg_Initialize::WriteReplyParams(reply_message, true);
   Send(reply_message);
 
   if (handle_.is_null() && !active_url_.is_empty()) {
     GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
     gpu_channel_manager->Send(new GpuHostMsg_DidCreateOffscreenContext(
         active_url_));
   }
 }
 
-void GpuCommandBufferStub::OnSetGetBuffer(int32 shm_id,
-                                          IPC::Message* reply_message) {
+void GpuCommandBufferStub::OnSetGetBuffer(int32 shm_id) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnSetGetBuffer");
   if (command_buffer_.get())
     command_buffer_->SetGetBuffer(shm_id);
-  Send(reply_message);
 }
 
 void GpuCommandBufferStub::OnSetParent(int32 parent_route_id,
                                        uint32 parent_texture_id,
                                        IPC::Message* reply_message) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnSetParent");
   GpuCommandBufferStub* parent_stub = NULL;
   if (parent_route_id != MSG_ROUTING_NONE) {
     parent_stub = channel_->LookupCommandBuffer(parent_route_id);
   }
@@ skipping 41 matching lines @@
   Send(msg);
 
   // Tell the browser about this context loss as well, so it can
   // determine whether client APIs like WebGL need to be immediately
   // blocked from automatically running.
   GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
   gpu_channel_manager->Send(new GpuHostMsg_DidLoseContext(
       handle_.is_null(), state.context_lost_reason, active_url_));
 }
 
-void GpuCommandBufferStub::OnGetStateFast(IPC::Message* reply_message) {
+void GpuCommandBufferStub::OnGetStateFast(gpu::CommandBuffer::State* state) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnGetStateFast");
   DCHECK(command_buffer_.get());
-  gpu::CommandBuffer::State state = command_buffer_->GetState();
-  if (state.error == gpu::error::kLostContext &&
+  *state = command_buffer_->GetState();
+  if (state->error == gpu::error::kLostContext &&
       gfx::GLContext::LosesAllContextsOnContextLost())
     channel_->LoseAllContexts();
-
-  GpuCommandBufferMsg_GetStateFast::WriteReplyParams(reply_message, state);
-  Send(reply_message);
 }
 
 void GpuCommandBufferStub::OnAsyncFlush(int32 put_offset,
                                         uint32 flush_count) {
   TRACE_EVENT1("gpu", "GpuCommandBufferStub::OnAsyncFlush",
                "put_offset", put_offset);
   DCHECK(command_buffer_.get());
   if (flush_count - last_flush_count_ < 0x8000000U) {
     last_flush_count_ = flush_count;
     command_buffer_->Flush(put_offset);
@@ skipping 268 matching lines @@
     if (surface_ && MakeCurrent())
       surface_->SetFrontbufferAllocation(
           allocation.browser_allocation.suggest_have_frontbuffer);
   }
 
   last_memory_allocation_valid_ = true;
   last_memory_allocation_ = allocation;
 }
 
 }  // namespace content