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

chrome/installer/setup/setup_util.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 declares util functions for setup project.
 
 #include "chrome/installer/setup/setup_util.h"
 
 #include <windows.h>
 
@@ skipping 121 matching lines @@
                         patch_status + kBsdiffErrorOffset : 0;
 
   LOG_IF(ERROR, exit_code)
       << "Failed to apply bsdiff patch " << patch.value()
       << " to file " << src.value() << " and generating file " << dest.value()
       << ". err=" << exit_code;
 
   return exit_code;
 }
 
-Version* GetMaxVersionFromArchiveDir(const base::FilePath& chrome_path) {
+base::Version* GetMaxVersionFromArchiveDir(const base::FilePath& chrome_path) {
   VLOG(1) << "Looking for Chrome version folder under " << chrome_path.value();
   base::FileEnumerator version_enum(chrome_path, false,
       base::FileEnumerator::DIRECTORIES);
   // TODO(tommi): The version directory really should match the version of
   // setup.exe.  To begin with, we should at least DCHECK that that's true.
 
-  scoped_ptr<Version> max_version(new Version("0.0.0.0"));
+  scoped_ptr<base::Version> max_version(new base::Version("0.0.0.0"));
   bool version_found = false;
 
   while (!version_enum.Next().empty()) {
     base::FileEnumerator::FileInfo find_data = version_enum.GetInfo();
     VLOG(1) << "directory found: " << find_data.GetName().value();
 
-    scoped_ptr<Version> found_version(
-        new Version(WideToASCII(find_data.GetName().value())));
+    scoped_ptr<base::Version> found_version(
+        new base::Version(WideToASCII(find_data.GetName().value())));
     if (found_version->IsValid() &&
         found_version->CompareTo(*max_version.get()) > 0) {
       max_version.reset(found_version.release());
       version_found = true;
     }
   }
 
   return (version_found ? max_version.release() : NULL);
 }
 
 base::FilePath FindArchiveToPatch(const InstallationState& original_state,
                                   const InstallerState& installer_state) {
   // Check based on the version number advertised to Google Update, since that
   // is the value used to select a specific differential update. If an archive
   // can't be found using that, fallback to using the newest version present.
   base::FilePath patch_source;
   const ProductState* product =
       original_state.GetProductState(installer_state.system_install(),
                                      installer_state.state_type());
   if (product) {
     patch_source = installer_state.GetInstallerDirectory(product->version())
         .Append(installer::kChromeArchive);
     if (base::PathExists(patch_source))
       return patch_source;
   }
-  scoped_ptr<Version> version(
+  scoped_ptr<base::Version> version(
       installer::GetMaxVersionFromArchiveDir(installer_state.target_path()));
   if (version) {
     patch_source = installer_state.GetInstallerDirectory(*version)
         .Append(installer::kChromeArchive);
     if (base::PathExists(patch_source))
       return patch_source;
   }
   return base::FilePath();
 }
 
@@ skipping 51 matching lines @@
     ::CloseHandle(pi.hThread);
     ::CloseHandle(pi.hProcess);
   }
 
   return ok != FALSE;
 }
 
 bool GetExistingHigherInstaller(
     const InstallationState& original_state,
     bool system_install,
-    const Version& installer_version,
+    const base::Version& installer_version,
     base::FilePath* setup_exe) {
   DCHECK(setup_exe);
   bool trying_single_browser = false;
   const ProductState* existing_state =
       original_state.GetProductState(system_install,
                                      BrowserDistribution::CHROME_BINARIES);
   if (!existing_state) {
     // The binaries aren't installed, but perhaps a single-install Chrome is.
     trying_single_browser = true;
     existing_state =
@@ skipping 217 matching lines @@
 }
 
 ScopedTokenPrivilege::~ScopedTokenPrivilege() {
   if (is_enabled_ && previous_privileges_.PrivilegeCount != 0) {
     ::AdjustTokenPrivileges(token_, FALSE, &previous_privileges_,
                             sizeof(TOKEN_PRIVILEGES), NULL, NULL);
   }
 }
 
 }  // namespace installer