[Installer] Cleaning up dead code for App Launcher / App Host 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 "chrome/installer/setup/setup_main.h"
 
 #include <windows.h>
 #include <msi.h>
 #include <shellapi.h>
 #include <shlobj.h>
@@ skipping 29 matching lines @@
 #include "chrome/installer/setup/archive_patch_helper.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/eula_util.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/google_update_util.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/html_dialog.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/installation_validator.h"
 #include "chrome/installer/util/installer_state.h"
 #include "chrome/installer/util/l10n_string_util.h"
@@ skipping 313 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* app_host =
-        installer_state->FindProduct(BrowserDistribution::CHROME_APP_HOST);
     const Product* binaries =
         installer_state->FindProduct(BrowserDistribution::CHROME_BINARIES);
     const ProductState* chrome_state =
         original_state.GetProductState(system_level,
                                        BrowserDistribution::CHROME_BROWSER);
 
     if (binaries) {
       if (products.size() == 1) {
         // There are no products aside from the binaries, so there is no update
         // to be applied. This can happen after multi-install Chrome Frame is
         // migrated to single-install. This is treated as an update failure
         // unless the binaries are not in-use, in which case they will be
         // uninstalled and success will be reported (see handling in wWinMain).
         VLOG(1) << "No products to be updated.";
         *status = installer::UNUSED_BINARIES;
         installer_state->WriteInstallerResult(*status, 0, NULL);
         return false;
       }
     } else {
-      // This will only be hit if --multi-install is given with no products, or
-      // if the app host is being installed and doesn't need the binaries at
-      // user-level.
-      // The former case might be due to a request by an orphaned Application
-      // Host to re-install the binaries. Thus we add them to the installation.
-      // The latter case is fine and we let it be.
-      // If this is not an app host install and the binaries are not already
-      // present, the installation will fail later due to a lack of products to
-      // install.
-      if (app_host && !chrome && !chrome_state) {
-        DCHECK(!system_level);
-        // App Host may use Chrome/Chrome binaries at system-level.
-        if (original_state.GetProductState(
-                true,  // system
-                BrowserDistribution::CHROME_BROWSER) ||
-            original_state.GetProductState(
-                true,  // system
-                BrowserDistribution::CHROME_BINARIES)) {
-          VLOG(1) << "Installing/updating App Launcher without binaries.";
-        } else {
-          // Somehow the binaries were present when the quick-enable app host
-          // command was run, but now they appear to be missing.
-          // Force binaries to be installed/updated.
-          scoped_ptr<Product> binaries_to_add(new Product(
-              BrowserDistribution::GetSpecificDistribution(
-                  BrowserDistribution::CHROME_BINARIES)));
-          binaries_to_add->SetOption(installer::kOptionMultiInstall, true);
-          binaries = installer_state->AddProduct(&binaries_to_add);
-          VLOG(1) <<
-              "Adding binaries for pre-existing App Launcher installation.";
-        }
-      }
-
+      // This will only be hit if --multi-install is given with no products.
       return true;
     }
 
     if (!chrome && chrome_state) {
       // A product other than Chrome is being installed in multi-install mode,
       // and Chrome is already present. 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)));
@@ skipping 17 matching lines @@
         installer_state->WriteInstallerResult(*status,
             IDS_INSTALL_MULTI_INSTALLATION_EXISTS_BASE, NULL);
         return false;
       }
     }
   }
 
   return true;
 }
 
-// Checks app host pre-install conditions, specifically that this is a
-// user-level multi-install.  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 CheckAppHostPreconditions(const InstallationState& original_state,
-                               InstallerState* installer_state,
-                               installer::InstallStatus* status) {
-  if (installer_state->FindProduct(BrowserDistribution::CHROME_APP_HOST)) {
-    if (!installer_state->is_multi_install()) {
-      LOG(DFATAL) << "App Launcher requires multi install";
-      *status = installer::APP_HOST_REQUIRES_MULTI_INSTALL;
-      // No message string since there is nothing a user can do.
-      installer_state->WriteInstallerResult(*status, 0, NULL);
-      return false;
-    }
-
-    if (installer_state->system_install()) {
-      LOG(DFATAL) << "App Launcher may only be installed at user-level.";
-      *status = installer::APP_HOST_REQUIRES_USER_LEVEL;
-      // No message string since there is nothing a user can do.
-      installer_state->WriteInstallerResult(*status, 0, NULL);
-      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, status)) {
-    DCHECK_NE(*status, installer::UNKNOWN_STATUS);
-    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 (!CheckMultiInstallConditions(original_state, installer_state, status)) {
     DCHECK_NE(*status, installer::UNKNOWN_STATUS);
     return false;
   }
 
   const Products& products = installer_state->products();
@@ skipping 60 matching lines @@
             base::LaunchProcess(cmd, base::LaunchOptions());
           }
         } else {
           // It's no longer possible for |product| to be anything other than
           // Chrome.
           NOTREACHED();
         }
         return false;
       }
     }
-
-  } else {  // System-level install.
-    // --ensure-google-update-present is supported for user-level only.
-    // The flag is generic, but its primary use case involves App Host.
-    if (installer_state->ensure_google_update_present()) {
-      LOG(DFATAL) << "--" << installer::switches::kEnsureGoogleUpdatePresent
-                  << " is supported for user-level only.";
-      *status = installer::APP_HOST_REQUIRES_USER_LEVEL;
-      // No message string since there is nothing a user can do.
-      installer_state->WriteInstallerResult(*status, 0, NULL);
-      return false;
-    }
   }
 
   return true;
 }
 
 // Initializes |temp_path| to "Temp" within the target directory, and
 // |unpack_path| to a random directory beginning with "source" within
 // |temp_path|. Returns false on error.
 bool CreateTemporaryAndUnpackDirectories(
     const InstallerState& installer_state,
@@ skipping 512 matching lines @@
         installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER);
     installer::InstallStatus status = installer::INVALID_STATE_FOR_OPTION;
     if (chrome_install) {
       installer::HandleOsUpgradeForBrowser(*installer_state,
                                            *chrome_install);
       status = installer::INSTALL_REPAIRED;
     } else {
       LOG(DFATAL) << "Chrome product not found.";
     }
     *exit_code = InstallUtil::GetInstallReturnCode(status);
-  } else if (cmd_line.HasSwitch(installer::switches::kQueryEULAAcceptance)) {
-    *exit_code = installer::IsEULAAccepted(installer_state->system_install());
   } else if (cmd_line.HasSwitch(installer::switches::kInactiveUserToast)) {
     // Launch the inactive user toast experiment.
     int flavor = -1;
     base::StringToInt(cmd_line.GetSwitchValueNative(
         installer::switches::kInactiveUserToast), &flavor);
     std::string experiment_group =
         cmd_line.GetSwitchValueASCII(installer::switches::kExperimentGroup);
     DCHECK_NE(-1, flavor);
     if (flavor == -1) {
       *exit_code = installer::UNKNOWN_STATUS;
@@ skipping 357 matching lines @@
       if (product_state != NULL &&
           (product_state->version().CompareTo(*installer_version) > 0)) {
         LOG(ERROR) << "Higher version of "
                    << product.distribution()->GetDisplayName()
                    << " is already installed.";
         higher_products |= (1 << product.distribution()->GetType());
       }
     }
 
     if (higher_products != 0) {
-      COMPILE_ASSERT(BrowserDistribution::NUM_TYPES == 4,
+      COMPILE_ASSERT(BrowserDistribution::NUM_TYPES == 3,
                      add_support_for_new_products_here_);
-      const uint32 kBrowserBit = 1 << BrowserDistribution::CHROME_BROWSER;
-      int message_id = 0;
-
+      int message_id = IDS_INSTALL_HIGHER_VERSION_BASE;
       proceed_with_installation = false;
       install_status = HIGHER_VERSION_EXISTS;
-      switch (higher_products) {
-        case kBrowserBit:
-          message_id = IDS_INSTALL_HIGHER_VERSION_BASE;
-          break;
-        default:
-          message_id = IDS_INSTALL_HIGHER_VERSION_APP_LAUNCHER_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);
 
     if (proceed_with_installation) {
-      // If Google Update is absent at user-level, install it using the
-      // Google Update installer from an existing system-level installation.
-      // This is for quick-enable App Host install from a system-level
-      // Chrome Binaries installation.
-      if (!system_install && installer_state.ensure_google_update_present()) {
-        if (!google_update::EnsureUserLevelGoogleUpdatePresent()) {
-          LOG(ERROR) << "Failed to install Google Update";
-          proceed_with_installation = false;
-          install_status = INSTALL_OF_GOOGLE_UPDATE_FAILED;
-          installer_state.WriteInstallerResult(install_status, 0, NULL);
-        }
-      }
-
-    }
-
-    if (proceed_with_installation) {
       base::FilePath prefs_source_path(cmd_line.GetSwitchValueNative(
           switches::kInstallerData));
       install_status = InstallOrUpdateProduct(
           original_state, installer_state, setup_exe, uncompressed_archive,
           temp_path.path(), src_path, prefs_source_path, prefs,
           *installer_version);
 
       int install_msg_base = IDS_INSTALL_FAILED_BASE;
       base::FilePath chrome_exe;
       base::string16 quoted_chrome_exe;
@@ skipping 245 matching lines @@
     // 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;
 }