Remove GetSwitchValue() from chrome/* where easy.

Review URL: http://codereview.chromium.org/3057033

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@54966 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 56 insertions, 50 deletions

diff --git a/chrome/test/mini_installer_test/test.cc b/chrome/test/mini_installer_test/test.cc
index 6d877dc..8903517 100644
--- a/chrome/test/mini_installer_test/test.cc
+++ b/chrome/test/mini_installer_test/test.cc
@@ -53,7 +53,8 @@ class MiniInstallTest : public testing::Test {
     virtual void SetUp() {
       // Parse test command-line arguments.
       const CommandLine* cmd = CommandLine::ForCurrentProcess();
-      std::wstring build = cmd->GetSwitchValue(switches::kInstallerTestBuild);
+      std::wstring build =
+          cmd->GetSwitchValueNative(switches::kInstallerTestBuild);
       if (build.empty())
         build = L"latest";
       force_tests_ = cmd->HasSwitch(switches::kInstallerTestForce);
diff --git a/chrome/test/reliability/page_load_test.cc b/chrome/test/reliability/page_load_test.cc
index abf83ca..4c77378 100644
--- a/chrome/test/reliability/page_load_test.cc
+++ b/chrome/test/reliability/page_load_test.cc
@@ -628,11 +628,13 @@ void SetPageRange(const CommandLine& parsed_command_line) {
   if (parsed_command_line.HasSwitch(kStartPageSwitch)) {
     ASSERT_TRUE(parsed_command_line.HasSwitch(kEndPageSwitch));
     ASSERT_TRUE(
-        base::StringToInt(WideToUTF16(parsed_command_line.GetSwitchValue(
-            kStartPageSwitch)), &g_start_page));
+        base::StringToInt(parsed_command_line.GetSwitchValueASCII(
+                              kStartPageSwitch),
+                          &g_start_page));
     ASSERT_TRUE(
-        base::StringToInt(WideToUTF16(parsed_command_line.GetSwitchValue(
-            kEndPageSwitch)), &g_end_page));
+        base::StringToInt(parsed_command_line.GetSwitchValueASCII(
+                              kEndPageSwitch),
+                          &g_end_page));
     ASSERT_TRUE(g_start_page > 0 && g_end_page > 0);
     ASSERT_TRUE(g_start_page < g_end_page);
     g_append_page_id = true;
@@ -641,20 +643,22 @@ void SetPageRange(const CommandLine& parsed_command_line) {
   }
 
   if (parsed_command_line.HasSwitch(kSiteSwitch)) {
-    g_server_url = WideToUTF8(parsed_command_line.GetSwitchValue(kSiteSwitch));
+    g_server_url = parsed_command_line.GetSwitchValueASCII(kSiteSwitch);
   }
 
   if (parsed_command_line.HasSwitch(kStartIndexSwitch)) {
     ASSERT_TRUE(
-        base::StringToInt(WideToUTF16(parsed_command_line.GetSwitchValue(
-            kStartIndexSwitch)), &g_start_index));
+        base::StringToInt(parsed_command_line.GetSwitchValueASCII(
+                              kStartIndexSwitch),
+                          &g_start_index));
     ASSERT_GT(g_start_index, 0);
   }
 
   if (parsed_command_line.HasSwitch(kEndIndexSwitch)) {
     ASSERT_TRUE(
-        base::StringToInt(WideToUTF16(parsed_command_line.GetSwitchValue(
-            kEndIndexSwitch)), &g_end_index));
+        base::StringToInt(parsed_command_line.GetSwitchValueASCII(
+                              kEndIndexSwitch),
+                          &g_end_index));
     ASSERT_GT(g_end_index, 0);
   }
 
@@ -665,8 +669,9 @@ void SetPageRange(const CommandLine& parsed_command_line) {
 
   if (parsed_command_line.HasSwitch(kIterationSwitch)) {
     ASSERT_TRUE(
-        base::StringToInt(WideToUTF16(parsed_command_line.GetSwitchValue(
-            kIterationSwitch)), &g_iterations));
+        base::StringToInt(parsed_command_line.GetSwitchValueASCII(
+                              kIterationSwitch),
+                          &g_iterations));
     ASSERT_GT(g_iterations, 0);
   }
 
@@ -676,18 +681,17 @@ void SetPageRange(const CommandLine& parsed_command_line) {
   if (parsed_command_line.HasSwitch(kContinuousLoadSwitch))
     g_continuous_load = true;
 
-  if (parsed_command_line.HasSwitch(kEndURLSwitch)) {
-    g_end_url = WideToUTF8(
-        parsed_command_line.GetSwitchValue(kEndURLSwitch));
-  }
+  if (parsed_command_line.HasSwitch(kEndURLSwitch))
+    g_end_url = parsed_command_line.GetSwitchValueASCII(kEndURLSwitch);
 
   if (parsed_command_line.HasSwitch(kLogFileSwitch))
     g_log_file_path = parsed_command_line.GetSwitchValuePath(kLogFileSwitch);
 
   if (parsed_command_line.HasSwitch(kTimeoutSwitch)) {
     ASSERT_TRUE(
-        base::StringToInt(WideToUTF16(parsed_command_line.GetSwitchValue(
-            kTimeoutSwitch)), &g_timeout_ms));
+        base::StringToInt(parsed_command_line.GetSwitchValueASCII(
+                              kTimeoutSwitch),
+                          &g_timeout_ms));
     ASSERT_GT(g_timeout_ms, 0);
   }
 
diff --git a/chrome/test/test_launcher/out_of_proc_test_runner.cc b/chrome/test/test_launcher/out_of_proc_test_runner.cc
index 2401a36..eb4e172 100644
--- a/chrome/test/test_launcher/out_of_proc_test_runner.cc
+++ b/chrome/test/test_launcher/out_of_proc_test_runner.cc
@@ -86,10 +86,10 @@ class OutOfProcTestRunner : public tests::TestRunner {
 
     int test_terminate_timeout_ms = kDefaultTestTimeoutMs;
     if (cmd_line->HasSwitch(kTestTerminateTimeoutFlag)) {
-      std::wstring timeout_str(
-          cmd_line->GetSwitchValue(kTestTerminateTimeoutFlag));
+      std::string timeout_str =
+          cmd_line->GetSwitchValueASCII(kTestTerminateTimeoutFlag);
       int timeout;
-      base::StringToInt(WideToUTF8(timeout_str), &timeout);
+      base::StringToInt(timeout_str, &timeout);
       test_terminate_timeout_ms = std::max(test_terminate_timeout_ms, timeout);
     }
 
diff --git a/chrome/test/ui/ui_test.cc b/chrome/test/ui/ui_test.cc
index bef3801..a80718f 100644
--- a/chrome/test/ui/ui_test.cc
+++ b/chrome/test/ui/ui_test.cc
@@ -214,41 +214,41 @@ void UITestBase::TearDown() {
 void UITestBase::InitializeTimeouts() {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(kUiTestTimeout)) {
-    std::wstring timeout_str = command_line.GetSwitchValue(kUiTestTimeout);
+    std::string timeout_str = command_line.GetSwitchValueASCII(kUiTestTimeout);
     int timeout;
-    base::StringToInt(WideToUTF8(timeout_str), &timeout);
+    base::StringToInt(timeout_str, &timeout);
     command_execution_timeout_ms_ = std::max(kCommandExecutionTimeout, timeout);
   }
 
   if (command_line.HasSwitch(kUiTestActionTimeout)) {
-    std::wstring act_str = command_line.GetSwitchValue(kUiTestActionTimeout);
+    std::string act_str =
+        command_line.GetSwitchValueASCII(kUiTestActionTimeout);
     int act_timeout;
-    base::StringToInt(WideToUTF8(act_str), &act_timeout);
+    base::StringToInt(act_str, &act_timeout);
     action_timeout_ms_ = std::max(kWaitForActionMsec, act_timeout);
   }
 
   if (command_line.HasSwitch(kUiTestActionMaxTimeout)) {
-    std::wstring action_max_str =
-        command_line.GetSwitchValue(kUiTestActionMaxTimeout);
+    std::string action_max_str =
+        command_line.GetSwitchValueASCII(kUiTestActionMaxTimeout);
     int max_timeout;
-    base::StringToInt(WideToUTF8(action_max_str), &max_timeout);
+    base::StringToInt(action_max_str, &max_timeout);
     action_max_timeout_ms_ = std::max(kWaitForActionMaxMsec, max_timeout);
   }
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(kUiTestSleepTimeout)) {
-    std::wstring sleep_timeout_str =
-        CommandLine::ForCurrentProcess()->GetSwitchValue(kUiTestSleepTimeout);
+    std::string sleep_timeout_str =
+        command_line.GetSwitchValueASCII(kUiTestSleepTimeout);
     int sleep_timeout;
-    base::StringToInt(WideToUTF8(sleep_timeout_str), &sleep_timeout);
+    base::StringToInt(sleep_timeout_str, &sleep_timeout);
     sleep_timeout_ms_ = std::max(kWaitForActionMsec, sleep_timeout);
   }
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(kUiTestTerminateTimeout)) {
-    std::wstring terminate_timeout_str =
-        CommandLine::ForCurrentProcess()->GetSwitchValue(
-            kUiTestTerminateTimeout);
+    std::string terminate_timeout_str =
+        command_line.GetSwitchValueASCII(kUiTestTerminateTimeout);
     int terminate_timeout;
-    base::StringToInt(WideToUTF8(terminate_timeout_str), &terminate_timeout);
+    base::StringToInt(terminate_timeout_str, &terminate_timeout);
     terminate_timeout_ms_ = std::max(kWaitForActionMsec, terminate_timeout);
   }
 }
diff --git a/chrome/test/ui/ui_test_suite.cc b/chrome/test/ui/ui_test_suite.cc
index 5ba7f1f..3d6d068 100644
--- a/chrome/test/ui/ui_test_suite.cc
+++ b/chrome/test/ui/ui_test_suite.cc
@@ -49,26 +49,26 @@ void UITestSuite::Initialize() {
       parsed_command_line.HasSwitch(switches::kSilentDumpOnDCHECK));
   UITest::set_disable_breakpad(
       parsed_command_line.HasSwitch(switches::kDisableBreakpad));
-  std::wstring test_timeout =
-      parsed_command_line.GetSwitchValue(UITestSuite::kTestTimeout);
+  std::string test_timeout =
+      parsed_command_line.GetSwitchValueASCII(UITestSuite::kTestTimeout);
   if (!test_timeout.empty()) {
     int timeout;
-    base::StringToInt(WideToUTF8(test_timeout), &timeout);
+    base::StringToInt(test_timeout, &timeout);
     UITest::set_test_timeout_ms(timeout);
   }
 
 #if defined(OS_WIN)
   int batch_count = 0;
   int batch_index = 0;
-  std::wstring batch_count_str =
-      parsed_command_line.GetSwitchValue(UITestSuite::kBatchCount);
+  std::string batch_count_str =
+      parsed_command_line.GetSwitchValueASCII(UITestSuite::kBatchCount);
   if (!batch_count_str.empty()) {
-    base::StringToInt(WideToUTF16Hack(batch_count_str), &batch_count);
+    base::StringToInt(batch_count_str, &batch_count);
   }
-  std::wstring batch_index_str =
-      parsed_command_line.GetSwitchValue(UITestSuite::kBatchIndex);
+  std::string batch_index_str =
+      parsed_command_line.GetSwitchValueASCII(UITestSuite::kBatchIndex);
   if (!batch_index_str.empty()) {
-    base::StringToInt(WideToUTF16Hack(batch_index_str), &batch_index);
+    base::StringToInt(batch_index_str, &batch_index);
   }
   if (batch_count > 0 && batch_index >= 0 && batch_index < batch_count) {
     // Running UI test in parallel. Gtest supports running tests in shards,
diff --git a/chrome/test/url_fetch_test/url_fetch_test.cc b/chrome/test/url_fetch_test/url_fetch_test.cc
index ec87c76..5729785 100644
--- a/chrome/test/url_fetch_test/url_fetch_test.cc
+++ b/chrome/test/url_fetch_test/url_fetch_test.cc
@@ -49,7 +49,7 @@ class UrlFetchTest : public UITest {
   }
 
   void RunTest(const GURL& url, const char* wait_cookie_name,
-               const char* wait_cookie_value, const wchar_t* var_to_fetch,
+               const char* wait_cookie_value, const char* var_to_fetch,
                UrlFetchTestResult* result) {
     scoped_refptr<TabProxy> tab(GetActiveTab());
     ASSERT_EQ(AUTOMATION_MSG_NAVIGATION_SUCCESS, tab->NavigateToURL(url));
@@ -67,11 +67,12 @@ class UrlFetchTest : public UITest {
       }
     }
     if (var_to_fetch) {
-      std::wstring script = StringPrintf(
-          L"window.domAutomationController.send(%ls);", var_to_fetch);
+      std::string script = StringPrintf(
+          "window.domAutomationController.send(%s);", var_to_fetch);
 
       std::wstring value;
-      bool success = tab->ExecuteAndExtractString(L"", script, &value);
+      bool success = tab->ExecuteAndExtractString(L"", ASCIIToWide(script),
+                                                  &value);
       ASSERT_TRUE(success);
       result->javascript_variable = WideToUTF8(value);
     }
@@ -121,10 +122,10 @@ TEST_F(UrlFetchTest, UrlFetch) {
   std::string cookie_value =
       cmd_line->GetSwitchValueASCII("wait_cookie_value");
 
-  std::wstring jsvar = cmd_line->GetSwitchValue("jsvar");
+  std::string jsvar = cmd_line->GetSwitchValueASCII("jsvar");
 
   UrlFetchTestResult result;
-  RunTest(GURL(WideToASCII(cmd_line->GetSwitchValue("url"))),
+  RunTest(GURL(cmd_line->GetSwitchValueASCII("url")),
           cookie_name.length() > 0 ? cookie_name.c_str() : NULL,
           cookie_value.length() > 0 ? cookie_value.c_str() : NULL,
           jsvar.length() > 0 ? jsvar.c_str() : NULL,