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

chrome/browser/component_updater/recovery_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/recovery_component_installer.h"
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 28 matching lines @@
 #else  // OS_LINUX, OS_MACOSX, etc.
     FILE_PATH_LITERAL("ChromeRecovery");
 #endif
 
 const char kRecoveryManifestName[] = "ChromeRecovery";
 
 }  // namespace
 
 class RecoveryComponentInstaller : public ComponentInstaller {
  public:
-  explicit RecoveryComponentInstaller(const base::Version& version,
+  explicit RecoveryComponentInstaller(const Version& version,
                                       PrefService* prefs);
 
   virtual ~RecoveryComponentInstaller() {}
 
   virtual void OnUpdateError(int error) OVERRIDE;
 
   virtual bool Install(const base::DictionaryValue& manifest,
                        const base::FilePath& unpack_path) OVERRIDE;
 
   virtual bool GetInstalledFile(const std::string& file,
                                 base::FilePath* installed_file) OVERRIDE;
 
  private:
-  base::Version current_version_;
+  Version current_version_;
   PrefService* prefs_;
 };
 
 void RecoveryRegisterHelper(ComponentUpdateService* cus,
                             PrefService* prefs) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  base::Version version(prefs->GetString(prefs::kRecoveryComponentVersion));
+  Version version(prefs->GetString(prefs::kRecoveryComponentVersion));
   if (!version.IsValid()) {
     NOTREACHED();
     return;
   }
 
   CrxComponent recovery;
   recovery.name = "recovery";
   recovery.installer = new RecoveryComponentInstaller(version, prefs);
   recovery.version = version;
   recovery.pk_hash.assign(kSha2Hash, &kSha2Hash[sizeof(kSha2Hash)]);
   if (cus->RegisterComponent(recovery) != ComponentUpdateService::kOk) {
     NOTREACHED() << "Recovery component registration failed.";
   }
 }
 
-void RecoveryUpdateVersionHelper(const base::Version& version,
-                                 PrefService* prefs) {
+void RecoveryUpdateVersionHelper(const Version& version, PrefService* prefs) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   prefs->SetString(prefs::kRecoveryComponentVersion, version.GetString());
 }
 
 RecoveryComponentInstaller::RecoveryComponentInstaller(
-      const base::Version& version, PrefService* prefs)
+      const Version& version, PrefService* prefs)
     : current_version_(version), prefs_(prefs){
   DCHECK(version.IsValid());
 }
 
 void RecoveryComponentInstaller::OnUpdateError(int error) {
   NOTREACHED() << "Recovery component update error: " << error;
 }
 
 bool RecoveryComponentInstaller::Install(const base::DictionaryValue& manifest,
                                          const base::FilePath& unpack_path) {
   std::string name;
   manifest.GetStringASCII("name", &name);
   if (name != kRecoveryManifestName)
     return false;
   std::string proposed_version;
   manifest.GetStringASCII("version", &proposed_version);
-  base::Version version(proposed_version.c_str());
+  Version version(proposed_version.c_str());
   if (!version.IsValid())
     return false;
   if (current_version_.CompareTo(version) >= 0)
     return false;
   base::FilePath main_file = unpack_path.Append(kRecoveryFileName);
   if (!base::PathExists(main_file))
     return false;
   // Passed the basic tests. The installation continues with the
   // recovery component itself running from the temp directory.
   CommandLine cmdline(main_file);
@@ skipping 27 matching lines @@
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&RecoveryRegisterHelper, cus, prefs),
       base::TimeDelta::FromSeconds(6));
 #endif
 }
 
 void RegisterPrefsForRecoveryComponent(PrefRegistrySimple* registry) {
   registry->RegisterStringPref(prefs::kRecoveryComponentVersion, "0.0.0.0");
 }