Write installer results in all relevant registry keys so that we're sure that Google Update will ...

chrome/installer/setup/setup_main.cc

 // Copyright (c) 2011 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 <string>
@@ skipping 294 matching lines @@
           VLOG(1) << "Performing initial install of Chrome Frame ready-mode.";
         }
       }
     } else if (chrome_frame != NULL) {
       // We're being asked to install or update Chrome Frame alone.
       const ProductState* chrome_state =
           original_state.GetProductState(system_level,
                                          BrowserDistribution::CHROME_BROWSER);
       if (chrome_state != NULL) {
         // Chrome Frame may not yet be installed if this is a first install, so
-        // use InstallationState's GetNonVersionedProductState() which will lets
-        // us access the ap value from the partially constructed product state.
+        // use InstallationState's GetNonVersionedProductState() which lets us
+        // access the ap value from the partially constructed product state.
         // There will be no value if we're not being managed by Google Update.
         const ProductState* cf_non_versioned_state =
             original_state.GetNonVersionedProductState(
                 system_level, BrowserDistribution::CHROME_FRAME);
         DCHECK(cf_non_versioned_state);
         const installer::ChannelInfo& cf_channel(
             cf_non_versioned_state->channel());
 
         // Fail if Chrome is already installed but is on a different update
         // channel.
         if (!cf_channel.EqualsBaseOf(chrome_state->channel())) {
           LOG(ERROR) << "Cannot install Chrome Frame because existing Chrome "
                         "install is on a different update channel.";
           *status = installer::CONFLICTING_CHANNEL_EXISTS;
-          InstallUtil::WriteInstallerResult(system_level,
-              installer_state->state_key(), *status,
+          installer_state->WriteInstallerResult(*status,
               IDS_INSTALL_CONFLICTING_CHANNEL_EXISTS_BASE, NULL);
           return false;
         }
         // Otherwise, 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 multi-install Chrome browser along with "
                 << chrome_frame->distribution()->GetApplicationName();
       } else if (chrome_frame->HasOption(installer::kOptionReadyMode)) {
         // Chrome Frame with ready-mode is to be installed, yet Chrome is
         // neither installed nor being installed.  Fail.
         LOG(ERROR) << "Cannot install Chrome Frame in ready mode without "
                       "Chrome.";
         *status = installer::READY_MODE_REQUIRES_CHROME;
-        InstallUtil::WriteInstallerResult(system_level,
-            installer_state->state_key(), *status,
+        installer_state->WriteInstallerResult(*status,
             IDS_INSTALL_READY_MODE_REQUIRES_CHROME_BASE, NULL);
         return false;
       }
     }
 
     // Fail if we're installing Chrome Frame when a single-install of it is
     // already installed.
     // TODO(grt): Add support for migration of Chrome Frame from single- to
     // multi-install.
     if (chrome_frame != NULL &&
         cf_state != NULL && !cf_state->is_multi_install()) {
       LOG(ERROR) << "Cannot migrate existing Chrome Frame installation to "
                     "multi-install.";
       *status = installer::NON_MULTI_INSTALLATION_EXISTS;
-      InstallUtil::WriteInstallerResult(system_level,
-          installer_state->state_key(), *status,
+      installer_state->WriteInstallerResult(*status,
           IDS_INSTALL_NON_MULTI_INSTALLATION_EXISTS_BASE, NULL);
       return false;
     }
   } else if (DCHECK_IS_ON()) {
     // It isn't possible to stuff two products into a single-install
     // InstallerState.  Abort the process here in debug builds just in case
     // someone finds a way.
     DCHECK_EQ(1U, products.size());
   }
 
@@ skipping 29 matching lines @@
     const ProductState* product_state =
         original_state.GetProductState(system_level, browser_dist->GetType());
     if (product_state != NULL) {
       is_first_install = false;
       // Block downgrades from multi-install to single-install.
       if (!installer_state->is_multi_install() &&
           product_state->is_multi_install()) {
         LOG(ERROR) << "Multi-install " << browser_dist->GetApplicationName()
                    << " exists; aborting single install.";
         *status = installer::MULTI_INSTALLATION_EXISTS;
-        InstallUtil::WriteInstallerResult(system_level,
-            installer_state->state_key(), *status,
+        installer_state->WriteInstallerResult(*status,
             IDS_INSTALL_MULTI_INSTALLATION_EXISTS_BASE, NULL);
         return false;
       }
     }
 
     // Check to avoid attempting to lay down a user-level installation on top
     // of a system-level one.
     const ProductState* other_state =
         original_state.GetProductState(!system_level, browser_dist->GetType());
     if (other_state != NULL && !system_level) {
       LOG(ERROR) << "Already installed version "
                  << other_state->version().GetString()
                  << " conflicts with the current install mode.";
       if (is_first_install && product->is_chrome()) {
         // This is user-level install and there is a system-level chrome
         // installation. Instruct Google Update to launch the existing one.
         // There should be no error dialog.
         FilePath chrome_exe(installer::GetChromeInstallPath(!system_level,
                                                             browser_dist));
         if (chrome_exe.empty()) {
           // If we failed to construct install path. Give up.
           *status = installer::OS_ERROR;
-          InstallUtil::WriteInstallerResult(system_level,
-                                            installer_state->state_key(),
-                                            *status,
-                                            IDS_INSTALL_OS_ERROR_BASE,
-                                            NULL);
+          installer_state->WriteInstallerResult(*status,
+              IDS_INSTALL_OS_ERROR_BASE, NULL);
         } else {
           *status = installer::EXISTING_VERSION_LAUNCHED;
           chrome_exe = chrome_exe.Append(installer::kChromeExe);
           CommandLine cmd(chrome_exe);
           cmd.AppendSwitch(switches::kFirstRun);
-          InstallUtil::WriteInstallerResult(system_level,
-              installer_state->state_key(), *status, 0, NULL);
+          installer_state->WriteInstallerResult(*status, 0, NULL);
           VLOG(1) << "Launching existing system-level chrome instead.";
           base::LaunchApp(cmd, false, false, NULL);
         }
         return false;
       }
 
       // This is an update, not an install. Omaha should know the difference
       // and not show a dialog.
       *status = installer::SYSTEM_LEVEL_INSTALL_EXISTS;
-      InstallUtil::WriteInstallerResult(system_level,
-                                        installer_state->state_key(),
-                                        *status,
-                                        IDS_INSTALL_SYSTEM_LEVEL_EXISTS_BASE,
-                                        NULL);
+      installer_state->WriteInstallerResult(*status,
+          IDS_INSTALL_SYSTEM_LEVEL_EXISTS_BASE, NULL);
       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 no previous installation of Chrome, make sure installation directory
   // either does not exist or can be deleted (i.e. is not locked by some other
   // process).
   if (is_first_install) {
     if (file_util::PathExists(installer_state->target_path()) &&
         !file_util::Delete(installer_state->target_path(), true)) {
       LOG(ERROR) << "Installation directory "
                  << installer_state->target_path().value()
                  << " exists and can not be deleted.";
       *status = installer::INSTALL_DIR_IN_USE;
       int str_id = IDS_INSTALL_DIR_IN_USE_BASE;
-      InstallUtil::WriteInstallerResult(system_level,
-          installer_state->state_key(), *status, str_id, NULL);
+      installer_state->WriteInstallerResult(*status, str_id, NULL);
       return false;
     }
   }
 
   return true;
 }
 
 installer::InstallStatus InstallProductsHelper(
     const InstallationState& original_state,
     const CommandLine& cmd_line,
@@ skipping 16 matching lines @@
   }
   VLOG(1) << "Archive found to install Chrome " << archive.value();
   const Products& products = installer_state.products();
 
   // Create a temp folder where we will unpack Chrome archive. If it fails,
   // then we are doomed, so return immediately and no cleanup is required.
   installer::SelfCleaningTempDir temp_path;
   if (!temp_path.Initialize(installer_state.target_path().DirName(),
                             installer::kInstallTempDir)) {
     PLOG(ERROR) << "Could not create temporary path.";
-    InstallUtil::WriteInstallerResult(system_install,
-        installer_state.state_key(), installer::TEMP_DIR_FAILED,
+    installer_state.WriteInstallerResult(installer::TEMP_DIR_FAILED,
         IDS_INSTALL_TEMP_DIR_FAILED_BASE, NULL);
     return installer::TEMP_DIR_FAILED;
   }
   VLOG(1) << "created path " << temp_path.path().value();
 
   FilePath unpack_path(temp_path.path().Append(installer::kInstallSourceDir));
   if (UnPackArchive(archive, installer_state, temp_path.path(), unpack_path,
                     archive_type)) {
     install_status = (*archive_type) == installer::INCREMENTAL_ARCHIVE_TYPE ?
         installer::APPLY_DIFF_PATCH_FAILED : installer::UNCOMPRESSION_FAILED;
-    InstallUtil::WriteInstallerResult(system_install,
-        installer_state.state_key(), install_status,
+    installer_state.WriteInstallerResult(install_status,
         IDS_INSTALL_UNCOMPRESSION_FAILED_BASE, NULL);
   } else {
     VLOG(1) << "unpacked to " << unpack_path.value();
     FilePath src_path(unpack_path.Append(installer::kInstallSourceChromeDir));
     scoped_ptr<Version>
         installer_version(installer::GetMaxVersionFromArchiveDir(src_path));
     if (!installer_version.get()) {
       LOG(ERROR) << "Did not find any valid version in installer.";
       install_status = installer::INVALID_ARCHIVE;
-      InstallUtil::WriteInstallerResult(system_install,
-          installer_state.state_key(), install_status,
+      installer_state.WriteInstallerResult(install_status,
           IDS_INSTALL_INVALID_ARCHIVE_BASE, NULL);
     } else {
       // TODO(tommi): Move towards having only a single version that is common
       // to all products.  Only the package should have a version since it
       // represents all the binaries.  When a single product is upgraded, all
       // currently installed product for the shared binary installation, should
       // (or rather must) be upgraded.
       VLOG(1) << "version to install: " << installer_version->GetString();
       bool higher_version_installed = false;
       for (size_t i = 0; i < installer_state.products().size(); ++i) {
         const Product* product = installer_state.products()[i];
         const ProductState* product_state =
             original_state.GetProductState(system_install,
                                            product->distribution()->GetType());
         if (product_state != NULL &&
             (product_state->version().CompareTo(*installer_version) > 0)) {
           LOG(ERROR) << "Higher version is already installed.";
           higher_version_installed = true;
           install_status = installer::HIGHER_VERSION_EXISTS;
 
           if (product->is_chrome()) {
             // TODO(robertshield): We should take the installer result text
             // strings from the Product.
-            InstallUtil::WriteInstallerResult(system_install,
-                installer_state.state_key(), install_status,
+            installer_state.WriteInstallerResult(install_status,
                 IDS_INSTALL_HIGHER_VERSION_BASE, NULL);
           } else {
-            InstallUtil::WriteInstallerResult(system_install,
-                installer_state.state_key(), install_status,
+            installer_state.WriteInstallerResult(install_status,
                 IDS_INSTALL_HIGHER_VERSION_CF_BASE, NULL);
           }
         }
       }
 
       if (!higher_version_installed) {
         // We want to keep uncompressed archive (chrome.7z) that we get after
         // uncompressing and binary patching. Get the location for this file.
         FilePath archive_to_copy(
             temp_path.path().Append(installer::kChromeArchive));
@@ skipping 37 matching lines @@
           prefs.GetBool(
               installer::master_preferences::kDoNotRegisterForUpdateLaunch,
               &value);
         } else {
           value = true;  // Never register.
         }
 
         bool write_chrome_launch_string = (!value) &&
             (install_status != installer::IN_USE_UPDATED);
 
-        InstallUtil::WriteInstallerResult(system_install,
-            installer_state.state_key(), install_status, install_msg_base,
+        installer_state.WriteInstallerResult(install_status, install_msg_base,
             write_chrome_launch_string ? &chrome_exe : NULL);
 
         if (install_status == installer::FIRST_INSTALL_SUCCESS) {
           VLOG(1) << "First install successful.";
           if (chrome_install) {
             // We never want to launch Chrome in system level install mode.
             bool do_not_launch_chrome = false;
             prefs.GetBool(
                 installer::master_preferences::kDoNotLaunchChrome,
                 &do_not_launch_chrome);
@@ skipping 182 matching lines @@
         // the Windows last-error code.
         LOG(WARNING) << "Scheduling temporary path " << temp_path.path().value()
                      << " for deletion at reboot.";
         ScheduleDirectoryForDeletion(temp_path.path().value().c_str());
       }
     }
 
     *exit_code = InstallUtil::GetInstallReturnCode(status);
     if (*exit_code) {
       LOG(WARNING) << "setup.exe patching failed.";
-      InstallUtil::WriteInstallerResult(installer_state->system_install(),
-          installer_state->state_key(), status, IDS_SETUP_PATCH_FAILED_BASE,
+      installer_state->WriteInstallerResult(status, IDS_SETUP_PATCH_FAILED_BASE,
           NULL);
     }
   } 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.
     std::wstring inner_frame =
         cmd_line.GetSwitchValueNative(installer::switches::kShowEula);
     *exit_code = ShowEULADialog(inner_frame);
     if (installer::EULA_REJECTED != *exit_code)
       GoogleUpdateSettings::SetEULAConsent(*installer_state, true);
@@ skipping 252 matching lines @@
   original_state.Initialize();
 
   InstallerState installer_state;
   installer_state.Initialize(cmd_line, prefs, original_state);
   const bool is_uninstall = cmd_line.HasSwitch(installer::switches::kUninstall);
 
   // Check to make sure current system is WinXP or later. If not, log
   // error message and get out.
   if (!InstallUtil::IsOSSupported()) {
     LOG(ERROR) << "Chrome only supports Windows XP or later.";
-    InstallUtil::WriteInstallerResult(system_install,
-        installer_state.state_key(), installer::OS_NOT_SUPPORTED,
+    installer_state.WriteInstallerResult(installer::OS_NOT_SUPPORTED,
         IDS_INSTALL_OS_NOT_SUPPORTED_BASE, NULL);
     return installer::OS_NOT_SUPPORTED;
   }
 
   // Initialize COM for use later.
   AutoCom auto_com;
   if (!auto_com.Init(system_install)) {
-    InstallUtil::WriteInstallerResult(system_install,
-        installer_state.state_key(), installer::OS_ERROR,
+    installer_state.WriteInstallerResult(installer::OS_ERROR,
         IDS_INSTALL_OS_ERROR_BASE, NULL);
     return installer::OS_ERROR;
   }
 
   // Some command line options don't work with SxS install/uninstall
   if (InstallUtil::IsChromeSxSProcess()) {
     if (system_install ||
         prefs.is_multi_install() ||
         cmd_line.HasSwitch(installer::switches::kForceUninstall) ||
         cmd_line.HasSwitch(installer::switches::kMakeChromeDefault) ||
@@ skipping 18 matching lines @@
       CommandLine new_cmd(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);
       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.";
-      InstallUtil::WriteInstallerResult(system_install,
-          installer_state.state_key(), installer::INSUFFICIENT_RIGHTS,
+      installer_state.WriteInstallerResult(installer::INSUFFICIENT_RIGHTS,
           IDS_INSTALL_INSUFFICIENT_RIGHTS_BASE, NULL);
       return installer::INSUFFICIENT_RIGHTS;
     }
   }
 
   installer::InstallStatus install_status = installer::UNKNOWN_STATUS;
   // If --uninstall option is given, uninstall the identified product(s)
   if (is_uninstall) {
     const Products& products = installer_state.products();
     // InstallerState::Initialize always puts Chrome first, and we rely on that
@@ skipping 55 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;
 }