Implement installation of the Chrome App Host.

chrome/installer/util/installation_validator.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.
 
 // Implementation of the installation validator.
 
 #include "chrome/installer/util/installation_validator.h"
 
 #include <algorithm>
 #include <set>
@@ skipping 94 matching lines @@
 }
 
 bool InstallationValidator::ChromeFrameRules::UsageStatsAllowed(
     const ProductState& product_state) const {
   // Products must not have usagestats consent values when multi-install
   // (only the multi-install binaries may).
   return !product_state.is_multi_install();
 }
 
 BrowserDistribution::Type
+    InstallationValidator::ChromeAppHostRules::distribution_type() const {
+  return BrowserDistribution::CHROME_APP_HOST;
+}
+
+void InstallationValidator::ChromeAppHostRules::AddUninstallSwitchExpectations(
+    const InstallationState& machine_state,
+    bool system_install,
+    const ProductState& product_state,
+    SwitchExpectations* expectations) const {
+  DCHECK(!system_install);
+
+  // --chrome-app-host must be present.
+  expectations->push_back(std::make_pair(std::string(switches::kChromeAppHost),
+                                         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 InstallationState& machine_state,
+    bool system_install,
+    const ProductState& product_state,
+    SwitchExpectations* expectations) const {
+  // TODO(erikwright): I guess there will be none?
+}
+
+bool InstallationValidator::ChromeAppHostRules::UsageStatsAllowed(
+    const ProductState& product_state) 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 InstallationState& machine_state,
     bool system_install,
     const ProductState& product_state,
     SwitchExpectations* expectations) const {
   NOTREACHED();
@@ skipping 17 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_FRAME_READY_MODE_CHROME_MULTI
+  CHROME_FRAME_READY_MODE_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,
+  CHROME_APP_HOST_CHROME_MULTI_CHROME_FRAME_READY_MODE,
 };
 
 // Validates the "quick-enable-cf" Google Update product command.
 void InstallationValidator::ValidateQuickEnableCfCommand(
     const ProductContext& ctx,
     const AppCommand& command,
     bool* is_valid) {
   DCHECK(is_valid);
 
   CommandLine the_command(CommandLine::FromString(command.command_line()));
@@ skipping 62 matching lines @@
                << scan->first << "\".";
   }
 }
 
 // Validates the multi-install binaries' Google Update commands.
 void InstallationValidator::ValidateBinariesCommands(
     const ProductContext& ctx,
     bool* is_valid) {
   DCHECK(is_valid);
 
-  // The quick-enable-cf command must be present if Chrome is installed either
-  // alone or with CF in ready-mode.
+  // The quick-enable-cf command must be present if Chrome Binaries are
+  // installed and Chrome Frame is not installed (or installed in ready mode).
   const ChannelInfo& channel = ctx.state.channel();
-  const ProductState* chrome_state = ctx.machine_state.GetProductState(
-      ctx.system_install, BrowserDistribution::CHROME_BROWSER);
+  const ProductState* binaries_state = ctx.machine_state.GetProductState(
+      ctx.system_install, BrowserDistribution::CHROME_BINARIES);
   const ProductState* cf_state = ctx.machine_state.GetProductState(
       ctx.system_install, BrowserDistribution::CHROME_FRAME);
 
   CommandExpectations expectations;
 
-  if (chrome_state != NULL && (cf_state == NULL || channel.IsReadyMode()))
+  if (binaries_state != NULL && (cf_state == NULL || channel.IsReadyMode()))
     expectations[kCmdQuickEnableCf] = &ValidateQuickEnableCfCommand;
 
   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,
@@ skipping 47 matching lines @@
       LOG(ERROR) << "Chrome Binaries are missing \"-readymode\" in channel"
                     " name: \"" << channel.value() << "\"";
     }
   } else if (channel.IsReadyMode()) {
     *is_valid = false;
     LOG(ERROR) << "Chrome Binaries have \"-readymode\" in channel name, yet "
                   "Chrome Frame is not in ready mode: \"" << channel.value()
                << "\"";
   }
 
-  // Chrome or Chrome Frame must be present
-  if (chrome_state == NULL && cf_state == NULL) {
+  // ap must have -apphost iff Chrome Frame 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 Host is installed in non-multi mode.";
+    }
+    if (!channel.IsAppHost()) {
+      *is_valid = false;
+      LOG(ERROR) << "Chrome Binaries are missing \"-apphost\" in channel"
+                    " name: \"" << channel.value() << "\"";
+    }
+  } else if (channel.IsAppHost()) {
+    *is_valid = false;
+    LOG(ERROR) << "Chrome Binaries have \"-apphost\" in channel name, yet "
+                  "Chrome App Host 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) {
     *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 is not present.
-  if (cf_state != NULL && chrome_state == NULL &&
+  // Chrome Frame must be multi-install if Chrome & App Host are not present.
+  if (cf_state != NULL && app_host_state == NULL && chrome_state == NULL &&
       !cf_state->is_multi_install()) {
     *is_valid = false;
-    LOG(ERROR) << "Chrome Binaries are present without Chrome yet Chrome Frame "
-                  "is not multi-install.";
+    LOG(ERROR) << "Chrome Binaries are present without Chrome nor App Host "
+               << "yet Chrome Frame is not multi-install.";
   }
 
   ChromeBinariesRules binaries_rules;
   ProductContext ctx = {
     machine_state,
     system_install,
     BrowserDistribution::GetSpecificDistribution(
         BrowserDistribution::CHROME_BINARIES),
     binaries_state,
     binaries_rules
@@ skipping 260 matching lines @@
                     chrome_frame_rules, &rock_on);
     int cf_bit = !product_state->is_multi_install() ?
         ProductBits::CHROME_FRAME_SINGLE :
         (product_state->uninstall_command().HasSwitch(
              switches::kChromeFrameReadyMode) ?
                  ProductBits::CHROME_FRAME_READY_MODE :
                  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 (system_level) {
+      LOG(ERROR) << "Chrome App Host must not be installed at system level.";
+      rock_on = false;
+    }
+    if (!product_state->is_multi_install()) {
+      LOG(ERROR) << "Chrome App Host 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