Ensuring Google Update at user-level is installed alongside App Host, for the quick-enable App Host…

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 <windows.h>
 #include <msi.h>
 #include <shellapi.h>
 #include <shlobj.h>
 
 #include "base/at_exit.h"
@@ skipping 21 matching lines @@
 #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/google_update_constants.h"
 #include "chrome/installer/util/google_update_settings.h"
+#include "chrome/installer/util/google_update_util.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/html_dialog.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/installation_validator.h"
 #include "chrome/installer/util/installer_state.h"
 #include "chrome/installer/util/l10n_string_util.h"
 #include "chrome/installer/util/logging_installer.h"
 #include "chrome/installer/util/lzma_util.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/master_preferences_constants.h"
 #include "chrome/installer/util/self_cleaning_temp_dir.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/installer/util/util_constants.h"
 
 #include "installer_util_strings.h"  // NOLINT
 
 using installer::InstallerState;
 using installer::InstallationState;
 using installer::InstallationValidator;
 using installer::Product;
 using installer::ProductState;
 using installer::Products;
 using installer::MasterPreferences;
 
 const wchar_t kChromePipeName[] = L"\\\\.\\pipe\\ChromeCrashServices";
 const wchar_t kGoogleUpdatePipeName[] = L"\\\\.\\pipe\\GoogleCrashServices\\";
 const wchar_t kSystemPrincipalSid[] = L"S-1-5-18";
-const int kGoogleUpdateTimeoutMs = 20 * 1000;
 
 const MINIDUMP_TYPE kLargerDumpType = static_cast<MINIDUMP_TYPE>(
     MiniDumpWithProcessThreadData |  // Get PEB and TEB.
     MiniDumpWithUnloadedModules |  // Get unloaded modules when available.
     MiniDumpWithIndirectlyReferencedMemory);  // Get memory referenced by stack.
 
 namespace {
 
 // This method unpacks and uncompresses the given archive file. For Chrome
 // install we are creating a uncompressed archive that contains all the files
@@ skipping 511 matching lines @@
           }
         } else {
           // Display an error message for other products.
           *status = installer::SYSTEM_LEVEL_INSTALL_EXISTS;
           installer_state->WriteInstallerResult(
               *status, IDS_INSTALL_SYSTEM_LEVEL_EXISTS_BASE, NULL);
         }
         return false;
       }
     }
+
+  } else {  // System-level install.
+    // --ensure-google-update-present is supported for user-level only.
+    // The flag is generic, but its primary use case involves App Host.
+    if (installer_state->ensure_google_update_present()) {
+      LOG(DFATAL) << "--" << installer::switches::kEnsureGoogleUpdatePresent
+                  << " is supported for user-level only.";
+      *status = installer::APP_HOST_REQUIRES_USER_LEVEL;
+      // No message string since there is nothing a user can do.
+      installer_state->WriteInstallerResult(*status, 0, NULL);
+      return false;
+    }
   }
 
   return true;
 }
 
 installer::InstallStatus InstallProductsHelper(
     const InstallationState& original_state,
     const CommandLine& cmd_line,
     const MasterPreferences& prefs,
     const InstallerState& installer_state,
@@ skipping 129 matching lines @@
 
         installer_state.WriteInstallerResult(install_status, message_id, NULL);
       }
 
       proceed_with_installation =
           proceed_with_installation &&
           CheckGroupPolicySettings(original_state, installer_state,
                                    *installer_version, &install_status);
 
       if (proceed_with_installation) {
+        // If Google Update is absent at user-level, install it using the
+        // Google Update installer from an existing system-level installation.
+        // This is for quick-enable App Host install from a system-level
+        // Chrome Binaries installation.
+        if (!system_install && installer_state.ensure_google_update_present()) {
+          if (!google_update::EnsureUserLevelGoogleUpdatePresent()) {
+            LOG(ERROR) << "Failed to install Google Update";
+            proceed_with_installation = false;
+            install_status = installer::INSTALL_OF_GOOGLE_UPDATE_FAILED;
+            installer_state.WriteInstallerResult(install_status, 0, NULL);
+          }
+        }
+      }
+
+      if (proceed_with_installation) {
         FilePath prefs_source_path(cmd_line.GetSwitchValueNative(
             installer::switches::kInstallerData));
         install_status = installer::InstallOrUpdateProduct(
             original_state, installer_state, cmd_line.GetProgram(),
             archive_to_copy, temp_path.path(), prefs_source_path, prefs,
             *installer_version);
 
         int install_msg_base = IDS_INSTALL_FAILED_BASE;
         string16 chrome_exe;
         string16 quoted_chrome_exe;
@@ skipping 165 matching lines @@
     LOG(ERROR) << product.distribution()->GetAppShortCutName()
                << " not found for uninstall.";
     return installer::CHROME_NOT_INSTALLED;
   }
 
   return installer::UninstallProduct(
       original_state, installer_state, cmd_line.GetProgram(), product,
       remove_all, force_uninstall, cmd_line);
 }
 
-// Tell Google Update that an uninstall has taken place.  This gives it a chance
-// to uninstall itself straight away if no more products are installed on the
-// system rather than waiting for the next time the scheduled task runs.
-// Success or failure of Google Update has no bearing on the success or failure
-// of Chrome's uninstallation.
-void UninstallGoogleUpdate(bool system_install) {
-  string16 uninstall_cmd(
-      GoogleUpdateSettings::GetUninstallCommandLine(system_install));
-  if (!uninstall_cmd.empty()) {
-    base::win::ScopedHandle process;
-    LOG(INFO) << "Launching Google Update's uninstaller: " << uninstall_cmd;
-    if (base::LaunchProcess(uninstall_cmd, base::LaunchOptions(),
-                            process.Receive())) {
-      int exit_code = 0;
-      if (base::WaitForExitCodeWithTimeout(
-              process, &exit_code,
-              base::TimeDelta::FromMilliseconds(kGoogleUpdateTimeoutMs))) {
-        if (exit_code == 0) {
-          LOG(INFO) << "  normal exit.";
-        } else {
-          LOG(ERROR) << "Google Update uninstaller (" << uninstall_cmd
-                     << ") exited with code " << exit_code << ".";
-        }
-      } else {
-        // The process didn't finish in time, or GetExitCodeProcess failed.
-        LOG(ERROR) << "Google Update uninstaller (" << uninstall_cmd
-                   << ") is taking more than " << kGoogleUpdateTimeoutMs
-                   << " milliseconds to complete.";
-      }
-    } else {
-      PLOG(ERROR) << "Failed to launch Google Update uninstaller ("
-                  << uninstall_cmd << ")";
-    }
-  }
-}
-
 installer::InstallStatus UninstallProducts(
     const InstallationState& original_state,
     const InstallerState& installer_state,
     const CommandLine& cmd_line) {
   const Products& products = installer_state.products();
 
   if (installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER)) {
     // InstallerState::Initialize always puts Chrome first, and we rely on that
     // here for this reason: if Chrome is in-use, the user will be prompted to
     // confirm uninstallation.  Upon cancel, we should not continue with the
@@ skipping 14 matching lines @@
 
   for (Products::const_iterator it = products.begin();
        install_status != installer::UNINSTALL_CANCELLED && it < products.end();
        ++it) {
     prod_status = UninstallProduct(original_state, installer_state,
         cmd_line, remove_all, force, **it);
     if (prod_status != installer::UNINSTALL_SUCCESSFUL)
       install_status = prod_status;
   }
 
-  UninstallGoogleUpdate(installer_state.system_install());
+  // Tell Google Update that an uninstall has taken place.
+  // Ignore the return value: success or failure of Google Update
+  // has no bearing on the success or failure of Chrome's uninstallation.
+  google_update::UninstallGoogleUpdate(installer_state.system_install());
 
   return install_status;
 }
 
 installer::InstallStatus ShowEULADialog(const string16& inner_frame) {
   VLOG(1) << "About to show EULA";
   string16 eula_path = installer::GetLocalizedEulaResource();
   if (eula_path.empty()) {
     LOG(ERROR) << "No EULA path available";
     return installer::EULA_REJECTED;
@@ skipping 70 matching lines @@
   } else if (cmd_line.HasSwitch(installer::switches::kShowEula)) {
     // Check if we need to show the EULA. If it is passed as a command line
     // then the dialog is shown and regardless of the outcome setup exits here.
     string16 inner_frame =
         cmd_line.GetSwitchValueNative(installer::switches::kShowEula);
     *exit_code = ShowEULADialog(inner_frame);
     if (installer::EULA_REJECTED != *exit_code) {
       GoogleUpdateSettings::SetEULAConsent(
           original_state, BrowserDistribution::GetDistribution(), true);
     }
-  } else if (cmd_line.HasSwitch(
-      installer::switches::kConfigureUserSettings)) {
+  } else if (cmd_line.HasSwitch(installer::switches::kConfigureUserSettings)) {
     DCHECK(installer_state->system_install());
     const Product* chrome_install =
         installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER);
     DCHECK(chrome_install);
     // TODO(gab): Implement the new shortcut functionality here.
     LOG(ERROR) << "--configure-user-settings is not implemented.";
-  } else if (cmd_line.HasSwitch(
-      installer::switches::kRegisterChromeBrowser)) {
+  } else if (cmd_line.HasSwitch(installer::switches::kRegisterChromeBrowser)) {
     installer::InstallStatus status = installer::UNKNOWN_STATUS;
     const Product* chrome_install =
         installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER);
     if (chrome_install) {
       // If --register-chrome-browser option is specified, register all
       // Chrome protocol/file associations, as well as register it as a valid
       // browser for Start Menu->Internet shortcut. This switch will also
       // register Chrome as a valid handler for a set of URL protocols that
       // Chrome may become the default handler for, either by the user marking
       // Chrome as the default browser, through the Windows Default Programs
       // control panel settings, or through website use of
       // registerProtocolHandler. These protocols are found in
       // ShellUtil::kPotentialProtocolAssociations.
       // The --register-url-protocol will additionally register Chrome as a
       // potential handler for the supplied protocol, and is used if a website
       // registers a handler for a protocol not found in
       // ShellUtil::kPotentialProtocolAssociations.
       // These options should only be used when setup.exe is launched with admin
       // rights. We do not make any user specific changes with this option.
       DCHECK(IsUserAnAdmin());
       string16 chrome_exe(cmd_line.GetSwitchValueNative(
           installer::switches::kRegisterChromeBrowser));
       string16 suffix;
       if (cmd_line.HasSwitch(
           installer::switches::kRegisterChromeBrowserSuffix)) {
         suffix = cmd_line.GetSwitchValueNative(
             installer::switches::kRegisterChromeBrowserSuffix);
       }
-      if (cmd_line.HasSwitch(
-          installer::switches::kRegisterURLProtocol)) {
+      if (cmd_line.HasSwitch(installer::switches::kRegisterURLProtocol)) {
         string16 protocol = cmd_line.GetSwitchValueNative(
             installer::switches::kRegisterURLProtocol);
         // ShellUtil::RegisterChromeForProtocol performs all registration
         // done by ShellUtil::RegisterChromeBrowser, as well as registering
         // with Windows as capable of handling the supplied protocol.
         if (ShellUtil::RegisterChromeForProtocol(
                 chrome_install->distribution(), chrome_exe, suffix, protocol,
                 false))
           status = installer::IN_USE_UPDATED;
       } else {
@@ skipping 372 matching lines @@
   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);
 
   VLOG(1) << "Installation complete, returning: " << return_code;
 
   return return_code;
 }