Replace scoped_ptr with std::unique_ptr in //ui

ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.h

 // Copyright 2014 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 UI_EVENTS_OZONE_EVDEV_LIBGESTURES_GLUE_GESTURE_PROPERTY_PROVIDER_H_
 #define UI_EVENTS_OZONE_EVDEV_LIBGESTURES_GLUE_GESTURE_PROPERTY_PROVIDER_H_
 
 #include <gestures/gestures.h>
 #include <libevdev/libevdev.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <ostream>
 #include <string>
 #include <vector>
 
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "ui/events/ozone/evdev/event_device_info.h"
 #include "ui/events/ozone/evdev/events_ozone_evdev_export.h"
 
 namespace ui {
 
 class GesturesPropFunctionsWrapper;
 class GestureInterpreterLibevdevCros;
 
 // Not for public consumption, so we wrap it in namespace internal.
@@ skipping 79 matching lines @@
   friend class GesturesPropFunctionsWrapper;
 
   // Mapping table from a device id to its device pointer.
   typedef std::map<DeviceId, DevicePtr> DeviceMap;
 
   // Mapping table from a device id to its property data.
   // GestureDevicePropertyData contains both properties in use and default
   // properties whose values will be applied upon the device attachment.
   typedef base::ScopedPtrHashMap<
       DeviceId,
-      scoped_ptr<internal::GestureDevicePropertyData>> ScopedDeviceDataMap;
+      std::unique_ptr<internal::GestureDevicePropertyData>>
+      ScopedDeviceDataMap;
 
   // Register a device. Setup data-structures and the device's default
   // properties.
   void RegisterDevice(const DeviceId id, const DevicePtr device);
 
   // Unregister a device. Remove all of its properties being tracked.
   void UnregisterDevice(const DeviceId id);
 
   // Called by functions in GesturesPropFunctionsWrapper to manipulate
   // properties. Note these functions do not new/delete the GesturesProp
   // pointers. It is caller's responsibility to manage them.
   void AddProperty(const DeviceId device_id,
                    const std::string& name,
-                   scoped_ptr<GesturesProp> property);
+                   std::unique_ptr<GesturesProp> property);
   void DeleteProperty(const DeviceId device_id, const std::string& name);
 
   // Check if a property exists for a device. Return if it is found.
   GesturesProp* FindProperty(const DeviceId device_id, const std::string& name);
 
   // Get the default value of a property based on the configuration files.
   GesturesProp* GetDefaultProperty(const DeviceId device_id,
                                    const std::string& name);
 
   // The device configuration files are parsed and stored in the memory upon
   // Chrome starts. The default property values are then applied to each device
   // when it is attached/detected.
   void LoadDeviceConfigurations();
 
   // Parse a xorg-conf file. We ignore all sections other than InputClass.
   // Check the xorg-conf spec for more infomation about its format.
   void ParseXorgConfFile(const std::string& content);
 
   // Create a match criteria.
-  scoped_ptr<internal::MatchCriteria> CreateMatchCriteria(
+  std::unique_ptr<internal::MatchCriteria> CreateMatchCriteria(
       const std::string& match_type,
       const std::string& arg);
 
   // Create a property that comes from the conf files.
-  scoped_ptr<GesturesProp> CreateDefaultProperty(const std::string& name,
-                                                 const std::string& value);
+  std::unique_ptr<GesturesProp> CreateDefaultProperty(const std::string& name,
+                                                      const std::string& value);
 
   // Setup default property values for a newly found device.
   void SetupDefaultProperties(const DeviceId device_id, const DevicePtr device);
 
   // Map from device ids to device pointers.
   DeviceMap device_map_;
 
   // GestureDevicePropertyData indexed by their respective device ids. Owns the
   // objects.
   ScopedDeviceDataMap device_data_map_;
 
   // A vector of parsed sections in configuration files. Owns MatchCriterias,
   // GesturesProps and ConfigurationSections in it.
-  std::vector<scoped_ptr<internal::ConfigurationSection>> configurations_;
+  std::vector<std::unique_ptr<internal::ConfigurationSection>> configurations_;
 
   DISALLOW_COPY_AND_ASSIGN(GesturePropertyProvider);
 };
 
 // Wrapper of GesturesProp related functions. We group them together so that we
 // can friend them all at once.
 class GesturesPropFunctionsWrapper {
  public:
   // Property provider interface implementation.
   //
@@ skipping 58 matching lines @@
                                       const T* init);
 
   // Do things that should happen BEFORE we create the property.
   static bool PreCreateProperty(void* device_data,
                                 const char* name,
                                 GesturesProp** default_property);
 
   // Do things that should happen AFTER we create the property.
   static void PostCreateProperty(void* device_data,
                                  const char* name,
-                                 scoped_ptr<GesturesProp> property);
+                                 std::unique_ptr<GesturesProp> property);
 
   // Some other utility functions used in InitializeDeviceProperties.
   static GesturesProp* CreateIntSingle(void* device_data,
                                        const char* name,
                                        int* value,
                                        int init);
   static GesturesProp* CreateBoolSingle(void* device_data,
                                         const char* name,
                                         GesturesPropBool* value,
                                         GesturesPropBool init);
@@ skipping 72 matching lines @@
   // Handler function pointers and the data to be passed to them when the
   // property is accessed.
   GesturesPropGetHandler get_;
   GesturesPropSetHandler set_;
   void* handler_data_;
 
   DISALLOW_COPY_AND_ASSIGN(GesturesProp);
 };
 
 #endif  // UI_EVENTS_OZONE_EVDEV_LIBGESTURES_GLUE_GESTURE_PROPERTY_PROVIDER_H_