Revert of Remove installation of Chrome Frame.

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 18 matching lines @@
 #include "base/win/registry.h"
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "breakpad/src/client/windows/handler/exception_handler.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/setup/archive_patch_helper.h"
+#include "chrome/installer/setup/cf_migration.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"
@@ skipping 193 matching lines @@
   // Move chrome.exe to old_chrome.exe, then move new_chrome.exe to chrome.exe.
   install_list->AddMoveTreeWorkItem(chrome_exe.value(),
                                     chrome_old_exe.value(),
                                     temp_path.path().value(),
                                     WorkItem::ALWAYS_MOVE);
   install_list->AddMoveTreeWorkItem(chrome_new_exe.value(),
                                     chrome_exe.value(),
                                     temp_path.path().value(),
                                     WorkItem::ALWAYS_MOVE);
   install_list->AddDeleteTreeWorkItem(chrome_new_exe, temp_path.path());
+  // Delete an elevation policy associated with the old version, should one
+  // exist.
+  if (installer_state->FindProduct(BrowserDistribution::CHROME_FRAME)) {
+    installer::AddDeleteOldIELowRightsPolicyWorkItems(*installer_state,
+                                                      install_list.get());
+  }
   // old_chrome.exe is still in use in most cases, so ignore failures here.
   install_list->AddDeleteTreeWorkItem(chrome_old_exe, temp_path.path())->
       set_ignore_failure(true);
 
   // Add work items to delete the "opv", "cpv", and "cmd" values from all
   // products we're operating on (which including the multi-install binaries).
   const Products& products = installer_state->products();
   HKEY reg_root = installer_state->root_key();
   base::string16 version_key;
   for (Products::const_iterator it = products.begin(); it < products.end();
@@ skipping 90 matching lines @@
     *status = installer::INCONSISTENT_UPDATE_POLICY;
     installer_state.WriteInstallerResult(
         *status, IDS_INSTALL_INCONSISTENT_UPDATE_POLICY_BASE, NULL);
   }
 
   return settings_are_valid;
 #endif  // defined(GOOGLE_CHROME_BUILD)
 }
 
 // If only the binaries are being updated, fail.
+// If Chrome Frame is being installed by itself in multi-mode:
+//   - If a non-multi Chrome Frame installation is present, fail.
 // If any product is being installed in single-mode that already exists in
 // multi-mode, fail.
 bool CheckMultiInstallConditions(const InstallationState& original_state,
                                  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 Product* chrome_frame =
+        installer_state->FindProduct(BrowserDistribution::CHROME_FRAME);
+    const ProductState* cf_state =
+        original_state.GetProductState(system_level,
+                                       BrowserDistribution::CHROME_FRAME);
     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) {
+      if (app_host && !chrome && !chrome_frame && !cf_state && !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 {
@@ skipping 17 matching lines @@
       // 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)));
       multi_chrome->SetOption(installer::kOptionMultiInstall, true);
       chrome = installer_state->AddProduct(&multi_chrome);
       VLOG(1) << "Upgrading existing Chrome browser in multi-install mode.";
     }
+
+    // Fail if we're installing Chrome Frame when a single-install of it is
+    // already installed.
+    if (chrome_frame && cf_state && !cf_state->is_multi_install()) {
+      LOG(ERROR) << "Cannot migrate existing Chrome Frame installation to "
+                 << "multi-install.";
+      *status = installer::NON_MULTI_INSTALLATION_EXISTS;
+      installer_state->WriteInstallerResult(*status,
+          IDS_INSTALL_NON_MULTI_INSTALLATION_EXISTS_BASE, NULL);
+      return false;
+    }
   } else {
     // This is a non-multi installation.
 
     // Check for an existing installation of the product.
     const ProductState* product_state = original_state.GetProductState(
         system_level, products[0]->distribution()->GetType());
     if (product_state != NULL) {
       // Block downgrades from multi-install to single-install.
       if (product_state->is_multi_install()) {
         LOG(ERROR) << "Multi-install "
@@ skipping 746 matching lines @@
       *exit_code = installer::CourgettePatchFiles(input_file,
                                                   patch_file,
                                                   output_file);
     } else if (patch_type_str == installer::kBsdiff) {
       *exit_code = installer::BsdiffPatchFiles(input_file,
                                                patch_file,
                                                output_file);
     } else {
       *exit_code = installer::PATCH_INVALID_ARGUMENTS;
     }
+  } else if (cmd_line.HasSwitch(installer::switches::kMigrateChromeFrame)) {
+    *exit_code = MigrateChromeFrame(original_state, installer_state);
   } else {
     handled = false;
   }
 
   return handled;
 }
 
 bool ShowRebootDialog() {
   // Get a token for this process.
   HANDLE token;
@@ skipping 291 matching lines @@
                    << product.distribution()->GetDisplayName()
                    << " is already installed.";
         higher_products |= (1 << product.distribution()->GetType());
       }
     }
 
     if (higher_products != 0) {
       COMPILE_ASSERT(BrowserDistribution::NUM_TYPES == 4,
                      add_support_for_new_products_here_);
       const uint32 kBrowserBit = 1 << BrowserDistribution::CHROME_BROWSER;
+      const uint32 kGCFBit = 1 << BrowserDistribution::CHROME_FRAME;
       const uint32 kAppHostBit = 1 << BrowserDistribution::CHROME_APP_HOST;
       int message_id = 0;
 
       proceed_with_installation = false;
       install_status = HIGHER_VERSION_EXISTS;
       switch (higher_products) {
         case kBrowserBit:
           message_id = IDS_INSTALL_HIGHER_VERSION_BASE;
           break;
+        case kGCFBit:
+          message_id = IDS_INSTALL_HIGHER_VERSION_CF_BASE;
+          break;
+        case kGCFBit | kBrowserBit:
+          message_id = IDS_INSTALL_HIGHER_VERSION_CB_CF_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 &&
@@ skipping 21 matching lines @@
           switches::kInstallerData));
       install_status = InstallOrUpdateProduct(
           original_state, installer_state, cmd_line.GetProgram(),
           uncompressed_archive, temp_path.path(), src_path, prefs_source_path,
           prefs, *installer_version);
 
       int install_msg_base = IDS_INSTALL_FAILED_BASE;
       base::string16 chrome_exe;
       base::string16 quoted_chrome_exe;
       if (install_status == SAME_VERSION_REPAIR_FAILED) {
-        install_msg_base = IDS_SAME_VERSION_REPAIR_FAILED_BASE;
+        if (installer_state.FindProduct(BrowserDistribution::CHROME_FRAME)) {
+          install_msg_base = IDS_SAME_VERSION_REPAIR_FAILED_CF_BASE;
+        } else {
+          install_msg_base = IDS_SAME_VERSION_REPAIR_FAILED_BASE;
+        }
       } else if (install_status != INSTALL_FAILED) {
         if (installer_state.target_path().empty()) {
           // If we failed to construct install path, it means the OS call to
           // get %ProgramFiles% or %AppData% failed. Report this as failure.
           install_msg_base = IDS_INSTALL_OS_ERROR_BASE;
           install_status = OS_ERROR;
         } else {
           chrome_exe = installer_state.target_path().Append(kChromeExe).value();
           quoted_chrome_exe = L"\"" + chrome_exe + L"\"";
           install_msg_base = 0;
@@ skipping 149 matching lines @@
         cmd_line.HasSwitch(installer::switches::kForceUninstall) ||
         cmd_line.HasSwitch(installer::switches::kMakeChromeDefault) ||
         cmd_line.HasSwitch(installer::switches::kRegisterChromeBrowser) ||
         cmd_line.HasSwitch(installer::switches::kRemoveChromeRegistration) ||
         cmd_line.HasSwitch(installer::switches::kInactiveUserToast) ||
         cmd_line.HasSwitch(installer::switches::kSystemLevelToast)) {
       return installer::SXS_OPTION_NOT_SUPPORTED;
     }
   }
 
-  // Some command line options are no longer supported and must error out.
-  if (installer::ContainsUnsupportedSwitch(cmd_line))
-    return installer::UNSUPPORTED_OPTION;
-
   int exit_code = 0;
   if (HandleNonInstallCmdLineOptions(
           original_state, cmd_line, &installer_state, &exit_code)) {
     return exit_code;
   }
 
   if (system_install && !IsUserAnAdmin()) {
     if (base::win::GetVersion() >= base::win::VERSION_VISTA &&
         !cmd_line.HasSwitch(installer::switches::kRunAsAdmin)) {
       CommandLine new_cmd(CommandLine::NO_PROGRAM);
@@ skipping 36 matching lines @@
 
   // Validate that the machine is now in a good state following the operation.
   // TODO(grt): change this to log at DFATAL once we're convinced that the
   // validator handles all cases properly.
   InstallationValidator::InstallationType installation_type =
       InstallationValidator::NO_PRODUCTS;
   LOG_IF(ERROR,
          !InstallationValidator::ValidateInstallationType(system_install,
                                                           &installation_type));
 
+  const Product* cf_install =
+      installer_state.FindProduct(BrowserDistribution::CHROME_FRAME);
+  if (cf_install &&
+      !cmd_line.HasSwitch(installer::switches::kForceUninstall)) {
+    if (install_status == installer::UNINSTALL_REQUIRES_REBOOT) {
+      ShowRebootDialog();
+    } else if (is_uninstall) {
+      // Only show the message box if Chrome Frame was the only product being
+      // uninstalled.
+      const Products& products = installer_state.products();
+      int num_products = 0;
+      for (Products::const_iterator it = products.begin(); it < products.end();
+           ++it) {
+        if (!(*it)->is_chrome_binaries())
+          ++num_products;
+      }
+      if (num_products == 1U) {
+        ::MessageBoxW(NULL,
+                      installer::GetLocalizedString(
+                          IDS_UNINSTALL_COMPLETE_BASE).c_str(),
+                      cf_install->distribution()->GetDisplayName().c_str(),
+                      MB_OK);
+      }
+    }
+  }
+
   int return_code = 0;
   // MSI demands that custom actions always return 0 (ERROR_SUCCESS) or it will
   // rollback the action. If we're uninstalling we want to avoid this, so always
   // report success, squashing any more informative return codes.
   if (!(installer_state.is_msi() && is_uninstall)) {
     // 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);
   }
 
+  // Reinitialize original_state to make sure it reflects the now-current
+  // state of the system.
+  original_state.Initialize();
+
+  // If multi Chrome Frame was just updated, migrate the installation to a SxS
+  // install. Do this right before quitting.
+  const ProductState* chrome_frame_state =
+      original_state.GetProductState(system_install,
+                                     BrowserDistribution::CHROME_FRAME);
+  if ((install_status == installer::NEW_VERSION_UPDATED ||
+       install_status == installer::IN_USE_UPDATED) &&
+      chrome_frame_state &&
+      installer_state.operation() == InstallerState::MULTI_UPDATE) {
+    // Call the newly updated setup.exe with kUncompressedArchive and
+    // kMigrateChromeFrame to perform the migration.
+    LaunchChromeFrameMigrationProcess(*chrome_frame_state, cmd_line,
+                                      installer_directory, system_install);
+  }
+
   VLOG(1) << "Installation complete, returning: " << return_code;
 
   return return_code;
 }