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

chrome/installer/util/installer_state_unittest.cc

Index: chrome/installer/util/installer_state_unittest.cc
diff --git a/chrome/installer/util/installer_state_unittest.cc b/chrome/installer/util/installer_state_unittest.cc
index 5576fbc0a7d0164f466a4111c3cd8a096a459797..88db263d9cbcec3b92d0aa0500079e842188e0a7 100644
--- a/chrome/installer/util/installer_state_unittest.cc
+++ b/chrome/installer/util/installer_state_unittest.cc
@@ -67,7 +67,7 @@ class MockInstallerState : public InstallerState {
   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) {
@@ -152,7 +152,7 @@ TEST_F(InstallerStateTest, Delete) {
 
   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());
@@ -232,8 +232,8 @@ TEST_F(InstallerStateTest, DeleteInUsed) {
 
   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());
@@ -276,8 +276,8 @@ TEST_F(InstallerStateTest, Basic) {
   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());
 
@@ -357,7 +357,7 @@ TEST_F(InstallerStateTest, WithProduct) {
   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());
@@ -375,7 +375,8 @@ TEST_F(InstallerStateTest, WithProduct) {
                                 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);
@@ -466,7 +467,7 @@ TEST_F(InstallerStateTest, GetCurrentVersionMigrateChrome) {
 
   // 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(
@@ -476,7 +477,7 @@ TEST_F(InstallerStateTest, GetCurrentVersionMigrateChrome) {
   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);
 }
@@ -519,11 +520,11 @@ TEST_F(InstallerStateTest, RemoveOldVersionDirs) {
   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());
@@ -557,7 +558,7 @@ TEST_F(InstallerStateTest, RemoveOldVersionDirs) {
 
   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 },
@@ -601,7 +602,7 @@ TEST_F(InstallerStateTest, RemoveOldVersionDirs) {
   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();
@@ -693,11 +694,11 @@ class InstallerStateCriticalVersionTest : public ::testing::Test {
 
   // 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.
@@ -712,7 +713,7 @@ class InstallerStateCriticalVersionTest : public ::testing::Test {
   // 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=" +
@@ -723,11 +724,11 @@ class InstallerStateCriticalVersionTest : public ::testing::Test {
     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_;
@@ -735,11 +736,11 @@ class InstallerStateCriticalVersionTest : public ::testing::Test {
   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.