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

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 <stdint.h>
 
 #include <memory>
 #include <string>
@@ skipping 75 matching lines @@
 bool SimulatingElevatedRecovery() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kSimulateElevatedRecovery);
 }
 #endif  // !defined(OS_CHROMEOS)
 
 base::CommandLine GetRecoveryInstallCommandLine(
     const base::FilePath& command,
     const base::DictionaryValue& manifest,
     bool is_deferred_run,
-    const Version& version) {
+    const base::Version& version) {
   base::CommandLine command_line(command);
 
   // Add a flag to for re-attempted install with elevated privilege so that the
   // recovery executable can report back accordingly.
   if (is_deferred_run)
     command_line.AppendArg("/deferredrun");
 
   std::string arguments;
   if (manifest.GetStringASCII("x-recovery-args", &arguments))
     command_line.AppendArg(arguments);
@@ skipping 37 matching lines @@
   if (!base::PathExists(main_file) || !base::PathExists(manifest_file))
     return;
 
   std::unique_ptr<base::DictionaryValue> manifest(ReadManifest(manifest_file));
   std::string name;
   manifest->GetStringASCII("name", &name);
   if (name != kRecoveryManifestName)
     return;
   std::string proposed_version;
   manifest->GetStringASCII("version", &proposed_version);
-  const Version version(proposed_version.c_str());
+  const base::Version version(proposed_version.c_str());
   if (!version.IsValid())
     return;
 
   const bool is_deferred_run = true;
   const auto cmdline = GetRecoveryInstallCommandLine(
       main_file, *manifest, is_deferred_run, version);
 
   RecordRecoveryComponentUMAEvent(RCE_RUNNING_ELEVATED);
 
   base::LaunchOptions options;
@@ skipping 20 matching lines @@
 // or repair the Google update installation. This is a last resort safety
 // mechanism.
 // For user Chrome, recovery component just installs silently. For machine
 // Chrome, elevation may be needed. If that happens, the installer will set
 // preference flag prefs::kRecoveryComponentNeedsElevation to request that.
 // There is a global error service monitors this flag and will pop up
 // bubble if the flag is set to true.
 // See chrome/browser/recovery/recovery_install_global_error.cc for details.
 class RecoveryComponentInstaller : public update_client::CrxInstaller {
  public:
-  RecoveryComponentInstaller(const Version& version, PrefService* prefs);
+  RecoveryComponentInstaller(const base::Version& version, PrefService* prefs);
 
   // ComponentInstaller implementation:
   void OnUpdateError(int error) override;
 
   bool Install(const base::DictionaryValue& manifest,
                const base::FilePath& unpack_path) override;
 
   bool GetInstalledFile(const std::string& file,
                         base::FilePath* installed_file) override;
 
   bool Uninstall() override;
 
  private:
   ~RecoveryComponentInstaller() override {}
 
   bool RunInstallCommand(const base::CommandLine& cmdline,
                          const base::FilePath& installer_folder) const;
 
-  Version current_version_;
+  base::Version current_version_;
   PrefService* prefs_;
 };
 
 void SimulateElevatedRecoveryHelper(PrefService* prefs) {
   prefs->SetBoolean(prefs::kRecoveryComponentNeedsElevation, true);
 }
 
 void RecoveryRegisterHelper(ComponentUpdateService* cus, PrefService* prefs) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  Version version(prefs->GetString(prefs::kRecoveryComponentVersion));
+  base::Version version(prefs->GetString(prefs::kRecoveryComponentVersion));
   if (!version.IsValid()) {
     NOTREACHED();
     return;
   }
 
   update_client::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)) {
     NOTREACHED() << "Recovery component registration failed.";
   }
 }
 
-void RecoveryUpdateVersionHelper(const Version& version, PrefService* prefs) {
+void RecoveryUpdateVersionHelper(
+    const base::Version& version, PrefService* prefs) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   prefs->SetString(prefs::kRecoveryComponentVersion, version.GetString());
 }
 
 void SetPrefsForElevatedRecoveryInstall(const base::FilePath& unpack_path,
                                         PrefService* prefs) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   prefs->SetFilePath(prefs::kRecoveryComponentUnpackPath, unpack_path);
   prefs->SetBoolean(prefs::kRecoveryComponentNeedsElevation, true);
 }
 
-RecoveryComponentInstaller::RecoveryComponentInstaller(const Version& version,
-                                                       PrefService* prefs)
+RecoveryComponentInstaller::RecoveryComponentInstaller(
+    const base::Version& version, PrefService* prefs)
     : current_version_(version), prefs_(prefs) {
   DCHECK(version.IsValid());
 }
 
 void RecoveryComponentInstaller::OnUpdateError(int error) {
   RecordRecoveryComponentUMAEvent(RCE_COMPONENT_DOWNLOAD_ERROR);
   NOTREACHED() << "Recovery component update error: " << error;
 }
 
 #if defined(OS_WIN)
@@ skipping 69 matching lines @@
 #endif  // defined(OS_POSIX)
 
 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);
-  Version version(proposed_version.c_str());
+  base::Version version(proposed_version.c_str());
   if (!version.IsValid())
     return false;
   if (current_version_.CompareTo(version) >= 0)
     return false;
 
   // Passed the basic tests. Copy the installation to a permanent directory.
   base::FilePath path;
   if (!PathService::Get(DIR_RECOVERY_BASE, &path))
     return false;
   if (!base::PathExists(path) && !base::CreateDirectory(path))
@@ skipping 86 matching lines @@
 #endif  // OS_WIN
   prefs->SetBoolean(prefs::kRecoveryComponentNeedsElevation, false);
 }
 
 void DeclinedElevatedRecoveryInstall(PrefService* prefs) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   prefs->SetBoolean(prefs::kRecoveryComponentNeedsElevation, false);
 }
 
 }  // namespace component_updater