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

content/gpu/gpu_main.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 <stdlib.h>
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
@@ skipping 28 matching lines @@
 #endif
 
 #if defined(USE_X11)
 #include "ui/base/x/x11_util.h"
 #endif
 
 #if defined(OS_LINUX)
 #include "content/public/common/sandbox_init.h"
 #endif
 
+namespace content {
 namespace {
-void WarmUpSandbox(const content::GPUInfo&, bool);
+void WarmUpSandbox(const GPUInfo&, bool);
 }
 
 // Main function for starting the Gpu process.
-int GpuMain(const content::MainFunctionParams& parameters) {
+int GpuMain(const MainFunctionParams& parameters) {
   TRACE_EVENT0("gpu", "GpuMain");
 
   base::Time start_time = base::Time::Now();
 
   const CommandLine& command_line = parameters.command_line;
   if (command_line.HasSwitch(switches::kGpuStartupDialog)) {
     ChildProcess::WaitForDebugger("Gpu");
   }
 
   if (!command_line.HasSwitch(switches::kSingleProcess)) {
@@ skipping 23 matching lines @@
   // will need to tear down this process. However, we can not do so
   // safely until the IPC channel is set up, because the detection of
   // early return of a child process is implemented using an IPC
   // channel error. If the IPC channel is not fully set up between the
   // browser and GPU process, and the GPU process crashes or exits
   // early, the browser process will never detect it.  For this reason
   // we defer tearing down the GPU process until receiving the
   // GpuMsg_Initialize message from the browser.
   bool dead_on_arrival = false;
 
-  content::GPUInfo gpu_info;
+  GPUInfo gpu_info;
   // Get vendor_id, device_id, driver_version from browser process through
   // commandline switches.
   DCHECK(command_line.HasSwitch(switches::kGpuVendorID) &&
          command_line.HasSwitch(switches::kGpuDeviceID) &&
          command_line.HasSwitch(switches::kGpuDriverVersion));
   bool success = base::HexStringToInt(
       command_line.GetSwitchValueASCII(switches::kGpuVendorID),
       reinterpret_cast<int*>(&(gpu_info.gpu.vendor_id)));
   DCHECK(success);
   success = base::HexStringToInt(
       command_line.GetSwitchValueASCII(switches::kGpuDeviceID),
       reinterpret_cast<int*>(&(gpu_info.gpu.device_id)));
   DCHECK(success);
   gpu_info.driver_vendor =
       command_line.GetSwitchValueASCII(switches::kGpuDriverVendor);
   gpu_info.driver_version =
       command_line.GetSwitchValueASCII(switches::kGpuDriverVersion);
-  content::GetContentClient()->SetGpuInfo(gpu_info);
+  GetContentClient()->SetGpuInfo(gpu_info);
 
   // We need to track that information for the WarmUpSandbox function.
   bool initialized_gl_context = false;
   // Load and initialize the GL implementation and locate the GL entry points.
   if (gfx::GLSurface::InitializeOneOff()) {
     if (!command_line.HasSwitch(switches::kSkipGpuFullInfoCollection)) {
       if (!gpu_info_collector::CollectGraphicsInfo(&gpu_info))
         VLOG(1) << "gpu_info_collector::CollectGraphicsInfo failed";
-      content::GetContentClient()->SetGpuInfo(gpu_info);
+      GetContentClient()->SetGpuInfo(gpu_info);
 
       // We know that CollectGraphicsInfo will initialize a GLContext.
       initialized_gl_context = true;
     }
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
     if (gpu_info.gpu.vendor_id == 0x10de &&  // NVIDIA
         gpu_info.driver_vendor == "NVIDIA") {
       base::ThreadRestrictions::AssertIOAllowed();
       if (access("/dev/nvidiactl", R_OK) != 0) {
@@ skipping 22 matching lines @@
     TRACE_EVENT0("gpu", "Initialize sandbox");
     bool do_init_sandbox = true;
 
 #if defined(OS_CHROMEOS) && defined(NDEBUG)
     // On Chrome OS and when not on a debug build, initialize
     // the GPU process' sandbox only for Intel GPUs.
     do_init_sandbox = gpu_info.gpu.vendor_id == 0x8086;   // Intel GPU.
 #endif
 
     if (do_init_sandbox) {
-      gpu_info.sandboxed = content::InitializeSandbox();
+      gpu_info.sandboxed = InitializeSandbox();
     }
   }
 #endif
 
 #if defined(OS_WIN)
   {
     TRACE_EVENT0("gpu", "Lower token");
     // For windows, if the target_services interface is not zero, the process
     // is sandboxed and we must call LowerToken() before rendering untrusted
     // content.
@@ skipping 65 matching lines @@
 
   // Similarly, this is needed for /dev/nvidia0.
   if (context->MakeCurrent(surface)) {
     context->ReleaseCurrent(surface.get());
   } else {
     VLOG(1)  << "gfx::GLContext::MakeCurrent failed";
   }
 }
 #endif
 
-void WarmUpSandbox(const content::GPUInfo& gpu_info,
+void WarmUpSandbox(const GPUInfo& gpu_info,
                    bool should_initialize_gl_context) {
   {
     TRACE_EVENT0("gpu", "Warm up rand");
     // Warm up the random subsystem, which needs to be done pre-sandbox on all
     // platforms.
     (void) base::RandUint64();
   }
   {
     TRACE_EVENT0("gpu", "Warm up HMAC");
     // Warm up the crypto subsystem, which needs to done pre-sandbox on all
@@ skipping 36 matching lines @@
   {
     TRACE_EVENT0("gpu", "Initialize DXVA");
     // Initialize H/W video decoding stuff which fails in the sandbox.
     DXVAVideoDecodeAccelerator::PreSandboxInitialization();
   }
 #endif
 }
 
 }  // namespace.
 
+}  // namespace content