Moved code that runs in both the browser and GPU process from content/gpu to content/common/gpu.

content/common/gpu/gpu_command_buffer_stub.cc

 // Copyright (c) 2011 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 "content/common/child_thread.h"
 #include "content/common/gpu_messages.h"
-#include "content/common/child_thread.h"
-#include "content/gpu/gpu_channel.h"
-#include "content/gpu/gpu_command_buffer_stub.h"
-#include "content/gpu/gpu_render_thread.h"
+#include "content/common/gpu/gpu_channel.h"
+#include "content/common/gpu/gpu_channel_manager.h"
+#include "content/common/gpu/gpu_command_buffer_stub.h"
 #include "content/gpu/gpu_watchdog_thread.h"
 #include "gpu/common/gpu_trace_event.h"
 
 #if defined(OS_WIN)
 #include "base/win/wrapped_window_proc.h"
 #endif
 
 using gpu::Buffer;
 
 #if defined(OS_WIN)
@@ skipping 115 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() {
-  GpuRenderThread* render_thread = channel_->gpu_render_thread();
-  render_thread->Send(new GpuHostMsg_ScheduleComposite(
+  GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
+  gpu_channel_manager->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;
   }
 #endif  // defined(OS_WIN)
 
-  GpuRenderThread* render_thread = channel_->gpu_render_thread();
-  render_thread->Send(new GpuHostMsg_DestroyCommandBuffer(
+  GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
+  gpu_channel_manager->Send(new GpuHostMsg_DestroyCommandBuffer(
       handle_, renderer_id_, render_view_id_));
 }
 
 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);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncGetState, OnAsyncGetState);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Flush, OnFlush);
@@ skipping 181 matching lines @@
   processor_->ResizeOffscreenFrameBuffer(size);
 }
 
 void GpuCommandBufferStub::OnSwapBuffers() {
   GPU_TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnSwapBuffers");
   Send(new GpuCommandBufferMsg_SwapBuffers(route_id_));
 }
 
 #if defined(OS_MACOSX)
 void GpuCommandBufferStub::OnSetWindowSize(const gfx::Size& size) {
-  GpuRenderThread* gpu_render_thread = channel_->gpu_render_thread();
+  GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
   // 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_render_thread->Send(
+    gpu_channel_manager->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();
-  GpuRenderThread* gpu_render_thread = channel_->gpu_render_thread();
+  GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
   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_render_thread->Send(
+  gpu_channel_manager->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) {
     processor_->decoder()->ResizeOffscreenFrameBuffer(size);
     processor_->decoder()->UpdateOffscreenFrameBufferSize();
   } else {
 #if defined(OS_LINUX) && !defined(TOUCH_UI)
-    GpuRenderThread* gpu_render_thread = channel_->gpu_render_thread();
+    GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
     bool result = false;
-    gpu_render_thread->Send(
+    gpu_channel_manager->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)