[Installer] Cleaning up dead code for App Launcher / App Host installs.

chrome/installer/util/installer_state.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/util/installer_state.h"
 
 #include <algorithm>
 #include <functional>
 #include <utility>
 
@@ skipping 52 matching lines @@
 }
 
 InstallerState::InstallerState()
     : operation_(UNINITIALIZED),
       state_type_(BrowserDistribution::CHROME_BROWSER),
       multi_package_distribution_(NULL),
       level_(UNKNOWN_LEVEL),
       package_type_(UNKNOWN_PACKAGE_TYPE),
       root_key_(NULL),
       msi_(false),
-      verbose_logging_(false),
-      ensure_google_update_present_(false) {
+      verbose_logging_(false) {
 }
 
 InstallerState::InstallerState(Level level)
     : operation_(UNINITIALIZED),
       state_type_(BrowserDistribution::CHROME_BROWSER),
       multi_package_distribution_(NULL),
       level_(UNKNOWN_LEVEL),
       package_type_(UNKNOWN_PACKAGE_TYPE),
       root_key_(NULL),
       msi_(false),
-      verbose_logging_(false),
-      ensure_google_update_present_(false) {
+      verbose_logging_(false) {
   // Use set_level() so that root_key_ is updated properly.
   set_level(level);
 }
 
 void InstallerState::Initialize(const base::CommandLine& command_line,
                                 const MasterPreferences& prefs,
                                 const InstallationState& machine_state) {
   Clear();
 
   bool pref_bool;
   if (!prefs.GetBool(master_preferences::kSystemLevel, &pref_bool))
     pref_bool = false;
   set_level(pref_bool ? SYSTEM_LEVEL : USER_LEVEL);
 
   if (!prefs.GetBool(master_preferences::kVerboseLogging, &verbose_logging_))
     verbose_logging_ = false;
 
   if (!prefs.GetBool(master_preferences::kMultiInstall, &pref_bool))
     pref_bool = false;
   set_package_type(pref_bool ? MULTI_PACKAGE : SINGLE_PACKAGE);
 
   if (!prefs.GetBool(master_preferences::kMsi, &msi_))
     msi_ = false;
 
-  ensure_google_update_present_ =
-      command_line.HasSwitch(installer::switches::kEnsureGoogleUpdatePresent);
-
   const bool is_uninstall = command_line.HasSwitch(switches::kUninstall);
 
   if (prefs.install_chrome()) {
     Product* p = AddProductFromPreferences(
         BrowserDistribution::CHROME_BROWSER, prefs, machine_state);
     VLOG(1) << (is_uninstall ? "Uninstall" : "Install")
             << " distribution: " << p->distribution()->GetDisplayName();
   }
 
-  if (prefs.install_chrome_app_launcher()) {
+  // Binaries are only used by Chrome.
+  if (is_multi_install() &&
+      FindProduct(BrowserDistribution::CHROME_BROWSER)) {
     Product* p = AddProductFromPreferences(
-        BrowserDistribution::CHROME_APP_HOST, prefs, machine_state);
+        BrowserDistribution::CHROME_BINARIES, prefs, machine_state);
     VLOG(1) << (is_uninstall ? "Uninstall" : "Install")
             << " distribution: " << p->distribution()->GetDisplayName();
   }
 
-  if (!is_uninstall && is_multi_install()) {
-    bool need_binaries = false;
-    if (FindProduct(BrowserDistribution::CHROME_APP_HOST)) {
-      // App Host will happily use Chrome at system level, or binaries at system
-      // level, even if app host is user level.
-      const ProductState* chrome_state = machine_state.GetProductState(
-          true,  // system level
-          BrowserDistribution::CHROME_BROWSER);
-      // If Chrome is at system-level, multi- or otherwise. We'll use it.
-      if (!chrome_state) {
-        const ProductState* binaries_state = machine_state.GetProductState(
-            true,  // system level
-            BrowserDistribution::CHROME_BINARIES);
-        if (!binaries_state)
-          need_binaries = true;
-      }
-    }
-
-    // Chrome multi needs Binaries at its own level.
-    if (FindProduct(BrowserDistribution::CHROME_BROWSER))
-      need_binaries = true;
-
-    if (need_binaries && !FindProduct(BrowserDistribution::CHROME_BINARIES)) {
-      // Force binaries to be installed/updated.
-      Product* p = AddProductFromPreferences(
-          BrowserDistribution::CHROME_BINARIES, prefs, machine_state);
-      VLOG(1) << "Install distribution: "
-              << p->distribution()->GetDisplayName();
-    }
-  }
-
-  if (is_uninstall && prefs.is_multi_install()) {
-    if (FindProduct(BrowserDistribution::CHROME_BROWSER)) {
-      // Uninstall each product of type |type| listed below based on the
-      // presence or absence of |switch_name| in that product's uninstall
-      // command.
-      const struct {
-        BrowserDistribution::Type type;
-        const char* switch_name;
-        bool switch_expected;
-      } conditional_additions[] = {
-        // If the App Host is installed, but not the App Launcher, remove it
-        // with Chrome. Note however that for system-level Chrome uninstalls,
-        // any installed user-level App Host will remain even if there is no
-        // App Launcher present (the orphaned app_host.exe will prompt the user
-        // for further action when executed).
-        { BrowserDistribution::CHROME_APP_HOST,
-          switches::kChromeAppLauncher,
-          false },
-      };
-
-      for (size_t i = 0; i < arraysize(conditional_additions); ++i) {
-        const ProductState* product_state = machine_state.GetProductState(
-            system_install(), conditional_additions[i].type);
-        if (product_state != NULL &&
-            product_state->uninstall_command().HasSwitch(
-                conditional_additions[i].switch_name) ==
-                    conditional_additions[i].switch_expected &&
-            !FindProduct(conditional_additions[i].type)) {
-          Product* p = AddProductFromPreferences(
-              conditional_additions[i].type, prefs, machine_state);
-          VLOG(1) << "Uninstall distribution: "
-                  << p->distribution()->GetDisplayName();
-        }
-      }
-    }
-
-    bool keep_binaries = false;
-    // Look for a multi-install product that is not the binaries and that is not
-    // being uninstalled. If not found, binaries are uninstalled too.
-    for (size_t i = 0; i < BrowserDistribution::NUM_TYPES; ++i) {
-      BrowserDistribution::Type type =
-          static_cast<BrowserDistribution::Type>(i);
-
-      if (type == BrowserDistribution::CHROME_BINARIES)
-        continue;
-
-      const ProductState* product_state =
-          machine_state.GetProductState(system_install(), type);
-      if (product_state == NULL) {
-        // The product is not installed.
-        continue;
-      }
-
-      if (!product_state->is_multi_install() &&
-          type != BrowserDistribution::CHROME_BROWSER) {
-        // The product is not sharing the binaries. It is ordinarily impossible
-        // for single-install Chrome to be installed along with any
-        // multi-install product. Treat single-install Chrome the same as any
-        // multi-install product just in case the impossible happens.
-        continue;
-      }
-
-      // The product is installed.
-
-      if (!FindProduct(type)) {
-        // The product is not being uninstalled.
-        if (type != BrowserDistribution::CHROME_APP_HOST) {
-          keep_binaries = true;
-          break;
-        } else {
-          // If binaries/chrome are at system-level, we can discard them at
-          // user-level...
-          if (!machine_state.GetProductState(
-                  true,  // system-level
-                  BrowserDistribution::CHROME_BROWSER) &&
-              !machine_state.GetProductState(
-                  true,  // system-level
-                  BrowserDistribution::CHROME_BINARIES)) {
-            // ... otherwise keep them.
-            keep_binaries = true;
-            break;
-          }
-        }
-      }
-
-      // The product is being uninstalled.
-    }
-    if (!keep_binaries &&
-        machine_state.GetProductState(system_install(),
-                                      BrowserDistribution::CHROME_BINARIES)) {
-      Product* p = AddProductFromPreferences(
-          BrowserDistribution::CHROME_BINARIES, prefs, machine_state);
-      VLOG(1) << (is_uninstall ? "Uninstall" : "Install")
-              << " distribution: " << p->distribution()->GetDisplayName();
-    }
-  }
-
   BrowserDistribution* operand = NULL;
 
   if (is_uninstall) {
     operation_ = UNINSTALL;
   } else if (!prefs.is_multi_install()) {
     // For a single-install, the current browser dist is the operand.
     operand = BrowserDistribution::GetDistribution();
     operation_ = SINGLE_INSTALL_OR_UPDATE;
   } else if (IsMultiInstallUpdate(prefs, machine_state)) {
     // Updates driven by Google Update take place under the multi-installer's
     // app guid.
     operand = multi_package_distribution_;
     operation_ = MULTI_UPDATE;
   } else {
     operation_ = MULTI_INSTALL;
   }
 
-  // Initial, over, and un-installs will take place under one of the product app

[grt (UTC plus 2), 2015/01/28 20:34:07]

please retain this comment (just update the parenthetical remark at the end).

[huangs, 2015/01/28 21:06:58]

Done.

-  // guids (Chrome, App Host, or Binaries, in order of preference).
   if (operand == NULL) {
-    BrowserDistribution::Type operand_distribution_type =
-        BrowserDistribution::CHROME_BINARIES;
-    if (prefs.install_chrome())
-      operand_distribution_type = BrowserDistribution::CHROME_BROWSER;
-    else if (prefs.install_chrome_app_launcher())
-      operand_distribution_type = BrowserDistribution::CHROME_APP_HOST;
-
     operand = BrowserDistribution::GetSpecificDistribution(
-        operand_distribution_type);
+        prefs.install_chrome() ?
+            BrowserDistribution::CHROME_BROWSER :
+            BrowserDistribution::CHROME_BINARIES);
   }
 
   state_key_ = operand->GetStateKey();
   state_type_ = operand->GetType();
 
   // Parse --critical-update-version=W.X.Y.Z
   std::string critical_version_value(
       command_line.GetSwitchValueASCII(switches::kCriticalUpdateVersion));
   critical_update_version_ = Version(critical_version_value);
 }
@@ skipping 302 matching lines @@
   state_key_.clear();
   state_type_ = BrowserDistribution::CHROME_BROWSER;
   products_.clear();
   multi_package_distribution_ = NULL;
   critical_update_version_ = base::Version();
   level_ = UNKNOWN_LEVEL;
   package_type_ = UNKNOWN_PACKAGE_TYPE;
   root_key_ = NULL;
   msi_ = false;
   verbose_logging_ = false;
-  ensure_google_update_present_ = false;
 }
 
 bool InstallerState::AnyExistsAndIsInUse(
     const InstallationState& machine_state,
     uint32 file_bits) const {
   static const wchar_t* const kBinaryFileNames[] = {
     kChromeDll,
     kChromeFrameDll,
     kChromeFrameHelperDll,
     kChromeFrameHelperExe,
@@ skipping 204 matching lines @@
   }
   if (!install_list->Do())
     LOG(ERROR) << "Failed to record installer error information in registry.";
 }
 
 bool InstallerState::RequiresActiveSetup() const {
   return system_install() && FindProduct(BrowserDistribution::CHROME_BROWSER);
 }
 
 }  // namespace installer