Prefix CommandLine usage with base namespace (Part 9: components)

components/nacl/browser/nacl_process_host.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 "components/nacl/browser/nacl_process_host.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 255 matching lines @@
       weak_factory_(this) {
   process_.reset(content::BrowserChildProcessHost::Create(
       PROCESS_TYPE_NACL_LOADER, this));
 
   // Set the display name so the user knows what plugin the process is running.
   // We aren't on the UI thread so getting the pref locale for language
   // formatting isn't possible, so IDN will be lost, but this is probably OK
   // for this use case.
   process_->SetName(net::FormatUrl(manifest_url_, std::string()));
 
-  enable_debug_stub_ = CommandLine::ForCurrentProcess()->HasSwitch(
+  enable_debug_stub_ = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableNaClDebug);
   DCHECK(process_type_ != kUnknownNaClProcessType);
   enable_crash_throttling_ = process_type_ != kNativeNaClProcessType;
 }
 
 NaClProcessHost::~NaClProcessHost() {
   // Report exit status only if the process was successfully started.
   if (process_->GetData().handle != base::kNullProcessHandle) {
     int exit_code = 0;
     process_->GetTerminationStatus(false /* known_dead */, &exit_code);
@@ skipping 16 matching lines @@
   }
 #if defined(OS_WIN)
   if (process_launched_by_broker_) {
     NaClBrokerService::GetInstance()->OnLoaderDied();
   }
 #endif
 }
 
 void NaClProcessHost::OnProcessCrashed(int exit_status) {
   if (enable_crash_throttling_ &&
-      !CommandLine::ForCurrentProcess()->HasSwitch(
+      !base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisablePnaclCrashThrottling)) {
     NaClBrowser::GetInstance()->OnProcessCrashed();
   }
 }
 
 // This is called at browser startup.
 // static
 void NaClProcessHost::EarlyStartup() {
   NaClBrowser::GetInstance()->EarlyStartup();
   // Inform NaClBrowser that we exist and will have a debug port at some point.
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   // Open the IRT file early to make sure that it isn't replaced out from
   // under us by autoupdate.
   NaClBrowser::GetInstance()->EnsureIrtAvailable();
 #endif
-  CommandLine* cmd = CommandLine::ForCurrentProcess();
+  base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
   UMA_HISTOGRAM_BOOLEAN(
       "NaCl.nacl-gdb",
       !cmd->GetSwitchValuePath(switches::kNaClGdb).empty());
   UMA_HISTOGRAM_BOOLEAN(
       "NaCl.nacl-gdb-script",
       !cmd->GetSwitchValuePath(switches::kNaClGdbScript).empty());
   UMA_HISTOGRAM_BOOLEAN(
       "NaCl.enable-nacl-debug",
       cmd->HasSwitch(switches::kEnableNaClDebug));
   std::string nacl_debug_mask =
@@ skipping 17 matching lines @@
     NaClHostMessageFilter* nacl_host_message_filter,
     IPC::Message* reply_msg,
     const base::FilePath& manifest_path) {
   nacl_host_message_filter_ = nacl_host_message_filter;
   reply_msg_ = reply_msg;
   manifest_path_ = manifest_path;
 
   // Do not launch the requested NaCl module if NaCl is marked "unstable" due
   // to too many crashes within a given time period.
   if (enable_crash_throttling_ &&
-      !CommandLine::ForCurrentProcess()->HasSwitch(
+      !base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisablePnaclCrashThrottling) &&
       NaClBrowser::GetInstance()->IsThrottled()) {
     SendErrorToRenderer("Process creation was throttled due to excessive"
                         " crashes");
     delete this;
     return;
   }
 
-  const CommandLine* cmd = CommandLine::ForCurrentProcess();
+  const base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
 #if defined(OS_WIN)
   if (cmd->HasSwitch(switches::kEnableNaClDebug) &&
       !cmd->HasSwitch(switches::kNoSandbox)) {
     // We don't switch off sandbox automatically for security reasons.
     SendErrorToRenderer("NaCl's GDB debug stub requires --no-sandbox flag"
                         " on Windows. See crbug.com/265624.");
     delete this;
     return;
   }
 #endif
@@ skipping 61 matching lines @@
   // reporting crash information.
   crash_info_shmem_.CreateAnonymous(kNaClCrashInfoShmemSize);
 
   // Launch the process
   if (!LaunchSelLdr()) {
     delete this;
   }
 }
 
 void NaClProcessHost::OnChannelConnected(int32 peer_pid) {
-  if (!CommandLine::ForCurrentProcess()->GetSwitchValuePath(
+  if (!base::CommandLine::ForCurrentProcess()->GetSwitchValuePath(
           switches::kNaClGdb).empty()) {
     LaunchNaClGdb();
   }
 }
 
 #if defined(OS_WIN)
 void NaClProcessHost::OnProcessLaunchedByBroker(base::ProcessHandle handle) {
   process_launched_by_broker_ = true;
   process_->SetHandle(handle);
   SetDebugStubPort(nacl::kGdbDebugStubPortUnknown);
   if (!StartWithLaunchedProcess())
     delete this;
 }
 
 void NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker(bool success) {
   IPC::Message* reply = attach_debug_exception_handler_reply_msg_.release();
   NaClProcessMsg_AttachDebugExceptionHandler::WriteReplyParams(reply, success);
   Send(reply);
 }
 #endif
 
 // Needed to handle sync messages in OnMessageReceived.
 bool NaClProcessHost::Send(IPC::Message* msg) {
   return process_->Send(msg);
 }
 
 bool NaClProcessHost::LaunchNaClGdb() {
+  const base::CommandLine& command_line =
+      *base::CommandLine::ForCurrentProcess();
 #if defined(OS_WIN)
   base::FilePath nacl_gdb =
-      CommandLine::ForCurrentProcess()->GetSwitchValuePath(switches::kNaClGdb);
-  CommandLine cmd_line(nacl_gdb);
+      command_line.GetSwitchValuePath(switches::kNaClGdb);
+  base::CommandLine cmd_line(nacl_gdb);
 #else
-  CommandLine::StringType nacl_gdb =
-      CommandLine::ForCurrentProcess()->GetSwitchValueNative(
-          switches::kNaClGdb);
-  CommandLine::StringVector argv;
+  base::CommandLine::StringType nacl_gdb =
+      command_line.GetSwitchValueNative(switches::kNaClGdb);
+  base::CommandLine::StringVector argv;
   // We don't support spaces inside arguments in --nacl-gdb switch.
-  base::SplitString(nacl_gdb, static_cast<CommandLine::CharType>(' '), &argv);
-  CommandLine cmd_line(argv);
+  base::SplitString(nacl_gdb, static_cast<base::CommandLine::CharType>(' '),
+                    &argv);
+  base::CommandLine cmd_line(argv);
 #endif
   cmd_line.AppendArg("--eval-command");
   base::FilePath::StringType irt_path(
       NaClBrowser::GetInstance()->GetIrtFilePath().value());
   // Avoid back slashes because nacl-gdb uses posix escaping rules on Windows.
   // See issue https://code.google.com/p/nativeclient/issues/detail?id=3482.
   std::replace(irt_path.begin(), irt_path.end(), '\\', '/');
   cmd_line.AppendArgNative(FILE_PATH_LITERAL("nacl-irt \"") + irt_path +
                            FILE_PATH_LITERAL("\""));
   if (!manifest_path_.empty()) {
     cmd_line.AppendArg("--eval-command");
     base::FilePath::StringType manifest_path_value(manifest_path_.value());
     std::replace(manifest_path_value.begin(), manifest_path_value.end(),
                  '\\', '/');
     cmd_line.AppendArgNative(FILE_PATH_LITERAL("nacl-manifest \"") +
                              manifest_path_value + FILE_PATH_LITERAL("\""));
   }
   cmd_line.AppendArg("--eval-command");
   cmd_line.AppendArg("target remote :4014");
-  base::FilePath script = CommandLine::ForCurrentProcess()->GetSwitchValuePath(
-      switches::kNaClGdbScript);
+  base::FilePath script =
+      command_line.GetSwitchValuePath(switches::kNaClGdbScript);
   if (!script.empty()) {
     cmd_line.AppendArg("--command");
     cmd_line.AppendArgNative(script.value());
   }
   return base::LaunchProcess(cmd_line, base::LaunchOptions(), NULL);
 }
 
 bool NaClProcessHost::LaunchSelLdr() {
   std::string channel_id = process_->GetHost()->CreateChannel();
   if (channel_id.empty()) {
@@ skipping 51 matching lines @@
     } else if (!IsInPath(old_path, x64_crt_path)) {
       std::string new_path(old_path);
       new_path.append(";");
       new_path.append(x64_crt_path);
       env->SetVar(kPath, new_path);
     }
 #endif  // _DLL
   }
 #endif
 
-  scoped_ptr<CommandLine> cmd_line(new CommandLine(exe_path));
+  scoped_ptr<base::CommandLine> cmd_line(new base::CommandLine(exe_path));
   CopyNaClCommandLineArguments(cmd_line.get());
 
   cmd_line->AppendSwitchASCII(switches::kProcessType,
                               (uses_nonsfi_mode_ ?
                                switches::kNaClLoaderNonSfiProcess :
                                switches::kNaClLoaderProcess));
   cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id);
   if (NaClBrowser::GetDelegate()->DialogsAreSuppressed())
     cmd_line->AppendSwitch(switches::kNoErrorDialogs);
 
@@ skipping 359 matching lines @@
         render_view_id_,
         profile_directory_));
     ppapi_host_->SetOnKeepaliveCallback(
         NaClBrowser::GetDelegate()->GetOnKeepaliveCallback());
 
     ppapi::PpapiNaClPluginArgs args;
     args.off_the_record = nacl_host_message_filter_->off_the_record();
     args.permissions = permissions_;
     args.keepalive_throttle_interval_milliseconds =
         keepalive_throttle_interval_milliseconds_;
-    CommandLine* cmdline = CommandLine::ForCurrentProcess();
+    base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
     DCHECK(cmdline);
     std::string flag_whitelist[] = {
       switches::kV,
       switches::kVModule,
     };
     for (size_t i = 0; i < arraysize(flag_whitelist); ++i) {
       std::string value = cmdline->GetSwitchValueASCII(flag_whitelist[i]);
       if (!value.empty()) {
         args.switch_names.push_back(flag_whitelist[i]);
         args.switch_values.push_back(value);
@@ skipping 192 matching lines @@
         process_handle.Take(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif
 
 }  // namespace nacl