Remove two deprecated methods from base::Version

chrome/browser/gpu_blacklist.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/gpu_blacklist.h"
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/version.h"
 #include "chrome/browser/gpu_util.h"
 #include "chrome/common/chrome_version_info.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/gpu_info.h"
 
 using content::GpuDataManager;
 using content::GpuFeatureType;
 
 namespace {
 
 // Encode a date as Version, where [0] is year, [1] is month, and [2] is day.
-Version* GetDateFromString(const std::string& date_string) {
+void GetDateFromString(const std::string& date_string, Version* version) {
   // TODO(zmo): verify if in Windows registry, driver dates are always in the
   // format of "mm-dd-yyyy".
   std::vector<std::string> pieces;
   base::SplitString(date_string, '-', &pieces);
-  if (pieces.size() != 3)
-    return NULL;
+  if (pieces.size() != 3) {
+    *version = Version();
+    return;
+  }
   std::string date_as_version_string = pieces[2];
   for (size_t i = 0; i < 2; ++i) {
     date_as_version_string += ".";
     date_as_version_string += pieces[i];
   }
-  return Version::GetVersionFromString(date_as_version_string);
+  *version = Version(date_as_version_string);
 }
 
 // We assume the input format is major.minor, and we treat major version
 // as numerical and minor as lexical.
 // Otherwise we simply return the original string.
 // For example, if input numerical is 8.103, returned lexical is 8.1.0.3.
 std::string NumericalToLexical(const std::string& numerical) {
   std::string lexical;
   bool valid = true;
   size_t pos = numerical.find_first_of('.');
@@ skipping 34 matching lines @@
     return;
   version_style_ = StringToVersionStyle(version_style);
   std::string processed_version_string, processed_version_string2;
   if (version_style_ == kVersionStyleLexical) {
     processed_version_string = NumericalToLexical(version_string);
     processed_version_string2 = NumericalToLexical(version_string2);
   } else {
     processed_version_string = version_string;
     processed_version_string2 = version_string2;
   }
-  version_.reset(Version::GetVersionFromString(processed_version_string));
-  if (version_.get() == NULL) {
+  version_.reset(new Version(processed_version_string));
+  if (!version_->IsValid()) {
     op_ = kUnknown;
     return;
   }
   if (op_ == kBetween) {
-    version2_.reset(Version::GetVersionFromString(processed_version_string2));
-    if (version2_.get() == NULL)
+    version2_.reset(new Version(processed_version_string2));
+    if (!version2_->IsValid())
       op_ = kUnknown;
   }
 }
 
 GpuBlacklist::VersionInfo::~VersionInfo() {
 }
 
 bool GpuBlacklist::VersionInfo::Contains(const Version& version) const {
   if (op_ == kUnknown)
     return false;
@@ skipping 676 matching lines @@
   }
   if (driver_vendor_info_.get() != NULL &&
       !driver_vendor_info_->Contains(gpu_info.driver_vendor))
     return false;
   if (driver_version_info_.get() != NULL) {
     std::string processed_driver_version;
     if (driver_version_info_->IsLexical())
       processed_driver_version = NumericalToLexical(gpu_info.driver_version);
     else
       processed_driver_version = gpu_info.driver_version;
-    scoped_ptr<Version> driver_version(
-        Version::GetVersionFromString(processed_driver_version));
-    if (driver_version.get() == NULL ||
-        !driver_version_info_->Contains(*driver_version))
+    Version driver_version(processed_driver_version);
+    if (!driver_version.IsValid() ||
+        !driver_version_info_->Contains(driver_version))
       return false;
   }
   if (driver_date_info_.get() != NULL) {
-    scoped_ptr<Version> driver_date(GetDateFromString(gpu_info.driver_date));
-    if (driver_date.get() == NULL ||
-        !driver_date_info_->Contains(*driver_date))
+    Version driver_date;
+    GetDateFromString(gpu_info.driver_date, &driver_date);
+    if (!driver_date.IsValid() || !driver_date_info_->Contains(driver_date))
       return false;
   }
   if (gl_vendor_info_.get() != NULL &&
       !gl_vendor_info_->Contains(gpu_info.gl_vendor))
     return false;
   if (gl_renderer_info_.get() != NULL &&
       !gl_renderer_info_->Contains(gpu_info.gl_renderer))
     return false;
   if (perf_graphics_info_.get() != NULL &&
       (gpu_info.performance_stats.graphics == 0.0 ||
@@ skipping 53 matching lines @@
   chrome::VersionInfo chrome_version_info;
   std::string chrome_version_string =
       chrome_version_info.is_valid() ? chrome_version_info.Version() : "0";
   return LoadGpuBlacklist(chrome_version_string, json_context, os_filter);
 }
 
 bool GpuBlacklist::LoadGpuBlacklist(
     const std::string& browser_version_string,
     const std::string& json_context,
     GpuBlacklist::OsFilter os_filter) {
-  browser_version_.reset(Version::GetVersionFromString(browser_version_string));
-  DCHECK(browser_version_.get() != NULL);
+  browser_version_.reset(new Version(browser_version_string));
+  DCHECK(browser_version_->IsValid());
 
   scoped_ptr<Value> root;
   root.reset(base::JSONReader::Read(json_context));
   if (root.get() == NULL || !root->IsType(Value::TYPE_DICTIONARY))
     return false;
 
   DictionaryValue* root_dictionary = static_cast<DictionaryValue*>(root.get());
   DCHECK(root_dictionary);
   return LoadGpuBlacklist(*root_dictionary, os_filter);
 }
 
 bool GpuBlacklist::LoadGpuBlacklist(
     const DictionaryValue& parsed_json, GpuBlacklist::OsFilter os_filter) {
   std::vector<ScopedGpuBlacklistEntry> entries;
 
   std::string version_string;
   parsed_json.GetString("version", &version_string);
-  version_.reset(Version::GetVersionFromString(version_string));
-  if (version_.get() == NULL)
+  version_.reset(new Version(version_string));
+  if (!version_->IsValid())
     return false;
 
   ListValue* list = NULL;
   if (!parsed_json.GetList("entries", &list))
     return false;
 
   uint32 max_entry_id = 0;
   bool contains_unknown_fields = false;
   for (size_t i = 0; i < list->GetSize(); ++i) {
     DictionaryValue* list_item = NULL;
@@ skipping 47 matching lines @@
   int type = 0;
 
   if (os == kOsAny)
     os = GetOsType();
   scoped_ptr<Version> my_os_version;
   if (os_version == NULL) {
     std::string version_string = base::SysInfo::OperatingSystemVersion();
     size_t pos = version_string.find_first_not_of("0123456789.");
     if (pos != std::string::npos)
       version_string = version_string.substr(0, pos);
-    my_os_version.reset(Version::GetVersionFromString(version_string));
+    my_os_version.reset(new Version(version_string));
     os_version = my_os_version.get();
   }
   DCHECK(os_version != NULL);
 
   for (size_t i = 0; i < blacklist_.size(); ++i) {
     if (blacklist_[i]->Contains(os, *os_version, gpu_info)) {
       if (!blacklist_[i]->disabled())
         type |= blacklist_[i]->GetGpuFeatureType();
       active_entries_.push_back(blacklist_[i]);
     }
@@ skipping 130 matching lines @@
     return kGT;
   if (op == ">=")
     return kGE;
   if (op == "any")
     return kAny;
   if (op == "between")
     return kBetween;
   return kUnknown;
 }