Upgrade all multi-install products present on the system when the installer is run with only the ...

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 130 matching lines @@
       output_directory.value(), &unpacked_file);
 }
 
 // In multi-install, adds all products to |installer_state| that are
 // multi-installed and must be updated along with the products already present
 // in |installer_state|.
 void AddExistingMultiInstalls(const InstallationState& original_state,
                               InstallerState* installer_state) {
   if (installer_state->is_multi_install()) {
     // TODO(grt): Find all occurrences of such arrays and generalize/centralize.
-    BrowserDistribution::Type product_checks[] = {
+    static const BrowserDistribution::Type product_checks[] = {
       BrowserDistribution::CHROME_BROWSER,
       BrowserDistribution::CHROME_FRAME
     };
 
     for (size_t i = 0; i < arraysize(product_checks); ++i) {
       BrowserDistribution::Type type = product_checks[i];
       if (!installer_state->FindProduct(type)) {
         const ProductState* state =
             original_state.GetProductState(installer_state->system_install(),
                                            type);
@@ skipping 197 matching lines @@
 // specifically, the |installer_state| object.
 // Also blocks simultaneous user-level and system-level installs.  In the case
 // of trying to install user-level Chrome when system-level exists, the
 // existing system-level Chrome is launched.
 // When the pre-install conditions are not satisfied, the result is written to
 // the registry (via WriteInstallerResult), |status| is set appropriately, and
 // false is returned.
 bool CheckPreInstallConditions(const InstallationState& original_state,
                                InstallerState* installer_state,
                                installer::InstallStatus* status) {
+  // See what products are already installed in multi mode.  When we do multi
+  // installs, we must upgrade all installations since they share the binaries.
+  AddExistingMultiInstalls(original_state, installer_state);

[robertshield, 2011/05/31 15:30:19]

Nice fix :)

+
   const Products& products = installer_state->products();
-  DCHECK(products.size());
+  if (products.empty()) {
+    // We haven't been given any products on which to operate.
+    LOG(ERROR)
+        << "Not given any products to install and no products found to update.";
+    *status = installer::CHROME_NOT_INSTALLED;
+    installer_state->WriteInstallerResult(*status,
+        IDS_INSTALL_NO_PRODUCTS_TO_UPDATE_BASE, NULL);
+    return false;
+  }
 
   if (!CheckMultiInstallConditions(original_state, installer_state, status))
     return false;
 
   bool is_first_install = true;
   const bool system_level = installer_state->system_install();
 
   for (size_t i = 0; i < products.size(); ++i) {
     const Product* product = products[i];
     BrowserDistribution* browser_dist = product->distribution();
@@ skipping 48 matching lines @@
 
       // This is an update, not an install. Omaha should know the difference
       // and not show a dialog.
       *status = installer::SYSTEM_LEVEL_INSTALL_EXISTS;
       installer_state->WriteInstallerResult(*status,
           IDS_INSTALL_SYSTEM_LEVEL_EXISTS_BASE, NULL);
       return false;
     }
   }
 
-  // See what products are already installed in multi mode.  When we do multi
-  // installs, we must upgrade all installations since they share the binaries.
-  AddExistingMultiInstalls(original_state, installer_state);
-
   // If no previous installation of Chrome, make sure installation directory
   // either does not exist or can be deleted (i.e. is not locked by some other
   // process).
   if (is_first_install) {
     if (file_util::PathExists(installer_state->target_path()) &&
         !file_util::Delete(installer_state->target_path(), true)) {
       LOG(ERROR) << "Installation directory "
                  << installer_state->target_path().value()
                  << " exists and can not be deleted.";
       *status = installer::INSTALL_DIR_IN_USE;
@@ skipping 218 matching lines @@
   installer::InstallStatus install_status = installer::UNKNOWN_STATUS;
   installer::ArchiveType archive_type = installer::UNKNOWN_ARCHIVE_TYPE;
   bool incremental_install = 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, &archive_type);
   }
 
   const Products& products = installer_state->products();
 
   for (size_t i = 0; i < products.size(); ++i) {
     const Product* product = products[i];
     product->distribution()->UpdateInstallStatus(
         system_install, archive_type, install_status);
@@ skipping 471 matching lines @@
          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;
     }
   } else {
     // If --uninstall option is not specified, we assume it is install case.
-    VLOG(1) << "Installing to " << installer_state.target_path().value();
     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 =
       InstallationValidator::NO_PRODUCTS;
   LOG_IF(ERROR,
@@ skipping 27 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;
 }