Consistently use namespaced base::Version in extensions code.

extensions/browser/updater/extension_downloader.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 "extensions/browser/updater/extension_downloader.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 133 matching lines @@
   std::string new_query_string = base::JoinString(new_query_parts, "&");
   url::Component new_query(0, new_query_string.size());
   url::Replacements<char> replacements;
   replacements.SetQuery(new_query_string.c_str(), new_query);
   *url = url->ReplaceComponents(replacements);
   return true;
 }
 
 }  // namespace
 
-UpdateDetails::UpdateDetails(const std::string& id, const Version& version)
-    : id(id), version(version) {
-}
+UpdateDetails::UpdateDetails(const std::string& id,
+                             const base::Version& version)
+    : id(id), version(version) {}
 
 UpdateDetails::~UpdateDetails() {
 }
 
 ExtensionDownloader::ExtensionFetch::ExtensionFetch()
     : url(), credentials(CREDENTIALS_NONE) {
 }
 
 ExtensionDownloader::ExtensionFetch::ExtensionFetch(
     const std::string& id,
@@ skipping 54 matching lines @@
       extension.id(), *extension.version(), extension.GetType(),
       ManifestURL::GetUpdateURL(&extension), update_url_data, request_id);
 }
 
 bool ExtensionDownloader::AddPendingExtension(const std::string& id,
                                               const GURL& update_url,
                                               int request_id) {
   // Use a zero version to ensure that a pending extension will always
   // be updated, and thus installed (assuming all extensions have
   // non-zero versions).
-  Version version("0.0.0.0");
+  base::Version version("0.0.0.0");
   DCHECK(version.IsValid());
 
   return AddExtensionData(id, version, Manifest::TYPE_UNKNOWN, update_url,
                           std::string(), request_id);
 }
 
 void ExtensionDownloader::StartAllPending(ExtensionCache* cache) {
   if (cache) {
     extension_cache_ = cache;
     extension_cache_->Start(base::Bind(&ExtensionDownloader::DoStartAllPending,
@@ skipping 38 matching lines @@
   identity_provider_.swap(identity_provider);
 }
 
 // static
 void ExtensionDownloader::set_test_delegate(
     ExtensionDownloaderTestDelegate* delegate) {
   g_test_delegate = delegate;
 }
 
 bool ExtensionDownloader::AddExtensionData(const std::string& id,
-                                           const Version& version,
+                                           const base::Version& version,
                                            Manifest::Type extension_type,
                                            const GURL& extension_update_url,
                                            const std::string& update_url_data,
                                            int request_id) {
   GURL update_url(extension_update_url);
   // Skip extensions with non-empty invalid update URLs.
   if (!update_url.is_empty() && !update_url.is_valid()) {
     DLOG(WARNING) << "Extension " << id << " has invalid update url "
                   << update_url;
     return false;
@@ skipping 324 matching lines @@
       // version is the same or older than what's already installed,
       // we don't want it.
       std::string version;
       if (!delegate_->GetExtensionExistingVersion(id, &version)) {
         VLOG(2) << id << " is not installed";
         continue;
       }
 
       VLOG(2) << id << " is at '" << version << "'";
 
-      Version existing_version(version);
-      Version update_version(update->version);
+      base::Version existing_version(version);
+      base::Version update_version(update->version);
       if (!update_version.IsValid() ||
           update_version.CompareTo(existing_version) <= 0) {
         continue;
       }
     }
 
     // If the update specifies a browser minimum version, do we qualify?
     if (update->browser_min_version.length() > 0 &&
         !ExtensionsBrowserClient::Get()->IsMinBrowserVersionSupported(
             update->browser_min_version)) {
@@ skipping 196 matching lines @@
        it != extension_ids.end();
        ++it) {
     const ExtensionDownloaderDelegate::PingResult& ping = ping_results_[*it];
     delegate_->OnExtensionDownloadFailed(*it, error, ping, request_ids);
     ping_results_.erase(*it);
   }
 }
 
 void ExtensionDownloader::NotifyUpdateFound(const std::string& id,
                                             const std::string& version) {
-  UpdateDetails updateInfo(id, Version(version));
+  UpdateDetails updateInfo(id, base::Version(version));
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_EXTENSION_UPDATE_FOUND,
       content::NotificationService::AllBrowserContextsAndSources(),
       content::Details<UpdateDetails>(&updateInfo));
 }
 
 bool ExtensionDownloader::IterateFetchCredentialsAfterFailure(
     ExtensionFetch* fetch,
     const net::URLRequestStatus& status,
     int response_code) {
@@ skipping 76 matching lines @@
     const GURL& update_url,
     int request_id) {
   ManifestFetchData::PingMode ping_mode = ManifestFetchData::NO_PING;
   if (update_url.DomainIs(ping_enabled_domain_.c_str()))
     ping_mode = ManifestFetchData::PING_WITH_ENABLED_STATE;
   return new ManifestFetchData(
       update_url, request_id, brand_code_, manifest_query_params_, ping_mode);
 }
 
 }  // namespace extensions