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

chrome/installer/util/installation_validator.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.
 
 // Implementation of the installation validator.
 
 #include "chrome/installer/util/installation_validator.h"
 
 #include <algorithm>
 #include <set>
@@ skipping 69 matching lines @@
 }
 
 bool InstallationValidator::ChromeFrameRules::UsageStatsAllowed(
     const ProductContext& ctx) const {
   // Products must not have usagestats consent values when multi-install
   // (only the multi-install binaries may).
   return !ctx.state.is_multi_install();
 }
 
 BrowserDistribution::Type
-    InstallationValidator::ChromeAppHostRules::distribution_type() const {
-  return BrowserDistribution::CHROME_APP_HOST;
-}
-
-void InstallationValidator::ChromeAppHostRules::AddUninstallSwitchExpectations(
-    const ProductContext& ctx,
-    SwitchExpectations* expectations) const {
-  // --app-launcher must be present.
-  expectations->push_back(
-      std::make_pair(std::string(switches::kChromeAppLauncher), true));
-
-  // --chrome must not be present.
-  expectations->push_back(std::make_pair(std::string(switches::kChrome),
-                                         false));
-  // --chrome-frame must not be present.
-  expectations->push_back(std::make_pair(std::string(switches::kChromeFrame),
-                                         false));
-}
-
-void InstallationValidator::ChromeAppHostRules::AddRenameSwitchExpectations(
-    const ProductContext& ctx,
-    SwitchExpectations* expectations) const {
-  // TODO(erikwright): I guess there will be none?
-}
-
-bool InstallationValidator::ChromeAppHostRules::UsageStatsAllowed(
-    const ProductContext& ctx) const {
-  // App Host doesn't manage usage stats. The Chrome Binaries will.
-  return false;
-}
-
-BrowserDistribution::Type
     InstallationValidator::ChromeBinariesRules::distribution_type() const {
   return BrowserDistribution::CHROME_BINARIES;
 }
 
 void InstallationValidator::ChromeBinariesRules::AddUninstallSwitchExpectations(
     const ProductContext& ctx,
     SwitchExpectations* expectations) const {
   NOTREACHED();
 }
 
@@ skipping 13 matching lines @@
 const InstallationValidator::InstallationType
     InstallationValidator::kInstallationTypes[] = {
   NO_PRODUCTS,
   CHROME_SINGLE,
   CHROME_MULTI,
   CHROME_FRAME_SINGLE,
   CHROME_FRAME_SINGLE_CHROME_SINGLE,
   CHROME_FRAME_SINGLE_CHROME_MULTI,
   CHROME_FRAME_MULTI,
   CHROME_FRAME_MULTI_CHROME_MULTI,
-  CHROME_APP_HOST,
-  CHROME_APP_HOST_CHROME_FRAME_SINGLE,
-  CHROME_APP_HOST_CHROME_FRAME_SINGLE_CHROME_MULTI,
-  CHROME_APP_HOST_CHROME_FRAME_MULTI,
-  CHROME_APP_HOST_CHROME_FRAME_MULTI_CHROME_MULTI,
-  CHROME_APP_HOST_CHROME_MULTI,
 };
 
 void InstallationValidator::ValidateAppCommandFlags(
     const ProductContext& ctx,
     const AppCommand& app_cmd,
     const std::set<base::string16>& flags_exp,
     const base::string16& name,
     bool* is_valid) {
   const struct {
     const base::string16 exp_key;
@@ skipping 46 matching lines @@
   expected.push_back(std::make_pair(std::string(switches::kChrome),
                                     ctx.state.is_multi_install()));
 
   ValidateCommandExpectations(ctx, cmd_line, expected, name, is_valid);
 
   std::set<base::string16> flags_exp;
   flags_exp.insert(google_update::kRegAutoRunOnOSUpgradeField);
   ValidateAppCommandFlags(ctx, app_cmd, flags_exp, name, is_valid);
 }
 
-// Validates the "query-eula-acceptance" Google Update product command.
-void InstallationValidator::ValidateQueryEULAAcceptanceCommand(
-    const ProductContext& ctx,
-    const AppCommand& app_cmd,
-    bool* is_valid) {
-  DCHECK(is_valid);
-
-  CommandLine cmd_line(CommandLine::FromString(app_cmd.command_line()));
-  base::string16 name(kCmdQueryEULAAcceptance);
-
-  ValidateSetupPath(ctx, cmd_line.GetProgram(), name, is_valid);
-
-  SwitchExpectations expected;
-  expected.push_back(std::make_pair(std::string(switches::kQueryEULAAcceptance),
-                                    true));
-  expected.push_back(std::make_pair(std::string(switches::kSystemLevel),
-                                    ctx.system_install));
-
-  ValidateCommandExpectations(ctx, cmd_line, expected, name, is_valid);
-
-  std::set<base::string16> flags_exp;
-  flags_exp.insert(google_update::kRegWebAccessibleField);
-  flags_exp.insert(google_update::kRegRunAsUserField);
-  ValidateAppCommandFlags(ctx, app_cmd, flags_exp, name, is_valid);
-}
-
-// Validates the "quick-enable-application-host" Google Update product command.
-void InstallationValidator::ValidateQuickEnableApplicationHostCommand(
-    const ProductContext& ctx,
-    const AppCommand& app_cmd,
-    bool* is_valid) {
-  DCHECK(is_valid);
-
-  CommandLine cmd_line(CommandLine::FromString(app_cmd.command_line()));
-  base::string16 name(kCmdQuickEnableApplicationHost);
-
-  ValidateSetupPath(ctx, cmd_line.GetProgram(), name, is_valid);
-
-  SwitchExpectations expected;
-
-  expected.push_back(std::make_pair(
-      std::string(switches::kChromeAppLauncher), true));
-  expected.push_back(std::make_pair(
-      std::string(switches::kSystemLevel), false));
-  expected.push_back(std::make_pair(
-      std::string(switches::kMultiInstall), true));
-  expected.push_back(std::make_pair(
-      std::string(switches::kEnsureGoogleUpdatePresent), true));
-
-  ValidateCommandExpectations(ctx, cmd_line, expected, name, is_valid);
-
-  std::set<base::string16> flags_exp;
-  flags_exp.insert(google_update::kRegSendsPingsField);
-  flags_exp.insert(google_update::kRegWebAccessibleField);
-  flags_exp.insert(google_update::kRegRunAsUserField);
-  ValidateAppCommandFlags(ctx, app_cmd, flags_exp, name, is_valid);
-}
-
 // Validates a product's set of Google Update product commands against a
 // collection of expectations.
 void InstallationValidator::ValidateAppCommandExpectations(
     const ProductContext& ctx,
     const CommandExpectations& expectations,
     bool* is_valid) {
   DCHECK(is_valid);
 
   CommandExpectations the_expectations(expectations);
 
@@ skipping 20 matching lines @@
   CommandExpectations::const_iterator scan(the_expectations.begin());
   CommandExpectations::const_iterator end(the_expectations.end());
   for (; scan != end; ++scan) {
     *is_valid = false;
     LOG(ERROR) << ctx.dist->GetDisplayName()
                << " is missing the Google Update product command named \""
                << scan->first << "\".";
   }
 }
 
-// Validates the multi-install binaries' Google Update commands.
-void InstallationValidator::ValidateBinariesCommands(
-    const ProductContext& ctx,
-    bool* is_valid) {
-  DCHECK(is_valid);
-
-  const ProductState* binaries_state = ctx.machine_state.GetProductState(
-      ctx.system_install, BrowserDistribution::CHROME_BINARIES);
-
-  CommandExpectations expectations;
-
-  if (binaries_state != NULL) {
-    expectations[kCmdQuickEnableApplicationHost] =
-        &ValidateQuickEnableApplicationHostCommand;
-
-    expectations[kCmdQueryEULAAcceptance] = &ValidateQueryEULAAcceptanceCommand;
-  }
-
-  ValidateAppCommandExpectations(ctx, expectations, is_valid);
-}
-
 // Validates the multi-install binaries at level |system_level|.
 void InstallationValidator::ValidateBinaries(
     const InstallationState& machine_state,
     bool system_install,
     const ProductState& binaries_state,
     bool* is_valid) {
   const ChannelInfo& channel = binaries_state.channel();
 
   // ap must have -multi
   if (!channel.IsMultiInstall()) {
@@ skipping 26 matching lines @@
       LOG(ERROR) << "Chrome Binaries are missing \"-chromeframe\" in channel"
                     " name: \"" << channel.value() << "\"";
     }
   } else if (channel.IsChromeFrame()) {
     *is_valid = false;
     LOG(ERROR) << "Chrome Binaries have \"-chromeframe\" in channel name, yet "
                   "Chrome Frame is not installed multi: \"" << channel.value()
                << "\"";
   }
 
-  // ap must have -applauncher iff Chrome App Launcher is installed multi
-  const ProductState* app_host_state = machine_state.GetProductState(
-      system_install, BrowserDistribution::CHROME_APP_HOST);
-  if (app_host_state != NULL) {
-    if (!app_host_state->is_multi_install()) {
-      *is_valid = false;
-      LOG(ERROR) << "Chrome App Launcher is installed in non-multi mode.";
-    }
-    if (!channel.IsAppLauncher()) {
-      *is_valid = false;
-      LOG(ERROR) << "Chrome Binaries are missing \"-applauncher\" in channel"
-                    " name: \"" << channel.value() << "\"";
-    }
-  } else if (channel.IsAppLauncher()) {
-    *is_valid = false;
-    LOG(ERROR) << "Chrome Binaries have \"-applauncher\" in channel name, yet "
-                  "Chrome App Launcher is not installed: \"" << channel.value()
-               << "\"";
-  }
-
-  // Chrome, Chrome Frame, or App Host must be present
-  if (chrome_state == NULL && cf_state == NULL && app_host_state == NULL) {
+  // Chrome or Chrome Frame must be present
+  if (chrome_state == NULL && cf_state == NULL) {
     *is_valid = false;
     LOG(ERROR) << "Chrome Binaries are present with no other products.";
   }
 
+
   // Chrome must be multi-install if present.
   if (chrome_state != NULL && !chrome_state->is_multi_install()) {
     *is_valid = false;
     LOG(ERROR)
         << "Chrome Binaries are present yet Chrome is not multi-install.";
   }
 
-  // Chrome Frame must be multi-install if Chrome & App Host are not present.
-  if (cf_state != NULL && app_host_state == NULL && chrome_state == NULL &&
+  // Chrome Frame must be multi-install if Chrome is not present.
+  if (cf_state != NULL && chrome_state == NULL &&
       !cf_state->is_multi_install()) {
     *is_valid = false;
-    LOG(ERROR) << "Chrome Binaries are present without Chrome nor App Launcher "
-               << "yet Chrome Frame is not multi-install.";
+    LOG(ERROR) << "Chrome Binaries are present without Chrome, yet Chrome Frame"
+               << " is not multi-install.";
   }
 
   ChromeBinariesRules binaries_rules;
   ProductContext ctx(machine_state, system_install, binaries_state,
                      binaries_rules);
 
-  ValidateBinariesCommands(ctx, is_valid);
-
   ValidateUsageStats(ctx, is_valid);
 }
 
 // Validates the path to |setup_exe| for the product described by |ctx|.
 void InstallationValidator::ValidateSetupPath(const ProductContext& ctx,
                                               const base::FilePath& setup_exe,
                                               const base::string16& purpose,
                                               bool* is_valid) {
   DCHECK(is_valid);
 
@@ skipping 118 matching lines @@
 // Validates the multi-install state of the product described in |ctx|.
 void InstallationValidator::ValidateMultiInstallProduct(
     const ProductContext& ctx,
     bool* is_valid) {
   DCHECK(is_valid);
 
   const ProductState* binaries =
       ctx.machine_state.GetProductState(ctx.system_install,
                                         BrowserDistribution::CHROME_BINARIES);
   if (!binaries) {
-    if (ctx.dist->GetType() == BrowserDistribution::CHROME_APP_HOST) {
-      if (!ctx.machine_state.GetProductState(
-              true,  // system-level
-              BrowserDistribution::CHROME_BINARIES) &&
-          !ctx.machine_state.GetProductState(
-              true,  // system-level
-              BrowserDistribution::CHROME_BROWSER)) {
-        *is_valid = false;
-        LOG(ERROR) << ctx.dist->GetDisplayName()
-                   << " (" << ctx.state.version().GetString() << ") is "
-                   << "installed without Chrome Binaries or a system-level "
-                   << "Chrome.";
-      }
-    } else {
-      *is_valid = false;
-      LOG(ERROR) << ctx.dist->GetDisplayName()
-                 << " (" << ctx.state.version().GetString() << ") is installed "
-                 << "without Chrome Binaries.";
-    }
+    *is_valid = false;
+    LOG(ERROR) << ctx.dist->GetDisplayName()
+               << " (" << ctx.state.version().GetString() << ") is installed "
+               << "without Chrome Binaries.";
   } else {
     // Version must match that of binaries.
     if (ctx.state.version().CompareTo(binaries->version()) != 0) {
       *is_valid = false;
       LOG(ERROR) << "Version of " << ctx.dist->GetDisplayName()
                  << " (" << ctx.state.version().GetString() << ") does not "
                     "match that of Chrome Binaries ("
                  << binaries->version().GetString() << ").";
     }
 
@@ skipping 104 matching lines @@
   if (product_state != NULL) {
     ChromeFrameRules chrome_frame_rules;
     ValidateProduct(machine_state, system_level, *product_state,
                     chrome_frame_rules, &rock_on);
     int cf_bit = !product_state->is_multi_install() ?
         ProductBits::CHROME_FRAME_SINGLE :
         ProductBits::CHROME_FRAME_MULTI;
     *type = static_cast<InstallationType>(*type | cf_bit);
   }
 
-  // Is Chrome App Host installed?
-  product_state =
-      machine_state.GetProductState(system_level,
-                                    BrowserDistribution::CHROME_APP_HOST);
-  if (product_state != NULL) {
-    ChromeAppHostRules chrome_app_host_rules;
-    ValidateProduct(machine_state, system_level, *product_state,
-                    chrome_app_host_rules, &rock_on);
-    *type = static_cast<InstallationType>(*type | ProductBits::CHROME_APP_HOST);
-    if (!product_state->is_multi_install()) {
-      LOG(ERROR) << "Chrome App Launcher must always be multi-install.";
-      rock_on = false;
-    }
-  }
-
   DCHECK_NE(std::find(&kInstallationTypes[0],
                       &kInstallationTypes[arraysize(kInstallationTypes)],
                       *type),
             &kInstallationTypes[arraysize(kInstallationTypes)])
       << "Invalid combination of products found on system (" << *type << ")";
 
   return rock_on;
 }
 
 // static
 bool InstallationValidator::ValidateInstallationType(bool system_level,
                                                      InstallationType* type) {
   DCHECK(type);
   InstallationState machine_state;
 
   machine_state.Initialize();
 
   return ValidateInstallationTypeForState(machine_state, system_level, type);
 }
 
 }  // namespace installer