Attempt to remove non-namespaced base::Version usage.

chrome/browser/component_updater/pnacl_component_installer.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/component_updater/pnacl_component_installer.h"
 
 #include <stdint.h>
 #include <string>
 #include <vector>
 
@@ skipping 77 matching lines @@
   return base_path.AppendASCII("_platform_specific").AppendASCII(arch);
 }
 
 // Tell the rest of the world where to find the platform-specific PNaCl files.
 void OverrideDirPnaclComponent(const base::FilePath& base_path) {
   PathService::Override(chrome::DIR_PNACL_COMPONENT, GetPlatformDir(base_path));
 }
 
 bool GetLatestPnaclDirectory(const scoped_refptr<PnaclComponentInstaller>& pci,
                              base::FilePath* latest_dir,
-                             Version* latest_version,
+                             base::Version* latest_version,
                              std::vector<base::FilePath>* older_dirs) {
   // Enumerate all versions starting from the base directory.
   base::FilePath base_dir = pci->GetPnaclBaseDirectory();
   bool found = false;
   base::FileEnumerator file_enumerator(
       base_dir, false, base::FileEnumerator::DIRECTORIES);
   for (base::FilePath path = file_enumerator.Next(); !path.value().empty();
        path = file_enumerator.Next()) {
-    Version version(path.BaseName().MaybeAsASCII());
+    base::Version version(path.BaseName().MaybeAsASCII());
     if (!version.IsValid())
       continue;
     if (found) {
       if (version.CompareTo(*latest_version) > 0) {
         older_dirs->push_back(*latest_dir);
         *latest_dir = path;
         *latest_version = version;
       } else {
         older_dirs->push_back(path);
       }
@@ skipping 34 matching lines @@
       unpack_path.Append(FILE_PATH_LITERAL("manifest.json"));
   if (!base::PathExists(manifest_path))
     return NULL;
   return ReadJSONManifest(manifest_path);
 }
 
 // Check that the component's manifest is for PNaCl, and check the
 // PNaCl manifest indicates this is the correct arch-specific package.
 bool CheckPnaclComponentManifest(const base::DictionaryValue& manifest,
                                  const base::DictionaryValue& pnacl_manifest,
-                                 Version* version_out) {
+                                 base::Version* version_out) {
   // Make sure we have the right |manifest| file.
   std::string name;
   if (!manifest.GetStringASCII("name", &name)) {
     LOG(WARNING) << "'name' field is missing from manifest!";
     return false;
   }
   // For the webstore, we've given different names to each of the
   // architecture specific packages (and test/QA vs not test/QA)
   // so only part of it is the same.
   if (name.find(kPnaclManifestName) == std::string::npos) {
     LOG(WARNING) << "'name' field in manifest is invalid (" << name
                  << ") -- missing (" << kPnaclManifestName << ")";
     return false;
   }
 
   std::string proposed_version;
   if (!manifest.GetStringASCII("version", &proposed_version)) {
     LOG(WARNING) << "'version' field is missing from manifest!";
     return false;
   }
-  Version version(proposed_version.c_str());
+  base::Version version(proposed_version.c_str());
   if (!version.IsValid()) {
     LOG(WARNING) << "'version' field in manifest is invalid "
                  << version.GetString();
     return false;
   }
 
   // Now check the |pnacl_manifest|.
   std::string arch;
   if (!pnacl_manifest.GetStringASCII("pnacl-arch", &arch)) {
     LOG(WARNING) << "'pnacl-arch' field is missing from pnacl-manifest!";
@@ skipping 33 matching lines @@
 
 bool PnaclComponentInstaller::Install(const base::DictionaryValue& manifest,
                                       const base::FilePath& unpack_path) {
   std::unique_ptr<base::DictionaryValue> pnacl_manifest(
       ReadPnaclManifest(unpack_path));
   if (pnacl_manifest == NULL) {
     LOG(WARNING) << "Failed to read pnacl manifest.";
     return false;
   }
 
-  Version version;
+  base::Version version;
   if (!CheckPnaclComponentManifest(manifest, *pnacl_manifest, &version)) {
     LOG(WARNING) << "CheckPnaclComponentManifest failed, not installing.";
     return false;
   }
 
   // Don't install if the current version is actually newer.
   if (current_version().CompareTo(version) > 0) {
     return false;
   }
 
@@ skipping 17 matching lines @@
   OverrideDirPnaclComponent(path);
   return true;
 }
 
 // Given |file|, which can be a path like "_platform_specific/arm/pnacl_foo",
 // returns the assumed install path. The path separator in |file| is '/'
 // for all platforms. Caller is responsible for checking that the
 // |installed_file| actually exists.
 bool PnaclComponentInstaller::GetInstalledFile(const std::string& file,
                                                base::FilePath* installed_file) {
-  if (current_version() == Version(kNullVersion))
+  if (current_version() == base::Version(kNullVersion))
     return false;
 
   *installed_file = GetPnaclBaseDirectory()
                         .AppendASCII(current_version().GetString())
                         .AppendASCII(file);
   return true;
 }
 
 bool PnaclComponentInstaller::Uninstall() {
   return false;
 }
 
 CrxComponent PnaclComponentInstaller::GetCrxComponent() {
   CrxComponent pnacl_component;
   pnacl_component.version = current_version();
   pnacl_component.name = "pnacl";
   pnacl_component.installer = this;
   pnacl_component.fingerprint = current_fingerprint();
   SetPnaclHash(&pnacl_component);
 
   return pnacl_component;
 }
 
 namespace {
 
 void FinishPnaclUpdateRegistration(
-    const Version& current_version,
+    const base::Version& current_version,
     const std::string& current_fingerprint,
     const scoped_refptr<PnaclComponentInstaller>& pci) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   pci->set_current_version(current_version);
   CheckVersionCompatiblity(current_version);
   pci->set_current_fingerprint(current_fingerprint);
   CrxComponent pnacl_component = pci->GetCrxComponent();
 
   if (!pci->cus()->RegisterComponent(pnacl_component))
     NOTREACHED() << "Pnacl component registration failed.";
 }
 
 // Check if there is an existing version on disk first to know when
 // a hosted version is actually newer.
 void StartPnaclUpdateRegistration(
     const scoped_refptr<PnaclComponentInstaller>& pci) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   base::FilePath path = pci->GetPnaclBaseDirectory();
   if (!base::PathExists(path)) {
     if (!base::CreateDirectory(path)) {
       NOTREACHED() << "Could not create base Pnacl directory.";
       return;
     }
   }
 
-  Version current_version(kNullVersion);
+  base::Version current_version(kNullVersion);
   std::string current_fingerprint;
   std::vector<base::FilePath> older_dirs;
   if (GetLatestPnaclDirectory(pci, &path, &current_version, &older_dirs)) {
     std::unique_ptr<base::DictionaryValue> manifest(
         ReadComponentManifest(path));
     std::unique_ptr<base::DictionaryValue> pnacl_manifest(
         ReadPnaclManifest(path));
-    Version manifest_version;
+    base::Version manifest_version;
     // Check that the component manifest and PNaCl manifest files
     // are legit, and that the indicated version matches the one
     // encoded within the path name.
     if (manifest == NULL || pnacl_manifest == NULL ||
         !CheckPnaclComponentManifest(*manifest,
                                      *pnacl_manifest,
                                      &manifest_version) ||
         current_version != manifest_version) {
-      current_version = Version(kNullVersion);
+      current_version = base::Version(kNullVersion);
     } else {
       OverrideDirPnaclComponent(path);
       base::ReadFileToString(path.AppendASCII("manifest.fingerprint"),
                              &current_fingerprint);
     }
   }
 
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           base::Bind(&FinishPnaclUpdateRegistration,
@@ skipping 22 matching lines @@
 }  // namespace component_updater
 
 namespace pnacl {
 
 bool NeedsOnDemandUpdate() {
   return base::subtle::NoBarrier_Load(
              &component_updater::needs_on_demand_update) != 0;
 }
 
 }  // namespace pnacl