Revert of Remove installation of Chrome Frame.

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 12 matching lines @@
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/master_preferences_constants.h"
 #include "chrome/installer/util/product.h"
 #include "chrome/installer/util/work_item.h"
 #include "chrome/installer/util/work_item_list.h"
 
 namespace installer {
 
-bool InstallerState::IsMultiInstallUpdate(
-    const MasterPreferences& prefs,
+bool InstallerState::IsMultiInstallUpdate(const MasterPreferences& prefs,
     const InstallationState& machine_state) {
-  // First, are the binaries present?
-  const ProductState* binaries =
+  // First, is the package present?
+  const ProductState* package =
       machine_state.GetProductState(level_ == SYSTEM_LEVEL,
                                     BrowserDistribution::CHROME_BINARIES);
-  if (binaries == NULL) {
-    // The multi-install binaries have not been installed, so they certainly
-    // aren't being updated.
+  if (package == NULL) {
+    // The multi-install package has not been installed, so it certainly isn't
+    // being updated.
     return false;
   }
 
-  if (prefs.install_chrome()) {
+  BrowserDistribution::Type types[2];
+  size_t num_types = 0;
+  if (prefs.install_chrome())
+    types[num_types++] = BrowserDistribution::CHROME_BROWSER;
+  if (prefs.install_chrome_frame())
+    types[num_types++] = BrowserDistribution::CHROME_FRAME;
+
+  for (const BrowserDistribution::Type* scan = &types[0],
+           *end = &types[num_types]; scan != end; ++scan) {
     const ProductState* product =
-        machine_state.GetProductState(level_ == SYSTEM_LEVEL,
-                                      BrowserDistribution::CHROME_BROWSER);
+        machine_state.GetProductState(level_ == SYSTEM_LEVEL, *scan);
     if (product == NULL) {
-      VLOG(2) << "It seems that chrome is being installed for the first time.";
+      VLOG(2) << "It seems that distribution type " << *scan
+              << " is being installed for the first time.";
       return false;
     }
-    if (!product->channel().Equals(binaries->channel())) {
-      VLOG(2) << "It seems that chrome is being over installed.";
+    if (!product->channel().Equals(package->channel())) {
+      VLOG(2) << "It seems that distribution type " << *scan
+              << " is being over installed.";
       return false;
     }
   }
 
-  VLOG(2) << "It seems that the binaries are being updated.";
+  VLOG(2) << "It seems that the package is being updated.";
 
   return true;
 }
 
 InstallerState::InstallerState()
     : operation_(UNINITIALIZED),
       state_type_(BrowserDistribution::CHROME_BROWSER),
       multi_package_distribution_(NULL),
       level_(UNKNOWN_LEVEL),
       package_type_(UNKNOWN_PACKAGE_TYPE),
@@ skipping 41 matching lines @@
       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_frame()) {
+    Product* p = AddProductFromPreferences(
+        BrowserDistribution::CHROME_FRAME, prefs, machine_state);
+    VLOG(1) << (is_uninstall ? "Uninstall" : "Install")
+            << " distribution: " << p->distribution()->GetDisplayName();
+  }
 
   if (prefs.install_chrome_app_launcher()) {
     Product* p = AddProductFromPreferences(
         BrowserDistribution::CHROME_APP_HOST, 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.
+    // Chrome/Chrome Frame multi need Binaries at their own level.
     if (FindProduct(BrowserDistribution::CHROME_BROWSER))
       need_binaries = true;
 
+    if (FindProduct(BrowserDistribution::CHROME_FRAME))
+      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()) {
@@ skipping 104 matching lines @@
     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
-  // guids (Chrome, App Host, or Binaries, in order of preference).
+  // Initial, over, and un-installs will take place under one of the
+  // product app guids (Chrome, Chrome Frame, 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_frame())
+      operand_distribution_type = BrowserDistribution::CHROME_FRAME;
     else if (prefs.install_chrome_app_launcher())
       operand_distribution_type = BrowserDistribution::CHROME_APP_HOST;
 
     operand = BrowserDistribution::GetSpecificDistribution(
         operand_distribution_type);
   }
 
   state_key_ = operand->GetStateKey();
   state_type_ = operand->GetType();
 
@@ skipping 530 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