Make callers of CommandLine use it via the base:: namespace.

chrome/browser/process_singleton_posix.cc

 // Copyright 2014 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.
 
 // On Linux, when the user tries to launch a second copy of chrome, we check
 // for a socket in the user's profile directory.  If the socket file is open we
 // send a message to the first chrome browser process with the current
 // directory and second process command line flags.  The second process then
 // exits.
 //
@@ skipping 604 matching lines @@
   ml->WatchFileDescriptor(socket, true, base::MessageLoopForIO::WATCH_READ,
                           &fd_watcher_, this);
 }
 
 void ProcessSingleton::LinuxWatcher::HandleMessage(
     const std::string& current_dir, const std::vector<std::string>& argv,
     SocketReader* reader) {
   DCHECK(ui_message_loop_ == base::MessageLoop::current());
   DCHECK(reader);
 
-  if (parent_->notification_callback_.Run(CommandLine(argv),
+  if (parent_->notification_callback_.Run(base::CommandLine(argv),
                                           base::FilePath(current_dir))) {
     // Send back "ACK" message to prevent the client process from starting up.
     reader->FinishWithACK(kACKToken, arraysize(kACKToken) - 1);
   } else {
     LOG(WARNING) << "Not handling interprocess notification as browser"
                     " is shutting down";
     // Send back "SHUTDOWN" message, so that the client process can start up
     // without killing this process.
     reader->FinishWithACK(kShutdownToken, arraysize(kShutdownToken) - 1);
     return;
@@ skipping 112 matching lines @@
 
   kill_callback_ = base::Bind(&ProcessSingleton::KillProcess,
                               base::Unretained(this));
 }
 
 ProcessSingleton::~ProcessSingleton() {
 }
 
 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
   return NotifyOtherProcessWithTimeout(
-      *CommandLine::ForCurrentProcess(),
-      kRetryAttempts,
-      base::TimeDelta::FromSeconds(kTimeoutInSeconds),
-      true);
+      *base::CommandLine::ForCurrentProcess(), kRetryAttempts,
+      base::TimeDelta::FromSeconds(kTimeoutInSeconds), true);
 }
 
 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessWithTimeout(
-    const CommandLine& cmd_line,
+    const base::CommandLine& cmd_line,
     int retry_attempts,
     const base::TimeDelta& timeout,
     bool kill_unresponsive) {
   DCHECK_GE(retry_attempts, 0);
   DCHECK_GE(timeout.InMicroseconds(), 0);
 
   base::TimeDelta sleep_interval = timeout / retry_attempts;
 
   ScopedSocket socket;
   for (int retries = 0; retries <= retry_attempts; ++retries) {
@@ skipping 114 matching lines @@
     // Assume the other process is handling the request.
     return PROCESS_NOTIFIED;
   }
 
   NOTREACHED() << "The other process returned unknown message: " << buf;
   return PROCESS_NOTIFIED;
 }
 
 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessOrCreate() {
   return NotifyOtherProcessWithTimeoutOrCreate(
-      *CommandLine::ForCurrentProcess(),
-      kRetryAttempts,
+      *base::CommandLine::ForCurrentProcess(), kRetryAttempts,
       base::TimeDelta::FromSeconds(kTimeoutInSeconds));
 }
 
 ProcessSingleton::NotifyResult
 ProcessSingleton::NotifyOtherProcessWithTimeoutOrCreate(
-    const CommandLine& command_line,
+    const base::CommandLine& command_line,
     int retry_attempts,
     const base::TimeDelta& timeout) {
   NotifyResult result = NotifyOtherProcessWithTimeout(
       command_line, retry_attempts, timeout, true);
   if (result != PROCESS_NONE)
     return result;
   if (Create())
     return PROCESS_NONE;
   // If the Create() failed, try again to notify. (It could be that another
   // instance was starting at the same time and managed to grab the lock before
@@ skipping 149 matching lines @@
 }
 
 void ProcessSingleton::KillProcess(int pid) {
   // TODO(james.su@gmail.com): Is SIGKILL ok?
   int rv = kill(static_cast<base::ProcessHandle>(pid), SIGKILL);
   // ESRCH = No Such Process (can happen if the other process is already in
   // progress of shutting down and finishes before we try to kill it).
   DCHECK(rv == 0 || errno == ESRCH) << "Error killing process: "
                                     << safe_strerror(errno);
 }