convert //gpu to std::unique_ptr

gpu/config/gpu_control_list_unittest.cc

 // Copyright (c) 2013 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 "gpu/config/gpu_control_list.h"

[no sievers, 2016/04/05 19:02:42]

leave below

[Mostyn Bramley-Moore, 2016/04/05 21:35:32]

Fixed.

+
 #include <stdint.h>
 
+#include <memory>
 #include <vector>
 
-#include "base/memory/scoped_ptr.h"
-#include "gpu/config/gpu_control_list.h"
 #include "gpu/config/gpu_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 const char kOsVersion[] = "10.6.4";
 const uint32_t kIntelVendorId = 0x8086;
 const uint32_t kNvidiaVendorId = 0x10de;
 const uint32_t kAmdVendorId = 0x10de;
 
 #define LONG_STRING_CONST(...) #__VA_ARGS__
 
@@ skipping 40 matching lines @@
     gpu_info_.gl_renderer = "NVIDIA GeForce GT 120 OpenGL Engine";
   }
 
   void TearDown() override {}
 
  private:
   GPUInfo gpu_info_;
 };
 
 TEST_F(GpuControlListTest, DefaultControlListSettings) {
-  scoped_ptr<GpuControlList> control_list(Create());
+  std::unique_ptr<GpuControlList> control_list(Create());
   // Default control list settings: all feature are allowed.
   std::set<int> features = control_list->MakeDecision(
       GpuControlList::kOsMacosx, kOsVersion, gpu_info());
   EXPECT_EMPTY_SET(features);
 }
 
 TEST_F(GpuControlListTest, EmptyControlList) {
   // Empty list: all features are allowed.
   const std::string empty_list_json = LONG_STRING_CONST(
       {
         "name": "gpu control list",
         "version": "2.5",
         "entries": [
         ]
       }
   );
-  scoped_ptr<GpuControlList> control_list(Create());
+  std::unique_ptr<GpuControlList> control_list(Create());
 
   EXPECT_TRUE(control_list->LoadList(empty_list_json,
                                      GpuControlList::kAllOs));
   EXPECT_EQ("2.5", control_list->version());
   std::set<int> features = control_list->MakeDecision(
       GpuControlList::kOsMacosx, kOsVersion, gpu_info());
   EXPECT_EMPTY_SET(features);
 }
 
 TEST_F(GpuControlListTest, DetailedEntryAndInvalidJson) {
@@ skipping 18 matching lines @@
               "op": "=",
               "value": "1.6.18"
             },
             "features": [
               "test_feature_0"
             ]
           }
         ]
       }
   );
-  scoped_ptr<GpuControlList> control_list(Create());
+  std::unique_ptr<GpuControlList> control_list(Create());
 
   EXPECT_TRUE(control_list->LoadList(exact_list_json, GpuControlList::kAllOs));
   std::set<int> features = control_list->MakeDecision(
       GpuControlList::kOsMacosx, kOsVersion, gpu_info());
   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 
   // Invalid json input should not change the current control_list settings.
   const std::string invalid_json = "invalid";
 
   EXPECT_FALSE(control_list->LoadList(invalid_json, GpuControlList::kAllOs));
@@ skipping 17 matching lines @@
           {
             "id": 1,
             "vendor_id": "0x10de",
             "features": [
               "test_feature_0"
             ]
           }
         ]
       }
   );
-  scoped_ptr<GpuControlList> control_list(Create());
+  std::unique_ptr<GpuControlList> control_list(Create());
 
   // ControlList entries won't be filtered to the current OS only upon loading.
   EXPECT_TRUE(control_list->LoadList(vendor_json, GpuControlList::kAllOs));
   std::set<int> features = control_list->MakeDecision(
       GpuControlList::kOsMacosx, kOsVersion, gpu_info());
   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
   features = control_list->MakeDecision(
       GpuControlList::kOsWin, kOsVersion, gpu_info());
   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
   features = control_list->MakeDecision(
@@ skipping 31 matching lines @@
           },
           {
             "id": 2,
             "features": [
               "test_feature_0"
             ]
           }
         ]
       }
   );
-  scoped_ptr<GpuControlList> control_list(Create());
+  std::unique_ptr<GpuControlList> control_list(Create());
 
   EXPECT_FALSE(control_list->LoadList(
       unknown_field_json, GpuControlList::kAllOs));
 }
 
 TEST_F(GpuControlListTest, UnknownExceptionField) {
   const std::string unknown_exception_field_json = LONG_STRING_CONST(
       {
         "name": "gpu control list",
         "version": "0.1",
@@ skipping 18 matching lines @@
           },
           {
             "id": 3,
             "features": [
               "test_feature_0"
             ]
           }
         ]
       }
   );
-  scoped_ptr<GpuControlList> control_list(Create());
+  std::unique_ptr<GpuControlList> control_list(Create());
 
   EXPECT_FALSE(control_list->LoadList(
       unknown_exception_field_json, GpuControlList::kAllOs));
 }
 
 TEST_F(GpuControlListTest, DisabledEntry) {
   const std::string disabled_json = LONG_STRING_CONST(
       {
         "name": "gpu control list",
         "version": "0.1",
         "entries": [
           {
             "id": 1,
             "disabled": true,
             "features": [
               "test_feature_0"
             ]
           }
         ]
       }
   );
-  scoped_ptr<GpuControlList> control_list(Create());
+  std::unique_ptr<GpuControlList> control_list(Create());
   EXPECT_TRUE(control_list->LoadList(disabled_json, GpuControlList::kAllOs));
   std::set<int> features = control_list->MakeDecision(
       GpuControlList::kOsWin, kOsVersion, gpu_info());
   EXPECT_EMPTY_SET(features);
   std::vector<uint32_t> flag_entries;
   control_list->GetDecisionEntries(&flag_entries, false);
   EXPECT_EQ(0u, flag_entries.size());
   control_list->GetDecisionEntries(&flag_entries, true);
   EXPECT_EQ(1u, flag_entries.size());
 }
@@ skipping 17 matching lines @@
             "features": [
               "test_feature_0"
             ]
           }
         ]
       }
   );
   GPUInfo gpu_info;
   gpu_info.gpu.vendor_id = kNvidiaVendorId;
 
-  scoped_ptr<GpuControlList> control_list(Create());
+  std::unique_ptr<GpuControlList> control_list(Create());
   EXPECT_TRUE(control_list->LoadList(json, GpuControlList::kAllOs));
 
   std::set<int> features = control_list->MakeDecision(
       GpuControlList::kOsWin, kOsVersion, gpu_info);
   EXPECT_EMPTY_SET(features);
   EXPECT_TRUE(control_list->needs_more_info());
   std::vector<uint32_t> decision_entries;
   control_list->GetDecisionEntries(&decision_entries, false);
   EXPECT_EQ(0u, decision_entries.size());
 
@@ skipping 26 matching lines @@
             "features": [
               "test_feature_0"
             ]
           }
         ]
       }
   );
   GPUInfo gpu_info;
   gpu_info.gpu.vendor_id = kIntelVendorId;
 
-  scoped_ptr<GpuControlList> control_list(Create());
+  std::unique_ptr<GpuControlList> control_list(Create());
   EXPECT_TRUE(control_list->LoadList(json, GpuControlList::kAllOs));
 
   // The case this entry does not apply.
   std::set<int> features = control_list->MakeDecision(
       GpuControlList::kOsMacosx, kOsVersion, gpu_info);
   EXPECT_EMPTY_SET(features);
   EXPECT_FALSE(control_list->needs_more_info());
 
   // The case this entry might apply, but need more info.
   features = control_list->MakeDecision(
@@ skipping 49 matching lines @@
             "features": [
               "test_feature_0"
             ]
           }
         ]
       }
   );
   GPUInfo gpu_info;
   gpu_info.gpu.vendor_id = kIntelVendorId;
 
-  scoped_ptr<GpuControlList> control_list(Create());
+  std::unique_ptr<GpuControlList> control_list(Create());
   EXPECT_TRUE(control_list->LoadList(json, GpuControlList::kAllOs));
   std::set<int> features = control_list->MakeDecision(
       GpuControlList::kOsLinux, kOsVersion, gpu_info);
   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
   EXPECT_FALSE(control_list->needs_more_info());
 }
 
 TEST_F(GpuControlListTest, ExceptionWithoutVendorId) {
   const std::string json = LONG_STRING_CONST(
       {
@@ skipping 27 matching lines @@
             ]
           }
         ]
       }
   );
   GPUInfo gpu_info;
   gpu_info.gpu.vendor_id = kIntelVendorId;
   gpu_info.gpu.device_id = 0x2a02;
   gpu_info.driver_version = "9.1";
 
-  scoped_ptr<GpuControlList> control_list(Create());
+  std::unique_ptr<GpuControlList> control_list(Create());
   EXPECT_TRUE(control_list->LoadList(json, GpuControlList::kAllOs));
 
   std::set<int> features = control_list->MakeDecision(
       GpuControlList::kOsLinux, kOsVersion, gpu_info);
   EXPECT_EMPTY_SET(features);
 
   gpu_info.driver_version = "9.0";
   features = control_list->MakeDecision(
       GpuControlList::kOsLinux, kOsVersion, gpu_info);
   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
@@ skipping 22 matching lines @@
               },
               "multi_gpu_style": "amd_switchable_discrete",
               "features": [
                 "test_feature_0"
               ]
             }
           ]
         }
     );
 
-    scoped_ptr<GpuControlList> control_list(Create());
+    std::unique_ptr<GpuControlList> control_list(Create());
     EXPECT_TRUE(control_list->LoadList(json, GpuControlList::kAllOs));
 
     // Integrated GPU is active
     gpu_info.gpu.active = false;
     gpu_info.secondary_gpus[0].active = true;
     std::set<int> features = control_list->MakeDecision(
         GpuControlList::kOsWin, kOsVersion, gpu_info);
     EXPECT_EMPTY_SET(features);
 
     // Discrete GPU is active
@@ skipping 17 matching lines @@
               },
               "multi_gpu_style": "amd_switchable_integrated",
               "features": [
                 "test_feature_0"
               ]
             }
           ]
         }
     );
 
-    scoped_ptr<GpuControlList> control_list(Create());
+    std::unique_ptr<GpuControlList> control_list(Create());
     EXPECT_TRUE(control_list->LoadList(json, GpuControlList::kAllOs));
 
     // Discrete GPU is active
     gpu_info.gpu.active = true;
     gpu_info.secondary_gpus[0].active = false;
     std::set<int> features = control_list->MakeDecision(
         GpuControlList::kOsWin, kOsVersion, gpu_info);
     EXPECT_EMPTY_SET(features);
 
     // Integrated GPU is active
@@ skipping 34 matching lines @@
                 "type": "win"
               },
             "disabled_extensions": [
               "test_extension3",
               "test_extension2"
             ]
           }
         ]
       }
   );
-  scoped_ptr<GpuControlList> control_list(Create());
+  std::unique_ptr<GpuControlList> control_list(Create());
 
   EXPECT_TRUE(control_list->LoadList(exact_list_json, GpuControlList::kAllOs));
   GPUInfo gpu_info;
   control_list->MakeDecision(GpuControlList::kOsWin, kOsVersion, gpu_info);
 
   std::vector<std::string> disabled_extensions =
       control_list->GetDisabledExtensions();
 
   ASSERT_EQ(3u, disabled_extensions.size());
   ASSERT_STREQ("test_extension1", disabled_extensions[0].c_str());
@@ skipping 13 matching lines @@
               "type": "win"
             },
             "in_process_gpu": true,
             "features": [
               "test_feature_0"
             ]
           }
         ]
       }
   );
-  scoped_ptr<GpuControlList> control_list(Create());
+  std::unique_ptr<GpuControlList> control_list(Create());
 
   EXPECT_TRUE(control_list->LoadList(exact_list_json, GpuControlList::kAllOs));
   GPUInfo gpu_info;
 
   gpu_info.in_process_gpu = true;
   std::set<int> features = control_list->MakeDecision(
         GpuControlList::kOsWin, kOsVersion, gpu_info);
   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 
   gpu_info.in_process_gpu = false;
@@ skipping 19 matching lines @@
             ]
           }
         ]
       }
   );
   GPUInfo gpu_info;
   gpu_info.gpu.vendor_id = kIntelVendorId;
   // Real case on Intel GMA* on Windows
   gpu_info.secondary_gpus.push_back(gpu_info.gpu);
 
-  scoped_ptr<GpuControlList> control_list(Create());
+  std::unique_ptr<GpuControlList> control_list(Create());
   EXPECT_TRUE(control_list->LoadList(json, GpuControlList::kAllOs));
   std::set<int> features = control_list->MakeDecision(
       GpuControlList::kOsWin, kOsVersion, gpu_info);
   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
   EXPECT_FALSE(control_list->needs_more_info());
 }
 
 }  // namespace gpu