Fix Issue 19689: Command line URL parameter does not support Chinese....

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>
 #endif
@@ skipping 109 matching lines @@
     std::string switch_value;
     if (IsSwitch(arg, &switch_string, &switch_value)) {
       switches_[switch_string] = switch_value;
     } else {
       loose_values_.push_back(arg);
     }
   }
 }
 
 CommandLine::CommandLine(const std::wstring& program) {
-  argv_.push_back(WideToASCII(program));
+  argv_.push_back(base::SysWideToNativeMB(program));
 }
 #endif
 
 // static
 bool CommandLine::IsSwitch(const StringType& parameter_string,
                            std::string* switch_string,
                            StringType* switch_value) {
   switch_string->clear();
   switch_value->clear();
 
@@ skipping 76 matching lines @@
 
   std::map<std::string, StringType>::const_iterator result =
       switches_.find(WideToASCII(lowercased_switch));
 
   if (result == switches_.end()) {
     return L"";
   } else {
 #if defined(OS_WIN)
     return result->second;
 #else
-    return ASCIIToWide(result->second);
+    return base::SysNativeMBToWide(result->second);
 #endif
   }
 }
 
 #if defined(OS_WIN)
 std::vector<std::wstring> CommandLine::GetLooseValues() const {
   return loose_values_;
 }
 std::wstring CommandLine::program() const {
   return program_;
 }
 #else
 std::vector<std::wstring> CommandLine::GetLooseValues() const {
   std::vector<std::wstring> values;
   for (size_t i = 0; i < loose_values_.size(); ++i)
-    values.push_back(ASCIIToWide(loose_values_[i]));
+    values.push_back(base::SysNativeMBToWide(loose_values_[i]));
   return values;
 }
 std::wstring CommandLine::program() const {
   DCHECK(argv_.size() > 0);
-  return ASCIIToWide(argv_[0]);
+  return base::SysNativeMBToWide(argv_[0]);
 }
 #endif
 
 
 // static
 std::wstring CommandLine::PrefixedSwitchString(
     const std::wstring& switch_string) {
   return StringPrintf(L"%ls%ls",
                       kSwitchPrefixes[0],
                       switch_string.c_str());
@@ skipping 75 matching lines @@
 #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::AppendSwitchWithValue(const std::wstring& switch_string,
                                         const std::wstring& value_string) {
   std::string ascii_switch = WideToASCII(switch_string);
-  std::string ascii_value = WideToASCII(value_string);
+  std::string mb_value = base::SysWideToNativeMB(value_string);
 
   argv_.push_back(kSwitchPrefixes[0] + ascii_switch +
-                  kSwitchValueSeparator + ascii_value);
-  switches_[ascii_switch] = ascii_value;
+                  kSwitchValueSeparator + mb_value);
+  switches_[ascii_switch] = mb_value;
 }
 
 void CommandLine::AppendLooseValue(const std::wstring& value) {
-  argv_.push_back(WideToASCII(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.
   DCHECK(include_program ? !other.program().empty() : other.program().empty());
 
   size_t first_arg = include_program ? 0 : 1;
   for (size_t i = first_arg; i < other.argv_.size(); ++i)
     argv_.push_back(other.argv_[i]);
   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_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 = WideToASCII(wrapper_wide);
+  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