Add installer::SetupSingleton.

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 33 matching lines @@
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/setup/archive_patch_helper.h"
 #include "chrome/installer/setup/install.h"
 #include "chrome/installer/setup/install_worker.h"
 #include "chrome/installer/setup/installer_crash_reporting.h"
 #include "chrome/installer/setup/installer_metrics.h"
 #include "chrome/installer/setup/setup_constants.h"
+#include "chrome/installer/setup/setup_singleton.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/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"
@@ skipping 1018 matching lines @@
     LOG(ERROR) << "Path not found: " << chrome_exe.value();
     status = installer::INSTALL_FAILED;
   }
   return status;
 }
 
 // This method processes any command line options that make setup.exe do
 // various tasks other than installation (renaming chrome.exe, showing eula
 // among others). This function returns true if any such command line option
 // has been found and processed (so setup.exe should exit at that point).
-bool HandleNonInstallCmdLineOptions(const InstallationState& original_state,
-                                    const base::FilePath& setup_exe,
+bool HandleNonInstallCmdLineOptions(const base::FilePath& setup_exe,
                                     const base::CommandLine& cmd_line,
+                                    InstallationState* original_state,
                                     InstallerState* installer_state,
                                     int* exit_code) {
   // This option is independent of all others so doesn't belong in the if/else
   // block below.
   if (cmd_line.HasSwitch(installer::switches::kDelay)) {
     const std::string delay_seconds_string(
         cmd_line.GetSwitchValueASCII(installer::switches::kDelay));
     int delay_seconds;
     if (base::StringToInt(delay_seconds_string, &delay_seconds) &&
         delay_seconds > 0) {
@@ skipping 46 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.
     base::string16 inner_frame =
         cmd_line.GetSwitchValueNative(installer::switches::kShowEula);
     *exit_code = ShowEULADialog(inner_frame);
 
     if (installer::EULA_REJECTED != *exit_code) {
       if (GoogleUpdateSettings::SetEULAConsent(
-              original_state, BrowserDistribution::GetDistribution(), true)) {
+              *original_state, BrowserDistribution::GetDistribution(), true)) {
         CreateEULASentinel(BrowserDistribution::GetDistribution());
       }
       // For a metro-originated launch, we now need to launch back into metro.
       if (cmd_line.HasSwitch(installer::switches::kShowEulaForMetro))
         ActivateMetroChrome();
     }
   } else if (cmd_line.HasSwitch(installer::switches::kConfigureUserSettings)) {
     // NOTE: Should the work done here, on kConfigureUserSettings, change:
     // kActiveSetupVersion in install_worker.cc needs to be increased for Active
     // Setup to invoke this again for all users of this install.
     const Product* chrome_install =
         installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER);
     installer::InstallStatus status = installer::INVALID_STATE_FOR_OPTION;
     if (chrome_install && installer_state->system_install()) {
       bool force =
           cmd_line.HasSwitch(installer::switches::kForceConfigureUserSettings);
       installer::HandleActiveSetupForBrowser(installer_state->target_path(),
                                              *chrome_install, force);
       status = installer::INSTALL_REPAIRED;
     } else {
       LOG(DFATAL) << "chrome_install:" << chrome_install
                   << ", system_install:" << installer_state->system_install();
     }
     *exit_code = InstallUtil::GetInstallReturnCode(status);
   } else if (cmd_line.HasSwitch(installer::switches::kRegisterDevChrome)) {
     installer::InstallStatus status = RegisterDevChrome(
-        original_state, *installer_state, setup_exe, cmd_line);
+        *original_state, *installer_state, setup_exe, cmd_line);
     *exit_code = InstallUtil::GetInstallReturnCode(status);
   } 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
@@ skipping 32 matching lines @@
             chrome_exe, suffix, false))
           status = installer::IN_USE_UPDATED;
       }
     } else {
       LOG(DFATAL) << "Can't register browser - Chrome distribution not found";
     }
     *exit_code = InstallUtil::GetInstallReturnCode(status);
   } else if (cmd_line.HasSwitch(installer::switches::kRenameChromeExe)) {
     // If --rename-chrome-exe is specified, we want to rename the executables
     // and exit.
-    *exit_code = RenameChromeExecutables(original_state, installer_state);
+    std::unique_ptr<installer::SetupSingleton> setup_singleton(
+        installer::SetupSingleton::Acquire(
+            cmd_line, MasterPreferences::ForCurrentProcess(), installer_state,
+            original_state));
+    if (setup_singleton)
+      *exit_code = RenameChromeExecutables(*original_state, installer_state);
+    else
+      *exit_code = installer::SETUP_SINGLETON_ACQUISITION_FAILED;
   } else if (cmd_line.HasSwitch(
                  installer::switches::kRemoveChromeRegistration)) {
     // This is almost reverse of --register-chrome-browser option above.
     // Here we delete Chrome browser registration. This option should only
     // be used when setup.exe is launched with admin rights. We do not
     // make any user specific changes in this option.
     base::string16 suffix;
     if (cmd_line.HasSwitch(
             installer::switches::kRegisterChromeBrowserSuffix)) {
       suffix = cmd_line.GetSwitchValueNative(
@@ skipping 554 matching lines @@
   // the path service is the authoritative source for this path. One might think
   // that CommandLine::GetProgram would suffice, but it won't since
   // CreateProcess may have been called with a command line that is somewhat
   // ambiguous (e.g., an unquoted path with spaces, or a path lacking the file
   // extension), in which case CommandLineToArgv will not yield an argv with the
   // true path to the program at position 0.
   base::FilePath setup_exe;
   PathService::Get(base::FILE_EXE, &setup_exe);
 
   int exit_code = 0;
-  if (HandleNonInstallCmdLineOptions(
-          original_state, setup_exe, cmd_line, &installer_state, &exit_code)) {
+  if (HandleNonInstallCmdLineOptions(setup_exe, cmd_line, &original_state,
+                                     &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)) {
       base::CommandLine new_cmd(base::CommandLine::NO_PROGRAM);
       new_cmd.AppendArguments(cmd_line, true);
       // Append --run-as-admin flag to let the new instance of setup.exe know
       // that we already tried to launch ourselves as admin.
       new_cmd.AppendSwitch(installer::switches::kRunAsAdmin);
       // If system_install became true due to an environment variable, append
       // it to the command line here since env vars may not propagate past the
       // elevation.
       if (!new_cmd.HasSwitch(installer::switches::kSystemLevel))
         new_cmd.AppendSwitch(installer::switches::kSystemLevel);
 
       DWORD exit_code = installer::UNKNOWN_STATUS;
       InstallUtil::ExecuteExeAsAdmin(new_cmd, &exit_code);
       return exit_code;
     } else {
       LOG(ERROR) << "Non admin user can not install system level Chrome.";
       installer_state.WriteInstallerResult(installer::INSUFFICIENT_RIGHTS,
           IDS_INSTALL_INSUFFICIENT_RIGHTS_BASE, NULL);
       return installer::INSUFFICIENT_RIGHTS;
     }
   }
 
+  std::unique_ptr<installer::SetupSingleton> setup_singleton(
+      installer::SetupSingleton::Acquire(cmd_line, prefs, &installer_state,
+                                         &original_state));
+  if (!setup_singleton)
+    return installer::SETUP_SINGLETON_ACQUISITION_FAILED;

[grt (UTC plus 2), 2016/09/01 12:05:39]

please use WriteInstallerResult as well so that this error is reported through
Google Update's installer result API properly. i think there should also be a UI
string so that users see something like "Another operation on Google Chrome is
in progress; please try again later."

[fdoray, 2016/09/01 15:45:22]

Done.

When is the UI string shown? Users should see it when they try to manually
update Chrome but not when a --rename-chrome-exe is launched by Chrome.

Why don't we always write the installer result? e.g. installer::RENAME_FAILED is
not written
https://cs.chromium.org/chromium/src/chrome/installer/setup/setup_main.cc?l=415
Is it ok to write installer::SETUP_SINGLETON_ACQUISITION_FAILED from a
--rename-chrome-exe process like I did above?

[grt (UTC plus 2), 2016/09/01 21:22:41]

Google Update will show the string if the user is using an installer from the
dlapge (including a .msi) for either a same-version repair or an overinstall.
Chrome will show it in chrome://help if the user is doing an on-demand update.
Exactly. There is no UX for the rename dance.
No, don't do that. :-)  It only makes sense to write into the Google Update
"installer result api" values when the installer is being run by Google Update.
The rename dance is purely within Chrome. UMA is wonderful, though, so how about
a histogram for the timeout case there?

[fdoray, 2016/09/06 17:29:39]

Removed WriteInstallerResult for the --rename-chrome-exe case. Added UMA
histogram in setup_singleton.cc

+
   UninstallMultiChromeFrameIfPresent(cmd_line, prefs,
                                      &original_state, &installer_state);
 
   base::FilePath installer_directory;
   installer::InstallStatus install_status = installer::UNKNOWN_STATUS;
   // If --uninstall option is given, uninstall the identified product(s)
   if (is_uninstall) {
     install_status =
         UninstallProducts(original_state, installer_state, setup_exe, cmd_line);
   } else {
@@ skipping 36 matching lines @@
     // never invoked directly by Google Update.
     return_code = InstallUtil::GetInstallReturnCode(install_status);
   }
 
   installer::EndPersistentHistogramStorage(installer_state.target_path(),
                                            system_install);
   VLOG(1) << "Installation complete, returning: " << return_code;
 
   return return_code;
 }