Consistently use namespaced base::Version in chrome/installer.

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>
@@ skipping 64 matching lines @@
   key_path->assign(kElevationPolicyKeyPath,
                    arraysize(kElevationPolicyKeyPath) - 1);
   key_path->append(kIELowRightsPolicyOldGuid,
                    arraysize(kIELowRightsPolicyOldGuid)- 1);
 }
 
 // Local helper to call AddRegisterComDllWorkItems for all DLLs in a set of
 // products managed by a given package.
 // |old_version| can be NULL to indicate no Chrome is currently installed.
 void AddRegisterComDllWorkItemsForPackage(const InstallerState& installer_state,
-                                          const Version* old_version,
-                                          const Version& new_version,
+                                          const base::Version* old_version,
+                                          const base::Version& new_version,
                                           WorkItemList* work_item_list) {
   // First collect the list of DLLs to be registered from each product.
   std::vector<base::FilePath> com_dll_list;
   installer_state.AddComDllList(&com_dll_list);
 
   // Then, if we got some, attempt to unregister the DLLs from the old
   // version directory and then re-register them in the new one.
   // Note that if we are migrating the install directory then we will not
   // successfully unregister the old DLLs.
   // TODO(robertshield): See whether we need to fix the migration case.
@@ skipping 21 matching lines @@
                                           true,   // Register
                                           false,  // Must succeed.
                                           work_item_list);
   }
 }
 
 void AddInstallerCopyTasks(const InstallerState& installer_state,
                            const base::FilePath& setup_path,
                            const base::FilePath& archive_path,
                            const base::FilePath& temp_path,
-                           const Version& new_version,
+                           const base::Version& new_version,
                            WorkItemList* install_list) {
   DCHECK(install_list);
   base::FilePath installer_dir(
       installer_state.GetInstallerDirectory(new_version));
   install_list->AddCreateDirWorkItem(installer_dir);
 
   base::FilePath exe_dst(installer_dir.Append(setup_path.BaseName()));
 
   if (exe_dst != setup_path) {
     install_list->AddCopyTreeWorkItem(setup_path.value(), exe_dst.value(),
@@ skipping 82 matching lines @@
       base::Bind(&AddFirewallRulesCallback,
                  installer_state.system_install(),
                  dist,
                  installer_state.target_path().Append(kChromeExe),
                  is_new_install));
 }
 
 void AddProductSpecificWorkItems(const InstallationState& original_state,
                                  const InstallerState& installer_state,
                                  const base::FilePath& setup_path,
-                                 const Version& new_version,
-                                 const Version* current_version,
+                                 const base::Version& new_version,
+                                 const base::Version* current_version,
                                  bool add_language_identifier,
                                  WorkItemList* list) {
   const Products& products = installer_state.products();
   for (Products::const_iterator it = products.begin(); it < products.end();
        ++it) {
     const Product& p = **it;
     if (p.is_chrome()) {
       AddOsUpgradeWorkItems(installer_state, setup_path, new_version, p,
                             list);
       AddFirewallRulesWorkItems(installer_state, p.distribution(),
@@ skipping 35 matching lines @@
 }
 
 // Adds Chrome specific install work items to |install_list|.
 // |current_version| can be NULL to indicate no Chrome is currently installed.
 void AddChromeWorkItems(const InstallationState& original_state,
                         const InstallerState& installer_state,
                         const base::FilePath& setup_path,
                         const base::FilePath& archive_path,
                         const base::FilePath& src_path,
                         const base::FilePath& temp_path,
-                        const Version* current_version,
-                        const Version& new_version,
+                        const base::Version* current_version,
+                        const base::Version& new_version,
                         WorkItemList* install_list) {
   const base::FilePath& target_path = installer_state.target_path();
 
   if (current_version) {
     // Delete the archive from an existing install to save some disk space.
     base::FilePath old_installer_dir(
         installer_state.GetInstallerDirectory(*current_version));
     base::FilePath old_archive(
         old_installer_dir.Append(installer::kChromeArchive));
     // Don't delete the archive that we are actually installing from.
@@ skipping 105 matching lines @@
   }
 }
 
 }  // 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 base::Version& new_version,
                                    const Product& product,
                                    WorkItemList* install_list) {
   HKEY reg_root = installer_state.root_key();
   BrowserDistribution* browser_dist = product.distribution();
   DCHECK(browser_dist);
 
   // When we are installed via an MSI, we need to store our uninstall strings
   // in the Google Update client state key. We do this even for non-MSI
   // managed installs to avoid breaking the edge case whereby an MSI-managed
   // install is updated by a non-msi installer (which would confuse the MSI
@@ skipping 125 matching lines @@
           true);
     }
   }
 }
 
 // Create Version key for a product (if not already present) and sets the new
 // product version as the last step.
 void AddVersionKeyWorkItems(HKEY root,
                             const base::string16& version_key,
                             const base::string16& product_name,
-                            const Version& new_version,
+                            const base::Version& new_version,
                             bool add_language_identifier,
                             WorkItemList* list) {
   list->AddCreateRegKeyWorkItem(root, version_key, KEY_WOW64_32KEY);
 
   list->AddSetRegValueWorkItem(root,
                                version_key,
                                KEY_WOW64_32KEY,
                                google_update::kRegNameField,
                                product_name,
                                true);  // overwrite name also
@@ skipping 316 matching lines @@
       installer_state.root_key(),
       chrome_product->distribution()->GetStateKey(),
       KEY_WOW64_32KEY,
       google_update::kRegUsageStatsField,
       usagestats,
       true);
 }
 
 bool AppendPostInstallTasks(const InstallerState& installer_state,
                             const base::FilePath& setup_path,
-                            const Version* current_version,
-                            const Version& new_version,
+                            const base::Version* current_version,
+                            const base::Version& new_version,
                             WorkItemList* post_install_task_list) {
   DCHECK(post_install_task_list);
 
   HKEY root = installer_state.root_key();
   const Products& products = installer_state.products();
   base::FilePath new_chrome_exe(
       installer_state.target_path().Append(installer::kChromeNewExe));
 
   // Append work items that will only be executed if this was an update.
   // 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.
   {
     std::unique_ptr<WorkItemList> in_use_update_work_items(
         WorkItem::CreateConditionalWorkItemList(
             new ConditionRunIfFileExists(new_chrome_exe)));
     in_use_update_work_items->set_log_message("InUseUpdateWorkItemList");
 
     // |critical_version| will be valid only if this in-use update includes a
     // version considered critical relative to the version being updated.
-    Version critical_version(installer_state.DetermineCriticalVersion(
+    base::Version critical_version(installer_state.DetermineCriticalVersion(
         current_version, new_version));
     base::FilePath installer_path(
         installer_state.GetInstallerDirectory(new_version).Append(
             setup_path.BaseName()));
 
     base::CommandLine rename(installer_path);
     rename.AppendSwitch(switches::kRenameChromeExe);
     if (installer_state.system_install())
       rename.AppendSwitch(switches::kSystemLevel);
 
@@ skipping 105 matching lines @@
 
   return true;
 }
 
 void AddInstallWorkItems(const InstallationState& original_state,
                          const InstallerState& installer_state,
                          const base::FilePath& setup_path,
                          const base::FilePath& archive_path,
                          const base::FilePath& src_path,
                          const base::FilePath& temp_path,
-                         const Version* current_version,
-                         const Version& new_version,
+                         const base::Version* current_version,
+                         const base::Version& new_version,
                          WorkItemList* install_list) {
   DCHECK(install_list);
 
   const base::FilePath& target_path = installer_state.target_path();
 
   // A temp directory that work items need and the actual install directory.
   install_list->AddCreateDirWorkItem(temp_path);
   install_list->AddCreateDirWorkItem(target_path);
 
   // Create the directory in which persistent metrics will be stored.
@@ skipping 137 matching lines @@
     list->AddDeleteRegKeyWorkItem(HKEY_CURRENT_USER,
                                   dist->GetRegistryPath() + L"\\Metro",
                                   KEY_WOW64_32KEY);
     list->AddDeleteRegKeyWorkItem(HKEY_CURRENT_USER,
                                   dist->GetRegistryPath() + L"\\Metro",
                                   KEY_WOW64_64KEY);
   }
 }
 
 void AddActiveSetupWorkItems(const InstallerState& installer_state,
-                             const Version& new_version,
+                             const base::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
             << "-level " << dist->GetDisplayName();
@@ skipping 93 matching lines @@
     }
 
     FreeLibrary(ieframe);
   } else {
     VLOG(1) << "Cannot load " << kIEFrameDll;
   }
 }
 
 void AddOsUpgradeWorkItems(const InstallerState& installer_state,
                            const base::FilePath& setup_path,
-                           const Version& new_version,
+                           const base::Version& new_version,
                            const Product& product,
                            WorkItemList* install_list) {
   const HKEY root_key = installer_state.root_key();
   base::string16 cmd_key(
       GetRegCommandKey(product.distribution(), kCmdOnOsUpgrade));
 
   if (installer_state.operation() == InstallerState::UNINSTALL) {
     install_list->AddDeleteRegKeyWorkItem(root_key, cmd_key, KEY_WOW64_32KEY)
         ->set_log_message("Removing OS upgrade command");
   } else {
@@ skipping 29 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