Add base:: qualification to some CommandLine references in content.

content/app/content_main_runner.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/public/app/content_main_runner.h"
 
 #include <stdlib.h>
 
 #include "base/allocator/allocator_extension.h"
 #include "base/at_exit.h"
@@ skipping 172 matching lines @@
   // when presenting them to the user), reset the locale for numeric
   // formatting.
   // Note that this is not correct for plugin processes -- they can
   // surface UI -- but it's likely they get this wrong too so why not.
   setlocale(LC_NUMERIC, "C");
 #endif
 }
 
 // Only needed on Windows for creating stats tables.
 #if defined(OS_WIN)
-static base::ProcessId GetBrowserPid(const CommandLine& command_line) {
+static base::ProcessId GetBrowserPid(const base::CommandLine& command_line) {
   base::ProcessId browser_pid = base::GetCurrentProcId();
   if (command_line.HasSwitch(switches::kProcessChannelID)) {
     std::string channel_name =
         command_line.GetSwitchValueASCII(switches::kProcessChannelID);
 
     int browser_pid_int;
     base::StringToInt(channel_name, &browser_pid_int);
     browser_pid = static_cast<base::ProcessId>(browser_pid_int);
     DCHECK_NE(browser_pid_int, 0);
   }
   return browser_pid;
 }
 #endif
 
-static void InitializeStatsTable(const CommandLine& command_line) {
+static void InitializeStatsTable(const base::CommandLine& command_line) {
   // Initialize the Stats Counters table.  With this initialized,
   // the StatsViewer can be utilized to read counters outside of
   // Chrome.  These lines can be commented out to effectively turn
   // counters 'off'.  The table is created and exists for the life
   // of the process.  It is not cleaned up.
   if (command_line.HasSwitch(switches::kEnableStatsTable)) {
     // NOTIMPLEMENTED: we probably need to shut this down correctly to avoid
     // leaking shared memory regions on posix platforms.
 #if defined(OS_POSIX)
     // Stats table is in the global file descriptors table on Posix.
@@ skipping 32 matching lines @@
 
 #if !defined(OS_IOS) && !defined(CHROME_MULTIPLE_DLL_BROWSER)
     if (process_type == switches::kPluginProcess ||
         process_type == switches::kPpapiPluginProcess) {
       if (delegate)
         content_client->plugin_ = delegate->CreateContentPluginClient();
       if (!content_client->plugin_)
         content_client->plugin_ = &g_empty_content_plugin_client.Get();
       // Single process not supported in split dll mode.
     } else if (process_type == switches::kRendererProcess ||
-               CommandLine::ForCurrentProcess()->HasSwitch(
+               base::CommandLine::ForCurrentProcess()->HasSwitch(
                    switches::kSingleProcess)) {
       if (delegate)
         content_client->renderer_ = delegate->CreateContentRendererClient();
       if (!content_client->renderer_)
         content_client->renderer_ = &g_empty_content_renderer_client.Get();
     }
 
     if (process_type == switches::kUtilityProcess ||
-        CommandLine::ForCurrentProcess()->HasSwitch(
+        base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kSingleProcess)) {
       if (delegate)
         content_client->utility_ = delegate->CreateContentUtilityClient();
       // TODO(scottmg): http://crbug.com/237249 Should be in _child.
       if (!content_client->utility_)
         content_client->utility_ = &g_empty_content_utility_client.Get();
     }
 #endif  // !OS_IOS && !CHROME_MULTIPLE_DLL_BROWSER
   }
 };
@@ skipping 32 matching lines @@
   }
 
   // This function call can return multiple times, once per fork().
   if (!ZygoteMain(main_function_params, zygote_fork_delegates.Pass()))
     return 1;
 
   if (delegate) delegate->ZygoteForked();
 
   // Zygote::HandleForkRequest may have reallocated the command
   // line so update it here with the new version.
-  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  const base::CommandLine& command_line =
+      *base::CommandLine::ForCurrentProcess();
   std::string process_type =
       command_line.GetSwitchValueASCII(switches::kProcessType);
   ContentClientInitializer::Set(process_type, delegate);
 
   // The StatsTable must be initialized in each process; we already
   // initialized for the browser process, now we need to initialize
   // within the new processes as well.
   InitializeStatsTable(command_line);
 
   MainFunctionParams main_params(command_line);
@@ skipping 15 matching lines @@
 #if !defined(OS_IOS)
 static void RegisterMainThreadFactories() {
 #if !defined(CHROME_MULTIPLE_DLL_BROWSER)
   UtilityProcessHostImpl::RegisterUtilityMainThreadFactory(
       CreateInProcessUtilityThread);
   RenderProcessHostImpl::RegisterRendererMainThreadFactory(
       CreateInProcessRendererThread);
   GpuProcessHost::RegisterGpuMainThreadFactory(
       CreateInProcessGpuThread);
 #else
-  CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  base::CommandLine& command_line = *base::CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kSingleProcess)) {
     LOG(FATAL) <<
         "--single-process is not supported in chrome multiple dll browser.";
   }
   if (command_line.HasSwitch(switches::kInProcessGPU)) {
     LOG(FATAL) <<
         "--in-process-gpu is not supported in chrome multiple dll browser.";
   }
 #endif
 }
@@ skipping 212 matching lines @@
     // argc/argv are ignored on Windows and Android; see command_line.h for
     // details.
     int argc = 0;
     const char** argv = NULL;
 
 #if !defined(OS_WIN)
     argc = params.argc;
     argv = params.argv;
 #endif
 
-    CommandLine::Init(argc, argv);
+    base::CommandLine::Init(argc, argv);
 
     if (!delegate_ || delegate_->ShouldEnableTerminationOnHeapCorruption())
       base::EnableTerminationOnHeapCorruption();
     base::EnableTerminationOnOutOfMemory();
 
 #if !defined(OS_IOS)
     SetProcessTitleFromCommandLine(argv);
 #endif
 #endif // !OS_ANDROID
 
     int exit_code = 0;
     if (delegate_ && delegate_->BasicStartupComplete(&exit_code))
       return exit_code;
 
     completed_basic_startup_ = true;
 
-    const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+    const base::CommandLine& command_line =
+        *base::CommandLine::ForCurrentProcess();
     std::string process_type =
         command_line.GetSwitchValueASCII(switches::kProcessType);
 
 #if !defined(OS_IOS)
     // Initialize mojo here so that services can be registered.
     InitializeMojo();
 #endif
 
     if (!GetContentClient())
       SetContentClient(&empty_content_client_);
@@ skipping 118 matching lines @@
     if (delegate_)
       delegate_->SandboxInitialized(process_type);
 
     // Return -1 to indicate no early termination.
     return -1;
   }
 
   virtual int Run() OVERRIDE {
     DCHECK(is_initialized_);
     DCHECK(!is_shutdown_);
-    const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+    const base::CommandLine& command_line =
+        *base::CommandLine::ForCurrentProcess();
     std::string process_type =
-          command_line.GetSwitchValueASCII(switches::kProcessType);
+        command_line.GetSwitchValueASCII(switches::kProcessType);
 
     MainFunctionParams main_params(command_line);
     main_params.ui_task = ui_task_;
 #if defined(OS_WIN)
     main_params.sandbox_info = &sandbox_info_;
 #elif defined(OS_MACOSX)
     main_params.autorelease_pool = autorelease_pool_.get();
 #endif
 
 #if !defined(OS_IOS)
     return RunNamedProcessTypeMain(process_type, main_params, delegate_);
 #else
     return 1;
 #endif
   }
 
   virtual void Shutdown() OVERRIDE {
     DCHECK(is_initialized_);
     DCHECK(!is_shutdown_);
 
     if (completed_basic_startup_ && delegate_) {
-      const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+      const base::CommandLine& command_line =
+          *base::CommandLine::ForCurrentProcess();
       std::string process_type =
           command_line.GetSwitchValueASCII(switches::kProcessType);
 
       delegate_->ProcessExiting(process_type);
     }
 
 #if defined(OS_WIN)
 #ifdef _CRTDBG_MAP_ALLOC
     _CrtDumpMemoryLeaks();
 #endif  // _CRTDBG_MAP_ALLOC
@@ skipping 36 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ContentMainRunnerImpl);
 };
 
 // static
 ContentMainRunner* ContentMainRunner::Create() {
   return new ContentMainRunnerImpl();
 }
 
 }  // namespace content