convert //gpu to std::unique_ptr

gpu/config/gpu_control_list.h

 // 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.
 
 #ifndef GPU_CONFIG_GPU_CONTROL_LIST_H_
 #define GPU_CONFIG_GPU_CONTROL_LIST_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "gpu/gpu_export.h"
 
 namespace gpu {
 struct GPUInfo;
 
 class GPU_EXPORT GpuControlList {
  public:
   enum OsType {
@@ skipping 158 matching lines @@
     // Determines if the VersionInfo contains valid information.
     bool IsValid() const;
 
     OsType type() const;
 
     // Maps string to OsType; returns kOsUnknown if it's not a valid os.
     static OsType StringToOsType(const std::string& os);
 
    private:
     OsType type_;
-    scoped_ptr<VersionInfo> version_info_;
+    std::unique_ptr<VersionInfo> version_info_;
   };
 
   class GPU_EXPORT FloatInfo {
    public:
     FloatInfo(const std::string& float_op,
               const std::string& float_value,
               const std::string& float_value2);
 
     // Determines if a given float is included in the FloatInfo.
     bool Contains(float value) const;
@@ skipping 222 matching lines @@
     // Return the default GL type, depending on the OS.
     // See GLType declaration.
     static GLType GetDefaultGLType();
 
     uint32_t id_;
     bool disabled_;
     std::string description_;
     std::vector<int> cr_bugs_;
     std::vector<int> webkit_bugs_;
     std::vector<std::string> disabled_extensions_;
-    scoped_ptr<OsInfo> os_info_;
+    std::unique_ptr<OsInfo> os_info_;
     uint32_t vendor_id_;
     std::vector<uint32_t> device_id_list_;
     MultiGpuStyle multi_gpu_style_;
     MultiGpuCategory multi_gpu_category_;
     GLType gl_type_;
     std::string driver_vendor_info_;
-    scoped_ptr<VersionInfo> driver_version_info_;
-    scoped_ptr<VersionInfo> driver_date_info_;
-    scoped_ptr<VersionInfo> gl_version_info_;
+    std::unique_ptr<VersionInfo> driver_version_info_;
+    std::unique_ptr<VersionInfo> driver_date_info_;
+    std::unique_ptr<VersionInfo> gl_version_info_;
     std::string gl_vendor_info_;
     std::string gl_renderer_info_;
     std::string gl_extensions_info_;
-    scoped_ptr<IntInfo> gl_reset_notification_strategy_info_;
+    std::unique_ptr<IntInfo> gl_reset_notification_strategy_info_;
     std::string cpu_brand_;
-    scoped_ptr<FloatInfo> perf_graphics_info_;
-    scoped_ptr<FloatInfo> perf_gaming_info_;
-    scoped_ptr<FloatInfo> perf_overall_info_;
+    std::unique_ptr<FloatInfo> perf_graphics_info_;
+    std::unique_ptr<FloatInfo> perf_gaming_info_;
+    std::unique_ptr<FloatInfo> perf_overall_info_;
     std::vector<std::string> machine_model_name_list_;
-    scoped_ptr<VersionInfo> machine_model_version_info_;
-    scoped_ptr<IntInfo> gpu_count_info_;
-    scoped_ptr<BoolInfo> direct_rendering_info_;
-    scoped_ptr<BoolInfo> in_process_gpu_info_;
+    std::unique_ptr<VersionInfo> machine_model_version_info_;
+    std::unique_ptr<IntInfo> gpu_count_info_;
+    std::unique_ptr<BoolInfo> direct_rendering_info_;
+    std::unique_ptr<BoolInfo> in_process_gpu_info_;
     std::set<int> features_;
     std::vector<ScopedGpuControlListEntry> exceptions_;
   };
 
   // Gets the current OS type.
   static OsType GetOsType();
 
   bool LoadList(const base::DictionaryValue& parsed_json, OsFilter os_filter);
 
   void Clear();
@@ skipping 17 matching lines @@
   bool supports_feature_type_all_;
 
   bool control_list_logging_enabled_;
   std::string control_list_logging_name_;
 };
 
 }  // namespace gpu
 
 #endif  // GPU_CONFIG_GPU_CONTROL_LIST_H_