Comparison and streaming operators for base::Version

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 59 matching lines @@
 const char kMinPnaclVersion[] = "0.46.0.4";
 
 // Initially say that we do not need OnDemand updates. This should be
 // updated by CheckVersionCompatiblity(), before doing any URLRequests
 // that depend on PNaCl.
 volatile base::subtle::Atomic32 needs_on_demand_update = 0;
 
 void CheckVersionCompatiblity(const base::Version& current_version) {
   // Using NoBarrier, since needs_on_demand_update is standalone and does
   // not have other associated data.
-  base::subtle::NoBarrier_Store(&needs_on_demand_update,
-                                current_version.IsOlderThan(kMinPnaclVersion));
+  base::subtle::NoBarrier_Store(
+    &needs_on_demand_update,
+    current_version < base::Version(kMinPnaclVersion));
 }
 
 // PNaCl is packaged as a multi-CRX.  This returns the platform-specific
 // subdirectory that is part of that multi-CRX.
 base::FilePath GetPlatformDir(const base::FilePath& base_path) {
   std::string arch = SanitizeForPath(UpdateQueryParams::GetNaclArch());
   return base_path.AppendASCII("_platform_specific").AppendASCII(arch);
 }
 
 // Tell the rest of the world where to find the platform-specific PNaCl files.
@@ skipping 173 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(Version(kNullVersion)))
+  if (current_version() == Version(kNullVersion))
     return false;
 
   *installed_file = GetPnaclBaseDirectory()
                         .AppendASCII(current_version().GetString())
                         .AppendASCII(file);
   return true;
 }
 
 bool PnaclComponentInstaller::Uninstall() {
   return false;
@@ skipping 46 matching lines @@
     scoped_ptr<base::DictionaryValue> manifest(ReadComponentManifest(path));
     scoped_ptr<base::DictionaryValue> pnacl_manifest(ReadPnaclManifest(path));
     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 != manifest_version) {
       current_version = Version(kNullVersion);
     } else {
       OverrideDirPnaclComponent(path);
       base::ReadFileToString(path.AppendASCII("manifest.fingerprint"),
                              &current_fingerprint);
     }
   }
 
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
@@ skipping 23 matching lines @@
 }  // namespace component_updater
 
 namespace pnacl {
 
 bool NeedsOnDemandUpdate() {
   return base::subtle::NoBarrier_Load(
              &component_updater::needs_on_demand_update) != 0;
 }
 
 }  // namespace pnacl