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

chrome/installer/util/installer_state_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/util/installer_state.h"
 
 #include <windows.h>
 #include <stddef.h>
 
 #include <fstream>
@@ skipping 49 matching lines @@
 // An installer state on which we can access otherwise protected members.
 class MockInstallerState : public InstallerState {
  public:
   MockInstallerState() : InstallerState() { }
   void set_target_path(const base::FilePath& target_path) {
     target_path_ = target_path;
   }
   static bool IsFileInUse(const base::FilePath& file) {
     return InstallerState::IsFileInUse(file);
   }
-  const Version& critical_update_version() const {
+  const base::Version& critical_update_version() const {
     return critical_update_version_;
   }
   void GetExistingExeVersions(std::set<std::string>* existing_version_strings) {
     return InstallerState::GetExistingExeVersions(existing_version_strings);
   }
 };
 
 // Simple function to dump some text into a new file.
 void CreateTextFile(const std::wstring& filename,
                     const std::wstring& contents) {
@@ skipping 64 matching lines @@
   CreateTextFile(chrome_dll_3.value(), text_content_1);
   ASSERT_TRUE(base::PathExists(chrome_dll_3));
 
   base::FilePath chrome_dll_4(chrome_dir_4);
   chrome_dll_4 = chrome_dll_4.AppendASCII("chrome.dll");
   CreateTextFile(chrome_dll_4.value(), text_content_1);
   ASSERT_TRUE(base::PathExists(chrome_dll_4));
 
   MockInstallerState installer_state;
   BuildSingleChromeState(chrome_dir, &installer_state);
-  Version latest_version("1.0.4.0");
+  base::Version latest_version("1.0.4.0");
   {
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
     installer_state.RemoveOldVersionDirectories(latest_version, NULL,
                                                 temp_dir.path());
   }
 
   // old versions should be gone
   EXPECT_FALSE(base::PathExists(chrome_dir_1));
   EXPECT_FALSE(base::PathExists(chrome_dir_2));
@@ skipping 59 matching lines @@
   CreateTextFile(chrome_dll_3.value(), text_content_1);
   ASSERT_TRUE(base::PathExists(chrome_dll_3));
 
   base::FilePath chrome_dll_4(chrome_dir_4);
   chrome_dll_4 = chrome_dll_4.AppendASCII("chrome.dll");
   CreateTextFile(chrome_dll_4.value(), text_content_1);
   ASSERT_TRUE(base::PathExists(chrome_dll_4));
 
   MockInstallerState installer_state;
   BuildSingleChromeState(chrome_dir, &installer_state);
-  Version latest_version("1.0.4.0");
-  Version existing_version("1.0.1.0");
+  base::Version latest_version("1.0.4.0");
+  base::Version existing_version("1.0.1.0");
   {
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
     installer_state.RemoveOldVersionDirectories(latest_version,
                                                 &existing_version,
                                                 temp_dir.path());
   }
 
   // the version defined as the existing version should stay
   EXPECT_TRUE(base::PathExists(chrome_dir_1));
@@ skipping 22 matching lines @@
   machine_state.Initialize();
   MockInstallerState installer_state;
   installer_state.Initialize(cmd_line, prefs, machine_state);
   installer_state.set_target_path(test_dir_.path());
   EXPECT_EQ(test_dir_.path().value(), installer_state.target_path().value());
   EXPECT_EQ(1U, installer_state.products().size());
 
   const char kOldVersion[] = "1.2.3.4";
   const char kNewVersion[] = "2.3.4.5";
 
-  Version new_version(kNewVersion);
-  Version old_version(kOldVersion);
+  base::Version new_version(kNewVersion);
+  base::Version old_version(kOldVersion);
   ASSERT_TRUE(new_version.IsValid());
   ASSERT_TRUE(old_version.IsValid());
 
   base::FilePath installer_dir(
       installer_state.GetInstallerDirectory(new_version));
   EXPECT_FALSE(installer_dir.empty());
 
   base::FilePath new_version_dir(installer_state.target_path().Append(
       base::UTF8ToWide(new_version.GetString())));
   base::FilePath old_version_dir(installer_state.target_path().Append(
@@ skipping 59 matching lines @@
   MasterPreferences prefs(cmd_line);
   InstallationState machine_state;
   machine_state.Initialize();
   MockInstallerState installer_state;
   installer_state.Initialize(cmd_line, prefs, machine_state);
   installer_state.set_target_path(test_dir_.path());
   EXPECT_EQ(1U, installer_state.products().size());
   EXPECT_EQ(system_level, installer_state.system_install());
 
   const char kCurrentVersion[] = "1.2.3.4";
-  Version current_version(kCurrentVersion);
+  base::Version current_version(kCurrentVersion);
 
   HKEY root = system_level ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
   EXPECT_EQ(root, installer_state.root_key());
 
   {
     RegistryOverrideManager override_manager;
     override_manager.OverrideRegistry(root);
     BrowserDistribution* dist = BrowserDistribution::GetSpecificDistribution(
         BrowserDistribution::CHROME_BROWSER);
     RegKey chrome_key(root, dist->GetVersionKey().c_str(), KEY_ALL_ACCESS);
     EXPECT_TRUE(chrome_key.Valid());
     if (chrome_key.Valid()) {
       chrome_key.WriteValue(google_update::kRegVersionField,
                             base::UTF8ToWide(
                                 current_version.GetString()).c_str());
       machine_state.Initialize();
       // TODO(tommi): Also test for when there exists a new_chrome.exe.
-      Version found_version(*installer_state.GetCurrentVersion(machine_state));
+      base::Version found_version(
+          *installer_state.GetCurrentVersion(machine_state));
       EXPECT_TRUE(found_version.IsValid());
       if (found_version.IsValid())
         EXPECT_EQ(current_version, found_version);
     }
   }
 }
 
 TEST_F(InstallerStateTest, InstallerResult) {
   const bool system_level = true;
   HKEY root = system_level ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
@@ skipping 70 matching lines @@
 
 // Test GetCurrentVersion when migrating single Chrome to multi
 TEST_F(InstallerStateTest, GetCurrentVersionMigrateChrome) {
   using installer::FakeInstallationState;
 
   const bool system_install = false;
   FakeInstallationState machine_state;
 
   // Pretend that this version of single-install Chrome is already installed.
   machine_state.AddChrome(system_install, false,
-                          new Version(chrome::kChromeVersion));
+                          new base::Version(chrome::kChromeVersion));
 
   // Now we're invoked to install multi Chrome.
   base::CommandLine cmd_line(
       base::CommandLine::FromString(L"setup.exe --multi-install --chrome"));
   MasterPreferences prefs(cmd_line);
   InstallerState installer_state;
   installer_state.Initialize(cmd_line, prefs, machine_state);
 
   // Is the Chrome version picked up?
-  std::unique_ptr<Version> version(
+  std::unique_ptr<base::Version> version(
       installer_state.GetCurrentVersion(machine_state));
   EXPECT_TRUE(version.get() != NULL);
 }
 
 TEST_F(InstallerStateTest, IsFileInUse) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   base::FilePath temp_file;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir.path(), &temp_file));
@@ skipping 22 matching lines @@
   MockInstallerState installer_state;
   installer_state.set_target_path(test_dir_.path());
   EXPECT_EQ(test_dir_.path().value(), installer_state.target_path().value());
 
   const char kOldVersion[] = "2.0.0.0";
   const char kNewVersion[] = "3.0.0.0";
   const char kOldChromeExeVersion[] = "2.1.0.0";
   const char kChromeExeVersion[] = "2.1.1.1";
   const char kNewChromeExeVersion[] = "3.0.0.0";
 
-  Version new_version(kNewVersion);
-  Version old_version(kOldVersion);
-  Version old_chrome_exe_version(kOldChromeExeVersion);
-  Version chrome_exe_version(kChromeExeVersion);
-  Version new_chrome_exe_version(kNewChromeExeVersion);
+  base::Version new_version(kNewVersion);
+  base::Version old_version(kOldVersion);
+  base::Version old_chrome_exe_version(kOldChromeExeVersion);
+  base::Version chrome_exe_version(kChromeExeVersion);
+  base::Version new_chrome_exe_version(kNewChromeExeVersion);
 
   ASSERT_TRUE(new_version.IsValid());
   ASSERT_TRUE(old_version.IsValid());
   ASSERT_TRUE(old_chrome_exe_version.IsValid());
   ASSERT_TRUE(chrome_exe_version.IsValid());
   ASSERT_TRUE(new_chrome_exe_version.IsValid());
 
   // Set up a bunch of version dir paths.
   base::FilePath version_dirs[] = {
     installer_state.target_path().Append(L"1.2.3.4"),
@@ skipping 13 matching lines @@
     EXPECT_TRUE(base::PathExists(version_dirs[i]));
   }
 
   // Create exes with the appropriate version resource.
   // Use the current test exe as a baseline.
   base::FilePath exe_path;
   ASSERT_TRUE(PathService::Get(base::FILE_EXE, &exe_path));
 
   struct target_info {
     base::FilePath target_file;
-    const Version& target_version;
+    const base::Version& target_version;
   } targets[] = {
     { installer_state.target_path().Append(installer::kChromeOldExe),
       old_chrome_exe_version },
     { installer_state.target_path().Append(installer::kChromeExe),
       chrome_exe_version },
     { installer_state.target_path().Append(installer::kChromeNewExe),
       new_chrome_exe_version },
   };
   for (size_t i = 0; i < arraysize(targets); ++i) {
     ASSERT_TRUE(upgrade_test::GenerateSpecificPEFileVersion(
@@ skipping 23 matching lines @@
   expected_remaining_dirs.insert(kOldChromeExeVersion);
   expected_remaining_dirs.insert(kChromeExeVersion);
   expected_remaining_dirs.insert(kNewChromeExeVersion);
 
   // Enumerate dirs in target_path(), ensure only desired remain.
   base::FileEnumerator version_enum(installer_state.target_path(), false,
                                     base::FileEnumerator::DIRECTORIES);
   for (base::FilePath next_version = version_enum.Next(); !next_version.empty();
        next_version = version_enum.Next()) {
     base::FilePath dir_name(next_version.BaseName());
-    Version version(base::UTF16ToASCII(dir_name.value()));
+    base::Version version(base::UTF16ToASCII(dir_name.value()));
     if (version.IsValid()) {
       EXPECT_TRUE(expected_remaining_dirs.erase(version.GetString()))
           << "Unexpected version dir found: " << version.GetString();
     }
   }
 
   std::set<std::string>::const_iterator iter(
       expected_remaining_dirs.begin());
   for (; iter != expected_remaining_dirs.end(); ++iter)
     ADD_FAILURE() << "Expected to find version dir for " << *iter;
@@ skipping 71 matching lines @@
 
 // A fixture for testing InstallerState::DetermineCriticalVersion.  Individual
 // tests must invoke Initialize() with a critical version.
 class InstallerStateCriticalVersionTest : public ::testing::Test {
  protected:
   InstallerStateCriticalVersionTest()
       : cmd_line_(base::CommandLine::NO_PROGRAM) {}
 
   // Creates a set of versions for use by all test runs.
   static void SetUpTestCase() {
-    low_version_    = new Version("15.0.874.106");
-    opv_version_    = new Version("15.0.874.255");
-    middle_version_ = new Version("16.0.912.32");
-    pv_version_     = new Version("16.0.912.255");
-    high_version_   = new Version("17.0.932.0");
+    low_version_    = new base::Version("15.0.874.106");
+    opv_version_    = new base::Version("15.0.874.255");
+    middle_version_ = new base::Version("16.0.912.32");
+    pv_version_     = new base::Version("16.0.912.255");
+    high_version_   = new base::Version("17.0.932.0");
   }
 
   // Cleans up versions used by all test runs.
   static void TearDownTestCase() {
     delete low_version_;
     delete opv_version_;
     delete middle_version_;
     delete pv_version_;
     delete high_version_;
   }
 
   // Initializes the InstallerState to use for a test run.  The returned
   // instance's critical update version is set to |version|.  |version| may be
   // NULL, in which case the critical update version is unset.
-  MockInstallerState& Initialize(const Version* version) {
+  MockInstallerState& Initialize(const base::Version* version) {
     cmd_line_ = version == NULL ? base::CommandLine::FromString(L"setup.exe")
                                 : base::CommandLine::FromString(
                                       L"setup.exe --critical-update-version=" +
                                       base::ASCIIToUTF16(version->GetString()));
     prefs_.reset(new MasterPreferences(cmd_line_));
     machine_state_.Initialize();
     installer_state_.Initialize(cmd_line_, *prefs_, machine_state_);
     return installer_state_;
   }
 
-  static Version* low_version_;
-  static Version* opv_version_;
-  static Version* middle_version_;
-  static Version* pv_version_;
-  static Version* high_version_;
+  static base::Version* low_version_;
+  static base::Version* opv_version_;
+  static base::Version* middle_version_;
+  static base::Version* pv_version_;
+  static base::Version* high_version_;
 
   base::CommandLine cmd_line_;
   std::unique_ptr<MasterPreferences> prefs_;
   InstallationState machine_state_;
   MockInstallerState installer_state_;
 };
 
-Version* InstallerStateCriticalVersionTest::low_version_ = NULL;
-Version* InstallerStateCriticalVersionTest::opv_version_ = NULL;
-Version* InstallerStateCriticalVersionTest::middle_version_ = NULL;
-Version* InstallerStateCriticalVersionTest::pv_version_ = NULL;
-Version* InstallerStateCriticalVersionTest::high_version_ = NULL;
+base::Version* InstallerStateCriticalVersionTest::low_version_ = NULL;
+base::Version* InstallerStateCriticalVersionTest::opv_version_ = NULL;
+base::Version* InstallerStateCriticalVersionTest::middle_version_ = NULL;
+base::Version* InstallerStateCriticalVersionTest::pv_version_ = NULL;
+base::Version* InstallerStateCriticalVersionTest::high_version_ = NULL;
 
 // Test the case where the critical version is less than the currently-running
 // Chrome.  The critical version is ignored since it doesn't apply.
 TEST_F(InstallerStateCriticalVersionTest, CriticalBeforeOpv) {
   MockInstallerState& installer_state(Initialize(low_version_));
 
   EXPECT_EQ(installer_state.critical_update_version(), *low_version_);
   // Unable to determine the installed version, so assume critical update.
   EXPECT_TRUE(
       installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid());
@@ skipping 73 matching lines @@
   // Critical update newer than the new version.
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(NULL, *pv_version_).IsValid());
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(opv_version_, *pv_version_)
           .IsValid());
   EXPECT_FALSE(
       installer_state.DetermineCriticalVersion(pv_version_, *pv_version_)
           .IsValid());
 }