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

content/common/gpu/client/command_buffer_proxy_impl.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_impl.h"
 
 #include "base/callback.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/process_util.h"
@@ skipping 131 matching lines @@
 
   // This handle is owned by the GPU process and must be passed to it or it
   // will leak. In otherwords, do not early out on error between here and the
   // sending of the Initialize IPC below.
   base::SharedMemoryHandle handle =
       channel_->ShareToGpuProcess(shared_state_shm_.get());
   if (!base::SharedMemory::IsHandleValid(handle))
     return false;
 
   bool result;
-  if (!Send(new GpuCommandBufferMsg_Initialize(route_id_, handle, &result))) {
-    LOG(ERROR) << "Could not send GpuCommandBufferMsg_Initialize.";
-    return false;
+  {
+    base::ThreadRestrictions::ScopedAllowWait allow_wait;
+    if (!Send(new GpuCommandBufferMsg_Initialize(route_id_, handle, &result))) {

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

handler does not need DELAYED_RESPONSE, so should be ok?

+      LOG(ERROR) << "Could not send GpuCommandBufferMsg_Initialize.";
+      return false;
+    }
   }
 
   if (!result) {
     LOG(ERROR) << "Failed to initialize command buffer service.";
     return false;
   }
 
   return true;
 }
 
 gpu::CommandBuffer::State CommandBufferProxyImpl::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);
+    {
+      // Seems fine.
+      base::ThreadRestrictions::ScopedAllowWait allow_wait;
+      if (Send(new GpuCommandBufferMsg_GetState(route_id_, &state)))

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

Again doesn't really need DELAYED_RESPONSE except for using it to send back an
error, so should be ok?

+        OnUpdateState(state);
+    }
   }
 
   TryUpdateState();
   return last_state_;
 }
 
 gpu::CommandBuffer::State CommandBufferProxyImpl::GetLastState() {
   return last_state_;
 }
 
@@ skipping 25 matching lines @@
     int32 put_offset,
     int32 last_known_get) {
   TRACE_EVENT1("gpu", "CommandBufferProxyImpl::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);
+      {
+        base::ThreadRestrictions::ScopedAllowWait allow_wait;
+        if (Send(new GpuCommandBufferMsg_GetStateFast(route_id_,

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

I changed handler to not use DELAYED_RESPONSE

+                                                      &state)))
+          OnUpdateState(state);
+      }
     }
     TryUpdateState();
   }
 
   return last_state_;
 }
 
 void CommandBufferProxyImpl::SetGetBuffer(int32 shm_id) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
-  Send(new GpuCommandBufferMsg_SetGetBuffer(route_id_, shm_id));
+  {
+    // Seems safe, direct reply.
+    base::ThreadRestrictions::ScopedAllowWait allow_wait;
+    Send(new GpuCommandBufferMsg_SetGetBuffer(route_id_, shm_id));

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

Changed handler to not use DELAYED_RESPONSE

+  }
   last_put_offset_ = -1;
 }
 
 void CommandBufferProxyImpl::SetGetOffset(int32 get_offset) {
   // Not implemented in proxy.
   NOTREACHED();
 }
 
 gpu::Buffer CommandBufferProxyImpl::CreateTransferBuffer(size_t size,
                                                          int32* id) {
@@ skipping 284 matching lines @@
 void CommandBufferProxyImpl::SendManagedMemoryStats(
     const GpuManagedMemoryStats& stats) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   Send(new GpuCommandBufferMsg_SendClientManagedMemoryStats(route_id_,
                                                             stats));
 }
 
 }  // namespace content