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

chrome/browser/gpu_process_host_ui_shim.cc

 // TODO(jam): move this file to src/content once we have an interface that the
 // embedder provides.  We can then use it to get the resource and resize the
 // window.
 // 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.
 
 #include "chrome/browser/gpu_process_host_ui_shim.h"
 
 #include "base/command_line.h"
@@ skipping 52 matching lines @@
  public:
   virtual bool Send(IPC::Message* msg) {
   // The GPU process must never send a synchronous IPC message to the browser
   // process. This could result in deadlock. Unfortunately linux does this for
   // GpuHostMsg_ResizeXID. TODO(apatrick): fix this before issuing any GL calls
   // on the browser process' GPU thread.
 #if !defined(OS_LINUX)
     DCHECK(!msg->is_sync());
 #endif
 
-    // When the GpuRenderThread sends an IPC, post it to the UI thread without
+    // When the GpuChannelManager sends an IPC, post it to the UI thread without
     // using IPC.
     bool success = BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         new RouteToGpuProcessHostUIShimTask(0, *msg));
 
     delete msg;
     return success;
   }
 };
 
-void ForwardMessageToGpuThread(GpuRenderThread* render_thread,
+void ForwardMessageToGpuThread(GpuChannelManager* gpu_channel_manager,
                                IPC::Message* msg) {
-  bool success = render_thread->OnMessageReceived(*msg);
+  bool success = gpu_channel_manager->OnMessageReceived(*msg);
 
   // If the message was not handled, it is likely it was intended for the
   // GpuChildThread, which does not exist in single process and in process GPU
   // mode.
   DCHECK(success);
 
   delete msg;
 }
 
 }  // namespace
@@ skipping 57 matching lines @@
   RenderWidgetHostView* view = NULL;
   if (host)
     view = host->view();
 
   return view;
 }
 
 GpuProcessHostUIShim::GpuProcessHostUIShim(int host_id)
     : host_id_(host_id),
       gpu_process_(base::kNullProcessHandle),
-      gpu_render_thread_(NULL),
+      gpu_channel_manager_(NULL),
       ui_thread_sender_(NULL) {
   g_hosts_by_id.AddWithID(this, host_id_);
   gpu_data_manager_ = GpuDataManager::GetInstance();
   DCHECK(gpu_data_manager_);
 
   if (host_id == 0) {
     gpu_process_ = base::GetCurrentProcessHandle();
     ui_thread_sender_ = new UIThreadSender;
-    gpu_render_thread_ = new GpuRenderThread(
+    gpu_channel_manager_ = new GpuChannelManager(
         ui_thread_sender_,
         NULL,
         g_browser_process->io_thread()->message_loop(),
         g_browser_process->shutdown_event());
   } else {
     // Post a task to create the corresponding GpuProcessHost.
     // The GpuProcessHostUIShim will be destroyed if either the browser exits,
     // in which case it calls GpuProcessHostUIShim::DestroyAll, or the
     // GpuProcessHost is destroyed, which happens when the corresponding GPU
     // process terminates or fails to launch.
@@ skipping 83 matching lines @@
 bool GpuProcessHostUIShim::Send(IPC::Message* msg) {
   DCHECK(CalledOnValidThread());
 
   bool success;
 
   if (host_id_ == 0) {
     success = BrowserThread::PostTask(
         BrowserThread::GPU,
         FROM_HERE,
         NewRunnableFunction(ForwardMessageToGpuThread,
-                            gpu_render_thread_,
+                            gpu_channel_manager_,
                             msg));
   } else {
     success = BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         new SendOnIOThreadTask(host_id_, msg));
   }
 
   return success;
 }
@@ skipping 189 matching lines @@
 GpuProcessHostUIShim::~GpuProcessHostUIShim() {
   DCHECK(CalledOnValidThread());
   g_hosts_by_id.Remove(host_id_);
 
 #if defined(OS_WIN)
   if (gpu_process_)
     CloseHandle(gpu_process_);
 #endif
 
   // Ensure these are destroyed on the GPU thread.
-  if (gpu_render_thread_) {
+  if (gpu_channel_manager_) {
     BrowserThread::DeleteSoon(BrowserThread::GPU,
                               FROM_HERE,
-                              gpu_render_thread_);
-    gpu_render_thread_ = NULL;
+                              gpu_channel_manager_);
+    gpu_channel_manager_ = NULL;
   }
   if (ui_thread_sender_) {
     BrowserThread::DeleteSoon(BrowserThread::GPU,
                               FROM_HERE,
                               ui_thread_sender_);
     ui_thread_sender_ = NULL;
   }
 }
 
 void GpuProcessHostUIShim::AddCustomLogMessage(int level,
@@ skipping 163 matching lines @@
     int render_view_id) {
   RenderViewHost* host = RenderViewHost::FromID(renderer_id,
                                                 render_view_id);
   if (!host) {
     return;
   }
   host->ScheduleComposite();
 }
 
 #endif