GPU service respects --single-process

chrome/gpu/gpu_command_buffer_stub.cc

 // Copyright (c) 2010 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/process_util.h"
 #include "base/shared_memory.h"
 #include "build/build_config.h"
 #include "chrome/common/child_thread.h"
 #include "chrome/common/gpu_messages.h"
 #include "chrome/gpu/gpu_channel.h"
 #include "chrome/gpu/gpu_command_buffer_stub.h"
+#include "chrome/gpu/gpu_thread.h"
 
 using gpu::Buffer;
 
 #if defined(OS_WIN)
 #define kCompositorWindowOwner L"CompositorWindowOwner"
 #endif  // defined(OS_WIN)
 
 GpuCommandBufferStub::GpuCommandBufferStub(
     GpuChannel* channel,
     gfx::PluginWindowHandle handle,
@@ skipping 50 matching lines @@
     default:
       return DefWindowProc(hwnd, message, wparam, lparam);
   }
   return 0;
 }
 
 bool GpuCommandBufferStub::CreateCompositorWindow() {
   DCHECK(handle_ != gfx::kNullPluginWindow);
 
   // Ask the browser to create the the host window.
-  ChildThread* gpu_thread = ChildThread::current();
+  GpuThread* gpu_thread = channel_->gpu_thread();
   gfx::PluginWindowHandle host_window_id = gfx::kNullPluginWindow;
   gpu_thread->Send(new GpuHostMsg_GetCompositorHostWindow(
       renderer_id_,
       render_view_id_,
       &host_window_id));
   if (host_window_id == gfx::kNullPluginWindow)
     return false;
   HWND host_window = static_cast<HWND>(host_window_id);
 
   // Create the compositor window itself.
@@ skipping 44 matching lines @@
       NULL,
       0, 0,
       parent_rect.right - parent_rect.left,
       parent_rect.bottom - parent_rect.top,
       flags);
   compositor_window_ = static_cast<gfx::PluginWindowHandle>(compositor_window);
   return true;
 }
 
 void GpuCommandBufferStub::OnCompositorWindowPainted() {
-  ChildThread* gpu_thread = ChildThread::current();
+  GpuThread* gpu_thread = channel_->gpu_thread();
   gpu_thread->Send(new GpuHostMsg_ScheduleComposite(
       renderer_id_, render_view_id_));
 }
 #endif  // defined(OS_WIN)
 
 
 GpuCommandBufferStub::~GpuCommandBufferStub() {
   if (processor_.get()) {
     processor_->Destroy();
   }
 #if defined(OS_WIN)
   if (compositor_window_) {
     DestroyWindow(static_cast<HWND>(compositor_window_));
     compositor_window_ = NULL;
   }
 #elif defined(OS_LINUX)
-  ChildThread* gpu_thread = ChildThread::current();
+  GpuThread* gpu_thread = channel_->gpu_thread();
   gpu_thread->Send(
       new GpuHostMsg_ReleaseXID(handle_));
 #endif  // defined(OS_WIN)
 }
 
 bool GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuCommandBufferStub, message)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Initialize, OnInitialize);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_GetState, OnGetState);
@@ skipping 148 matching lines @@
 void GpuCommandBufferStub::OnResizeOffscreenFrameBuffer(const gfx::Size& size) {
   processor_->ResizeOffscreenFrameBuffer(size);
 }
 
 void GpuCommandBufferStub::OnSwapBuffers() {
   Send(new GpuCommandBufferMsg_SwapBuffers(route_id_));
 }
 
 #if defined(OS_MACOSX)
 void GpuCommandBufferStub::OnSetWindowSize(const gfx::Size& size) {
-  ChildThread* gpu_thread = ChildThread::current();
+  GpuThread* gpu_thread = channel_->gpu_thread();
   // Try using the IOSurface version first.
   uint64 new_backing_store = processor_->SetWindowSizeForIOSurface(size);
   if (new_backing_store) {
     GpuHostMsg_AcceleratedSurfaceSetIOSurface_Params params;
     params.renderer_id = renderer_id_;
     params.render_view_id = render_view_id_;
     params.window = handle_;
     params.width = size.width();
     params.height = size.height();
     params.identifier = new_backing_store;
     gpu_thread->Send(new GpuHostMsg_AcceleratedSurfaceSetIOSurface(params));
   } else {
     // TODO(kbr): figure out what to do here. It wouldn't be difficult
     // to support the compositor on 10.5, but the performance would be
     // questionable.
     NOTREACHED();
   }
 }
 
 void GpuCommandBufferStub::SwapBuffersCallback() {
   OnSwapBuffers();
-  ChildThread* gpu_thread = ChildThread::current();
+  GpuThread* gpu_thread = channel_->gpu_thread();
   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
   params.renderer_id = renderer_id_;
   params.render_view_id = render_view_id_;
   params.window = handle_;
   params.surface_id = processor_->GetSurfaceId();
   params.route_id = route_id();
   params.swap_buffers_count = processor_->swap_buffers_count();
   gpu_thread->Send(new GpuHostMsg_AcceleratedSurfaceBuffersSwapped(params));
 }
 
 void GpuCommandBufferStub::AcceleratedSurfaceBuffersSwapped(
     uint64 swap_buffers_count) {
   processor_->set_acknowledged_swap_buffers_count(swap_buffers_count);
   // Wake up the GpuProcessor to start doing work again.
   processor_->ScheduleProcessCommands();
 }
 #endif  // defined(OS_MACOSX)
 
 void GpuCommandBufferStub::ResizeCallback(gfx::Size size) {
   if (handle_ == gfx::kNullPluginWindow)
     return;
 
 #if defined(OS_LINUX)
-  ChildThread* gpu_thread = ChildThread::current();
+  GpuThread* gpu_thread = channel_->gpu_thread();
   bool result = false;
   gpu_thread->Send(
       new GpuHostMsg_ResizeXID(handle_, size, &result));
 #elif defined(OS_WIN)
   HWND hwnd = static_cast<HWND>(compositor_window_);
   UINT swp_flags = SWP_NOSENDCHANGING | SWP_NOOWNERZORDER | SWP_NOCOPYBITS |
     SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_DEFERERASE;
   SetWindowPos(hwnd, NULL, 0, 0, size.width(), size.height(), swp_flags);
 #endif  // defined(OS_LINUX)
 }
 
 #endif  // defined(ENABLE_GPU)