Use ASCII strings for switch names.

base/command_line.cc

 // Copyright (c) 2006-2008 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 "base/command_line.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #elif defined(OS_FREEBSD)
@@ skipping 27 matching lines @@
 // Unixes don't use slash as a switch.
 const char* const kSwitchPrefixes[] = {"--", "-"};
 const char kSwitchTerminator[] = "--";
 const char kSwitchValueSeparator[] = "=";
 #endif
 
 #if defined(OS_WIN)
 // Lowercase a string.  This is used to lowercase switch names.
 // Is this what we really want?  It seems crazy to me.  I've left it in
 // for backwards compatibility on Windows.
-static void Lowercase(std::wstring* parameter) {
+static void Lowercase(std::string* parameter) {
   transform(parameter->begin(), parameter->end(), parameter->begin(),
             tolower);
 }
 #endif
 
 #if defined(OS_WIN)
 void CommandLine::ParseFromString(const std::wstring& command_line) {
   TrimWhitespace(command_line, TRIM_ALL, &command_line_string_);
 
   if (command_line_string_.empty())
@@ skipping 109 matching lines @@
         kSwitchValueSeparator, switch_start);
     StringType switch_native;
     if (equals_position == StringType::npos) {
       switch_native = parameter_string.substr(switch_start);
     } else {
       switch_native = parameter_string.substr(
           switch_start, equals_position - switch_start);
       *switch_value = parameter_string.substr(equals_position + 1);
     }
 #if defined(OS_WIN)
-    Lowercase(&switch_native);
     *switch_string = WideToASCII(switch_native);
+    Lowercase(switch_string);
 #else
     *switch_string = switch_native;
 #endif
 
     return true;
   }
 
   return false;
 }
 
@@ skipping 34 matching lines @@
   setproctitle("%s", title.c_str());
 }
 #endif
 
 void CommandLine::Terminate() {
   DCHECK(current_process_commandline_ != NULL);
   delete current_process_commandline_;
   current_process_commandline_ = NULL;
 }
 
-bool CommandLine::HasSwitch(const std::wstring& switch_string) const {
-  std::wstring lowercased_switch(switch_string);
+bool CommandLine::HasSwitch(const std::string& switch_string) const {
+  std::string lowercased_switch(switch_string);
 #if defined(OS_WIN)
   Lowercase(&lowercased_switch);
 #endif
-  return switches_.find(WideToASCII(lowercased_switch)) != switches_.end();
+  return switches_.find(lowercased_switch) != switches_.end();
 }
 
 std::wstring CommandLine::GetSwitchValue(
-    const std::wstring& switch_string) const {
-  std::wstring lowercased_switch(switch_string);
+    const std::string& switch_string) const {
+  std::string lowercased_switch(switch_string);
 #if defined(OS_WIN)
   Lowercase(&lowercased_switch);
 #endif
 
   std::map<std::string, StringType>::const_iterator result =
-      switches_.find(WideToASCII(lowercased_switch));
+      switches_.find(lowercased_switch);
 
   if (result == switches_.end()) {
     return L"";
   } else {
 #if defined(OS_WIN)
     return result->second;
 #else
     return base::SysNativeMBToWide(result->second);
 #endif
   }
@@ skipping 15 matching lines @@
 }
 std::wstring CommandLine::program() const {
   DCHECK_GT(argv_.size(), 0U);
   return base::SysNativeMBToWide(argv_[0]);
 }
 #endif
 
 
 // static
 std::wstring CommandLine::PrefixedSwitchString(
-    const std::wstring& switch_string) {
+    const std::string& switch_string) {
 #if defined(OS_WIN)
-  return kSwitchPrefixes[0] + switch_string;
+  return kSwitchPrefixes[0] + ASCIIToWide(switch_string);
 #else
-  return ASCIIToWide(kSwitchPrefixes[0]) + switch_string;
+  return ASCIIToWide(kSwitchPrefixes[0] + switch_string);
 #endif
 }
 
 // static
 std::wstring CommandLine::PrefixedSwitchStringWithValue(
-    const std::wstring& switch_string, const std::wstring& value_string) {
+    const std::string& switch_string, const std::wstring& value_string) {
   if (value_string.empty()) {
     return PrefixedSwitchString(switch_string);
   }
 
   return PrefixedSwitchString(switch_string +
 #if defined(OS_WIN)
-                              kSwitchValueSeparator +
+                              WideToASCII(kSwitchValueSeparator)
 #else
-                              ASCIIToWide(kSwitchValueSeparator) +
+                              kSwitchValueSeparator
 #endif
-                              value_string);
+                              ) + value_string;
 }
 
 #if defined(OS_WIN)
-void CommandLine::AppendSwitch(const std::wstring& switch_string) {
+void CommandLine::AppendSwitch(const std::string& switch_string) {
   std::wstring prefixed_switch_string = PrefixedSwitchString(switch_string);
   command_line_string_.append(L" ");
   command_line_string_.append(prefixed_switch_string);
-  switches_[WideToASCII(switch_string)] = L"";
+  switches_[switch_string] = L"";
 }
 
-void CommandLine::AppendSwitchWithValue(const std::wstring& switch_string,
+void CommandLine::AppendSwitchWithValue(const std::string& switch_string,
                                         const std::wstring& value_string) {
   std::wstring value_string_edit;
 
   // NOTE(jhughes): If the value contains a quotation mark at one
   //                end but not both, you may get unusable output.
   if (!value_string.empty() &&
       (value_string.find(L" ") != std::wstring::npos) &&
       (value_string[0] != L'"') &&
       (value_string[value_string.length() - 1] != L'"')) {
     // need to provide quotes
     value_string_edit = StringPrintf(L"\"%ls\"", value_string.c_str());
   } else {
     value_string_edit = value_string;
   }
 
   std::wstring combined_switch_string =
-    PrefixedSwitchStringWithValue(switch_string, value_string_edit);
+      PrefixedSwitchStringWithValue(switch_string, value_string_edit);
 
   command_line_string_.append(L" ");
   command_line_string_.append(combined_switch_string);
 
-  switches_[WideToASCII(switch_string)] = value_string;
+  switches_[switch_string] = value_string;
 }
 
 void CommandLine::AppendLooseValue(const std::wstring& value) {
   // TODO(evan): quoting?
   command_line_string_.append(L" ");
   command_line_string_.append(value);
 }
 
 void CommandLine::AppendArguments(const CommandLine& other,
                                   bool include_program) {
   // Verify include_program is used correctly.
   // Logic could be shorter but this is clearer.
   DCHECK(include_program ? !other.program().empty() : other.program().empty());
   command_line_string_ += L" " + other.command_line_string_;
   std::map<std::string, StringType>::const_iterator i;
   for (i = other.switches_.begin(); i != other.switches_.end(); ++i)
     switches_[i->first] = i->second;
 }
 
 void CommandLine::PrependWrapper(const std::wstring& wrapper) {
   // The wrapper may have embedded arguments (like "gdb --args"). In this case,
   // we don't pretend to do anything fancy, we just split on spaces.
   std::vector<std::wstring> wrapper_and_args;
   SplitString(wrapper, ' ', &wrapper_and_args);
   program_ = wrapper_and_args[0];
   command_line_string_ = wrapper + L" " + command_line_string_;
 }
 
 #elif defined(OS_POSIX)
-void CommandLine::AppendSwitch(const std::wstring& switch_string) {
-  std::string ascii_switch = WideToASCII(switch_string);
-  argv_.push_back(kSwitchPrefixes[0] + ascii_switch);
-  switches_[ascii_switch] = "";
+void CommandLine::AppendSwitch(const std::string& switch_string) {
+  argv_.push_back(kSwitchPrefixes[0] + switch_string);
+  switches_[switch_string] = "";
 }
 
-void CommandLine::AppendSwitchWithValue(const std::wstring& switch_string,
+void CommandLine::AppendSwitchWithValue(const std::string& switch_string,
                                         const std::wstring& value_string) {
-  std::string ascii_switch = WideToASCII(switch_string);
   std::string mb_value = base::SysWideToNativeMB(value_string);
 
-  argv_.push_back(kSwitchPrefixes[0] + ascii_switch +
+  argv_.push_back(kSwitchPrefixes[0] + switch_string +
                   kSwitchValueSeparator + mb_value);
-  switches_[ascii_switch] = mb_value;
+  switches_[switch_string] = mb_value;
 }
 
 void CommandLine::AppendLooseValue(const std::wstring& value) {
   argv_.push_back(base::SysWideToNativeMB(value));
 }
 
 void CommandLine::AppendArguments(const CommandLine& other,
                                   bool include_program) {
   // Verify include_program is used correctly.
   // Logic could be shorter but this is clearer.
@@ skipping 10 matching lines @@
 void CommandLine::PrependWrapper(const std::wstring& wrapper_wide) {
   // The wrapper may have embedded arguments (like "gdb --args"). In this case,
   // we don't pretend to do anything fancy, we just split on spaces.
   const std::string wrapper = base::SysWideToNativeMB(wrapper_wide);
   std::vector<std::string> wrapper_and_args;
   SplitString(wrapper, ' ', &wrapper_and_args);
   argv_.insert(argv_.begin(), wrapper_and_args.begin(), wrapper_and_args.end());
 }
 
 #endif