Consistently use namespaced base::Version in extensions code.

chrome/browser/extensions/updater/local_extension_cache.cc

 // Copyright 2014 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/browser/extensions/updater/local_extension_cache.h"
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/sequenced_task_runner.h"
@@ skipping 114 matching lines @@
     return false;
 
   return (!expected_hash.empty() && it->second.expected_hash.empty());
 }
 
 // static
 bool LocalExtensionCache::NewerOrSame(const CacheMap::iterator& entry,
                                       const std::string& version,
                                       const std::string& expected_hash,
                                       int* compare) {
-  Version new_version(version);
-  Version prev_version(entry->second.version);
+  base::Version new_version(version);
+  base::Version prev_version(entry->second.version);
   int cmp = new_version.CompareTo(prev_version);
 
   if (compare)
     *compare = cmp;
 
   // Cache entry is newer if its version is greater or same, and in the latter
   // case we will prefer the existing one if we are trying to add an
   // unhashed file, or we already have a hashed file in cache.
   return (cmp < 0 || (cmp == 0 && (expected_hash.empty() ||
                                    !entry->second.expected_hash.empty())));
 }
 
 void LocalExtensionCache::PutExtension(const std::string& id,
                                        const std::string& expected_hash,
                                        const base::FilePath& file_path,
                                        const std::string& version,
                                        const PutExtensionCallback& callback) {
   if (state_ != kReady) {
     callback.Run(file_path, true);
     return;
   }
 
-  Version version_validator(version);
+  base::Version version_validator(version);
   if (!version_validator.IsValid()) {
     LOG(ERROR) << "Extension " << id << " has bad version " << version;
     callback.Run(file_path, true);
     return;
   }
 
   CacheMap::iterator it = FindExtension(cached_extensions_, id, expected_hash);
   if (it != cached_extensions_.end() &&
       NewerOrSame(it, version, expected_hash, NULL)) {
     LOG(WARNING) << "Cache contains newer or the same version "
@@ skipping 265 matching lines @@
       }
     }
 
     // Enforce a lower-case id.
     id = base::ToLowerASCII(id);
     if (!crx_file::id_util::IdIsValid(id)) {
       LOG(ERROR) << "Bad extension id in cache: " << id;
       id.clear();
     }
 
-    if (!Version(version).IsValid()) {
+    if (!base::Version(version).IsValid()) {
       LOG(ERROR) << "Bad extension version in cache: " << version;
       version.clear();
     }
 
     if (id.empty() || version.empty()) {
       LOG(ERROR) << "Invalid file in cache, erasing: " << basename;
       base::DeleteFile(path, true /* recursive */);
       continue;
     }
 
@@ skipping 160 matching lines @@
       size(size),
       file_path(file_path) {}
 
 LocalExtensionCache::CacheItemInfo::CacheItemInfo(const CacheItemInfo& other) =
     default;
 
 LocalExtensionCache::CacheItemInfo::~CacheItemInfo() {
 }
 
 }  // namespace extensions