Changing the installer switches from wchar_t[] to char[]....

chrome/installer/util/google_chrome_distribution.cc

 // Copyright (c) 2010 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.
 //
 // This file defines specific implementation of BrowserDistribution class for
 // Google Chrome.
 
 #include "chrome/installer/util/google_chrome_distribution.h"
 
 #include <windows.h>
@@ skipping 121 matching lines @@
 // If system_level_toast is true, appends --system-level-toast.
 // If handle to experiment result key was given at startup, re-add it.
 // Does not wait for the process to terminate.
 bool RelaunchSetup(const std::string& flag, int value,
                    bool system_level_toast) {
   CommandLine new_cmd_line(CommandLine::ForCurrentProcess()->GetProgram());
   new_cmd_line.AppendSwitchASCII(flag, base::IntToString(value));
 
   // Re-add the system level toast flag.
   if (system_level_toast) {
-    new_cmd_line.AppendSwitch(
-      WideToASCII(installer_util::switches::kSystemLevelToast));
+    new_cmd_line.AppendSwitch(installer_util::switches::kSystemLevelToast);
 
     // Re-add the toast result key. We need to do this because Setup running as
     // system passes the key to Setup running as user, but that child process
     // does not perform the actual toasting, it launches another Setup (as user)
     // to do so. That is the process that needs the key.
     const CommandLine& current_cmd_line = *CommandLine::ForCurrentProcess();
-    std::string key = WideToASCII(installer_util::switches::kToastResultsKey);
+    std::string key(installer_util::switches::kToastResultsKey);
     std::string toast_key = current_cmd_line.GetSwitchValueASCII(key);
     if (!toast_key.empty()) {
       new_cmd_line.AppendSwitchASCII(key, toast_key);
 
       // Use handle inheritance to make sure the duplicated toast results key
       // gets inherited by the child process.
       return base::LaunchAppWithHandleInheritance(
           new_cmd_line.command_line_string(), false, false, NULL);
     }
   }
@@ skipping 49 matching lines @@
 }
 
 // This function launches setup as the currently logged-in interactive
 // user that is the user whose logon session is attached to winsta0\default.
 // It assumes that currently we are running as SYSTEM in a non-interactive
 // windowstation.
 // The function fails if there is no interactive session active, basically
 // the computer is on but nobody has logged in locally.
 // Remote Desktop sessions do not count as interactive sessions; running this
 // method as a user logged in via remote desktop will do nothing.
-bool RelaunchSetupAsConsoleUser(const std::wstring& flag) {
+bool RelaunchSetupAsConsoleUser(const std::string& flag) {
   FilePath setup_exe = CommandLine::ForCurrentProcess()->GetProgram();
   CommandLine cmd_line(setup_exe);
-  cmd_line.AppendSwitch(WideToASCII(flag));
+  cmd_line.AppendSwitch(flag);
 
   // Get the Google Update results key, and pass it on the command line to
   // the child process.
   int key = GoogleUpdateSettings::DuplicateGoogleUpdateSystemClientKey();
-  cmd_line.AppendSwitchASCII(
-      WideToASCII(installer_util::switches::kToastResultsKey),
-      base::IntToString(key));
+  cmd_line.AppendSwitchASCII(installer_util::switches::kToastResultsKey,
+                             base::IntToString(key));
 
   if (base::win::GetVersion() > base::win::VERSION_XP) {
     // Make sure that in Vista and Above we have the proper DACLs so
     // the interactive user can launch it.
     if (!FixDACLsForExecute(setup_exe.ToWStringHack().c_str()))
       NOTREACHED();
   }
 
   DWORD console_id = ::WTSGetActiveConsoleSessionId();
   if (console_id == 0xFFFFFFFF)
@@ skipping 282 matching lines @@
 void SetClient(std::wstring experiment_group, bool last_write) {
   static int reg_key_handle = -1;
   if (reg_key_handle == -1) {
     // If a specific Toast Results key handle (presumably to our HKLM key) was
     // passed in to the command line (such as for system level installs), we use
     // it. Otherwise, we write to the key under HKCU.
     const CommandLine& cmd_line = *CommandLine::ForCurrentProcess();
     if (cmd_line.HasSwitch(installer_util::switches::kToastResultsKey)) {
       // Get the handle to the key under HKLM.
       base::StringToInt(cmd_line.GetSwitchValueASCII(
-          WideToASCII(installer_util::switches::kToastResultsKey)).c_str(),
+          installer_util::switches::kToastResultsKey).c_str(),
           &reg_key_handle);
     } else {
       reg_key_handle = 0;
     }
   }
 
   if (reg_key_handle) {
     // Use it to write the experiment results.
     GoogleUpdateSettings::WriteGoogleUpdateSystemClientKey(
         reg_key_handle, google_update::kRegClientField, experiment_group);
@@ skipping 116 matching lines @@
 
   if (outcome != kToastExpUninstallGroup)
     return;
   // The user wants to uninstall. This is a best effort operation. Note that
   // we waited for chrome to exit so the uninstall would not detect chrome
   // running.
   base::LaunchApp(InstallUtil::GetChromeUninstallCmd(system_install),
                   false, false, NULL);
 }
 #endif