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

chrome/installer/setup/install_worker_unittest.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.
 
 #include "chrome/installer/setup/install_worker.h"
 
 #include <vector>
 
 #include "base/macros.h"
 #include "base/version.h"
@@ skipping 97 matching lines @@
                          DWORD,
                          bool));
   MOCK_METHOD3(AddSelfRegWorkItem, WorkItem* (const std::wstring&,
                                               bool,
                                               bool));
 };
 
 class MockProductState : public ProductState {
  public:
   // Takes ownership of |version|.
-  void set_version(Version* version) { version_.reset(version); }
+  void set_version(base::Version* version) { version_.reset(version); }
   void set_multi_install(bool multi) { multi_install_ = multi; }
   void set_brand(const std::wstring& brand) { brand_ = brand; }
   void set_eula_accepted(DWORD eula_accepted) {
     has_eula_accepted_ = true;
     eula_accepted_ = eula_accepted;
   }
   void clear_eula_accepted() { has_eula_accepted_ = false; }
   void set_usagestats(DWORD usagestats) {
     has_usagestats_ = true;
     usagestats_ = usagestats;
@@ skipping 46 matching lines @@
     InstallerState::set_package_type(type);
   }
 };
 
 // The test fixture
 //------------------------------------------------------------------------------
 
 class InstallWorkerTest : public testing::Test {
  public:
   void SetUp() override {
-    current_version_.reset(new Version("1.0.0.0"));
-    new_version_.reset(new Version("42.0.0.0"));
+    current_version_.reset(new base::Version("1.0.0.0"));
+    new_version_.reset(new base::Version("42.0.0.0"));
 
     // Don't bother ensuring that these paths exist. Since we're just
     // building the work item lists and not running them, they shouldn't
     // actually be touched.
     archive_path_ =
         base::FilePath(L"C:\\UnlikelyPath\\Temp\\chrome_123\\chrome.7z");
     // TODO(robertshield): Take this from the BrowserDistribution once that
     // no longer depends on MasterPreferences.
     installation_path_ =
         base::FilePath(L"C:\\Program Files\\Google\\Chrome\\");
     src_path_ = base::FilePath(
         L"C:\\UnlikelyPath\\Temp\\chrome_123\\source\\Chrome-bin");
     setup_path_ = base::FilePath(
         L"C:\\UnlikelyPath\\Temp\\CR_123.tmp\\setup.exe");
     temp_dir_ = base::FilePath(L"C:\\UnlikelyPath\\Temp\\chrome_123");
   }
 
   void TearDown() override {}
 
   void MaybeAddBinariesToInstallationState(
       bool system_level,
       MockInstallationState* installation_state) {
     if (installation_state->GetProductState(
             system_level, BrowserDistribution::CHROME_BINARIES) == NULL) {
       MockProductState product_state;
-      product_state.set_version(new Version(*current_version_));
+      product_state.set_version(new base::Version(*current_version_));
       product_state.set_brand(L"TEST");
       product_state.set_multi_install(true);
       BrowserDistribution* dist =
           BrowserDistribution::GetSpecificDistribution(
               BrowserDistribution::CHROME_BINARIES);
       base::FilePath install_path =
           installer::GetChromeInstallPath(system_level, dist);
       product_state.SetUninstallProgram(
           install_path.AppendASCII(current_version_->GetString())
           .Append(installer::kInstallerDir)
           .Append(installer::kSetupExe));
       product_state.AddUninstallSwitch(installer::switches::kUninstall);
       product_state.AddUninstallSwitch(installer::switches::kMultiInstall);
       if (system_level)
         product_state.AddUninstallSwitch(installer::switches::kSystemLevel);
       installation_state->SetProductState(system_level,
                                           BrowserDistribution::CHROME_BINARIES,
                                           product_state);
     }
   }
 
   void AddChromeToInstallationState(
       bool system_level,
       bool multi_install,
       MockInstallationState* installation_state) {
     if (multi_install)
       MaybeAddBinariesToInstallationState(system_level, installation_state);
     MockProductState product_state;
-    product_state.set_version(new Version(*current_version_));
+    product_state.set_version(new base::Version(*current_version_));
     product_state.set_multi_install(multi_install);
     product_state.set_brand(L"TEST");
     product_state.set_eula_accepted(1);
     BrowserDistribution* dist =
         BrowserDistribution::GetSpecificDistribution(
             BrowserDistribution::CHROME_BROWSER);
     base::FilePath install_path =
         installer::GetChromeInstallPath(system_level, dist);
     product_state.SetUninstallProgram(
       install_path.AppendASCII(current_version_->GetString())
@@ skipping 12 matching lines @@
                                         product_state);
   }
 
   void AddChromeFrameToInstallationState(
       bool system_level,
       bool multi_install,
       MockInstallationState* installation_state) {
     if (multi_install)
       MaybeAddBinariesToInstallationState(system_level, installation_state);
     MockProductState product_state;
-    product_state.set_version(new Version(*current_version_));
+    product_state.set_version(new base::Version(*current_version_));
     product_state.set_multi_install(multi_install);
     BrowserDistribution* dist =
         BrowserDistribution::GetSpecificDistribution(
             multi_install ? BrowserDistribution::CHROME_BINARIES :
                 BrowserDistribution::CHROME_FRAME);
     base::FilePath install_path =
         installer::GetChromeInstallPath(system_level, dist);
     product_state.SetUninstallProgram(
       install_path.AppendASCII(current_version_->GetString())
           .Append(installer::kInstallerDir)
@@ skipping 141 matching lines @@
     std::unique_ptr<MockInstallerState> installer_state(
         BuildBasicInstallerState(system_install, multi_install, machine_state,
                                  operation));
     if (multi_install)
       AddChromeBinariesToInstallerState(machine_state, installer_state.get());
     AddChromeFrameToInstallerState(machine_state, installer_state.get());
     return installer_state.release();
   }
 
  protected:
-  std::unique_ptr<Version> current_version_;
-  std::unique_ptr<Version> new_version_;
+  std::unique_ptr<base::Version> current_version_;
+  std::unique_ptr<base::Version> new_version_;
   base::FilePath archive_path_;
   base::FilePath installation_path_;
   base::FilePath setup_path_;
   base::FilePath src_path_;
   base::FilePath temp_dir_;
 };
 
 // Tests
 //------------------------------------------------------------------------------
 
@@ skipping 109 matching lines @@
 TEST_F(InstallWorkerTest, GoogleUpdateWorkItemsTest) {
   const bool system_level = true;
   const bool multi_install = true;
   MockWorkItemList work_item_list;
 
   // Per-machine single-install Chrome is installed.
   std::unique_ptr<MockInstallationState> installation_state(
       BuildChromeInstallationState(system_level, false));
 
   MockProductState cf_state;
-  cf_state.set_version(new Version(*current_version_));
+  cf_state.set_version(new base::Version(*current_version_));
   cf_state.set_multi_install(false);
 
   // Per-machine single-install Chrome Frame is installed.
   installation_state->SetProductState(system_level,
       BrowserDistribution::CHROME_FRAME, cf_state);
 
   // Prepare per-machine multi-install Chrome for installation.
   std::unique_ptr<MockInstallerState> installer_state(BuildChromeInstallerState(
       system_level, multi_install, *installation_state,
       InstallerState::MULTI_INSTALL));
@@ skipping 50 matching lines @@
 // Test that usagestats values are migrated properly.
 TEST_F(InstallWorkerTest, AddUsageStatsWorkItems) {
   const bool system_level = true;
   const bool multi_install = true;
   MockWorkItemList work_item_list;
 
   std::unique_ptr<MockInstallationState> installation_state(
       BuildChromeInstallationState(system_level, multi_install));
 
   MockProductState chrome_state;
-  chrome_state.set_version(new Version(*current_version_));
+  chrome_state.set_version(new base::Version(*current_version_));
   chrome_state.set_multi_install(false);
   chrome_state.set_usagestats(1);
 
   installation_state->SetProductState(system_level,
       BrowserDistribution::CHROME_BROWSER, chrome_state);
 
   std::unique_ptr<MockInstallerState> installer_state(BuildChromeInstallerState(
       system_level, multi_install, *installation_state,
       InstallerState::MULTI_INSTALL));
 
@@ skipping 172 matching lines @@
               prod_type_list[i_type_check]);
           bool prod_expect = (mach_after & (1 << i_type_check)) != 0;
           EXPECT_EQ(prod_expect, prod_res);
         }
       }
     }
   }
 }
 
 #endif  // defined(GOOGLE_CHROME_BUILD)