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

content/gpu/gpu_watchdog_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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/gpu/gpu_watchdog_thread.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/process_util.h"
 #include "base/process.h"
 #include "build/build_config.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 
+namespace content {
 namespace {
 const int64 kCheckPeriodMs = 2000;
 }  // namespace
 
 GpuWatchdogThread::GpuWatchdogThread(int timeout)
     : base::Thread("Watchdog"),
       watched_message_loop_(MessageLoop::current()),
       timeout_(base::TimeDelta::FromMilliseconds(timeout)),
       armed_(false),
 #if defined(OS_WIN)
@@ skipping 167 matching lines @@
 #endif
 
   LOG(ERROR) << "The GPU process hung. Terminating after "
              << timeout_.InMilliseconds() << " ms.";
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kCrashOnGpuHang)) {
     // Deliberately crash the process to create a crash dump.
     *((volatile int*)0) = 0x1337;
   } else {
     base::Process current_process(base::GetCurrentProcessHandle());
-    current_process.Terminate(content::RESULT_CODE_HUNG);
+    current_process.Terminate(RESULT_CODE_HUNG);
   }
 
   terminated = true;
 }
 
 #if defined(OS_WIN)
 base::TimeDelta GpuWatchdogThread::GetWatchedThreadTime() {
   FILETIME creation_time;
   FILETIME exit_time;
   FILETIME user_time;
@@ skipping 17 matching lines @@
   // summed to deal with to kinds of hangs. One is where the GPU process is
   // stuck in user level, never calling into the kernel and kernel time is
   // not increasing. The other is where either the kernel hangs and never
   // returns to user level or where user level code
   // calls into kernel level repeatedly, giving up its quanta before it is
   // tracked, for example a loop that repeatedly Sleeps.
   return base::TimeDelta::FromMilliseconds(static_cast<int64>(
       (user_time64.QuadPart + kernel_time64.QuadPart) / 10000));
 }
 #endif
+
+}  // namespace content