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

chrome/installer/setup/setup_main.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.
 
 #include <windows.h>
 #include <msi.h>
 #include <shellapi.h>
 #include <shlobj.h>
 
 #include <string>
@@ skipping 383 matching lines @@
       ScheduleDirectoryForDeletion(prefs_path.c_str());
     }
   }
 
   dist->UpdateDiffInstallStatus(system_level, incremental_install,
                                 install_status);
   return install_status;
 }
 
 installer_util::InstallStatus UninstallChrome(const CommandLine& cmd_line,
-                                              const wchar_t* cmd_params,
                                               const installer::Version* version,
                                               bool system_install) {
   VLOG(1) << "Uninstalling Chome";
   bool force = cmd_line.HasSwitch(installer_util::switches::kForceUninstall);
   if (!version && !force) {
     LOG(ERROR) << "No Chrome installation found for uninstall.";
     InstallUtil::WriteInstallerResult(system_install,
                                       installer_util::CHROME_NOT_INSTALLED,
                                       IDS_UNINSTALL_FAILED_BASE, NULL);
     return installer_util::CHROME_NOT_INSTALLED;
   }
 
   bool remove_all = !cmd_line.HasSwitch(
       installer_util::switches::kDoNotRemoveSharedItems);
 
   return installer_setup::UninstallChrome(cmd_line.GetProgram().value(),
                                           system_install,
                                           remove_all, force,
-                                          cmd_line, cmd_params);
+                                          cmd_line);
 }
 
 installer_util::InstallStatus ShowEULADialog(const std::wstring& inner_frame) {
   VLOG(1) << "About to show EULA";
   std::wstring eula_path = installer_util::GetLocalizedEulaResource();
   if (eula_path.empty()) {
     LOG(ERROR) << "No EULA path available";
     return installer_util::EULA_REJECTED;
   }
   // Newer versions of the caller pass an inner frame parameter that must
@@ skipping 240 matching lines @@
   }
 
   int exit_code = 0;
   if (HandleNonInstallCmdLineOptions(parsed_command_line, system_install,
                                      exit_code))
     return exit_code;
 
   if (system_install && !IsUserAnAdmin()) {
     if (base::win::GetVersion() >= base::win::VERSION_VISTA &&
         !parsed_command_line.HasSwitch(installer_util::switches::kRunAsAdmin)) {
-      std::wstring exe = parsed_command_line.GetProgram().value();
-      std::wstring params(command_line);
+      CommandLine new_cmd(CommandLine::NO_PROGRAM);
+      new_cmd.AppendArguments(parsed_command_line, true);
       // Append --run-as-admin flag to let the new instance of setup.exe know
       // that we already tried to launch ourselves as admin.
-      params.append(L" --");
-      params.append(installer_util::switches::kRunAsAdmin);
+      new_cmd.AppendSwitch(installer_util::switches::kRunAsAdmin);
       DWORD exit_code = installer_util::UNKNOWN_STATUS;
-      InstallUtil::ExecuteExeAsAdmin(exe, params, &exit_code);
+      InstallUtil::ExecuteExeAsAdmin(new_cmd, &exit_code);
       return exit_code;
     } else {
       LOG(ERROR) << "Non admin user can not install system level Chrome.";
       InstallUtil::WriteInstallerResult(system_install,
                                         installer_util::INSUFFICIENT_RIGHTS,
                                         IDS_INSTALL_INSUFFICIENT_RIGHTS_BASE,
                                         NULL);
       return installer_util::INSUFFICIENT_RIGHTS;
     }
   }
 
   // Check the existing version installed.
   scoped_ptr<installer::Version>
       installed_version(InstallUtil::GetChromeVersion(system_install));
   if (installed_version.get())
     VLOG(1) << "version on the system: " << installed_version->GetString();
 
   installer_util::InstallStatus install_status = installer_util::UNKNOWN_STATUS;
   // If --uninstall option is given, uninstall chrome
   if (parsed_command_line.HasSwitch(installer_util::switches::kUninstall)) {
     install_status = UninstallChrome(parsed_command_line,
-                                     command_line,
                                      installed_version.get(),
                                      system_install);
   // If --uninstall option is not specified, we assume it is install case.
   } else {
     install_status = InstallChrome(parsed_command_line, installed_version.get(),
                                    prefs);
   }
 
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 
@@ skipping 20 matching lines @@
         parsed_command_line.HasSwitch(installer_util::switches::kUninstall))) {
     // Note that we allow the status installer_util::UNINSTALL_REQUIRES_REBOOT
     // to pass through, since this is only returned on uninstall which is never
     // invoked directly by Google Update.
     return_code = dist->GetInstallReturnCode(install_status);
   }
 
   VLOG(1) << "Installation complete, returning: " << return_code;
   return return_code;
 }