Implement installation of the Chrome App Host.

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 "base/at_exit.h"
@@ skipping 338 matching lines @@
                                  InstallerState* installer_state,
                                  installer::InstallStatus* status) {
   const Products& products = installer_state->products();
   DCHECK(products.size());
 
   const bool system_level = installer_state->system_install();
 
   if (installer_state->is_multi_install()) {
     const Product* chrome =
         installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER);
+    const Product* binaries =
+        installer_state->FindProduct(BrowserDistribution::CHROME_BINARIES);
     const Product* chrome_frame =
         installer_state->FindProduct(BrowserDistribution::CHROME_FRAME);
     const ProductState* cf_state =
         original_state.GetProductState(system_level,
                                        BrowserDistribution::CHROME_FRAME);
     if (chrome != NULL) {
       if (chrome_frame != NULL &&
           chrome_frame->HasOption(installer::kOptionReadyMode)) {
         // We're being asked to install Chrome with Chrome Frame in ready-mode.
         // This is an optimistic operation: if a SxS install of Chrome Frame
         // is already present, don't touch it; if a multi-install of Chrome
         // Frame is present, preserve its settings (ready-mode).
         if (cf_state != NULL) {
           installer_state->RemoveProduct(chrome_frame);
           chrome_frame = NULL;
           if (cf_state->is_multi_install()) {
             chrome_frame = installer_state->AddProductFromState(
                 BrowserDistribution::CHROME_FRAME, *cf_state);
             VLOG(1) << "Upgrading existing multi-install Chrome Frame rather "
                        "than installing in ready-mode.";
           } else {
             VLOG(1) << "Skipping upgrade of single-install Chrome Frame rather "
                        "than installing in ready-mode.";
           }
         } else {
           VLOG(1) << "Performing initial install of Chrome Frame ready-mode.";
         }
       }
-    } else if (chrome_frame != NULL) {
-      // We're being asked to install or update Chrome Frame alone.
+    } else if (binaries != NULL) {
+      // We're being asked to install or update the binaries without Chrome.
       const ProductState* chrome_state =
           original_state.GetProductState(system_level,
                                          BrowserDistribution::CHROME_BROWSER);
       if (chrome_state != NULL) {
         // Add Chrome to the set of products (making it multi-install in the
         // process) so that it is updated, too.
         scoped_ptr<Product> multi_chrome(new Product(
             BrowserDistribution::GetSpecificDistribution(
                 BrowserDistribution::CHROME_BROWSER)));
         multi_chrome->SetOption(installer::kOptionMultiInstall, true);
         chrome = installer_state->AddProduct(&multi_chrome);
-        VLOG(1) << "Upgrading existing multi-install Chrome browser along with "
-                << chrome_frame->distribution()->GetAppShortCutName();
-      } else if (chrome_frame->HasOption(installer::kOptionReadyMode)) {
+        VLOG(1) << "Upgrading existing Chrome browser in multi-install mode.";
+      } else if (chrome_frame && chrome_frame->HasOption(installer::kOptionReadyMode)) {

[grt (UTC plus 2), 2012/07/12 18:37:10]

80 cols

[erikwright (departed), 2012/07/16 20:13:11]

Done.

         // Chrome Frame with ready-mode is to be installed, yet Chrome is
         // neither installed nor being installed.  Fail.
         LOG(ERROR) << "Cannot install Chrome Frame in ready mode without "
                       "Chrome.";
         *status = installer::READY_MODE_REQUIRES_CHROME;
         installer_state->WriteInstallerResult(*status,
             IDS_INSTALL_READY_MODE_REQUIRES_CHROME_BASE, NULL);
         return false;
       }
     }
@@ skipping 14 matching lines @@
   } else if (DCHECK_IS_ON()) {
     // It isn't possible to stuff two products into a single-install
     // InstallerState.  Abort the process here in debug builds just in case
     // someone finds a way.
     DCHECK_EQ(1U, products.size());
   }
 
   return true;
 }
 
+bool CheckAppHostPreconditions(const InstallationState& original_state,

[grt (UTC plus 2), 2012/07/12 18:37:10]

please document the failure modes and side effects of this function (e.g., that
the binaries are added to |installer_state| if neither single-install chrome nor
any multi-install product is present on the machine).

[erikwright (departed), 2012/07/16 20:13:11]

The logic you refer to moved to InstallerState.

+                               InstallerState* installer_state) {
+  if (!installer_state->FindProduct(BrowserDistribution::CHROME_APP_HOST))
+    return true;
+
+  if (installer_state->level() == InstallerState::SYSTEM_LEVEL)
+    return false;

[grt (UTC plus 2), 2012/07/12 18:37:10]

VLOG(1) the reason for failure

[erikwright (departed), 2012/07/16 20:13:11]

Done.

+

[grt (UTC plus 2), 2012/07/12 18:37:10]

if (instaler_state->package_type() != InstallerState::MULTI_PACKAGE) {
  VLOG(1) << ??;
  return false;
}

[erikwright (departed), 2012/07/16 20:13:11]

Done.

+  const ProductState* chrome_state = original_state.GetProductState(
+      true /* system level */, BrowserDistribution::CHROME_BROWSER);

[tommi (sloooow) - chröme, 2012/07/12 08:11:31]

nit: I think we avoid /**/ comments in general. instead you could do:
GetProductState(
    true,  // system_level
    BrowserDistribution::CHROME_BROWSER);

As a side note, maybe it would be good for readability to change all these 'bool
system_level' variables to an enum.
    

[grt (UTC plus 2), 2012/07/12 18:37:10]

InstallerState::Level could be moved up into the "installer" namespace and given
a less collision-prone name.

[erikwright (departed), 2012/07/16 20:13:11]

Done.

[erikwright (departed), 2012/07/16 20:13:11]

Not done for this CL.

+  if (chrome_state) {
+    // Chrome is at system-level, multi- or otherwise. We'll use it.
+    return true;
+  }
+
+  const ProductState* binaries_state = original_state.GetProductState(
+      false /* system level */, BrowserDistribution::CHROME_BINARIES);

[grt (UTC plus 2), 2012/07/12 18:37:10]

should the comment be "!system level"?  i find it confusing for the comment to
be the same for calls with opposing values.

[erikwright (departed), 2012/07/16 20:13:11]

This particular instance is gone.

+  if (!binaries_state) {
+    binaries_state = original_state.GetProductState(
+        true /* system level */, BrowserDistribution::CHROME_BINARIES);
+  }
+
+  if (binaries_state) {
+    // Binaries are installed somewhere. We'll use 'em.
+    return true;
+  }
+
+  if (!binaries_state && ! installer_state->is_multi_install()) {

[grt (UTC plus 2), 2012/07/12 18:37:10]

remove this block as discussed

[erikwright (departed), 2012/07/16 20:13:11]

Done.

+    // Can't install binaries because this isn't a multi install.
+    return false;
+  }
+
+  if (!installer_state->FindProduct(BrowserDistribution::CHROME_BINARIES)) {
+    // Force binaries to be installed.
+    scoped_ptr<Product> binaries_product(new Product(
+        BrowserDistribution::GetSpecificDistribution(
+            BrowserDistribution::CHROME_BINARIES)));
+    binaries_product->SetOption(installer::kOptionMultiInstall, true);
+    if (!installer_state->AddProduct(&binaries_product)) {
+      // Can't install binaries for some reason.
+      return false;
+    }
+  }
+
+  return true;
+}
+
 // Checks for compatibility between the current state of the system and the
 // desired operation.  Also applies policy that mutates the desired operation;
 // 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) {
+  if (!CheckAppHostPreconditions(original_state, installer_state))
+    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);
 
   const Products& products = installer_state->products();
   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;
@@ skipping 158 matching lines @@
         if (product_state != NULL &&
             (product_state->version().CompareTo(*installer_version) > 0)) {
           LOG(ERROR) << "Higher version of "
                      << product->distribution()->GetAppShortCutName()
                      << " is already installed.";
           higher_products |= (1 << product->distribution()->GetType());
         }
       }
 
       if (higher_products != 0) {
-        COMPILE_ASSERT(BrowserDistribution::NUM_TYPES == 3,
+        COMPILE_ASSERT(BrowserDistribution::NUM_TYPES == 4,
                        add_support_for_new_products_here_);
         const uint32 kBrowserBit = 1 << BrowserDistribution::CHROME_BROWSER;
         const uint32 kGCFBit = 1 << BrowserDistribution::CHROME_FRAME;
+        const uint32 kAppHostBit = 1 << BrowserDistribution::CHROME_APP_HOST;
         int message_id = 0;
 
         proceed_with_installation = false;
         install_status = installer::HIGHER_VERSION_EXISTS;
-        if ((higher_products & kBrowserBit) != 0) {
-          if ((higher_products & kGCFBit) != 0)
+        switch (higher_products) {
+          case kBrowserBit:
+            message_id = IDS_INSTALL_HIGHER_VERSION_BASE;
+            break;
+          case kGCFBit:
+            message_id = IDS_INSTALL_HIGHER_VERSION_CF_BASE;
+            break;
+          case kGCFBit & kBrowserBit:

[grt (UTC plus 2), 2012/07/12 18:37:10]

i think you mean "kGCFBit | kBrowserBit" here.

[erikwright (departed), 2012/07/16 20:13:11]

Done.

             message_id = IDS_INSTALL_HIGHER_VERSION_CB_CF_BASE;
-          else
-            message_id = IDS_INSTALL_HIGHER_VERSION_BASE;
-        } else {
-          DCHECK(higher_products == kGCFBit);
-          message_id = IDS_INSTALL_HIGHER_VERSION_CF_BASE;
+            break;
+          default:
+            message_id = IDS_INSTALL_HIGHER_VERSION_APP_HOST_BASE;
+            break;
         }
 
         installer_state.WriteInstallerResult(install_status, message_id, NULL);
       }
 
       proceed_with_installation =
           proceed_with_installation &&
           CheckGroupPolicySettings(original_state, installer_state,
                                    *installer_version, &install_status);
 
@@ skipping 223 matching lines @@
 
 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());
+  // TODO(erikwright): if product 0 is not chrome, assert chrome not in products

[tommi (sloooow) - chröme, 2012/07/12 08:11:31]

do you intend to do that before checkin?

[erikwright (departed), 2012/07/16 20:13:11]

Done.

   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);
 
   for (size_t i = 0;
        install_status != installer::UNINSTALL_CANCELLED &&
            i < products.size();
        ++i) {
@@ skipping 491 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;
 }