Consistently use namespaced base::Version in extensions code.

chrome/browser/extensions/external_provider_impl.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/browser/extensions/external_provider_impl.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
@@ skipping 325 matching lines @@
       if (!path.IsAbsolute()) {
         base::FilePath base_path = loader_->GetBaseCrxFilePath();
         if (base_path.empty()) {
           LOG(WARNING) << "File path " << external_crx.c_str()
                        << " is relative.  An absolute path is required.";
           continue;
         }
         path = base_path.Append(external_crx);
       }
 
-      std::unique_ptr<Version> version(new Version(external_version));
+      std::unique_ptr<base::Version> version(
+          new base::Version(external_version));
       if (!version->IsValid()) {
         LOG(WARNING) << "Malformed extension dictionary for extension: "
                      << extension_id.c_str() << ".  Invalid version string \""
                      << external_version << "\".";
         continue;
       }
       external_file_extensions->push_back(new ExternalInstallInfoFile(
           extension_id, std::move(version), path, crx_location_, creation_flags,
           auto_acknowledge_, install_immediately_));
     } else {  // if (has_external_update_url)
@@ skipping 38 matching lines @@
     const std::string& id) const {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(prefs_.get());
   CHECK(ready_);
   return prefs_->HasKey(id);
 }
 
 bool ExternalProviderImpl::GetExtensionDetails(
     const std::string& id,
     Manifest::Location* location,
-    std::unique_ptr<Version>* version) const {
+    std::unique_ptr<base::Version>* version) const {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(prefs_.get());
   CHECK(ready_);
   base::DictionaryValue* extension = NULL;
   if (!prefs_->GetDictionary(id, &extension))
     return false;
 
   Manifest::Location loc = Manifest::INVALID_LOCATION;
   if (extension->HasKey(kExternalUpdateUrl)) {
     loc = download_location_;
 
   } else if (extension->HasKey(kExternalCrx)) {
     loc = crx_location_;
 
     std::string external_version;
     if (!extension->GetString(kExternalVersion, &external_version))
       return false;
 
     if (version)
-      version->reset(new Version(external_version));
+      version->reset(new base::Version(external_version));
 
   } else {
     NOTREACHED();  // Chrome should not allow prefs to get into this state.
     return false;
   }
 
   if (location)
     *location = loc;
 
   return true;
 }
 
 bool ExternalProviderImpl::HandleMinProfileVersion(
     const base::DictionaryValue* extension,
     const std::string& extension_id,
     std::set<std::string>* unsupported_extensions) {
   std::string min_profile_created_by_version;
   if (profile_ &&
       extension->GetString(kMinProfileCreatedByVersion,
                            &min_profile_created_by_version)) {
-    Version profile_version(
+    base::Version profile_version(
         profile_->GetPrefs()->GetString(prefs::kProfileCreatedByVersion));
-    Version min_version(min_profile_created_by_version);
+    base::Version min_version(min_profile_created_by_version);
     if (min_version.IsValid() && profile_version.CompareTo(min_version) < 0) {
       unsupported_extensions->insert(extension_id);
       VLOG(1) << "Skip installing (or uninstall) external extension: "
               << extension_id
               << " profile.created_by_version: " << profile_version.GetString()
               << " min_profile_created_by_version: "
               << min_profile_created_by_version;
       return false;
     }
   }
@@ skipping 278 matching lines @@
       new ExternalProviderImpl(
           service,
           new ExternalComponentLoader(profile),
           profile,
           Manifest::INVALID_LOCATION,
           Manifest::EXTERNAL_COMPONENT,
           Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT)));
 }
 
 }  // namespace extensions