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

chrome_frame/dll_redirector.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_frame/dll_redirector.h"
 
 #include <aclapi.h>
 #include <atlbase.h>
 #include <atlsecurity.h>
 #include <sddl.h>
@@ skipping 105 matching lines @@
   }
 
   return success;
 }
 
 
 bool DllRedirector::RegisterAsFirstCFModule() {
   DCHECK(first_module_handle_ == NULL);
 
   // Build our own file version outside of the lock:
-  scoped_ptr<Version> our_version(GetCurrentModuleVersion());
+  scoped_ptr<base::Version> our_version(GetCurrentModuleVersion());
 
   // We sadly can't use the autolock here since we want to have a timeout.
   // Be careful not to return while holding the lock. Also, attempt to do as
   // little as possible while under this lock.
 
   bool lock_acquired = false;
   CSecurityAttributes sec_attr;
   if (base::win::GetVersion() >= base::win::VERSION_VISTA &&
       BuildSecurityAttributesForLock(&sec_attr)) {
     // On vista and above, we need to explicitly allow low integrity access
@@ skipping 43 matching lines @@
       if (created_beacon) {
         dll_version_.swap(our_version);
 
         lstrcpynA(reinterpret_cast<char*>(shared_memory_->memory()),
                   dll_version_->GetString().c_str(),
                   std::min(kSharedMemorySize,
                            dll_version_->GetString().length() + 1));
       } else {
         char buffer[kSharedMemorySize] = {0};
         memcpy(buffer, shared_memory_->memory(), kSharedMemorySize - 1);
-        dll_version_.reset(new Version(buffer));
+        dll_version_.reset(new base::Version(buffer));
 
         if (!dll_version_->IsValid() ||
             dll_version_->Equals(*our_version.get())) {
           // If we either couldn't parse a valid version out of the shared
           // memory or we did parse a version and it is the same as our own,
           // then pretend we're first in to avoid trying to load any other DLLs.
           dll_version_.reset(our_version.release());
           created_beacon = true;
         }
       }
@@ skipping 30 matching lines @@
   if (first_module_handle) {
     proc_ptr = reinterpret_cast<LPFNGETCLASSOBJECT>(
         GetProcAddress(first_module_handle, "DllGetClassObject"));
     DPLOG_IF(ERROR, !proc_ptr) << "DllRedirector: Could not get address of "
                                   "DllGetClassObject from first loaded module.";
   }
 
   return proc_ptr;
 }
 
-Version* DllRedirector::GetCurrentModuleVersion() {
+base::Version* DllRedirector::GetCurrentModuleVersion() {
   scoped_ptr<FileVersionInfo> file_version_info(
       FileVersionInfo::CreateFileVersionInfoForCurrentModule());
   DCHECK(file_version_info.get());
 
-  scoped_ptr<Version> current_version;
+  scoped_ptr<base::Version> current_version;
   if (file_version_info.get()) {
      current_version.reset(
-         new Version(WideToASCII(file_version_info->file_version())));
+         new base::Version(WideToASCII(file_version_info->file_version())));
     DCHECK(current_version->IsValid());
   }
 
   return current_version.release();
 }
 
 HMODULE DllRedirector::GetFirstModule() {
   DCHECK(dll_version_.get())
       << "Error: Did you call RegisterAsFirstCFModule() first?";
 
   if (first_module_handle_ == NULL) {
     first_module_handle_ = LoadVersionedModule(dll_version_.get());
   }
 
   if (first_module_handle_ == reinterpret_cast<HMODULE>(&__ImageBase)) {
     NOTREACHED() << "Should not be loading own version.";
     first_module_handle_ = NULL;
   }
 
   return first_module_handle_;
 }
 
-HMODULE DllRedirector::LoadVersionedModule(Version* version) {
+HMODULE DllRedirector::LoadVersionedModule(base::Version* version) {
   DCHECK(version);
 
   HMODULE hmodule = NULL;
   wchar_t system_buffer[MAX_PATH];
   HMODULE this_module = reinterpret_cast<HMODULE>(&__ImageBase);
   system_buffer[0] = 0;
   if (GetModuleFileName(this_module, system_buffer,
                         arraysize(system_buffer)) != 0) {
     base::FilePath module_path(system_buffer);
 
     // For a module located in
     // Foo\XXXXXXXXX\<module>.dll, load
     // Foo\<version>\<module>.dll:
     base::FilePath module_name = module_path.BaseName();
     module_path = module_path.DirName()
                              .DirName()
                              .Append(ASCIIToWide(version->GetString()))
                              .Append(module_name);
 
     hmodule = LoadLibrary(module_path.value().c_str());
     if (hmodule == NULL) {
       DPLOG(ERROR) << "Could not load reported module version "
                    << version->GetString();
     }
   } else {
     DPLOG(FATAL) << "Failed to get module file name";
   }
   return hmodule;
 }