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

chrome/browser/process_singleton_posix_unittest.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.
 
 #include "chrome/browser/process_singleton.h"
 
 #include <fcntl.h>
 #include <signal.h>
 #include <sys/types.h>
 #include <sys/un.h>
@@ skipping 28 matching lines @@
  public:
   // A ProcessSingleton exposing some protected methods for testing.
   class TestableProcessSingleton : public ProcessSingleton {
    public:
     explicit TestableProcessSingleton(const base::FilePath& user_data_dir)
         : ProcessSingleton(
             user_data_dir,
             base::Bind(&TestableProcessSingleton::NotificationCallback,
                        base::Unretained(this))) {}
 
-
-    std::vector<CommandLine::StringVector> callback_command_lines_;
+    std::vector<base::CommandLine::StringVector> callback_command_lines_;
 
     using ProcessSingleton::NotifyOtherProcessWithTimeout;
     using ProcessSingleton::NotifyOtherProcessWithTimeoutOrCreate;
     using ProcessSingleton::OverrideCurrentPidForTesting;
     using ProcessSingleton::OverrideKillCallbackForTesting;
 
    private:
-    bool NotificationCallback(const CommandLine& command_line,
+    bool NotificationCallback(const base::CommandLine& command_line,
                               const base::FilePath& current_directory) {
       callback_command_lines_.push_back(command_line.argv());
       return true;
     }
   };
 
   ProcessSingletonPosixTest()
       : kill_callbacks_(0),
         io_thread_(BrowserThread::IO),
         wait_event_(true, false),
@@ skipping 87 matching lines @@
     base::FilePath remote_cookie_path = socket_target_path.DirName().
         Append(chrome::kSingletonCookieFilename);
     len = readlink(remote_cookie_path.value().c_str(), buf, PATH_MAX);
     ASSERT_GT(len, 0);
     EXPECT_EQ(cookie, std::string(buf, len));
   }
 
   ProcessSingleton::NotifyResult NotifyOtherProcess(bool override_kill) {
     scoped_ptr<TestableProcessSingleton> process_singleton(
         CreateProcessSingleton());
-    CommandLine command_line(CommandLine::ForCurrentProcess()->GetProgram());
+    base::CommandLine command_line(
+        base::CommandLine::ForCurrentProcess()->GetProgram());
     command_line.AppendArg("about:blank");
     if (override_kill) {
       process_singleton->OverrideCurrentPidForTesting(
           base::GetCurrentProcId() + 1);
       process_singleton->OverrideKillCallbackForTesting(
           base::Bind(&ProcessSingletonPosixTest::KillCallback,
                      base::Unretained(this)));
     }
 
     return process_singleton->NotifyOtherProcessWithTimeout(
         command_line, kRetryAttempts, timeout(), true);
   }
 
   // A helper method to call ProcessSingleton::NotifyOtherProcessOrCreate().
   ProcessSingleton::NotifyResult NotifyOtherProcessOrCreate(
       const std::string& url) {
     scoped_ptr<TestableProcessSingleton> process_singleton(
         CreateProcessSingleton());
-    CommandLine command_line(CommandLine::ForCurrentProcess()->GetProgram());
+    base::CommandLine command_line(
+        base::CommandLine::ForCurrentProcess()->GetProgram());
     command_line.AppendArg(url);
     return process_singleton->NotifyOtherProcessWithTimeoutOrCreate(
         command_line, kRetryAttempts, timeout());
   }
 
   void CheckNotified() {
     ASSERT_TRUE(process_singleton_on_thread_ != NULL);
     ASSERT_EQ(1u, process_singleton_on_thread_->callback_command_lines_.size());
     bool found = false;
     for (size_t i = 0;
@@ skipping 224 matching lines @@
 // Test that if there is an existing lock file, and it's not locked, we replace
 // it.
 TEST_F(ProcessSingletonPosixTest, CreateReplacesOldMacLock) {
   scoped_ptr<TestableProcessSingleton> process_singleton(
       CreateProcessSingleton());
   EXPECT_EQ(0, base::WriteFile(lock_path_, "", 0));
   EXPECT_TRUE(process_singleton->Create());
   VerifyFiles();
 }
 #endif  // defined(OS_MACOSX)