Add support for --critical-update-version to installer.

chrome/installer/setup/install_worker.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.
 //
 // This file contains the definitions of the installer functions that build
 // the WorkItemList used to install the application.
 
 #include "chrome/installer/setup/install_worker.h"
 
 #include <shlobj.h>
@@ skipping 181 matching lines @@
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"NoRepair", static_cast<DWORD>(1),
                                          true);
 
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"Publisher",
                                          browser_dist->GetPublisherName(),
                                          true);
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"Version",
-                                         UTF8ToWide(new_version.GetString()),
+                                         ASCIIToWide(new_version.GetString()),
                                          true);
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"DisplayVersion",
-                                         UTF8ToWide(new_version.GetString()),
+                                         ASCIIToWide(new_version.GetString()),
                                          true);
     install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
                                          L"InstallDate",
                                          InstallUtil::GetCurrentDate(),
                                          false);
   }
 }
 
 // Add uninstall-related work items for multi-install scenarios.
 void AddMultiUninstallWorkItems(const InstallerState& installer_state,
@@ skipping 30 matching lines @@
 
   std::wstring product_name(dist->GetAppShortCutName());
   list->AddSetRegValueWorkItem(root, version_key, google_update::kRegNameField,
                                product_name, true);  // overwrite name also
   list->AddSetRegValueWorkItem(root, version_key,
                                google_update::kRegOopcrashesField,
                                static_cast<DWORD>(1),
                                false);  // set during first install
   list->AddSetRegValueWorkItem(root, version_key,
                                google_update::kRegVersionField,
-                               UTF8ToWide(new_version.GetString()),
+                               ASCIIToWide(new_version.GetString()),
                                true);  // overwrite version
 }
 
 void AddProductSpecificWorkItems(const InstallationState& original_state,
                                  const InstallerState& installer_state,
                                  const FilePath& setup_path,
                                  const Version& new_version,
                                  WorkItemList* list) {
   const Products& products = installer_state.products();
   for (size_t i = 0; i < products.size(); ++i) {
@@ skipping 272 matching lines @@
                             const Version* current_version,
                             const Version& new_version,
                             const FilePath& temp_path,
                             WorkItemList* post_install_task_list) {
   DCHECK(post_install_task_list);
 
   HKEY root = installer_state.root_key();
   const Products& products = installer_state.products();
 
   // Append work items that will only be executed if this was an update.
-  // We update the 'opv' key with the current version that is active and 'cmd'
-  // key with the rename command to run.
+  // We update the 'opv' value with the current version that is active,
+  // the 'cpv' value with the critical update version (if present), and the
+  // 'cmd' value with the rename command to run.
   {
     scoped_ptr<WorkItemList> in_use_update_work_items(
         WorkItem::CreateConditionalWorkItemList(
             new ConditionRunIfFileExists(new_chrome_exe)));
     in_use_update_work_items->set_log_message("InUseUpdateWorkItemList");
 
+    // An invalid version if this in-use update doesn't contain a critical
+    // update relative to the version being updated.

[Finnur, 2011/11/11 10:31:01]

Is there a word missing or something from this comment? I can't make heads nor
tails of it.

[grt (UTC plus 2), 2011/11/11 11:40:08]

Uh, yeah . Updated.

+    Version critical_version(installer_state.DetermineCriticalVersion(
+        current_version, new_version));
     FilePath installer_path(installer_state.GetInstallerDirectory(new_version)
         .Append(setup_path.BaseName()));
 
     CommandLine rename(installer_path);
     rename.AppendSwitch(switches::kRenameChromeExe);
     if (installer_state.system_install())
       rename.AppendSwitch(switches::kSystemLevel);
 
     if (installer_state.verbose_logging())
       rename.AppendSwitch(switches::kVerboseLogging);
 
     std::wstring version_key;
     for (size_t i = 0; i < products.size(); ++i) {
       BrowserDistribution* dist = products[i]->distribution();
       version_key = dist->GetVersionKey();
 
       if (current_version != NULL) {
         in_use_update_work_items->AddSetRegValueWorkItem(root, version_key,
             google_update::kRegOldVersionField,
-            UTF8ToWide(current_version->GetString()), true);
+            ASCIIToWide(current_version->GetString()), true);
+      }
+      if (critical_version.IsValid()) {
+        in_use_update_work_items->AddSetRegValueWorkItem(root, version_key,
+            google_update::kRegCriticalVersionField,
+            ASCIIToWide(critical_version.GetString()), true);
+      } else {
+        in_use_update_work_items->AddDeleteRegValueWorkItem(root, version_key,
+            google_update::kRegCriticalVersionField);
       }
 
       // Adding this registry entry for all products is overkill.
       // However, as it stands, we don't have a way to know which distribution
       // will check the key and run the command, so we add it for all.  The
       // first to run it will perform the operation and clean up the other
       // values.
       CommandLine product_rename_cmd(rename);
       products[i]->AppendRenameFlags(&product_rename_cmd);
       in_use_update_work_items->AddSetRegValueWorkItem(
-          root,
-          version_key,
-          google_update::kRegRenameCmdField,
-          product_rename_cmd.GetCommandLineString(),
-          true);
+          root, version_key, google_update::kRegRenameCmdField,
+          product_rename_cmd.GetCommandLineString(), true);
     }
 
     if (current_version != NULL && installer_state.is_multi_install()) {
       BrowserDistribution* dist =
           installer_state.multi_package_binaries_distribution();
+      version_key = dist->GetVersionKey();
       in_use_update_work_items->AddSetRegValueWorkItem(
-          root,
-          dist->GetVersionKey(),
-          google_update::kRegOldVersionField,
-          UTF8ToWide(current_version->GetString()),
-          true);
+          root, version_key, google_update::kRegOldVersionField,
+          ASCIIToWide(current_version->GetString()), true);
+      if (critical_version.IsValid()) {
+        in_use_update_work_items->AddSetRegValueWorkItem(
+            root, version_key, google_update::kRegCriticalVersionField,
+            ASCIIToWide(critical_version.GetString()), true);
+      } else {
+        in_use_update_work_items->AddDeleteRegValueWorkItem(
+            root, version_key, google_update::kRegCriticalVersionField);
+      }
       // TODO(tommi): We should move the rename command here. We also need to
       // update upgrade_utils::SwapNewChromeExeIfPresent.
     }
 
     if (installer_state.FindProduct(BrowserDistribution::CHROME_FRAME)) {
       AddCopyIELowRightsPolicyWorkItems(installer_state,
                                         in_use_update_work_items.get());
     }
 
     post_install_task_list->AddWorkItem(in_use_update_work_items.release());
   }
 
   // Append work items that will be executed if this was NOT an in-use update.
   {
     scoped_ptr<WorkItemList> regular_update_work_items(
         WorkItem::CreateConditionalWorkItemList(
             new Not(new ConditionRunIfFileExists(new_chrome_exe))));
     regular_update_work_items->set_log_message("RegularUpdateWorkItemList");
 
-    // Since this was not an in-use-update, delete 'opv' and 'cmd' keys.
+    // Since this was not an in-use-update, delete 'opv', 'cpv', and 'cmd' keys.
     for (size_t i = 0; i < products.size(); ++i) {
       BrowserDistribution* dist = products[i]->distribution();
       std::wstring version_key(dist->GetVersionKey());
       regular_update_work_items->AddDeleteRegValueWorkItem(root, version_key,
-                                            google_update::kRegOldVersionField);
+          google_update::kRegOldVersionField);
       regular_update_work_items->AddDeleteRegValueWorkItem(root, version_key,
-                                            google_update::kRegRenameCmdField);
+          google_update::kRegCriticalVersionField);
+      regular_update_work_items->AddDeleteRegValueWorkItem(root, version_key,
+          google_update::kRegRenameCmdField);
     }
 
     if (installer_state.FindProduct(BrowserDistribution::CHROME_FRAME)) {
       AddDeleteOldIELowRightsPolicyWorkItems(installer_state,
                                              regular_update_work_items.get());
     }
 
     post_install_task_list->AddWorkItem(regular_update_work_items.release());
   }
 
@@ skipping 578 matching lines @@
     } else {
       DCHECK(operation == REMOVE_COMMAND);
       work_item_list->AddDeleteRegKeyWorkItem(installer_state.root_key(),
                                               cmd_key)->set_log_message(
           "removing quick-enable-cf command");
     }
   }
 }
 
 }  // namespace installer