Fix in-use updates for Chrome Frame.

chrome/installer/setup/setup_main.cc

 // Copyright (c) 2011 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 12 matching lines @@
 #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"
 #include "chrome/installer/setup/chrome_frame_quick_enable.h"
 #include "chrome/installer/setup/chrome_frame_ready_mode.h"
 #include "chrome/installer/setup/install.h"
+#include "chrome/installer/setup/install_worker.h"
 #include "chrome/installer/setup/setup_constants.h"
 #include "chrome/installer/setup/setup_util.h"
 #include "chrome/installer/setup/uninstall.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/channel_info.h"
 #include "chrome/installer/util/delete_after_reboot_helper.h"
 #include "chrome/installer/util/delete_tree_work_item.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/helper.h"
@@ skipping 119 matching lines @@
       }
     }
   }
 }
 
 // This function is called when --rename-chrome-exe option is specified on
 // setup.exe command line. This function assumes an in-use update has happened
 // for Chrome so there should be a file called new_chrome.exe on the file
 // system and a key called 'opv' in the registry. This function will move
 // new_chrome.exe to chrome.exe and delete 'opv' key in one atomic operation.
+// This function also deletes elevation policies associated with the old version
+// if they exist.
 installer::InstallStatus RenameChromeExecutables(
     const InstallationState& original_state,
     InstallerState* installer_state) {
   // See what products are already installed in multi mode.  When we do the
   // rename for multi installs, we must update all installations since they
   // share the binaries.
   AddExistingMultiInstalls(original_state, installer_state);
   const FilePath &target_path = installer_state->target_path();
   FilePath chrome_exe(target_path.Append(installer::kChromeExe));
   FilePath chrome_new_exe(target_path.Append(installer::kChromeNewExe));
@@ skipping 13 matching lines @@
   // Move chrome.exe to old_chrome.exe, then move new_chrome.exe to chrome.exe.
   install_list->AddMoveTreeWorkItem(chrome_exe.value(),
                                     chrome_old_exe.value(),
                                     temp_path.path().value(),
                                     WorkItem::ALWAYS_MOVE);
   install_list->AddMoveTreeWorkItem(chrome_new_exe.value(),
                                     chrome_exe.value(),
                                     temp_path.path().value(),
                                     WorkItem::ALWAYS_MOVE);
   install_list->AddDeleteTreeWorkItem(chrome_new_exe, temp_path.path());
+  // Delete an elevation policy associated with the old version, should one
+  // exist.
+  if (installer_state->FindProduct(BrowserDistribution::CHROME_FRAME)) {
+    installer::AddDeleteOldIELowRightsPolicyWorkItems(*installer_state,
+                                                      install_list.get());
+  }
   // old_chrome.exe is still in use in most cases, so ignore failures here.
   install_list->AddDeleteTreeWorkItem(chrome_old_exe, temp_path.path())
       ->set_ignore_failure(true);
 
   // Collect the set of distributions we need to update, which is the
   // multi-install binaries (if this is a multi-install operation) and all
   // products we're operating on.
   BrowserDistribution* dists[BrowserDistribution::NUM_TYPES];
   int num_dists = 0;
   // First, add the multi-install binaries, if relevant.
@@ skipping 368 matching lines @@
     VLOG(1) << "unpacked to " << unpack_path.value();
     FilePath src_path(unpack_path.Append(installer::kInstallSourceChromeDir));
     scoped_ptr<Version>
         installer_version(installer::GetMaxVersionFromArchiveDir(src_path));
     if (!installer_version.get()) {
       LOG(ERROR) << "Did not find any valid version in installer.";
       install_status = installer::INVALID_ARCHIVE;
       installer_state.WriteInstallerResult(install_status,
           IDS_INSTALL_INVALID_ARCHIVE_BASE, NULL);
     } else {
-      // TODO(tommi): Move towards having only a single version that is common
-      // to all products.  Only the package should have a version since it
-      // represents all the binaries.  When a single product is upgraded, all
-      // currently installed product for the shared binary installation, should
-      // (or rather must) be upgraded.
       VLOG(1) << "version to install: " << installer_version->GetString();
       bool proceed_with_installation = true;
       uint32 higher_products = 0;
       COMPILE_ASSERT(
           sizeof(higher_products) * 8 > BrowserDistribution::NUM_TYPES,
           too_many_distribution_types_);
       for (size_t i = 0; i < installer_state.products().size(); ++i) {
         const Product* product = installer_state.products()[i];
         const ProductState* product_state =
             original_state.GetProductState(system_install,
@@ skipping 191 matching lines @@
   }
 
   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) {
-  bool force = cmd_line.HasSwitch(installer::switches::kForceUninstall);
   const ProductState* product_state =
       original_state.GetProductState(installer_state.system_install(),
                                      product.distribution()->GetType());
   if (product_state != NULL) {
     VLOG(1) << "version on the system: "
             << product_state->version().GetString();
-  } else if (!force) {
-    LOG(ERROR) << "No Chrome installation found for uninstall.";
+  } else if (!force_uninstall) {
+    LOG(ERROR) << product.distribution()->GetAppShortCutName()
+               << " not found for uninstall.";
     return installer::CHROME_NOT_INSTALLED;
   }
 
-  bool remove_all = !cmd_line.HasSwitch(
+  return installer::UninstallProduct(original_state, installer_state,
+      cmd_line.GetProgram(), product, remove_all, force_uninstall, cmd_line);
+}
+
+installer::InstallStatus UninstallProducts(
+    const InstallationState& original_state,
+    const InstallerState& installer_state,
+    const CommandLine& cmd_line) {
+  const Products& products = installer_state.products();
+  // InstallerState::Initialize always puts Chrome first, and we rely on that
+  // here for this reason: if Chrome is in-use, the user will be prompted to
+  // confirm uninstallation.  Upon cancel, we should not continue with the
+  // other products.
+  DCHECK(products.size() < 2 || products[0]->is_chrome());
+  installer::InstallStatus install_status = installer::UNINSTALL_SUCCESSFUL;
+  installer::InstallStatus prod_status = installer::UNKNOWN_STATUS;
+  const bool force = cmd_line.HasSwitch(installer::switches::kForceUninstall);
+  const bool remove_all = !cmd_line.HasSwitch(
       installer::switches::kDoNotRemoveSharedItems);
 
-  return installer::UninstallProduct(original_state, installer_state,
-      cmd_line.GetProgram(), product, remove_all, force, cmd_line);
+  for (size_t i = 0;
+       install_status != installer::UNINSTALL_CANCELLED &&
+           i < products.size();
+       ++i) {
+    prod_status = UninstallProduct(original_state, installer_state,
+        cmd_line, remove_all, force, *products[i]);
+    if (prod_status != installer::UNINSTALL_SUCCESSFUL)
+      install_status = prod_status;
+  }
+
+  return install_status;
 }
 
 installer::InstallStatus ShowEULADialog(const std::wstring& inner_frame) {
   VLOG(1) << "About to show EULA";
   std::wstring 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
@@ skipping 416 matching lines @@
       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;
     }
   }
 
   installer::InstallStatus install_status = installer::UNKNOWN_STATUS;
   // If --uninstall option is given, uninstall the identified product(s)
   if (is_uninstall) {
-    const Products& products = installer_state.products();
-    // InstallerState::Initialize always puts Chrome first, and we rely on that
-    // here for this reason: if Chrome is in-use, the user will be prompted to
-    // confirm uninstallation.  Upon cancel, we should not continue with the
-    // other products.
-    DCHECK(products.size() < 2 || products[0]->is_chrome());
-    install_status = installer::UNINSTALL_SUCCESSFUL;  // I'm an optimist.
-    installer::InstallStatus prod_status = installer::UNKNOWN_STATUS;
-    for (size_t i = 0;
-         install_status != installer::UNINSTALL_CANCELLED &&
-             i < products.size();
-         ++i) {
-      prod_status = UninstallProduct(original_state, installer_state,
-          cmd_line, *products[i]);
-      if (prod_status != installer::UNINSTALL_SUCCESSFUL)
-        install_status = prod_status;
-    }
+    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);
   }
 
   // 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 =
@@ skipping 29 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;
 }