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

chrome/browser/extensions/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 "chrome/browser/extensions/updater/extension_downloader.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 78 matching lines @@
 bool ShouldRetryRequest(const net::URLRequestStatus& status,
                         int response_code) {
   // Retry if the response code is a server error, or the request failed because
   // of network errors as opposed to file errors.
   return (response_code >= 500 && status.is_success()) ||
          status.status() == net::URLRequestStatus::FAILED;
 }
 
 }  // namespace
 
-UpdateDetails::UpdateDetails(const std::string& id, const Version& version)
+UpdateDetails::UpdateDetails(const std::string& id,
+                             const base::Version& version)
     : id(id), version(version) {}
 
 UpdateDetails::~UpdateDetails() {}
 
 ExtensionDownloader::ExtensionFetch::ExtensionFetch() : url() {}
 
 ExtensionDownloader::ExtensionFetch::ExtensionFetch(
     const std::string& id,
     const GURL& url,
     const std::string& package_hash,
@@ skipping 43 matching lines @@
                           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);
 }
 
@@ skipping 24 matching lines @@
   DCHECK(blacklist_fetch->base_url().SchemeIsSecure());
   blacklist_fetch->AddExtension(kBlacklistAppID,
                                 version,
                                 &ping_data,
                                 std::string(),
                                 kDefaultInstallSource);
   StartUpdateCheck(blacklist_fetch.Pass());
 }
 
 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()) {
     LOG(WARNING) << "Extension " << id << " has invalid update url "
                  << update_url;
     return false;
@@ skipping 304 matching lines @@
       fetch_data.request_ids(),
       ExtensionDownloaderDelegate::NO_UPDATE_AVAILABLE);
 }
 
 void ExtensionDownloader::DetermineUpdates(
     const ManifestFetchData& fetch_data,
     const UpdateManifest::Results& possible_updates,
     std::vector<int>* result) {
   // This will only be valid if one of possible_updates specifies
   // browser_min_version.
-  Version browser_version;
+  base::Version browser_version;
 
   for (size_t i = 0; i < possible_updates.list.size(); i++) {
     const UpdateManifest::Result* update = &possible_updates.list[i];
     const std::string& id = update->extension_id;
 
     if (!fetch_data.Includes(id)) {
       VLOG(2) << "Ignoring " << id << " from this manifest";
       continue;
     }
 
@@ skipping 10 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) {
       // First determine the browser version if we haven't already.
       if (!browser_version.IsValid()) {
         chrome::VersionInfo version_info;
         if (version_info.is_valid())
-          browser_version = Version(version_info.Version());
+          browser_version = base::Version(version_info.Version());
       }
-      Version browser_min_version(update->browser_min_version);
+      base::Version browser_min_version(update->browser_min_version);
       if (browser_version.IsValid() && browser_min_version.IsValid() &&
           browser_min_version.CompareTo(browser_version) > 0) {
         // TODO(asargent) - We may want this to show up in the extensions UI
         // eventually. (http://crbug.com/12547).
         LOG(WARNING) << "Updated version of extension " << id
                      << " available, but requires chrome version "
                      << update->browser_min_version;
         continue;
       }
     }
@@ skipping 106 matching lines @@
   for (std::set<std::string>::const_iterator it = extension_ids.begin();
        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(
       chrome::NOTIFICATION_EXTENSION_UPDATE_FOUND,
       content::NotificationService::AllBrowserContextsAndSources(),
       content::Details<UpdateDetails>(&updateInfo));
 }
 
 }  // namespace extensions