Remove two deprecated methods from base::Version

chrome/browser/gpu_blacklist_unittest.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 <vector>
 
 #include "base/base_paths.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 58 matching lines @@
   ASSERT_EQ(file_util::ReadFile(data_file, data.get(), data_file_size),
             data_file_size);
   std::string json_string(data.get(), data_file_size);
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       json_string, GpuBlacklist::kAllOs));
   EXPECT_FALSE(blacklist->contains_unknown_fields());
 }
 
 TEST_F(GpuBlacklistTest, DefaultBlacklistSettings) {
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
   scoped_ptr<GpuBlacklist> blacklist(Create());
   // Default blacklist settings: all feature are allowed.
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
+      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
   EXPECT_EQ(type, 0);
 }
 
 TEST_F(GpuBlacklistTest, EmptyBlacklist) {
   // Empty list: all features are allowed.
   const std::string empty_list_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"2.5\",\n"
       "  \"entries\": [\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
   scoped_ptr<GpuBlacklist> blacklist(Create());
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       empty_list_json, GpuBlacklist::kAllOs));
   EXPECT_EQ(blacklist->GetVersion(), std::string("2.5"));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
+      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
   EXPECT_EQ(type, 0);
 }
 
 TEST_F(GpuBlacklistTest, DetailedEntryAndInvalidJson) {
   // Blacklist accelerated_compositing with exact setting.
   const std::string exact_list_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
@@ skipping 11 matching lines @@
       "      \"driver_version\": {\n"
       "        \"op\": \"=\",\n"
       "        \"number\": \"1.6.18\"\n"
       "      },\n"
       "      \"blacklist\": [\n"
       "        \"accelerated_compositing\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
   scoped_ptr<GpuBlacklist> blacklist(Create());
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       exact_list_json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
+      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING);
 
   // Invalid json input should not change the current blacklist settings.
   const std::string invalid_json = "invalid";
 
   EXPECT_FALSE(blacklist->LoadGpuBlacklist(
       invalid_json, GpuBlacklist::kAllOs));
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
+      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING);
   std::vector<uint32> entries;
   bool disabled = false;
   blacklist->GetGpuFeatureTypeEntries(
       content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING, entries, disabled);
   EXPECT_EQ(entries.size(), 1u);
   EXPECT_EQ(entries[0], 5u);
   blacklist->GetGpuFeatureTypeEntries(
       content::GPU_FEATURE_TYPE_ALL, entries, disabled);
   EXPECT_EQ(entries.size(), 1u);
@@ skipping 10 matching lines @@
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"vendor_id\": \"0x10de\",\n"
       "      \"blacklist\": [\n"
       "        \"webgl\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
   scoped_ptr<GpuBlacklist> blacklist(Create());
 
   // Blacklist entries won't be filtered to the current OS only upon loading.
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       vendor_json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
+      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info());
+      GpuBlacklist::kOsLinux, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 #if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_MACOSX) || \
     defined(OS_OPENBSD)
   // Blacklist entries will be filtered to the current OS only upon loading.
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       vendor_json, GpuBlacklist::kCurrentOsOnly));
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
+      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info());
+      GpuBlacklist::kOsLinux, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 #endif
 }
 
 TEST_F(GpuBlacklistTest, VendorOnLinuxEntry) {
   // Blacklist a vendor on Linux only.
   const std::string vendor_linux_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"os\": {\n"
       "        \"type\": \"linux\"\n"
       "      },\n"
       "      \"vendor_id\": \"0x10de\",\n"
       "      \"blacklist\": [\n"
       "        \"accelerated_2d_canvas\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
   scoped_ptr<GpuBlacklist> blacklist(Create());
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       vendor_linux_json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
+      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
   EXPECT_EQ(type, 0);
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, 0);
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info());
+      GpuBlacklist::kOsLinux, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS);
 }
 
 TEST_F(GpuBlacklistTest, AllExceptNVidiaOnLinuxEntry) {
   // Blacklist all cards in Linux except NVIDIA.
   const std::string linux_except_nvidia_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"os\": {\n"
       "        \"type\": \"linux\"\n"
       "      },\n"
       "      \"exceptions\": [\n"
       "        {\n"
       "          \"vendor_id\": \"0x10de\"\n"
       "        }\n"
       "      ],\n"
       "      \"blacklist\": [\n"
       "        \"accelerated_2d_canvas\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
   scoped_ptr<GpuBlacklist> blacklist(Create());
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       linux_except_nvidia_json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
+      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
   EXPECT_EQ(type, 0);
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, 0);
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info());
+      GpuBlacklist::kOsLinux, &os_version, gpu_info());
   EXPECT_EQ(type, 0);
 }
 
 TEST_F(GpuBlacklistTest, AllExceptIntelOnLinuxEntry) {
   // Blacklist all cards in Linux except Intel.
   const std::string linux_except_intel_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"os\": {\n"
       "        \"type\": \"linux\"\n"
       "      },\n"
       "      \"exceptions\": [\n"
       "        {\n"
       "          \"vendor_id\": \"0x8086\"\n"
       "        }\n"
       "      ],\n"
       "      \"blacklist\": [\n"
       "        \"accelerated_2d_canvas\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
   scoped_ptr<GpuBlacklist> blacklist(Create());
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       linux_except_intel_json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
+      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
   EXPECT_EQ(type, 0);
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, 0);
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info());
+      GpuBlacklist::kOsLinux, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS);
 }
 
 TEST_F(GpuBlacklistTest, DateOnWindowsEntry) {
   // Blacklist all drivers earlier than 2010-01 in Windows.
   const std::string date_windows_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"os\": {\n"
       "        \"type\": \"win\"\n"
       "      },\n"
       "      \"driver_date\": {\n"
       "        \"op\": \"<\",\n"
       "        \"number\": \"2010.1\"\n"
       "      },\n"
       "      \"blacklist\": [\n"
       "        \"accelerated_2d_canvas\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
   scoped_ptr<GpuBlacklist> blacklist(Create());
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       date_windows_json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
+      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
   EXPECT_EQ(type, 0);
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info());
+      GpuBlacklist::kOsLinux, &os_version, gpu_info());
   EXPECT_EQ(type, 0);
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS);
 }
 
 TEST_F(GpuBlacklistTest, MultipleDevicesEntry) {
   const std::string devices_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"vendor_id\": \"0x10de\",\n"
       "      \"device_id\": [\"0x1023\", \"0x0640\"],\n"
       "      \"blacklist\": [\n"
       "        \"multisampling\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
   scoped_ptr<GpuBlacklist> blacklist(Create());
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       devices_json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
+      GpuBlacklist::kOsMacosx, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_MULTISAMPLING);
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_MULTISAMPLING);
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info());
+      GpuBlacklist::kOsLinux, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_MULTISAMPLING);
 }
 
 TEST_F(GpuBlacklistTest, ChromeOSEntry) {
   const std::string devices_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"os\": {\n"
       "        \"type\": \"chromeos\"\n"
       "      },\n"
       "      \"blacklist\": [\n"
       "        \"webgl\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
   scoped_ptr<GpuBlacklist> blacklist(Create());
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       devices_json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsChromeOS, os_version.get(), gpu_info());
+      GpuBlacklist::kOsChromeOS, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info());
+      GpuBlacklist::kOsLinux, &os_version, gpu_info());
   EXPECT_EQ(type, 0);
 }
 
 TEST_F(GpuBlacklistTest, ChromeVersionEntry) {
   const std::string browser_version_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"browser_version\": {\n"
       "        \"op\": \">=\",\n"
       "        \"number\": \"10\"\n"
       "      },\n"
       "      \"blacklist\": [\n"
       "        \"webgl\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
 
   scoped_ptr<GpuBlacklist> blacklist9(Create());
   EXPECT_TRUE(blacklist9->LoadGpuBlacklist(
       "9.0", browser_version_json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist9->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, 0);
 
   scoped_ptr<GpuBlacklist> blacklist10(Create());
   EXPECT_TRUE(blacklist10->LoadGpuBlacklist(
       "10.0", browser_version_json, GpuBlacklist::kAllOs));
   type = blacklist10->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
 TEST_F(GpuBlacklistTest, MalformedVendor) {
   // vendor_id is defined as list instead of string.
   const std::string malformed_vendor_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
@@ skipping 26 matching lines @@
       "      ]\n"
       "    },\n"
       "    {\n"
       "      \"id\": 2,\n"
       "      \"blacklist\": [\n"
       "        \"webgl\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
   scoped_ptr<GpuBlacklist> blacklist(Create());
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       unknown_field_json, GpuBlacklist::kAllOs));
   EXPECT_EQ(1u, blacklist->num_entries());
   EXPECT_TRUE(blacklist->contains_unknown_fields());
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
 TEST_F(GpuBlacklistTest, UnknownExceptionField) {
   const std::string unknown_exception_field_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
@@ skipping 15 matching lines @@
       "      ]\n"
       "    },\n"
       "    {\n"
       "      \"id\": 3,\n"
       "      \"blacklist\": [\n"
       "        \"webgl\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
   scoped_ptr<GpuBlacklist> blacklist(Create());
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       unknown_exception_field_json, GpuBlacklist::kAllOs));
   EXPECT_EQ(1u, blacklist->num_entries());
   EXPECT_TRUE(blacklist->contains_unknown_fields());
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
 TEST_F(GpuBlacklistTest, UnknownFeature) {
   const std::string unknown_feature_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"blacklist\": [\n"
       "        \"accelerated_something\",\n"
       "        \"webgl\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
   scoped_ptr<GpuBlacklist> blacklist(Create());
 
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       unknown_feature_json, GpuBlacklist::kAllOs));
   EXPECT_EQ(1u, blacklist->num_entries());
   EXPECT_TRUE(blacklist->contains_unknown_fields());
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
 TEST_F(GpuBlacklistTest, GlVendor) {
   const std::string gl_vendor_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"gl_vendor\": {\n"
       "        \"op\": \"beginwith\",\n"
       "        \"value\": \"NVIDIA\"\n"
       "      },\n"
       "      \"blacklist\": [\n"
       "        \"webgl\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
 
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       gl_vendor_json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
 TEST_F(GpuBlacklistTest, GlRenderer) {
   const std::string gl_renderer_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"gl_renderer\": {\n"
       "        \"op\": \"contains\",\n"
       "        \"value\": \"GeForce\"\n"
       "      },\n"
       "      \"blacklist\": [\n"
       "        \"webgl\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
 
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       gl_renderer_json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
 TEST_F(GpuBlacklistTest, PerfGraphics) {
   const std::string json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"perf_graphics\": {\n"
       "        \"op\": \"<\",\n"
       "        \"value\": \"6.0\"\n"
       "      },\n"
       "      \"blacklist\": [\n"
       "        \"webgl\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
 
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
 TEST_F(GpuBlacklistTest, PerfGaming) {
   const std::string json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"perf_gaming\": {\n"
       "        \"op\": \"<=\",\n"
       "        \"value\": \"4.0\"\n"
       "      },\n"
       "      \"blacklist\": [\n"
       "        \"webgl\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
 
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, 0);
 }
 
 TEST_F(GpuBlacklistTest, PerfOverall) {
   const std::string json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"perf_overall\": {\n"
       "        \"op\": \"between\",\n"
       "        \"value\": \"1.0\",\n"
       "        \"value2\": \"9.0\"\n"
       "      },\n"
       "      \"blacklist\": [\n"
       "        \"webgl\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
 
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
 TEST_F(GpuBlacklistTest, DisabledEntry) {
   const std::string disabled_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"disabled\": true,\n"
       "      \"blacklist\": [\n"
       "        \"webgl\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
 
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       disabled_json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+      GpuBlacklist::kOsWin, &os_version, gpu_info());
   EXPECT_EQ(type, 0);
   std::vector<uint32> flag_entries;
   bool disabled = false;
   blacklist->GetGpuFeatureTypeEntries(
       content::GPU_FEATURE_TYPE_ALL, flag_entries, disabled);
   EXPECT_EQ(flag_entries.size(), 0u);
   disabled = true;
   blacklist->GetGpuFeatureTypeEntries(
       content::GPU_FEATURE_TYPE_ALL, flag_entries, disabled);
   EXPECT_EQ(flag_entries.size(), 1u);
@@ skipping 10 matching lines @@
       "      \"os\": {\n"
       "        \"type\": \"linux\"\n"
       "      },\n"
       "      \"multi_gpu_style\": \"optimus\",\n"
       "      \"blacklist\": [\n"
       "        \"webgl\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
 
   content::GPUInfo gpu_info;
   gpu_info.optimus = true;
 
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       optimus_json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info);
+      GpuBlacklist::kOsLinux, &os_version, gpu_info);
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
 TEST_F(GpuBlacklistTest, AMDSwitchable) {
   const std::string amd_switchable_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"os\": {\n"
       "        \"type\": \"macosx\"\n"
       "      },\n"
       "      \"multi_gpu_style\": \"amd_switchable\",\n"
       "      \"blacklist\": [\n"
       "        \"webgl\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
 
   content::GPUInfo gpu_info;
   gpu_info.amd_switchable = true;
 
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       amd_switchable_json, GpuBlacklist::kAllOs));
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info);
+      GpuBlacklist::kOsMacosx, &os_version, gpu_info);
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 }
 
 TEST_F(GpuBlacklistTest, LexicalDriverVersion) {
   const std::string lexical_json =
       "{\n"
       "  \"name\": \"gpu blacklist\",\n"
       "  \"version\": \"0.1\",\n"
       "  \"entries\": [\n"
       "    {\n"
       "      \"id\": 1,\n"
       "      \"os\": {\n"
       "        \"type\": \"linux\"\n"
       "      },\n"
       "      \"vendor_id\": \"0x1002\",\n"
       "      \"driver_version\": {\n"
       "        \"op\": \"<\",\n"
       "        \"style\": \"lexical\",\n"
       "        \"number\": \"8.201\"\n"
       "      },\n"
       "      \"blacklist\": [\n"
       "        \"webgl\"\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}";
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  Version os_version("10.6.4");
 
   content::GPUInfo gpu_info;
   gpu_info.gpu.vendor_id = 0x1002;
 
   scoped_ptr<GpuBlacklist> blacklist(Create());
   EXPECT_TRUE(blacklist->LoadGpuBlacklist(
       lexical_json, GpuBlacklist::kAllOs));
 
   gpu_info.driver_version = "8.109";
   GpuFeatureType type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info);
+      GpuBlacklist::kOsLinux, &os_version, gpu_info);
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 
   gpu_info.driver_version = "8.2";
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info);
+      GpuBlacklist::kOsLinux, &os_version, gpu_info);
   EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL);
 
   gpu_info.driver_version = "8.21";
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info);
+      GpuBlacklist::kOsLinux, &os_version, gpu_info);
   EXPECT_EQ(type, 0);
 
   gpu_info.driver_version = "8.2010";
   type = blacklist->DetermineGpuFeatureType(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info);
+      GpuBlacklist::kOsLinux, &os_version, gpu_info);
   EXPECT_EQ(type, 0);
 }
-