Move CommandLine to base namespace.

chrome/browser/sync/test/integration/sync_test.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 "chrome/browser/sync/test/integration/sync_test.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 119 matching lines @@
     case MULTIPLE_CLIENT: {
       num_clients_ = 3;
       break;
     }
   }
 }
 
 SyncTest::~SyncTest() {}
 
 void SyncTest::SetUp() {
-  CommandLine* cl = CommandLine::ForCurrentProcess();
+  base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
   if (cl->HasSwitch(switches::kPasswordFileForTest)) {
     ReadPasswordFile();
   } else if (cl->HasSwitch(switches::kSyncUserForTest) &&
              cl->HasSwitch(switches::kSyncPasswordForTest)) {
     username_ = cl->GetSwitchValueASCII(switches::kSyncUserForTest);
     password_ = cl->GetSwitchValueASCII(switches::kSyncPasswordForTest);
   } else {
     username_ = "user@gmail.com";
     password_ = "password";
   }
@@ skipping 52 matching lines @@
   // Allow the InProcessBrowserTest framework to perform its tear down.
   InProcessBrowserTest::TearDown();
 
   // Stop the local python test server. This is a no-op if one wasn't started.
   TearDownLocalPythonTestServer();
 
   // Stop the local sync test server. This is a no-op if one wasn't started.
   TearDownLocalTestServer();
 }
 
-void SyncTest::SetUpCommandLine(CommandLine* cl) {
+void SyncTest::SetUpCommandLine(base::CommandLine* cl) {
   AddTestSwitches(cl);
   AddOptionalTypesToCommandLine(cl);
 }
 
-void SyncTest::AddTestSwitches(CommandLine* cl) {
+void SyncTest::AddTestSwitches(base::CommandLine* cl) {
   // Disable non-essential access of external network resources.
   if (!cl->HasSwitch(switches::kDisableBackgroundNetworking))
     cl->AppendSwitch(switches::kDisableBackgroundNetworking);
 
   if (!cl->HasSwitch(switches::kSyncShortInitialRetryOverride))
     cl->AppendSwitch(switches::kSyncShortInitialRetryOverride);
 
   // TODO(sync): Fix enable_disable_test.cc to play nice with priority
   // preferences.
   if (!cl->HasSwitch(switches::kDisableSyncPriorityPreferences))
     cl->AppendSwitch(switches::kDisableSyncPriorityPreferences);
 }
 
-void SyncTest::AddOptionalTypesToCommandLine(CommandLine* cl) {}
+void SyncTest::AddOptionalTypesToCommandLine(base::CommandLine* cl) {}
 
 // static
 Profile* SyncTest::MakeProfile(const base::FilePath::StringType name) {
   base::FilePath path;
   PathService::Get(chrome::DIR_USER_DATA, &path);
   path = path.Append(name);
 
   if (!base::PathExists(path))
     CHECK(base::CreateDirectory(path));
 
@@ skipping 164 matching lines @@
   resolver->AllowDirectLookup("*.gstatic.com");
   mock_host_resolver_override_.reset(
       new net::ScopedDefaultHostResolverProc(resolver));
 }
 
 void SyncTest::TearDownInProcessBrowserTestFixture() {
   mock_host_resolver_override_.reset();
 }
 
 void SyncTest::ReadPasswordFile() {
-  CommandLine* cl = CommandLine::ForCurrentProcess();
+  base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
   password_file_ = cl->GetSwitchValuePath(switches::kPasswordFileForTest);
   if (password_file_.empty())
     LOG(FATAL) << "Can't run live server test without specifying --"
                << switches::kPasswordFileForTest << "=<filename>";
   std::string file_contents;
   base::ReadFileToString(password_file_, &file_contents);
   ASSERT_NE(file_contents, "") << "Password file \""
       << password_file_.value() << "\" does not exist.";
   std::vector<std::string> tokens;
   std::string delimiters = "\r\n";
@@ skipping 100 matching lines @@
     // Nothing to do; we'll just talk to the URL we were given.
   } else {
     LOG(FATAL) << "Don't know which server environment to run test in.";
   }
 }
 
 bool SyncTest::SetUpLocalPythonTestServer() {
   EXPECT_TRUE(sync_server_.Start())
       << "Could not launch local python test server.";
 
-  CommandLine* cl = CommandLine::ForCurrentProcess();
+  base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
   if (server_type_ == LOCAL_PYTHON_SERVER) {
     std::string sync_service_url = sync_server_.GetURL("chromiumsync").spec();
     cl->AppendSwitchASCII(switches::kSyncServiceURL, sync_service_url);
     DVLOG(1) << "Started local python sync server at " << sync_service_url;
   }
 
   int xmpp_port = 0;
   if (!sync_server_.server_data().GetInteger("xmpp_port", &xmpp_port)) {
     LOG(ERROR) << "Could not find valid xmpp_port value";
     return false;
@@ skipping 13 matching lines @@
     // The local XMPP server only supports insecure connections.
     cl->AppendSwitch(switches::kSyncAllowInsecureXmppConnection);
   }
   DVLOG(1) << "Started local python XMPP server at "
            << xmpp_host_port_pair.ToString();
 
   return true;
 }
 
 bool SyncTest::SetUpLocalTestServer() {
-  CommandLine* cl = CommandLine::ForCurrentProcess();
-  CommandLine::StringType server_cmdline_string = cl->GetSwitchValueNative(
-      switches::kSyncServerCommandLine);
-  CommandLine::StringVector server_cmdline_vector;
-  CommandLine::StringType delimiters(FILE_PATH_LITERAL(" "));
+  base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
+  base::CommandLine::StringType server_cmdline_string =
+      cl->GetSwitchValueNative(switches::kSyncServerCommandLine);
+  base::CommandLine::StringVector server_cmdline_vector;
+  base::CommandLine::StringType delimiters(FILE_PATH_LITERAL(" "));
   Tokenize(server_cmdline_string, delimiters, &server_cmdline_vector);
-  CommandLine server_cmdline(server_cmdline_vector);
+  base::CommandLine server_cmdline(server_cmdline_vector);
   base::LaunchOptions options;
 #if defined(OS_WIN)
   options.start_hidden = true;
 #endif
   if (!base::LaunchProcess(server_cmdline, options, &test_server_handle_))
     LOG(ERROR) << "Could not launch local test server.";
 
   const base::TimeDelta kMaxWaitTime = TestTimeouts::action_max_timeout();
   const int kNumIntervals = 15;
   if (WaitForTestServerToStart(kMaxWaitTime, kNumIntervals)) {
@@ skipping 29 matching lines @@
 bool SyncTest::WaitForTestServerToStart(base::TimeDelta wait, int intervals) {
   for (int i = 0; i < intervals; ++i) {
     if (IsTestServerRunning())
       return true;
     base::PlatformThread::Sleep(wait / intervals);
   }
   return false;
 }
 
 bool SyncTest::IsTestServerRunning() {
-  CommandLine* cl = CommandLine::ForCurrentProcess();
+  base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
   std::string sync_url = cl->GetSwitchValueASCII(switches::kSyncServiceURL);
   GURL sync_url_status(sync_url.append("/healthz"));
   SyncServerStatusChecker delegate;
   scoped_ptr<net::URLFetcher> fetcher(net::URLFetcher::Create(
     sync_url_status, net::URLFetcher::GET, &delegate));
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE |
                         net::LOAD_DO_NOT_SEND_COOKIES |
                         net::LOAD_DO_NOT_SAVE_COOKIES);
   fetcher->SetRequestContext(g_browser_process->system_request_context());
   fetcher->Start();
@@ skipping 239 matching lines @@
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SetProxyConfigCallback, &done,
                  make_scoped_refptr(context_getter), proxy_config));
   done.Wait();
 }
 
 void SyncTest::UseFakeServer() {
   DCHECK_EQ(SERVER_TYPE_UNDECIDED, server_type_);
   server_type_ = IN_PROCESS_FAKE_SERVER;
 }