base: Remove using:: declaration from version.h header.

chrome/installer/util/installer_state.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 <algorithm>
 #include <functional>
 #include <utility>
 
@@ skipping 141 matching lines @@
             BrowserDistribution::CHROME_BROWSER :
             BrowserDistribution::CHROME_BINARIES);
   }
 
   state_key_ = operand->GetStateKey();
   state_type_ = operand->GetType();
 
   // Parse --critical-update-version=W.X.Y.Z
   std::string critical_version_value(
       command_line.GetSwitchValueASCII(switches::kCriticalUpdateVersion));
-  critical_update_version_ = Version(critical_version_value);
+  critical_update_version_ = base::Version(critical_version_value);
 }
 
 void InstallerState::set_level(Level level) {
   level_ = level;
   switch (level) {
     case USER_LEVEL:
       root_key_ = HKEY_CURRENT_USER;
       break;
     case SYSTEM_LEVEL:
       root_key_ = HKEY_LOCAL_MACHINE;
@@ skipping 187 matching lines @@
 const Product* InstallerState::FindProduct(
     BrowserDistribution::Type distribution_type) const {
   for (Products::const_iterator scan = products_.begin(), end = products_.end();
        scan != end; ++scan) {
      if ((*scan)->is_type(distribution_type))
        return *scan;
   }
   return NULL;
 }
 
-Version* InstallerState::GetCurrentVersion(
+base::Version* InstallerState::GetCurrentVersion(
     const InstallationState& machine_state) const {
   DCHECK(!products_.empty());
-  scoped_ptr<Version> current_version;
+  scoped_ptr<base::Version> current_version;
   // If we're doing a multi-install, the current version may be either an
   // existing multi or an existing single product that is being migrated
   // in place (i.e., Chrome).  In the latter case, there is no existing
   // CHROME_BINARIES installation so we need to search for the product.
   BrowserDistribution::Type prod_type;
   if (package_type_ == MULTI_PACKAGE) {
     prod_type = BrowserDistribution::CHROME_BINARIES;
     if (machine_state.GetProductState(level_ == SYSTEM_LEVEL,
                                       prod_type) == NULL) {
       // Search for a product on which we're operating that is installed in our
@@ skipping 11 matching lines @@
         }
       }
     }
   } else {
     prod_type = products_[0]->distribution()->GetType();
   }
   const ProductState* product_state =
       machine_state.GetProductState(level_ == SYSTEM_LEVEL, prod_type);
 
   if (product_state != NULL) {
-    const Version* version = NULL;
+    const base::Version* version = NULL;
 
     // Be aware that there might be a pending "new_chrome.exe" already in the
     // installation path.  If so, we use old_version, which holds the version of
     // "chrome.exe" itself.
     if (base::PathExists(target_path().Append(kChromeNewExe)))
       version = product_state->old_version();
 
     if (version == NULL)
       version = &product_state->version();
 
-    current_version.reset(new Version(*version));
+    current_version.reset(new base::Version(*version));
   }
 
   return current_version.release();
 }
 
-Version InstallerState::DetermineCriticalVersion(
-    const Version* current_version,
-    const Version& new_version) const {
+base::Version InstallerState::DetermineCriticalVersion(
+    const base::Version* current_version,
+    const base::Version& new_version) const {
   DCHECK(current_version == NULL || current_version->IsValid());
   DCHECK(new_version.IsValid());
   if (critical_update_version_.IsValid() &&
       (current_version == NULL ||
        (current_version->CompareTo(critical_update_version_) < 0)) &&
       new_version.CompareTo(critical_update_version_) >= 0) {
     return critical_update_version_;
   }
-  return Version();
+  return base::Version();
 }
 
 bool InstallerState::IsChromeFrameRunning(
     const InstallationState& machine_state) const {
   return AnyExistsAndIsInUse(machine_state, CHROME_FRAME_DLL);
 }
 
 bool InstallerState::AreBinariesInUse(
     const InstallationState& machine_state) const {
   return AnyExistsAndIsInUse(
       machine_state,
       (CHROME_FRAME_HELPER_EXE | CHROME_FRAME_HELPER_DLL |
        CHROME_FRAME_DLL | CHROME_DLL));
 }
 
 base::FilePath InstallerState::GetInstallerDirectory(
-    const Version& version) const {
+    const base::Version& version) const {
   return target_path().AppendASCII(version.GetString()).Append(kInstallerDir);
 }
 
 // static
 bool InstallerState::IsFileInUse(const base::FilePath& file) {
   // Call CreateFile with a share mode of 0 which should cause this to fail
   // with ERROR_SHARING_VIOLATION if the file exists and is in-use.
   return !base::win::ScopedHandle(CreateFile(file.value().c_str(),
                                              GENERIC_WRITE, 0, NULL,
                                              OPEN_EXISTING, 0, 0)).IsValid();
@@ skipping 26 matching lines @@
   DCHECK_NE(file_bits, 0U);
   DCHECK_LT(file_bits, 1U << NUM_BINARIES);
   COMPILE_ASSERT(CHROME_DLL == 1, no_youre_out_of_order);
   COMPILE_ASSERT(CHROME_FRAME_DLL == 2, no_youre_out_of_order);
   COMPILE_ASSERT(CHROME_FRAME_HELPER_DLL == 4, no_youre_out_of_order);
   COMPILE_ASSERT(CHROME_FRAME_HELPER_EXE == 8, no_youre_out_of_order);
 
   // Check only for the current version (i.e., the version we are upgrading
   // _from_). Later versions from pending in-use updates need not be checked
   // since the current version is guaranteed to be in use if any such are.
-  scoped_ptr<Version> current_version(GetCurrentVersion(machine_state));
+  scoped_ptr<base::Version> current_version(GetCurrentVersion(machine_state));
   if (!current_version)
     return false;
   base::FilePath directory(
       target_path().AppendASCII(current_version->GetString()));
   for (int i = 0; i < NUM_BINARIES; ++i) {
     if (!(file_bits & (1U << i)))
       continue;
     base::FilePath file(directory.Append(kBinaryFileNames[i]));
     if (base::PathExists(file) && IsFileInUse(file))
       return true;
@@ skipping 16 matching lines @@
         FileVersionInfo::CreateFileVersionInfo(chrome_exe));
     if (file_version_info) {
       base::string16 version_string = file_version_info->file_version();
       if (!version_string.empty() && base::IsStringASCII(version_string))
         existing_versions->insert(base::UTF16ToASCII(version_string));
     }
   }
 }
 
 void InstallerState::RemoveOldVersionDirectories(
-    const Version& new_version,
-    Version* existing_version,
+    const base::Version& new_version,
+    base::Version* existing_version,
     const base::FilePath& temp_path) const {
-  Version version;
+  base::Version version;
   scoped_ptr<WorkItem> item;
 
   std::set<std::string> existing_version_strings;
   existing_version_strings.insert(new_version.GetString());
   if (existing_version)
     existing_version_strings.insert(existing_version->GetString());
 
   // Make sure not to delete any version dir that is "referenced" by an existing
   // Chrome executable.
   GetExistingExeVersions(&existing_version_strings);
 
   // Try to delete all directories that are not in the set we care to keep.
   base::FileEnumerator version_enum(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()));
+    version = base::Version(base::UTF16ToASCII(dir_name.value()));
     // Delete the version folder if it is less than the new version and not
     // equal to the old version (if we have an old version).
     if (version.IsValid() &&
         existing_version_strings.count(version.GetString()) == 0) {
       // Note: temporarily log old version deletion at ERROR level to make it
       // more likely we see this in the installer log.
       LOG(ERROR) << "Deleting old version directory: " << next_version.value();
 
       // Attempt to recursively delete the old version dir.
       bool delete_succeeded = base::DeleteFile(next_version, true);
@@ skipping 120 matching lines @@
   }
   if (!install_list->Do())
     LOG(ERROR) << "Failed to record installer error information in registry.";
 }
 
 bool InstallerState::RequiresActiveSetup() const {
   return system_install() && FindProduct(BrowserDistribution::CHROME_BROWSER);
 }
 
 }  // namespace installer