Update Chrome's Active Setup version per component instead of as a single string.

chrome/installer/setup/install_worker.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.
 //
 // 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 <oaidl.h>
 #include <shlobj.h>
 #include <time.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
+#include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/version.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/setup/app_launcher_installer.h"
 #include "chrome/installer/setup/install.h"
@@ skipping 17 matching lines @@
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/installer/util/work_item_list.h"
 
 using base::ASCIIToUTF16;
 using base::win::RegKey;
 
 namespace installer {
 
 namespace {
 
-// The version identifying the work done by setup.exe --configure-user-settings
-// on user login by way of Active Setup.  Increase this value if the work done
-// in setup_main.cc's handling of kConfigureUserSettings changes and should be
-// executed again for all users.
-const wchar_t kActiveSetupVersion[] = L"43,0,0,0";
-
 // Although the UUID of the ChromeFrame class is used for the "current" value,
 // this is done only as a convenience; there is no need for the GUID of the Low
 // Rights policies to match the ChromeFrame class's GUID.  Hence, it is safe to
 // use this completely unrelated GUID for the "old" policies.
 const wchar_t kIELowRightsPolicyOldGuid[] =
     L"{6C288DD7-76FB-4721-B628-56FAC252E199}";
 
 const wchar_t kElevationPolicyKeyPath[] =
     L"SOFTWARE\\Microsoft\\Internet Explorer\\Low Rights\\ElevationPolicy\\";
 
@@ skipping 458 matching lines @@
     scoped_ptr<WorkItemList> no_rollback_list(
         WorkItem::CreateNoRollbackWorkItemList());
     AddUninstallDelegateExecuteWorkItems(
         HKEY_CURRENT_USER, google_chrome_delegate_execute_path,
         no_rollback_list.get());
     list->AddWorkItem(no_rollback_list.release());
     VLOG(1) << "Added deletion items for bad Canary registrations.";
   }
 }
 
+// Returns the version to be used for Active Setup as MM,XX,YY,ZZ where MM is
+// |kActiveSetupMajorVersion| and other components may be updated in various
+// situations. At this point YY represents the number of on-os-upgrade that were
+// handled by this installation and XX/ZZ are unused.
+base::string16 GetActiveSetupVersionFromExisting(
+    const base::string16& existing_version) {
+  // The major version and first component of the version identifying the work
+  // done by setup.exe --configure-user-settings on user login by way of Active
+  // Setup.  Increase this value if the work done in setup_main.cc's handling of
+  // kConfigureUserSettings changes and should be executed again for all users.
+  const base::char16 kActiveSetupMajorVersion[] = L"43";
+
+  std::vector<base::string16> version_components = base::SplitString(
+      existing_version, L",", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+
+  // If |existing_version| was empty or otherwise corrupted, turn it into a
+  // valid one.
+  if (version_components.size() != 4U)
+    version_components.assign(4U, L"0");
+
+  // Unconditionally update the major version.
+  version_components[0] = kActiveSetupMajorVersion;
+
+  return JoinString(version_components, L',');
+}
+
 }  // namespace
 
 // This method adds work items to create (or update) Chrome uninstall entry in
 // either the Control Panel->Add/Remove Programs list or in the Omaha client
 // state key if running under an MSI installer.
 void AddUninstallShortcutWorkItems(const InstallerState& installer_state,
                                    const base::FilePath& setup_path,
                                    const Version& new_version,
                                    const Product& product,
                                    WorkItemList* install_list) {
@@ skipping 680 matching lines @@
     AddVersionKeyWorkItems(root,
                            dist->GetVersionKey(),
                            dist->GetDisplayName(),
                            new_version,
                            add_language_identifier,
                            install_list);
 
     AddDelegateExecuteWorkItems(installer_state, target_path, new_version,
                                 product, install_list);
 
-    AddActiveSetupWorkItems(installer_state, setup_path, new_version, product,
+    AddActiveSetupWorkItems(installer_state, new_version, product,
                             install_list);
   }
 
   // Ensure that the Clients key for the binaries is gone for single installs
   // (but not for SxS Chrome).
   if (!installer_state.is_multi_install() &&
       !InstallUtil::IsChromeSxSProcess()) {
     BrowserDistribution* binaries_dist =
         BrowserDistribution::GetSpecificDistribution(
             BrowserDistribution::CHROME_BINARIES);
@@ skipping 137 matching lines @@
                                  L"ServerExecutable",
                                  delegate_execute.value(),
                                  true);
 
     subkey.assign(delegate_execute_path).append(L"\\Programmable");
     list->AddCreateRegKeyWorkItem(root, subkey, WorkItem::kWow64Default);
   }
 }
 
 void AddActiveSetupWorkItems(const InstallerState& installer_state,
-                             const base::FilePath& setup_path,
                              const Version& new_version,
                              const Product& product,
                              WorkItemList* list) {
   DCHECK(installer_state.operation() != InstallerState::UNINSTALL);
   BrowserDistribution* dist = product.distribution();
 
   if (!product.is_chrome() || !installer_state.system_install()) {
     const char* install_level =
         installer_state.system_install() ? "system" : "user";
     VLOG(1) << "No Active Setup processing to do for " << install_level
@@ skipping 42 matching lines @@
                                active_setup_path,
                                WorkItem::kWow64Default,
                                L"IsInstalled",
                                static_cast<DWORD>(1U),
                                true);
 
   list->AddSetRegValueWorkItem(root,
                                active_setup_path,
                                WorkItem::kWow64Default,
                                L"Version",
-                               kActiveSetupVersion,
-                               true);
+                               base::Bind(&GetActiveSetupVersionFromExisting));
 }
 
 void AddDeleteOldIELowRightsPolicyWorkItems(
     const InstallerState& installer_state,
     WorkItemList* install_list) {
   DCHECK(install_list);
 
   base::string16 key_path;
   GetOldIELowRightsElevationPolicyKeyPath(&key_path);
   install_list->AddDeleteRegKeyWorkItem(
@@ skipping 84 matching lines @@
   // Unconditionally remove the legacy Quick Enable command from the binaries.
   // Do this even if multi-install Chrome isn't installed to ensure that it is
   // not left behind in any case.
   work_item_list->AddDeleteRegKeyWorkItem(
                       installer_state.root_key(), cmd_key, KEY_WOW64_32KEY)
       ->set_log_message("removing " + base::UTF16ToASCII(kCmdQuickEnableCf) +
                         " command");
 }
 
 }  // namespace installer