Always suffix ChromeHTML entries on Windows for user-level installs.

chrome/installer/setup/setup_main.cc

 // Copyright (c) 2012 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>
-
 #include "base/at_exit.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/scoped_temp_dir.h"
+#include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "breakpad/src/client/windows/handler/exception_handler.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 62 matching lines @@
                     const FilePath& temp_path,
                     const FilePath& output_directory,
                     installer::ArchiveType* archive_type) {
   DCHECK(archive_type);
 
   installer_state.UpdateStage(installer::UNCOMPRESSING);
 
   // First uncompress the payload. This could be a differential
   // update (patch.7z) or full archive (chrome.7z). If this uncompress fails
   // return with error.
-  std::wstring unpacked_file;
+  string16 unpacked_file;
   int32 ret = LzmaUtil::UnPackArchive(archive.value(), temp_path.value(),
                                       &unpacked_file);
   if (ret != NO_ERROR)
     return ret;
 
   FilePath uncompressed_archive(temp_path.Append(installer::kChromeArchive));
   scoped_ptr<Version> archive_version(
       installer::GetMaxVersionFromArchiveDir(installer_state.target_path()));
 
   // Check if this is differential update and if it is, patch it to the
@@ skipping 114 matching lines @@
   // Next, add all products we're operating on.  std::transform can handily do
   // this for us, but this is discouraged as being too tricky.
   const Products& products = installer_state->products();
   for (Products::size_type i = 0; i < products.size(); ++i) {
     dists[num_dists++] = products[i]->distribution();
   }
 
   // Add work items to delete the "opv", "cpv", and "cmd" values from all
   // distributions.
   HKEY reg_root = installer_state->root_key();
-  std::wstring version_key;
+  string16 version_key;
   for (int i = 0; i < num_dists; ++i) {
     version_key = dists[i]->GetVersionKey();
     install_list->AddDeleteRegValueWorkItem(
         reg_root, version_key, google_update::kRegOldVersionField);
     install_list->AddDeleteRegValueWorkItem(
         reg_root, version_key, google_update::kRegCriticalVersionField);
     install_list->AddDeleteRegValueWorkItem(
         reg_root, version_key, google_update::kRegRenameCmdField);
   }
   installer::InstallStatus ret = installer::RENAME_SUCCESSFUL;
@@ skipping 408 matching lines @@
         // uncompressing and binary patching. Get the location for this file.
         FilePath archive_to_copy(
             temp_path.path().Append(installer::kChromeArchive));
         FilePath prefs_source_path(cmd_line.GetSwitchValueNative(
             installer::switches::kInstallerData));
         install_status = installer::InstallOrUpdateProduct(original_state,
             installer_state, cmd_line.GetProgram(), archive_to_copy,
             temp_path.path(), prefs_source_path, prefs, *installer_version);
 
         int install_msg_base = IDS_INSTALL_FAILED_BASE;
-        std::wstring chrome_exe;
+        string16 chrome_exe;
+        string16 quoted_chrome_exe;
         if (install_status == installer::SAME_VERSION_REPAIR_FAILED) {
           if (installer_state.FindProduct(BrowserDistribution::CHROME_FRAME)) {
             install_msg_base = IDS_SAME_VERSION_REPAIR_FAILED_CF_BASE;
           } else {
             install_msg_base = IDS_SAME_VERSION_REPAIR_FAILED_BASE;
           }
         } else if (install_status != installer::INSTALL_FAILED) {
           if (installer_state.target_path().empty()) {
             // If we failed to construct install path, it means the OS call to
             // get %ProgramFiles% or %AppData% failed. Report this as failure.
             install_msg_base = IDS_INSTALL_OS_ERROR_BASE;
             install_status = installer::OS_ERROR;
           } else {
             chrome_exe = installer_state.target_path()
                 .Append(installer::kChromeExe).value();
-            chrome_exe = L"\"" + chrome_exe + L"\"";
+            quoted_chrome_exe = L"\"" + chrome_exe + L"\"";
             install_msg_base = 0;
           }
         }
 
         installer_state.UpdateStage(installer::FINISHING);
 
         // Only do Chrome-specific stuff (like launching the browser) if
         // Chrome was specifically requested (rather than being upgraded as
         // part of a multi-install).
         const Product* chrome_install = prefs.install_chrome() ?
             installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER) :
             NULL;
 
         bool do_not_register_for_update_launch = false;
         if (chrome_install) {
           prefs.GetBool(
               installer::master_preferences::kDoNotRegisterForUpdateLaunch,
               &do_not_register_for_update_launch);
         } else {
           do_not_register_for_update_launch = true;  // Never register.
         }
 
         bool write_chrome_launch_string =
             (!do_not_register_for_update_launch &&
              install_status != installer::IN_USE_UPDATED);
 
         installer_state.WriteInstallerResult(install_status, install_msg_base,
-            write_chrome_launch_string ? &chrome_exe : NULL);
+            write_chrome_launch_string ? &quoted_chrome_exe : NULL);
 
         if (install_status == installer::FIRST_INSTALL_SUCCESS) {
           VLOG(1) << "First install successful.";
           if (chrome_install) {
             // We never want to launch Chrome in system level install mode.
             bool do_not_launch_chrome = false;
             prefs.GetBool(
                 installer::master_preferences::kDoNotLaunchChrome,
                 &do_not_launch_chrome);
             if (!system_install && !do_not_launch_chrome)
               chrome_install->LaunchChrome(installer_state.target_path());
           }
         } else if ((install_status == installer::NEW_VERSION_UPDATED) ||
                    (install_status == installer::IN_USE_UPDATED)) {
           const Product* chrome = installer_state.FindProduct(
               BrowserDistribution::CHROME_BROWSER);
-          if (chrome != NULL)
-            installer::RemoveChromeLegacyRegistryKeys(chrome->distribution());
+          if (chrome != NULL) {
+            DCHECK_NE(chrome_exe, string16());
+            installer::RemoveChromeLegacyRegistryKeys(chrome->distribution(),
+                                                      chrome_exe);
+          }
         }
       }
     }
 
     // There might be an experiment (for upgrade usually) that needs to happen.
     // An experiment's outcome can include chrome's uninstallation. If that is
     // the case we would not do that directly at this point but in another
     // instance of setup.exe
     //
     // There is another way to reach this same function if this is a system
@@ skipping 155 matching lines @@
         cmd_line, remove_all, force, *products[i]);
     if (prod_status != installer::UNINSTALL_SUCCESSFUL)
       install_status = prod_status;
   }
 
   UninstallGoogleUpdate(installer_state.system_install());
 
   return install_status;
 }
 
-installer::InstallStatus ShowEULADialog(const std::wstring& inner_frame) {
+installer::InstallStatus ShowEULADialog(const string16& inner_frame) {
   VLOG(1) << "About to show EULA";
-  std::wstring eula_path = installer::GetLocalizedEulaResource();
+  string16 eula_path = installer::GetLocalizedEulaResource();
   if (eula_path.empty()) {
     LOG(ERROR) << "No EULA path available";
     return installer::EULA_REJECTED;
   }
   // Newer versions of the caller pass an inner frame parameter that must
   // be given to the html page being launched.
   installer::EulaHTMLDialog dlg(eula_path, inner_frame);
   installer::EulaHTMLDialog::Outcome outcome = dlg.ShowModal();
   if (installer::EulaHTMLDialog::REJECTED == outcome) {
     LOG(ERROR) << "EULA rejected or EULA failure";
@@ skipping 21 matching lines @@
   if (cmd_line.HasSwitch(installer::switches::kUpdateSetupExe)) {
     installer::InstallStatus status = installer::SETUP_PATCH_FAILED;
     // If --update-setup-exe command line option is given, we apply the given
     // patch to current exe, and store the resulting binary in the path
     // specified by --new-setup-exe. But we need to first unpack the file
     // given in --update-setup-exe.
     ScopedTempDir temp_path;
     if (!temp_path.CreateUniqueTempDir()) {
       PLOG(ERROR) << "Could not create temporary path.";
     } else {
-      std::wstring setup_patch = cmd_line.GetSwitchValueNative(
+      string16 setup_patch = cmd_line.GetSwitchValueNative(
           installer::switches::kUpdateSetupExe);
       VLOG(1) << "Opening archive " << setup_patch;
-      std::wstring uncompressed_patch;
+      string16 uncompressed_patch;
       if (LzmaUtil::UnPackArchive(setup_patch, temp_path.path().value(),
                                   &uncompressed_patch) == NO_ERROR) {
         FilePath old_setup_exe = cmd_line.GetProgram();
         FilePath new_setup_exe = cmd_line.GetSwitchValuePath(
             installer::switches::kNewSetupExe);
         if (!installer::ApplyDiffPatch(old_setup_exe,
                                        FilePath(uncompressed_patch),
                                        new_setup_exe,
                                        installer_state))
           status = installer::NEW_VERSION_UPDATED;
@@ skipping 11 matching lines @@
     if (*exit_code) {
       LOG(WARNING) << "setup.exe patching failed.";
       installer_state->WriteInstallerResult(status, IDS_SETUP_PATCH_FAILED_BASE,
           NULL);
     }
     // We will be exiting normally, so clear the stage indicator.
     installer_state->UpdateStage(installer::NO_STAGE);
   } else if (cmd_line.HasSwitch(installer::switches::kShowEula)) {
     // Check if we need to show the EULA. If it is passed as a command line
     // then the dialog is shown and regardless of the outcome setup exits here.
-    std::wstring inner_frame =
+    string16 inner_frame =
         cmd_line.GetSwitchValueNative(installer::switches::kShowEula);
     *exit_code = ShowEULADialog(inner_frame);
     if (installer::EULA_REJECTED != *exit_code) {
       GoogleUpdateSettings::SetEULAConsent(
           original_state, BrowserDistribution::GetDistribution(), true);
     }
   } else if (cmd_line.HasSwitch(
       installer::switches::kRegisterChromeBrowser)) {
     installer::InstallStatus status = installer::UNKNOWN_STATUS;
     const Product* chrome_install =
         installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER);
     if (chrome_install) {
       // If --register-chrome-browser option is specified, register all
       // Chrome protocol/file associations, as well as register it as a valid
       // browser for Start Menu->Internet shortcut. This switch will also
       // register Chrome as a valid handler for a set of URL protocols that
       // Chrome may become the default handler for, either by the user marking
       // Chrome as the default browser, through the Windows Default Programs
       // control panel settings, or through website use of
       // registerProtocolHandler. These protocols are found in
       // ShellUtil::kPotentialProtocolAssociations.
       // The --register-url-protocol will additionally register Chrome as a
       // potential handler for the supplied protocol, and is used if a website
       // registers a handler for a protocol not found in
       // ShellUtil::kPotentialProtocolAssociations.
       // These options should only be used when setup.exe is launched with admin
       // rights. We do not make any user specific changes with this option.
       DCHECK(IsUserAnAdmin());
-      std::wstring chrome_exe(cmd_line.GetSwitchValueNative(
+      string16 chrome_exe(cmd_line.GetSwitchValueNative(
           installer::switches::kRegisterChromeBrowser));
-      std::wstring suffix;
+      string16 suffix;
       if (cmd_line.HasSwitch(
           installer::switches::kRegisterChromeBrowserSuffix)) {
         suffix = cmd_line.GetSwitchValueNative(
             installer::switches::kRegisterChromeBrowserSuffix);
       }
       if (cmd_line.HasSwitch(
           installer::switches::kRegisterURLProtocol)) {
-        std::wstring protocol = cmd_line.GetSwitchValueNative(
+        string16 protocol = cmd_line.GetSwitchValueNative(
             installer::switches::kRegisterURLProtocol);
         // ShellUtil::RegisterChromeForProtocol performs all registration
         // done by ShellUtil::RegisterChromeBrowser, as well as registering
         // with Windows as capable of handling the supplied protocol.
         if (ShellUtil::RegisterChromeForProtocol(chrome_install->distribution(),
             chrome_exe, suffix, protocol, false))
           status = installer::IN_USE_UPDATED;
       } else {
         if (ShellUtil::RegisterChromeBrowser(chrome_install->distribution(),
             chrome_exe, suffix, false))
           status = installer::IN_USE_UPDATED;
       }
     } else {
       LOG(DFATAL) << "Can't register browser - Chrome distribution not found";
     }
     *exit_code = InstallUtil::GetInstallReturnCode(status);
   } else if (cmd_line.HasSwitch(installer::switches::kRenameChromeExe)) {
     // If --rename-chrome-exe is specified, we want to rename the executables
     // and exit.
     *exit_code = RenameChromeExecutables(original_state, installer_state);
   } else if (cmd_line.HasSwitch(
       installer::switches::kRemoveChromeRegistration)) {
     // This is almost reverse of --register-chrome-browser option above.
     // Here we delete Chrome browser registration. This option should only
     // be used when setup.exe is launched with admin rights. We do not
     // make any user specific changes in this option.
-    std::wstring suffix;
+    string16 suffix;
     if (cmd_line.HasSwitch(
         installer::switches::kRegisterChromeBrowserSuffix)) {
       suffix = cmd_line.GetSwitchValueNative(
           installer::switches::kRegisterChromeBrowserSuffix);
     }
     installer::InstallStatus tmp = installer::UNKNOWN_STATUS;
     const Product* chrome_install =
         installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER);
     DCHECK(chrome_install);
     if (chrome_install) {
@@ skipping 114 matching lines @@
     return true;
   }
 
  private:
   bool initialized_;
 };
 
 // Returns the Custom information for the client identified by the exe path
 // passed in. This information is used for crash reporting.
 google_breakpad::CustomClientInfo* GetCustomInfo(const wchar_t* exe_path) {
-  std::wstring product;
-  std::wstring version;
+  string16 product;
+  string16 version;
   scoped_ptr<FileVersionInfo>
       version_info(FileVersionInfo::CreateFileVersionInfo(FilePath(exe_path)));
   if (version_info.get()) {
     version = version_info->product_version();
     product = version_info->product_short_name();
   }
 
   if (version.empty())
     version = L"0.1.0.0";
 
@@ skipping 24 matching lines @@
   FilePath temp_directory;
   if (!file_util::GetTempDir(&temp_directory) || temp_directory.empty())
     return NULL;
 
   wchar_t exe_path[MAX_PATH * 2] = {0};
   GetModuleFileName(NULL, exe_path, arraysize(exe_path));
 
   // Build the pipe name. It can be either:
   // System-wide install: "NamedPipe\GoogleCrashServices\S-1-5-18"
   // Per-user install: "NamedPipe\GoogleCrashServices\<user SID>"
-  std::wstring user_sid = kSystemPrincipalSid;
+  string16 user_sid = kSystemPrincipalSid;
 
   if (!system_install) {
     if (!base::win::GetUserSidString(&user_sid)) {
       return NULL;
     }
   }
 
-  std::wstring pipe_name = kGoogleUpdatePipeName;
+  string16 pipe_name = kGoogleUpdatePipeName;
   pipe_name += user_sid;
 
   google_breakpad::ExceptionHandler* breakpad =
       new google_breakpad::ExceptionHandler(
           temp_directory.value(), NULL, NULL, NULL,
           google_breakpad::ExceptionHandler::HANDLER_ALL, kLargerDumpType,
           pipe_name.c_str(), GetCustomInfo(exe_path));
   return breakpad;
 }
 
@@ skipping 135 matching lines @@
   if (!(installer_state.is_msi() && is_uninstall))
     // Note that we allow the status installer::UNINSTALL_REQUIRES_REBOOT
     // to pass through, since this is only returned on uninstall which is
     // never invoked directly by Google Update.
     return_code = InstallUtil::GetInstallReturnCode(install_status);
 
   VLOG(1) << "Installation complete, returning: " << return_code;
 
   return return_code;
 }