Move the remaning files in content\common to the content namespace.

content/browser/browser_main_loop.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/browser/browser_main_loop.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/hi_res_timer_manager.h"
@@ skipping 73 matching lines @@
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #endif
 
 // One of the linux specific headers defines this as a macro.
 #ifdef DestroyAll
 #undef DestroyAll
 #endif
 
-using content::TraceControllerImpl;
-
+namespace content {
 namespace {
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
 void SetupSandbox(const CommandLine& parsed_command_line) {
   // TODO(evanm): move this into SandboxWrapper; I'm just trying to move this
   // code en masse out of chrome_main for now.
   const char* sandbox_binary = NULL;
   struct stat st;
 
   // In Chromium branded builds, developers can set an environment variable to
@@ skipping 72 matching lines @@
                                                   G_LOG_LEVEL_CRITICAL |
                                                   G_LOG_LEVEL_WARNING),
                       GLibLogHandler,
                       NULL);
   }
 }
 #endif
 
 }  // namespace
 
-namespace content {
-
 // The currently-running BrowserMainLoop.  There can be one or zero.
 BrowserMainLoop* g_current_browser_main_loop = NULL;
 
 // This is just to be able to keep ShutdownThreadsAndCleanUp out of
 // the public interface of BrowserMainLoop.
 class BrowserShutdownImpl {
  public:
   static void ImmediateShutdownAndExitProcess() {
     DCHECK(g_current_browser_main_loop);
     g_current_browser_main_loop->ShutdownThreadsAndCleanUp();
 
 #if defined(OS_WIN)
     // At this point the message loop is still running yet we've shut everything
     // down. If any messages are processed we'll likely crash. Exit now.
-    ExitProcess(content::RESULT_CODE_NORMAL_EXIT);
+    ExitProcess(RESULT_CODE_NORMAL_EXIT);
 #elif defined(OS_POSIX) && !defined(OS_MACOSX)
-    _exit(content::RESULT_CODE_NORMAL_EXIT);
+    _exit(RESULT_CODE_NORMAL_EXIT);
 #else
     NOTIMPLEMENTED();
 #endif
   }
 };
 
 void ImmediateShutdownAndExitProcess() {
   BrowserShutdownImpl::ImmediateShutdownAndExitProcess();
 }
 
 // static
 media::AudioManager* BrowserMainLoop::GetAudioManager() {
   return g_current_browser_main_loop->audio_manager_.get();
 }
 
 // static
 media_stream::MediaStreamManager* BrowserMainLoop::GetMediaStreamManager() {
   return g_current_browser_main_loop->media_stream_manager_.get();
 }
 // BrowserMainLoop construction / destruction =============================
 
-BrowserMainLoop::BrowserMainLoop(const content::MainFunctionParams& parameters)
+BrowserMainLoop::BrowserMainLoop(const MainFunctionParams& parameters)
     : parameters_(parameters),
       parsed_command_line_(parameters.command_line),
-      result_code_(content::RESULT_CODE_NORMAL_EXIT) {
+      result_code_(RESULT_CODE_NORMAL_EXIT) {
   DCHECK(!g_current_browser_main_loop);
   g_current_browser_main_loop = this;
 }
 
 BrowserMainLoop::~BrowserMainLoop() {
   DCHECK_EQ(this, g_current_browser_main_loop);
 #if !defined(OS_IOS)
   ui::Clipboard::DestroyClipboardForCurrentThread();
 #endif  // !defined(OS_IOS)
   g_current_browser_main_loop = NULL;
@@ skipping 55 matching lines @@
   // seem dependent on SSL initialization().
   if (parsed_command_line_.HasSwitch(switches::kEnableTcpFastOpen))
     net::set_tcp_fastopen_enabled(true);
 
 #if !defined(OS_IOS)
   if (parsed_command_line_.HasSwitch(switches::kRendererProcessLimit)) {
     std::string limit_string = parsed_command_line_.GetSwitchValueASCII(
         switches::kRendererProcessLimit);
     size_t process_limit;
     if (base::StringToSizeT(limit_string, &process_limit)) {
-      content::RenderProcessHost::SetMaxRendererProcessCount(process_limit);
+      RenderProcessHost::SetMaxRendererProcessCount(process_limit);
     }
   }
 #endif  // !defined(OS_IOS)
 
   if (parts_.get())
     parts_->PostEarlyInitialization();
 }
 
 void BrowserMainLoop::MainMessageLoopStart() {
   if (parts_.get())
@@ skipping 135 matching lines @@
   // ChildProcess instance which is created by the renderer thread.
   if (GpuDataManagerImpl::GetInstance()->GpuAccessAllowed() &&
       !parsed_command_line_.HasSwitch(switches::kDisableGpuProcessPrelaunch) &&
       !parsed_command_line_.HasSwitch(switches::kSingleProcess) &&
       !parsed_command_line_.HasSwitch(switches::kInProcessGPU)) {
     TRACE_EVENT_INSTANT0("gpu", "Post task to launch GPU process");
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE, base::Bind(
             base::IgnoreResult(&GpuProcessHost::Get),
             GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
-            content::CAUSE_FOR_GPU_LAUNCH_BROWSER_STARTUP));
+            CAUSE_FOR_GPU_LAUNCH_BROWSER_STARTUP));
   }
 #endif  // !defined(OS_IOS)
 
   // If the UI thread blocks, the whole UI is unresponsive.
   // Do not allow disk IO from the UI thread.
   base::ThreadRestrictions::SetIOAllowed(false);
   base::ThreadRestrictions::DisallowWaiting();
 }
 
 void BrowserMainLoop::RunMainMessageLoopParts() {
@@ skipping 158 matching lines @@
   // Register the main thread by instantiating it, but don't call any methods.
   main_thread_.reset(new BrowserThreadImpl(BrowserThread::UI,
                                            MessageLoop::current()));
 }
 
 
 void BrowserMainLoop::BrowserThreadsStarted() {
 #if !defined(OS_IOS)
   HistogramSynchronizer::GetInstance();
 
-  content::BrowserGpuChannelHostFactory::Initialize();
+  BrowserGpuChannelHostFactory::Initialize();
 #if defined(USE_AURA)
   ImageTransportFactory::Initialize();
 #endif
 
 #if defined(OS_LINUX)
   device_monitor_linux_.reset(new DeviceMonitorLinux());
 #elif defined(OS_MACOSX)
   device_monitor_mac_.reset(new DeviceMonitorMac());
 #endif
 
@@ skipping 72 matching lines @@
   DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type());
   if (parameters_.ui_task)
     MessageLoopForUI::current()->PostTask(FROM_HERE, *parameters_.ui_task);
 
   base::RunLoop run_loop;
   run_loop.Run();
 #endif
 }
 
 }  // namespace content