Use GetSwitchValueASCII.

chrome/browser/browser_init.cc

 // Copyright (c) 2009 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/browser_init.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/event_recorder.h"
 #include "base/path_service.h"
@@ skipping 389 matching lines @@
   if (command_line_.HasSwitch(switches::kDnsLogDetails))
     chrome_browser_net::EnableDnsDetailedLog(true);
   if (command_line_.HasSwitch(switches::kDnsPrefetchDisable))
     chrome_browser_net::EnableDnsPrefetch(false);
 
   if (command_line_.HasSwitch(switches::kDumpHistogramsOnExit))
     StatisticsRecorder::set_dump_on_exit(true);
 
   if (command_line_.HasSwitch(switches::kRemoteShellPort)) {
     if (!RenderProcessHost::run_renderer_in_process()) {
-      std::wstring port_str =
-          command_line_.GetSwitchValue(switches::kRemoteShellPort);
-      int64 port = StringToInt64(WideToUTF16Hack(port_str));
+      std::string port_str =
+          command_line_.GetSwitchValueASCII(switches::kRemoteShellPort);
+      int64 port = StringToInt64(port_str);
       if (port > 0 && port < 65535) {
         g_browser_process->InitDebuggerWrapper(static_cast<int>(port));
       } else {
         DLOG(WARNING) << "Invalid port number " << port;
       }
     }
   }
 
   if (command_line_.HasSwitch(switches::kUserAgent)) {
-    webkit_glue::SetUserAgent(WideToUTF8(
-        command_line_.GetSwitchValue(switches::kUserAgent)));
+    webkit_glue::SetUserAgent(command_line_.GetSwitchValueASCII(
+        switches::kUserAgent));
   }
 
   // Open the required browser windows and tabs.
   // First, see if we're being run as a web application (thin frame window).
   if (!OpenApplicationURL(profile)) {
     std::vector<GURL> urls_to_open = GetURLsFromCommandLine(profile_);
     RecordLaunchModeHistogram(urls_to_open.empty()?
                               LM_TO_BE_DECIDED : LM_WITH_URLS);
     // Always attempt to restore the last session. OpenStartupURLs only opens
     // the home pages if no additional URLs were passed on the command line.
@@ skipping 38 matching lines @@
       base::EventRecorder::current()->StartPlayback(script_path);
   }
 
   return true;
 }
 
 bool BrowserInit::LaunchWithProfile::OpenApplicationURL(Profile* profile) {
   if (!command_line_.HasSwitch(switches::kApp))
     return false;
 
-  GURL url(WideToUTF8(command_line_.GetSwitchValue(switches::kApp)));
+  GURL url(command_line_.GetSwitchValueASCII(switches::kApp));
   if (!url.is_empty() && url.is_valid()) {
     Browser::OpenApplicationWindow(profile, url);
     return true;
   }
   return false;
 }
 
 bool BrowserInit::LaunchWithProfile::OpenStartupURLs(
     bool is_process_startup,
     const std::vector<GURL>& urls_to_open) {
@@ skipping 51 matching lines @@
     const std::vector<GURL>& urls) {
   DCHECK(!urls.empty());
   // If we don't yet have a profile, try to use the one we're given from
   // |browser|. While we may not end up actually using |browser| (since it
   // could be a popup window), we can at least use the profile.
   if (!profile_ && browser)
     profile_ = browser->profile();
 
   int pin_count = 0;
   if (!browser) {
-    std::wstring pin_count_string =
-        command_line_.GetSwitchValue(switches::kPinnedTabCount);
+    std::string pin_count_string =
+        command_line_.GetSwitchValueASCII(switches::kPinnedTabCount);
     if (!pin_count_string.empty())
-      pin_count = StringToInt(WideToUTF16Hack(pin_count_string));
+      pin_count = StringToInt(pin_count_string);
   }
   if (!browser || browser->type() != Browser::TYPE_NORMAL)
     browser = Browser::Create(profile_);
 
   for (size_t i = 0; i < urls.size(); ++i) {
     // We skip URLs that we'd have to launch an external protocol handler for.
     // This avoids us getting into an infinite loop asking ourselves to open
     // a URL, should the handler be (incorrectly) configured to be us. Anyone
     // asking us to open such a URL should really ask the handler directly.
     if (!process_startup && !URLRequest::IsHandledURL(urls[i]))
@@ skipping 112 matching lines @@
 }
 
 bool BrowserInit::ProcessCmdLineImpl(const CommandLine& command_line,
                                      const std::wstring& cur_dir,
                                      bool process_startup,
                                      Profile* profile,
                                      int* return_code,
                                      BrowserInit* browser_init) {
   DCHECK(profile);
   if (process_startup) {
-    const std::wstring popup_count_string =
-        command_line.GetSwitchValue(switches::kOmniBoxPopupCount);
+    const std::string popup_count_string =
+        command_line.GetSwitchValueASCII(switches::kOmniBoxPopupCount);
     if (!popup_count_string.empty()) {
       int count = 0;
-      if (StringToInt(WideToUTF16Hack(popup_count_string), &count)) {
+      if (StringToInt(popup_count_string, &count)) {
         const int popup_count = std::max(0, count);
         AutocompleteResult::set_max_matches(popup_count);
         AutocompleteProvider::set_max_matches(popup_count / 2);
       }
     }
 
     if (command_line.HasSwitch(switches::kDisablePromptOnRepost))
       NavigationController::DisablePromptOnRepost();
 
-    const std::wstring tab_count_string =
-        command_line.GetSwitchValue(switches::kTabCountToLoadOnSessionRestore);
+    const std::string tab_count_string = command_line.GetSwitchValueASCII(
+        switches::kTabCountToLoadOnSessionRestore);
     if (!tab_count_string.empty()) {
       int count = 0;
-      if (StringToInt(WideToUTF16Hack(tab_count_string), &count)) {
+      if (StringToInt(tab_count_string, &count)) {
         const int tab_count = std::max(0, count);
         SessionRestore::num_tabs_to_load_ = static_cast<size_t>(tab_count);
       }
     }
 
     // Look for the testing channel ID ONLY during process startup
     if (command_line.HasSwitch(switches::kTestingChannelID)) {
-      std::string testing_channel_id = WideToASCII(
-          command_line.GetSwitchValue(switches::kTestingChannelID));
+      std::string testing_channel_id = command_line.GetSwitchValueASCII(
+          switches::kTestingChannelID);
       // TODO(sanjeevr) Check if we need to make this a singleton for
       // compatibility with the old testing code
       // If there are any loose parameters, we expect each one to generate a
       // new tab; if there are none then we get one homepage tab.
       int expected_tab_count = 1;
       if (command_line.HasSwitch(switches::kRestoreLastSession)) {
-        std::wstring restore_session_value(
-            command_line.GetSwitchValue(switches::kRestoreLastSession));
-        StringToInt(WideToUTF16Hack(restore_session_value),
-                    &expected_tab_count);
+        std::string restore_session_value(
+            command_line.GetSwitchValueASCII(switches::kRestoreLastSession));
+        StringToInt(restore_session_value, &expected_tab_count);
       } else {
         expected_tab_count =
             std::max(1, static_cast<int>(command_line.GetLooseValues().size()));
       }
       CreateAutomationProvider<TestingAutomationProvider>(
           testing_channel_id,
           profile,
           static_cast<size_t>(expected_tab_count));
     }
 
     if (command_line.HasSwitch(switches::kPackExtension)) {
       // Input Paths.
       FilePath src_dir = FilePath::FromWStringHack(command_line.GetSwitchValue(
           switches::kPackExtension));
       FilePath private_key_path;
       if (command_line.HasSwitch(switches::kPackExtensionKey)) {
-        private_key_path = FilePath::FromWStringHack(
-            command_line.GetSwitchValue(switches::kPackExtensionKey));
+        private_key_path = command_line.GetSwitchValuePath(
+            switches::kPackExtensionKey);
       }
 
       // Output Paths.
       FilePath output(src_dir.DirName().Append(src_dir.BaseName().value()));
       FilePath crx_path(output);
       crx_path = crx_path.ReplaceExtension(chrome::kExtensionFileExtension);
       FilePath output_private_key_path;
       if (private_key_path.empty()) {
         output_private_key_path = FilePath(output);
         output_private_key_path =
@@ skipping 29 matching lines @@
       }
       return false;
     }
   }
 
   // Allow the command line to override the persisted setting of home page.
   SetOverrideHomePage(command_line, profile->GetPrefs());
 
   bool silent_launch = false;
   if (command_line.HasSwitch(switches::kAutomationClientChannelID)) {
-    std::string automation_channel_id = WideToASCII(
-        command_line.GetSwitchValue(switches::kAutomationClientChannelID));
+    std::string automation_channel_id = command_line.GetSwitchValueASCII(
+        switches::kAutomationClientChannelID);
     // If there are any loose parameters, we expect each one to generate a
     // new tab; if there are none then we have no tabs
     size_t expected_tabs =
         std::max(static_cast<int>(command_line.GetLooseValues().size()),
                  0);
     if (expected_tabs == 0)
       silent_launch = true;
     CreateAutomationProvider<AutomationProvider>(automation_channel_id,
                                                  profile, expected_tabs);
   }
@@ skipping 26 matching lines @@
   scoped_refptr<AutomationProviderClass> automation =
       new AutomationProviderClass(profile);
   automation->ConnectToChannel(channel_id);
   automation->SetExpectedTabCount(expected_tabs);
 
   AutomationProviderList* list =
       g_browser_process->InitAutomationProviderList();
   DCHECK(list);
   list->AddProvider(automation);
 }