Move a bunch of code in content\common (as well as a few left in renderer) to the content namespace.

content/gpu/gpu_child_thread.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/gpu/gpu_child_thread.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/threading/worker_pool.h"
 #include "build/build_config.h"
 #include "content/common/child_process.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/gpu/gpu_info_collector.h"
 #include "content/gpu/gpu_watchdog_thread.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "ui/gl/gl_implementation.h"
 
 const int kGpuTimeout = 10000;
 
+namespace content {
 namespace {
 
 bool GpuProcessLogMessageHandler(int severity,
                                  const char* file, int line,
                                  size_t message_start,
                                  const std::string& str) {
   std::string header = str.substr(0, message_start);
   std::string message = str.substr(message_start);
 
   // If we are not on main thread in child process, send through
   // the sync_message_filter; otherwise send directly.
   if (MessageLoop::current() !=
       ChildProcess::current()->main_thread()->message_loop()) {
     ChildProcess::current()->main_thread()->sync_message_filter()->Send(
         new GpuHostMsg_OnLogMessage(severity, header, message));
   } else {
     ChildThread::current()->Send(new GpuHostMsg_OnLogMessage(severity, header,
         message));
   }
 
   return false;
 }
 
 }  // namespace
 
-GpuChildThread::GpuChildThread(bool dead_on_arrival,
-                               const content::GPUInfo& gpu_info)
+GpuChildThread::GpuChildThread(bool dead_on_arrival, const GPUInfo& gpu_info)
     : dead_on_arrival_(dead_on_arrival),
       gpu_info_(gpu_info) {
 #if defined(OS_WIN)
   target_services_ = NULL;
   collecting_dx_diagnostics_ = false;
 #endif
 }
 
 GpuChildThread::GpuChildThread(const std::string& channel_id)
     : ChildThread(channel_id),
@@ skipping 119 matching lines @@
 void GpuChildThread::OnCollectGraphicsInfo() {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kDisableGpuSandbox) ||
       command_line->ForCurrentProcess()->HasSwitch(switches::kSingleProcess) ||
       command_line->ForCurrentProcess()->HasSwitch(switches::kInProcessGPU)) {
     // GPU full info collection should only happen on un-sandboxed GPU process
     // or single process/in-process gpu mode.
 
     if (!gpu_info_collector::CollectGraphicsInfo(&gpu_info_))
       VLOG(1) << "gpu_info_collector::CollectGraphicsInfo failed";
-    content::GetContentClient()->SetGpuInfo(gpu_info_);
+    GetContentClient()->SetGpuInfo(gpu_info_);
 
 #if defined(OS_WIN)
     if (!collecting_dx_diagnostics_) {
       // Prevent concurrent collection of DirectX diagnostics.
       collecting_dx_diagnostics_ = true;
 
       // Asynchronously collect the DirectX diagnostics because this can take a
       // couple of seconds.
       if (!base::WorkerPool::PostTask(
           FROM_HERE, base::Bind(&GpuChildThread::CollectDxDiagnostics, this),
           true)) {
         // Flag GPU info as complete if the DirectX diagnostics cannot be
         // collected.
         collecting_dx_diagnostics_ = false;
         gpu_info_.finalized = true;
       }
     }
 #endif
   }
   Send(new GpuHostMsg_GraphicsInfoCollected(gpu_info_));
 }
 
 void GpuChildThread::OnGetVideoMemoryUsageStats() {
-  content::GPUVideoMemoryUsageStats video_memory_usage_stats;
+  GPUVideoMemoryUsageStats video_memory_usage_stats;
   if (gpu_channel_manager_.get())
     gpu_channel_manager_->gpu_memory_manager()->GetVideoMemoryUsageStats(
         video_memory_usage_stats);
   Send(new GpuHostMsg_VideoMemoryUsageStats(video_memory_usage_stats));
 }
 
 void GpuChildThread::OnSetVideoMemoryWindowCount(uint32 window_count) {
   if (gpu_channel_manager_.get())
     gpu_channel_manager_->gpu_memory_manager()->SetWindowCount(window_count);
 }
@@ skipping 17 matching lines @@
     // Do not sleep here. The GPU watchdog timer tracks the amount of user
     // time this thread is using and it doesn't use much while calling Sleep.
   }
 }
 
 #if defined(OS_WIN)
 
 // Runs on a worker thread. The GPU process never terminates voluntarily so
 // it is safe to assume that its message loop is valid.
 void GpuChildThread::CollectDxDiagnostics(GpuChildThread* thread) {
-  content::DxDiagNode node;
+  DxDiagNode node;
   gpu_info_collector::GetDxDiagnostics(&node);
 
   thread->message_loop()->PostTask(
       FROM_HERE, base::Bind(&GpuChildThread::SetDxDiagnostics, thread, node));
 }
 
 // Runs on the main thread.
 void GpuChildThread::SetDxDiagnostics(GpuChildThread* thread,
-                                      const content::DxDiagNode& node) {
+                                      const DxDiagNode& node) {
   thread->gpu_info_.dx_diagnostics = node;
   thread->gpu_info_.finalized = true;
   thread->collecting_dx_diagnostics_ = false;
   thread->Send(new GpuHostMsg_GraphicsInfoCollected(thread->gpu_info_));
 }
 
 #endif
+
+}  // namespace content
+