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 390 matching lines @@
   }
 
   return true;
 }
 
 // Checks app host pre-install conditions, specifically that this is a
 // user-level multi-install.  When the pre-install conditions are not
 // satisfied, the result is written to the registry (via WriteInstallerResult),
 // |status| is set appropriately, and false is returned.
 bool CheckAppHostPreconditions(const InstallationState& original_state,
+                               const CommandLine& cmd_line,

[erikwright (departed), 2012/09/21 13:11:11]

Rather than introducing the cmd_line argument here and elsewhere, I suggest
adding a property to InstallerState (::ensure_google_update_present()) and
initializing it in InstallerState::Initialize.

Then you can just check installer_state everywhere you were previously accessing
cmd_line.

I don't think it makes sense to also put it in MasterPreferences.

grt, WDYT?

[grt (UTC plus 2), 2012/09/21 14:20:33]

sgtm.  MasterPreferences would only be required if this option needs to be set
in an installerdata block for distro deals, which doesn't appear to be the case.

[huangs, 2012/09/21 18:48:43]

Done.  "Present" sounds better than "installed", so changing that globally as
well.

                                InstallerState* installer_state,
                                installer::InstallStatus* status) {
   if (installer_state->FindProduct(BrowserDistribution::CHROME_APP_HOST)) {
 
     if (!installer_state->is_multi_install()) {
       LOG(DFATAL) << "Application Host requires multi install";
       *status = installer::APP_HOST_REQUIRES_MULTI_INSTALL;
       // No message string since there is nothing a user can do.
       installer_state->WriteInstallerResult(*status, 0, NULL);
       return false;
     }
 
     if (installer_state->system_install()) {
       LOG(DFATAL) << "Application Host may only be installed at user-level.";
       *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;
     }
 
   }
 
+  // --ensure-google-update-installed is for user-level only.
+  // The flag is generic, but it's primary use case involves App Host.

[grt (UTC plus 2), 2012/09/21 14:20:33]

it's -> its

[grt (UTC plus 2), 2012/09/21 14:20:33]

if it's generic, then do this check in CheckPreInstallConditions.

[huangs, 2012/09/21 18:48:43]

How did that happen?! Done.

[huangs, 2012/09/21 18:48:43]

Done.

+  // Therefore we make the check here, with the associated status.
+  if (cmd_line.HasSwitch(installer::switches::kEnsureGoogleUpdateInstalled)) {
+    if (installer_state->system_install()) {

[grt (UTC plus 2), 2012/09/21 14:20:33]

note that you'll never get here thanks to the block above.

[huangs, 2012/09/21 18:48:43]

--ensure-google-update-installed can be specified in a stand-alone fashion for
testing (but let me know if I'm missing something).

+      LOG(DFATAL) << "--" << installer::switches::kEnsureGoogleUpdateInstalled
+                  << " is enabled for user-level only.";

[erikwright (departed), 2012/09/21 14:08:49]

enabled -> supported.

[huangs, 2012/09/21 18:48:43]

Done.

+      *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;
 }
 
 // Checks for compatibility between the current state of the system and the
 // desired operation.  Also applies policy that mutates the desired operation;
 // specifically, the |installer_state| object.
 // Also blocks simultaneous user-level and system-level installs.  In the case
 // of trying to install user-level Chrome when system-level exists, the
 // existing system-level Chrome is launched.
 // When the pre-install conditions are not satisfied, the result is written to
 // the registry (via WriteInstallerResult), |status| is set appropriately, and
 // false is returned.
 bool CheckPreInstallConditions(const InstallationState& original_state,
+                               const CommandLine& cmd_line,
                                InstallerState* installer_state,
                                installer::InstallStatus* status) {
-  if (!CheckAppHostPreconditions(original_state, installer_state, status)) {
+  if (!CheckAppHostPreconditions(original_state, cmd_line, installer_state,
+                                 status)) {
     DCHECK_NE(*status, installer::UNKNOWN_STATUS);
     return false;
   }
 
   // See what products are already installed in multi mode.  When we do multi
   // installs, we must upgrade all installations since they share the binaries.
   AddExistingMultiInstalls(original_state, installer_state);
 
   if (!CheckMultiInstallConditions(original_state, installer_state, status)) {
     DCHECK_NE(*status, installer::UNKNOWN_STATUS);
@@ skipping 210 matching lines @@
             break;
         }
 
         installer_state.WriteInstallerResult(install_status, message_id, NULL);
       }
 
       proceed_with_installation =
           proceed_with_installation &&
           CheckGroupPolicySettings(original_state, installer_state,
                                    *installer_version, &install_status);
 

[erikwright (departed), 2012/09/21 14:08:49]

Put the Google Update installation here and set proceed_with_installation to
false if it fails.

Add a new error code for this in util_constants.h

[huangs, 2012/09/21 18:48:43]

Done.  Calling the flag INSTALL_OF_GOOGLE_UPDATE_FAILED (note that
GOOGLE_UPDATE_INSTALL_FAILED is ambiguous).

       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;
@@ skipping 84 matching lines @@
       }
       for (Products::const_iterator it = products.begin(); it < products.end();
            ++it) {
         const Product& product = **it;
         product.distribution()->LaunchUserExperiment(setup_path,
             install_status, *installer_version, product, system_install);
       }
     }
   }
 
+  // If Google Update is absent at user-level, install it using the installer
+  // from an existing system-level installation,
+  // This is for quick-enable App Host install from a system-level
+  // Chrome Binaries installation.
+  if (cmd_line.HasSwitch(installer::switches::kEnsureGoogleUpdateInstalled)) {

[grt (UTC plus 2), 2012/09/21 14:20:33]

if handling of this flag is general (not specific to the app host), i think it's
good to treat it as a best-effort thing in case someone adds this switch to a
normal "install Chrome" command line (it wouldn't be nice to blow up in that
case).  as such, what do you think of making the logic:
if (theNewSwitchIsPresent && isUserLevel) {
  if (!ensure...)
    LOG(ERROR) ...;
}
apologies for not suggesting this from the get-go.

[huangs, 2012/09/21 18:48:43]

Done.

+    DCHECK(!system_install);
+    if (!google_update::EnsureUserLevelGoogleUpdateInstalled())
+      LOG(ERROR) << "Failed to install Google Update";
+  }
+
   // Delete the master profile file if present. Note that we do not care about
   // rollback here and we schedule for deletion on reboot if the delete fails.
   // As such, we do not use DeleteTreeWorkItem.
   if (cmd_line.HasSwitch(installer::switches::kInstallerData)) {
     FilePath prefs_path(cmd_line.GetSwitchValuePath(
         installer::switches::kInstallerData));
     if (!file_util::Delete(prefs_path, true)) {
       LOG(ERROR) << "Failed deleting master preferences file "
                  << prefs_path.value()
                  << ", scheduling for deletion after reboot.";
@@ skipping 16 matching lines @@
   DCHECK(installer_state);
   const bool system_install = installer_state->system_install();
   installer::InstallStatus install_status = installer::UNKNOWN_STATUS;
   installer::ArchiveType archive_type = installer::UNKNOWN_ARCHIVE_TYPE;
   bool incremental_install = false;
   installer_state->UpdateStage(installer::PRECONDITIONS);
   // The stage provides more fine-grained information than -multifail, so remove
   // the -multifail suffix from the Google Update "ap" value.
   BrowserDistribution::GetSpecificDistribution(installer_state->state_type())->
       UpdateInstallStatus(system_install, archive_type, install_status);
-  if (CheckPreInstallConditions(original_state, installer_state,
+  if (CheckPreInstallConditions(original_state, cmd_line, installer_state,
                                 &install_status)) {
     VLOG(1) << "Installing to " << installer_state->target_path().value();
     install_status = InstallProductsHelper(
         original_state, cmd_line, prefs, *installer_state, &archive_type);
   } else {
     // CheckPreInstallConditions must set the status on failure.
     DCHECK_NE(install_status, installer::UNKNOWN_STATUS);
   }
 
   const Products& products = installer_state->products();
@@ skipping 25 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.
+  // Ignoring the return value: Success or failure of Google Update

[grt (UTC plus 2), 2012/09/21 14:20:33]

Ignoring -> Ignore, Success -> success

[huangs, 2012/09/21 18:48:43]

Done.

+  // 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;
 }