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

chrome/browser/printing/cloud_print/test/cloud_print_proxy_process_browsertest.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.
 
 // Create a service process that uses a Mock to respond to the browser in order
 // to test launching the browser using the cloud print policy check command
 // line switch.
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 194 matching lines @@
 
 typedef base::Callback<void(MockServiceIPCServer* server)>
     SetExpectationsCallback;
 
 // The return value from this routine is used as the exit code for the mock
 // service process. Any non-zero return value will be printed out and can help
 // determine the failure.
 int CloudPrintMockService_Main(SetExpectationsCallback set_expectations) {
   base::MessageLoopForUI main_message_loop;
   main_message_loop.set_thread_name("Main Thread");
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   content::RegisterPathProvider();
 
 #if defined(OS_MACOSX)
   if (!command_line->HasSwitch(kTestExecutablePath))
     return kMissingSwitch;
   base::FilePath executable_path =
       command_line->GetSwitchValuePath(kTestExecutablePath);
   EXPECT_FALSE(executable_path.empty());
   MockLaunchd mock_launchd(executable_path, &main_message_loop, true, true);
   Launchd::ScopedInstance use_mock(&mock_launchd);
@@ skipping 25 matching lines @@
   EXPECT_TRUE(server.Init());
   EXPECT_TRUE(state->SignalReady(service_process.IOMessageLoopProxy(),
                                  base::Bind(&ShutdownTask)));
 #if defined(OS_MACOSX)
   mock_launchd.SignalReady();
 #endif
 
   // Connect up the parent/child IPC channel to signal that the test can
   // continue.
   TestStartupClientChannelListener listener;
-  EXPECT_TRUE(CommandLine::ForCurrentProcess()->HasSwitch(
+  EXPECT_TRUE(base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kProcessChannelID));
   std::string startup_channel_name =
-      CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kProcessChannelID);
   scoped_ptr<IPC::ChannelProxy> startup_channel;
   startup_channel =
       IPC::ChannelProxy::Create(startup_channel_name,
                                 IPC::Channel::MODE_CLIENT,
                                 &listener,
                                 service_process.IOMessageLoopProxy());
 
   main_message_loop.Run();
   if (!Mock::VerifyAndClearExpectations(&server))
@@ skipping 36 matching lines @@
   base::ProcessHandle Launch(const std::string& name);
   void WaitForConnect();
   bool Send(IPC::Message* message);
   void ShutdownAndWaitForExitWithTimeout(base::ProcessHandle handle);
 
   // IPC::Listener implementation
   bool OnMessageReceived(const IPC::Message& message) override { return false; }
   void OnChannelConnected(int32 peer_pid) override;
 
   // MultiProcessTest implementation.
-  CommandLine MakeCmdLine(const std::string& procname) override;
+  base::CommandLine MakeCmdLine(const std::string& procname) override;
 
-  bool LaunchBrowser(const CommandLine& command_line, Profile* profile) {
+  bool LaunchBrowser(const base::CommandLine& command_line, Profile* profile) {
     int return_code = 0;
     StartupBrowserCreator browser_creator;
     return StartupBrowserCreator::ProcessCmdLineImpl(
         command_line, base::FilePath(), false, profile,
         StartupBrowserCreator::Profiles(), &return_code, &browser_creator);
   }
 
  protected:
   content::TestBrowserThreadBundle thread_bundle_;
   base::ScopedTempDir temp_user_data_dir_;
@@ skipping 66 matching lines @@
                                       base::MessageLoopForUI::current(),
                                       true, false));
   scoped_launchd_instance_.reset(
       new Launchd::ScopedInstance(mock_launchd_.get()));
 #endif
 
   // Ensure test does not use the standard profile directory. This is copied
   // from InProcessBrowserTest::SetUp(). These tests require a more complex
   // process startup so they are unable to just inherit from
   // InProcessBrowserTest.
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   base::FilePath user_data_dir =
       command_line->GetSwitchValuePath(switches::kUserDataDir);
   if (user_data_dir.empty()) {
     ASSERT_TRUE(temp_user_data_dir_.CreateUniqueTempDir() &&
                 temp_user_data_dir_.IsValid())
         << "Could not create temporary user data directory \""
         << temp_user_data_dir_.path().value() << "\".";
 
     user_data_dir = temp_user_data_dir_.path();
     command_line->AppendSwitchPath(switches::kUserDataDir, user_data_dir);
@@ skipping 62 matching lines @@
                                        TestTimeouts::action_timeout());
   EXPECT_TRUE(exited);
   EXPECT_EQ(exit_code, 0);
   base::CloseProcessHandle(handle);
 }
 
 void CloudPrintProxyPolicyStartupTest::OnChannelConnected(int32 peer_pid) {
   observer_.Notify();
 }
 
-CommandLine CloudPrintProxyPolicyStartupTest::MakeCmdLine(
+base::CommandLine CloudPrintProxyPolicyStartupTest::MakeCmdLine(
     const std::string& procname) {
-  CommandLine cl = MultiProcessTest::MakeCmdLine(procname);
+  base::CommandLine cl = MultiProcessTest::MakeCmdLine(procname);
   cl.AppendSwitchASCII(switches::kProcessChannelID, startup_channel_id_);
 #if defined(OS_MACOSX)
   cl.AppendSwitchASCII(kTestExecutablePath, executable_path_.value());
 #endif
   return cl;
 }
 
 TEST_F(CloudPrintProxyPolicyStartupTest, StartAndShutdown) {
   TestingBrowserProcess* browser_process =
       TestingBrowserProcess::GetGlobal();
@@ skipping 39 matching lines @@
   TestingProfile* profile =
       profile_manager.CreateTestingProfile("StartBrowserWithoutPolicy");
   CloudPrintProxyServiceFactory::GetInstance()->
       SetTestingFactory(profile, CloudPrintProxyServiceFactoryForPolicyTest);
 
   TestingPrefServiceSyncable* prefs = profile->GetTestingPrefService();
   prefs->SetUserPref(
       prefs::kCloudPrintEmail,
       new base::StringValue(MockServiceIPCServer::EnabledUserId()));
 
-  CommandLine command_line(CommandLine::NO_PROGRAM);
+  base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   command_line.AppendSwitch(switches::kCheckCloudPrintConnectorPolicy);
   test_launcher_utils::PrepareBrowserCommandLineForTests(&command_line);
 
   WaitForConnect();
   base::RunLoop run_loop;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       run_loop.QuitClosure(),
       TestTimeouts::action_timeout());
 
@@ skipping 29 matching lines @@
   CloudPrintProxyServiceFactory::GetInstance()->
       SetTestingFactory(profile, CloudPrintProxyServiceFactoryForPolicyTest);
 
   TestingPrefServiceSyncable* prefs = profile->GetTestingPrefService();
   prefs->SetUserPref(
       prefs::kCloudPrintEmail,
       new base::StringValue(MockServiceIPCServer::EnabledUserId()));
   prefs->SetManagedPref(prefs::kCloudPrintProxyEnabled,
                         new base::FundamentalValue(false));
 
-  CommandLine command_line(CommandLine::NO_PROGRAM);
+  base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   command_line.AppendSwitch(switches::kCheckCloudPrintConnectorPolicy);
   test_launcher_utils::PrepareBrowserCommandLineForTests(&command_line);
 
   WaitForConnect();
   base::RunLoop run_loop;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       run_loop.QuitClosure(),
       TestTimeouts::action_timeout());
 
   bool should_run_loop = LaunchBrowser(command_line, profile);
 
   // No expectations on run_loop being true here; that would be a race
   // condition.
   if (should_run_loop)
     run_loop.Run();
 
   EXPECT_EQ("", prefs->GetString(prefs::kCloudPrintEmail));
 
   ShutdownAndWaitForExitWithTimeout(handle);
   content::RunAllPendingInMessageLoop();
   profile_manager.DeleteTestingProfile("StartBrowserWithPolicy");
 }