Update all users of base::Version to explicitly specify the namespace, and clean up the header.

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 95 matching lines @@
   } else {
     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 52 matching lines @@
 }
 
 // Adds work items to create (or delete if uninstalling) app commands to launch
 // the app with a switch. The following criteria should be true:
 //  1. The switch takes one parameter.
 //  2. The command send pings.
 //  3. The command is web accessible.
 //  4. The command is run as the user.
 void AddCommandWithParameterWorkItems(const InstallerState& installer_state,
                                       const InstallationState& machine_state,
-                                      const Version& new_version,
+                                      const base::Version& new_version,
                                       const Product& product,
                                       const wchar_t* command_key,
                                       const wchar_t* app,
                                       const char* command_with_parameter,
                                       WorkItemList* work_item_list) {
   DCHECK(command_key);
   DCHECK(app);
   DCHECK(command_with_parameter);
   DCHECK(work_item_list);
 
@@ skipping 11 matching lines @@
     AppCommand cmd(cmd_line.GetCommandLineString());
     cmd.set_sends_pings(true);
     cmd.set_is_web_accessible(true);
     cmd.set_is_run_as_user(true);
     cmd.AddWorkItems(installer_state.root_key(), full_cmd_key, work_item_list);
   }
 }
 
 void AddInstallAppCommandWorkItems(const InstallerState& installer_state,
                                    const InstallationState& machine_state,
-                                   const Version& new_version,
+                                   const base::Version& new_version,
                                    const Product& product,
                                    WorkItemList* work_item_list) {
   DCHECK(product.is_chrome_app_host());
   AddCommandWithParameterWorkItems(installer_state, machine_state, new_version,
                                    product, kCmdInstallApp,
                                    installer::kChromeAppHostExe,
                                    ::switches::kInstallFromWebstore,
                                    work_item_list);
 }
 
 void AddInstallExtensionCommandWorkItem(const InstallerState& installer_state,
                                         const InstallationState& machine_state,
                                         const base::FilePath& setup_path,
-                                        const Version& new_version,
+                                        const base::Version& new_version,
                                         const Product& product,
                                         WorkItemList* work_item_list) {
   DCHECK(product.is_chrome());
   AddCommandWithParameterWorkItems(installer_state, machine_state, new_version,
                                    product, kCmdInstallExtension,
                                    installer::kChromeExe,
                                    ::switches::kLimitedInstallFromWebstore,
                                    work_item_list);
 }
 
 // Returns the basic CommandLine to setup.exe for a quick-enable operation on
 // the binaries. This will unconditionally include --multi-install as well as
 // --verbose-logging if the current installation was launched with
 // --verbose-logging.  |setup_path| and |new_version| are optional only when
 // the operation is an uninstall.
 CommandLine GetGenericQuickEnableCommand(
     const InstallerState& installer_state,
     const InstallationState& machine_state,
     const base::FilePath& setup_path,
-    const Version& new_version) {
+    const base::Version& new_version) {
   // Only valid for multi-install operations.
   DCHECK(installer_state.is_multi_install());
   // Only valid when Chrome Binaries aren't being uninstalled.
   DCHECK(installer_state.operation() != InstallerState::UNINSTALL ||
          !installer_state.FindProduct(BrowserDistribution::CHROME_BINARIES));
   // setup_path and new_version are required when not uninstalling.
   DCHECK(installer_state.operation() == InstallerState::UNINSTALL ||
          (!setup_path.empty() && new_version.IsValid()));
 
   // The path to setup.exe contains the version of the Chrome Binaries, so it
@@ skipping 24 matching lines @@
 }
 
 // Adds work items to add the "quick-enable-application-host" command to the
 // multi-installer binaries' version key on the basis of the current operation
 // (represented in |installer_state|) and the pre-existing machine configuration
 // (represented in |machine_state|).
 void AddQuickEnableApplicationLauncherWorkItems(
     const InstallerState& installer_state,
     const InstallationState& machine_state,
     const base::FilePath& setup_path,
-    const Version& new_version,
+    const base::Version& new_version,
     WorkItemList* work_item_list) {
   DCHECK(work_item_list);
 
   bool will_have_chrome_binaries =
       WillProductBePresentAfterSetup(installer_state, machine_state,
                                      BrowserDistribution::CHROME_BINARIES);
 
   // For system-level binaries there is no way to keep the command state in sync
   // with the installation/uninstallation of the Application Launcher (which is
   // always at user-level).  So we do not try to remove the command, i.e., it
@@ skipping 14 matching lines @@
     cmd.set_sends_pings(true);
     cmd.set_is_web_accessible(true);
     cmd.set_is_run_as_user(true);
     cmd.AddWorkItems(installer_state.root_key(), cmd_key, work_item_list);
   }
 }
 
 void AddProductSpecificWorkItems(const InstallationState& original_state,
                                  const InstallerState& installer_state,
                                  const base::FilePath& setup_path,
-                                 const Version& new_version,
+                                 const base::Version& new_version,
                                  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_app_host()) {
       AddInstallAppCommandWorkItems(installer_state, original_state,
                                     new_version, p, list);
     }
     if (p.is_chrome()) {
@@ skipping 60 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.  We
     // make this an unconditional work item since there's no need to roll this
     // back; if installation fails we'll be moved to the "-full" channel anyway.
     base::FilePath old_installer_dir(
         installer_state.GetInstallerDirectory(*current_version));
     base::FilePath old_archive(
@@ skipping 182 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 77 matching lines @@
       install_list->AddSetRegValueWorkItem(reg_root, uninstall_reg,
           L"VersionMinor", static_cast<DWORD>(version_components[3]), 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,
                             BrowserDistribution* dist,
-                            const Version& new_version,
+                            const base::Version& new_version,
                             bool add_language_identifier,
                             WorkItemList* list) {
   // Create Version key for each distribution (if not already present) and set
   // the new product version as the last step.
   base::string16 version_key(dist->GetVersionKey());
   list->AddCreateRegKeyWorkItem(root, version_key);
 
   base::string16 product_name(dist->GetDisplayName());
   list->AddSetRegValueWorkItem(root, version_key, google_update::kRegNameField,
                                product_name, true);  // overwrite name also
@@ skipping 225 matching lines @@
             google_update::kRegUsageStatsField);
       }
       install_list->AddDeleteRegValueWorkItem(
           root_key, dist->GetStateKey(), google_update::kRegUsageStatsField);
     }
   }
 }
 
 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,
                             const base::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();
   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.
   {
     scoped_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()));
 
     CommandLine rename(installer_path);
     rename.AppendSwitch(switches::kRenameChromeExe);
     if (installer_state.system_install())
       rename.AppendSwitch(switches::kSystemLevel);
 
@@ skipping 83 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);
 
   if (installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER) ||
@@ skipping 107 matching lines @@
   WorkItem* set_msi_work_item = work_item_list->AddSetRegValueWorkItem(
       installer_state.root_key(), dist->GetStateKey(),
       google_update::kRegMSIField, msi_value, true);
   DCHECK(set_msi_work_item);
   set_msi_work_item->set_ignore_failure(true);
   set_msi_work_item->set_log_message("Could not write MSI marker!");
 }
 
 void AddDelegateExecuteWorkItems(const InstallerState& installer_state,
                                  const base::FilePath& target_path,
-                                 const Version& new_version,
+                                 const base::Version& new_version,
                                  const Product& product,
                                  WorkItemList* list) {
   base::string16 handler_class_uuid;
   BrowserDistribution* dist = product.distribution();
   if (!dist->GetCommandExecuteImplClsid(&handler_class_uuid)) {
     if (InstallUtil::IsChromeSxSProcess()) {
       CleanupBadCanaryDelegateExecuteRegistration(target_path, list);
     } else {
       VLOG(1) << "No DelegateExecute verb handler processing to do for "
               << dist->GetDisplayName();
@@ skipping 41 matching lines @@
     list->AddSetRegValueWorkItem(root, subkey, L"ServerExecutable",
                                  delegate_execute.value(), true);
 
     subkey.assign(delegate_execute_path).append(L"\\Programmable");
     list->AddCreateRegKeyWorkItem(root, subkey);
   }
 }
 
 void AddActiveSetupWorkItems(const InstallerState& installer_state,
                              const base::FilePath& setup_path,
-                             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 75 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)->
         set_log_message("Removing OS upgrade command");
   } else {
@@ skipping 12 matching lines @@
     cmd_line.AppendSwitch(installer::switches::kVerboseLogging);
 
     AppCommand cmd(cmd_line.GetCommandLineString());
     cmd.set_is_auto_run_on_os_upgrade(true);
     cmd.AddWorkItems(installer_state.root_key(), cmd_key, install_list);
   }
 }
 
 void AddQueryEULAAcceptanceWorkItems(const InstallerState& installer_state,
                                      const base::FilePath& setup_path,
-                                     const Version& new_version,
+                                     const base::Version& new_version,
                                      const Product& product,
                                      WorkItemList* work_item_list) {
   const HKEY root_key = installer_state.root_key();
   base::string16 cmd_key(
       GetRegCommandKey(product.distribution(), kCmdQueryEULAAcceptance));
   if (installer_state.operation() == InstallerState::UNINSTALL) {
     work_item_list->AddDeleteRegKeyWorkItem(root_key, cmd_key)->
         set_log_message("Removing query EULA acceptance command");
   } else {
     CommandLine cmd_line(installer_state
@@ skipping 23 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)->set_log_message(
           "removing " + WideToASCII(kCmdQuickEnableCf) + " command");
 
 }
 
 }  // namespace installer