Revert "Update all users of base::Version to explicitly specify the namespace, and clean up the hea…

chrome/browser/component_updater/pnacl/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/pnacl_component_installer.h"
 
 #include "base/atomicops.h"
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 72 matching lines @@
 }
 
 // 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(PnaclComponentInstaller* pci,
                              base::FilePath* latest_dir,
-                             base::Version* latest_version,
+                             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()) {
-    base::Version version(path.BaseName().MaybeAsASCII());
+    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 35 matching lines @@
       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,
-                                 base::Version* version_out) {
+                                 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;
   }
-  base::Version version(proposed_version.c_str());
+  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 61 matching lines @@
 
 bool PnaclComponentInstaller::Install(const base::DictionaryValue& manifest,
                                       const base::FilePath& unpack_path) {
   scoped_ptr<base::DictionaryValue> pnacl_manifest(
       ReadPnaclManifest(unpack_path));
   if (pnacl_manifest == NULL) {
     LOG(WARNING) << "Failed to read pnacl manifest.";
     return false;
   }
 
-  base::Version version;
+  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().Equals(base::Version(kNullVersion)))
+  if (current_version().Equals(Version(kNullVersion)))
     return false;
 
   *installed_file = GetPnaclBaseDirectory().AppendASCII(
       current_version().GetString()).AppendASCII(file);
   return true;
 }
 
 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 base::Version& current_version,
+void FinishPnaclUpdateRegistration(const Version& current_version,
                                    const std::string& current_fingerprint,
                                    PnaclComponentInstaller* pci) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   pci->set_current_version(current_version);
   CheckVersionCompatiblity(current_version);
   pci->set_current_fingerprint(current_fingerprint);
   CrxComponent pnacl_component = pci->GetCrxComponent();
 
   ComponentUpdateService::Status status =
       pci->cus()->RegisterComponent(pnacl_component);
   if (status != ComponentUpdateService::kOk
       && status != ComponentUpdateService::kReplaced) {
     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(PnaclComponentInstaller* pci) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   base::FilePath path = pci->GetPnaclBaseDirectory();
   if (!base::PathExists(path)) {
     if (!base::CreateDirectory(path)) {
       NOTREACHED() << "Could not create base Pnacl directory.";
       return;
     }
   }
 
-  base::Version current_version(kNullVersion);
+  Version current_version(kNullVersion);
   std::string current_fingerprint;
   std::vector<base::FilePath> older_dirs;
   if (GetLatestPnaclDirectory(pci, &path, &current_version, &older_dirs)) {
     scoped_ptr<base::DictionaryValue> manifest(
         ReadComponentManifest(path));
     scoped_ptr<base::DictionaryValue> pnacl_manifest(
         ReadPnaclManifest(path));
-    base::Version manifest_version;
+    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.Equals(manifest_version)) {
-      current_version = base::Version(kNullVersion);
+      current_version = Version(kNullVersion);
     } else {
       OverrideDirPnaclComponent(path);
       base::ReadFileToString(path.AppendASCII("manifest.fingerprint"),
                              &current_fingerprint);
     }
   }
 
   // If updates are disabled, only discover the current version
   // and OverrideDirPnaclComponent. That way, developers can use
   // a pinned version. Do not actually finish registration with
@@ skipping 78 matching lines @@
 }
 
 
 namespace pnacl {
 
 bool NeedsOnDemandUpdate() {
   return base::subtle::NoBarrier_Load(&needs_on_demand_update) != 0;
 }
 
 }  // namespace pnacl