Uninstall multi-install Chrome Frame when updated.

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 "chrome/installer/setup/setup_main.h"
 
 #include <windows.h>
 #include <msi.h>
 #include <shellapi.h>
 #include <shlobj.h>
@@ skipping 683 matching lines @@
   if (!file_util::CreateTemporaryDirInDir(temp_path->path(),
                                           installer::kInstallSourceDir,
                                           unpack_path)) {
     PLOG(ERROR) << "Could not create temporary path for unpacked archive.";
     return false;
   }
 
   return true;
 }
 
-installer::InstallStatus InstallProducts(

[grt (UTC plus 2), 2013/11/29 04:23:03]

code motion only except for what is now line 902.

-    const InstallationState& original_state,
-    const CommandLine& cmd_line,
-    const MasterPreferences& prefs,
-    InstallerState* installer_state,
-    base::FilePath* installer_directory) {
-  DCHECK(installer_state);
-  const bool system_install = installer_state->system_install();
-  installer::InstallStatus install_status = installer::UNKNOWN_STATUS;
-  installer::ArchiveType archive_type = installer::UNKNOWN_ARCHIVE_TYPE;
-  bool delegated_to_existing = false;
-  installer_state->UpdateStage(installer::PRECONDITIONS);
-  // The stage provides more fine-grained information than -multifail, so remove
-  // the -multifail suffix from the Google Update "ap" value.
-  BrowserDistribution::GetSpecificDistribution(installer_state->state_type())->
-      UpdateInstallStatus(system_install, archive_type, install_status);
-  if (CheckPreInstallConditions(original_state, installer_state,
-                                &install_status)) {
-    VLOG(1) << "Installing to " << installer_state->target_path().value();
-    install_status = InstallProductsHelper(
-        original_state, cmd_line, prefs, *installer_state,
-        installer_directory, &archive_type, &delegated_to_existing);
-  } else {
-    // CheckPreInstallConditions must set the status on failure.
-    DCHECK_NE(install_status, installer::UNKNOWN_STATUS);
-  }
-
-  // Delete the master preferences file if present. Note that we do not care
-  // about rollback here and we schedule for deletion on reboot if the delete
-  // fails. As such, we do not use DeleteTreeWorkItem.
-  if (cmd_line.HasSwitch(installer::switches::kInstallerData)) {
-    base::FilePath prefs_path(cmd_line.GetSwitchValuePath(
-        installer::switches::kInstallerData));
-    if (!base::DeleteFile(prefs_path, false)) {
-      LOG(ERROR) << "Failed deleting master preferences file "
-                 << prefs_path.value()
-                 << ", scheduling for deletion after reboot.";
-      ScheduleFileSystemEntityForDeletion(prefs_path);
-    }
-  }
-
-  // Early exit if this setup.exe delegated to another, since that one would
-  // have taken care of UpdateInstallStatus and UpdateStage.
-  if (delegated_to_existing)
-    return install_status;
-
-  const Products& products = installer_state->products();
-  for (Products::const_iterator it = products.begin(); it < products.end();
-       ++it) {
-    (*it)->distribution()->UpdateInstallStatus(
-        system_install, archive_type, install_status);
-  }
-
-  installer_state->UpdateStage(installer::NO_STAGE);
-  return install_status;
-}
-
 installer::InstallStatus UninstallProduct(
     const InstallationState& original_state,
     const InstallerState& installer_state,
     const CommandLine& cmd_line,
     bool remove_all,
     bool force_uninstall,
     const Product& product) {
   const ProductState* product_state =
       original_state.GetProductState(installer_state.system_install(),
                                      product.distribution()->GetType());
@@ skipping 90 matching lines @@
     base::LaunchProcess(system_level_cmd, base::LaunchOptions(), NULL);
 
   // Tell Google Update that an uninstall has taken place.
   // Ignore the return value: success or failure of Google Update
   // has no bearing on the success or failure of Chrome's uninstallation.
   google_update::UninstallGoogleUpdate(installer_state.system_install());
 
   return install_status;
 }
 
+// Uninstall the binaries if they are the only product present and they're not
+// in-use.
+void UninstallBinariesIfUnused(

[grt (UTC plus 2), 2013/11/29 04:23:03]

this is more or less what used to be on line 1788, but now using state that more
accurately reflects what is being done. i believe that the prior code may have
been crashy (although i don't see corresponding crash reports for some reason),
and may have been prone to leaving an empty directory behind during cleanup.

+    const InstallationState& original_state,
+    const InstallerState& installer_state,
+    installer::InstallStatus* install_status) {
+  // Early exit if the binaries are still in use.
+  if (*install_status != installer::UNUSED_BINARIES ||
+      installer_state.AreBinariesInUse(original_state)) {
+    return;
+  }
+
+  LOG(INFO) << "Uninstalling unused binaries";
+  installer_state.UpdateStage(installer::UNINSTALLING_BINARIES);
+
+  // Simulate the uninstall as coming from the installed version.
+  const ProductState* binaries_state =
+      original_state.GetProductState(installer_state.system_install(),
+                                     BrowserDistribution::CHROME_BINARIES);
+  const CommandLine& uninstall_cmd(binaries_state->uninstall_command());
+  MasterPreferences uninstall_prefs(uninstall_cmd);
+  InstallerState uninstall_state;
+  uninstall_state.Initialize(uninstall_cmd, uninstall_prefs, original_state);
+
+  *install_status =
+      UninstallProducts(original_state, uninstall_state, uninstall_cmd);
+
+  // Report that the binaries were uninstalled if they were. This translates
+  // into a successful install return code.
+  if (IsUninstallSuccess(*install_status)) {
+    *install_status = installer::UNUSED_BINARIES_UNINSTALLED;
+    installer_state.WriteInstallerResult(*install_status, 0, NULL);
+  }
+}
+
+installer::InstallStatus InstallProducts(
+    const InstallationState& original_state,
+    const CommandLine& cmd_line,
+    const MasterPreferences& prefs,
+    InstallerState* installer_state,
+    base::FilePath* installer_directory) {
+  DCHECK(installer_state);
+  const bool system_install = installer_state->system_install();
+  installer::InstallStatus install_status = installer::UNKNOWN_STATUS;
+  installer::ArchiveType archive_type = installer::UNKNOWN_ARCHIVE_TYPE;
+  bool delegated_to_existing = false;
+  installer_state->UpdateStage(installer::PRECONDITIONS);
+  // The stage provides more fine-grained information than -multifail, so remove
+  // the -multifail suffix from the Google Update "ap" value.
+  BrowserDistribution::GetSpecificDistribution(installer_state->state_type())->
+      UpdateInstallStatus(system_install, archive_type, install_status);
+  if (CheckPreInstallConditions(original_state, installer_state,
+                                &install_status)) {
+    VLOG(1) << "Installing to " << installer_state->target_path().value();
+    install_status = InstallProductsHelper(
+        original_state, cmd_line, prefs, *installer_state,
+        installer_directory, &archive_type, &delegated_to_existing);
+  } else {
+    // CheckPreInstallConditions must set the status on failure.
+    DCHECK_NE(install_status, installer::UNKNOWN_STATUS);
+  }
+
+  // Delete the master preferences file if present. Note that we do not care
+  // about rollback here and we schedule for deletion on reboot if the delete
+  // fails. As such, we do not use DeleteTreeWorkItem.
+  if (cmd_line.HasSwitch(installer::switches::kInstallerData)) {
+    base::FilePath prefs_path(cmd_line.GetSwitchValuePath(
+        installer::switches::kInstallerData));
+    if (!base::DeleteFile(prefs_path, false)) {
+      LOG(ERROR) << "Failed deleting master preferences file "
+                 << prefs_path.value()
+                 << ", scheduling for deletion after reboot.";
+      ScheduleFileSystemEntityForDeletion(prefs_path);
+    }
+  }
+
+  // Early exit if this setup.exe delegated to another, since that one would
+  // have taken care of UpdateInstallStatus and UpdateStage.
+  if (delegated_to_existing)
+    return install_status;
+
+  const Products& products = installer_state->products();
+  for (Products::const_iterator it = products.begin(); it < products.end();
+       ++it) {
+    (*it)->distribution()->UpdateInstallStatus(
+        system_install, archive_type, install_status);
+  }
+
+  UninstallBinariesIfUnused(original_state, *installer_state, &install_status);

[grt (UTC plus 2), 2013/11/29 04:23:03]

this line is the only change between the old InstallProducts and this one.

+
+  installer_state->UpdateStage(installer::NO_STAGE);
+  return install_status;
+}
+
 installer::InstallStatus ShowEULADialog(const string16& inner_frame) {
   VLOG(1) << "About to show EULA";
   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);
@@ skipping 479 matching lines @@
   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;
 }
 
+// Uninstalls multi-install Chrome Frame if the current operation is a
+// multi-install install or update. The operation is performed directly rather
+// than delegated to the existing install since there is no facility in older
+// versions of setup.exe to uninstall GCF without touching the binaries. The
+// binaries will be uninstalled during later processing if they are not in-use
+// (see UninstallBinariesIfUnused). |original_state| and |installer_state| are
+// updated to reflect the state of the world following the operation.
+void UninstallMultiChromeFrameIfPresent(const CommandLine& cmd_line,
+                                        const MasterPreferences& prefs,
+                                        InstallationState* original_state,
+                                        InstallerState* installer_state) {
+  // Early exit if not installing or updating multi-install product(s).
+  if (installer_state->operation() != InstallerState::MULTI_INSTALL &&
+      installer_state->operation() != InstallerState::MULTI_UPDATE) {
+    return;
+  }
+
+  // Early exit if Chrome Frame is not present as multi-install.
+  const ProductState* chrome_frame_state =
+      original_state->GetProductState(installer_state->system_install(),
+                                      BrowserDistribution::CHROME_FRAME);
+  if (!chrome_frame_state || !chrome_frame_state->is_multi_install())
+    return;
+
+  LOG(INFO) << "Uninstalling multi-install Chrome Frame.";
+  installer_state->UpdateStage(installer::UNINSTALLING_CHROME_FRAME);
+
+  // Uninstall Chrome Frame without touching the multi-install binaries.
+  // Simulate the uninstall as coming from the installed version.
+  const CommandLine& uninstall_cmd(chrome_frame_state->uninstall_command());
+  MasterPreferences uninstall_prefs(uninstall_cmd);
+  InstallerState uninstall_state;
+  uninstall_state.Initialize(uninstall_cmd, uninstall_prefs, *original_state);
+  const Product* chrome_frame = uninstall_state.FindProduct(
+      BrowserDistribution::CHROME_FRAME);
+  if (chrome_frame) {
+    // No shared state should be left behind.
+    const bool remove_all = true;
+    // Don't accept no for an answer.
+    const bool force_uninstall = true;
+    installer::InstallStatus uninstall_status =
+        installer::UninstallProduct(*original_state, uninstall_state,
+                                    uninstall_cmd.GetProgram(), *chrome_frame,
+                                    remove_all, force_uninstall, cmd_line);
+
+    VLOG(1) << "Uninstallation of Chrome Frame returned status "
+            << uninstall_status;
+  } else {
+    LOG(ERROR) << "Chrome Frame not found for uninstall.";
+  }
+
+  // Refresh state for the continuation of the original install/update.
+  original_state->Initialize();
+  installer_state->Initialize(cmd_line, prefs, *original_state);
+}
+
 }  // namespace
 
 namespace installer {
 
 InstallStatus InstallProductsHelper(
     const InstallationState& original_state,
     const CommandLine& cmd_line,
     const MasterPreferences& prefs,
     const InstallerState& installer_state,
     base::FilePath* installer_directory,
@@ skipping 388 matching lines @@
       InstallUtil::ExecuteExeAsAdmin(new_cmd, &exit_code);
       return exit_code;
     } else {
       LOG(ERROR) << "Non admin user can not install system level Chrome.";
       installer_state.WriteInstallerResult(installer::INSUFFICIENT_RIGHTS,
           IDS_INSTALL_INSUFFICIENT_RIGHTS_BASE, NULL);
       return installer::INSUFFICIENT_RIGHTS;
     }
   }
 
+  UninstallMultiChromeFrameIfPresent(cmd_line, prefs,
+                                     &original_state, &installer_state);
+
   base::FilePath installer_directory;
   installer::InstallStatus install_status = installer::UNKNOWN_STATUS;
-  // If --uninstall option is not specified, we assume it is install case.
-  if (!is_uninstall) {
+  // If --uninstall option is given, uninstall the identified product(s)
+  if (is_uninstall) {
+    install_status =
+        UninstallProducts(original_state, installer_state, cmd_line);
+  } else {
+    // If --uninstall option is not specified, we assume it is install case.
     install_status =
         InstallProducts(original_state, cmd_line, prefs, &installer_state,
                         &installer_directory);
   }
-  // If --uninstall option is given or only the binaries are present and they're
-  // not in-use, uninstall the identified product(s).
-  if (is_uninstall || (install_status == installer::UNUSED_BINARIES &&
-                       !installer_state.AreBinariesInUse(original_state))) {
-    install_status =
-        UninstallProducts(original_state, installer_state, cmd_line);
-    // Report that the binaries were uninstalled if they were. This translates
-    // into a successful install return code.
-    if (!is_uninstall && IsUninstallSuccess(install_status)) {
-      install_status = installer::UNUSED_BINARIES_UNINSTALLED;
-      installer_state.WriteInstallerResult(install_status, 0, NULL);
-    }
-  }
 
   // Validate that the machine is now in a good state following the operation.
   // TODO(grt): change this to log at DFATAL once we're convinced that the
   // validator handles all cases properly.
   InstallationValidator::InstallationType installation_type =
       InstallationValidator::NO_PRODUCTS;
   LOG_IF(ERROR,
          !InstallationValidator::ValidateInstallationType(system_install,
                                                           &installation_type));
 
@@ skipping 50 matching lines @@
     // Call the newly updated setup.exe with kUncompressedArchive and
     // kMigrateChromeFrame to perform the migration.
     LaunchChromeFrameMigrationProcess(*chrome_frame_state, cmd_line,
                                       installer_directory, system_install);
   }
 
   VLOG(1) << "Installation complete, returning: " << return_code;
 
   return return_code;
 }