Convert //extensions/browser/api from scoped_ptr to std::unique_ptr

extensions/browser/api/networking_private/networking_private_linux.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 EXTENSIONS_BROWSER_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_LINUX_H_
 #define EXTENSIONS_BROWSER_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_LINUX_H_
 
 #include <stdint.h>
 
 #include <string>
@@ skipping 21 matching lines @@
 
 // Linux NetworkingPrivateDelegate implementation.
 class NetworkingPrivateLinux : public NetworkingPrivateDelegate {
  public:
   typedef std::map<base::string16, linked_ptr<base::DictionaryValue>>
       NetworkMap;
 
   typedef std::vector<std::string> GuidList;
 
   NetworkingPrivateLinux(content::BrowserContext* browser_context,
-                         scoped_ptr<VerifyDelegate> verify_delegate);
+                         std::unique_ptr<VerifyDelegate> verify_delegate);
 
   // NetworkingPrivateDelegate
   void GetProperties(const std::string& guid,
                      const DictionaryCallback& success_callback,
                      const FailureCallback& failure_callback) override;
   void GetManagedProperties(const std::string& guid,
                             const DictionaryCallback& success_callback,
                             const FailureCallback& failure_callback) override;
   void GetState(const std::string& guid,
                 const DictionaryCallback& success_callback,
                 const FailureCallback& failure_callback) override;
   void SetProperties(const std::string& guid,
-                     scoped_ptr<base::DictionaryValue> properties,
+                     std::unique_ptr<base::DictionaryValue> properties,
                      const VoidCallback& success_callback,
                      const FailureCallback& failure_callback) override;
   void CreateNetwork(bool shared,
-                     scoped_ptr<base::DictionaryValue> properties,
+                     std::unique_ptr<base::DictionaryValue> properties,
                      const StringCallback& success_callback,
                      const FailureCallback& failure_callback) override;
   void ForgetNetwork(const std::string& guid,
                      const VoidCallback& success_callback,
                      const FailureCallback& failure_callback) override;
   void GetNetworks(const std::string& network_type,
                    bool configured_only,
                    bool visible_only,
                    int limit,
                    const NetworkListCallback& success_callback,
@@ skipping 20 matching lines @@
                          const std::string& puk,
                          const VoidCallback& success_callback,
                          const FailureCallback& failure_callback) override;
   void SetCellularSimState(const std::string& guid,
                            bool require_pin,
                            const std::string& current_pin,
                            const std::string& new_pin,
                            const VoidCallback& success_callback,
                            const FailureCallback& failure_callback) override;
 
-  scoped_ptr<base::ListValue> GetEnabledNetworkTypes() override;
-  scoped_ptr<DeviceStateList> GetDeviceStateList() override;
+  std::unique_ptr<base::ListValue> GetEnabledNetworkTypes() override;
+  std::unique_ptr<DeviceStateList> GetDeviceStateList() override;
   bool EnableNetworkType(const std::string& type) override;
   bool DisableNetworkType(const std::string& type) override;
   bool RequestScan() override;
   void AddObserver(NetworkingPrivateDelegateObserver* observer) override;
   void RemoveObserver(NetworkingPrivateDelegateObserver* observer) override;
 
  private:
   ~NetworkingPrivateLinux() override;
 
   // https://developer.gnome.org/NetworkManager/unstable/spec.html#type-NM_DEVICE_TYPE
@@ skipping 62 matching lines @@
 
   // Helper function to enumerate WiFi networks. Takes a path to a Wireless
   // device, scans that device and appends networks to network_list.
   // Returns false if there is an error getting the access points visible
   // to the |device_path|.
   bool AddAccessPointsFromDevice(const dbus::ObjectPath& device_path,
                                  NetworkMap* network_map);
 
   // Reply callback accepts the map of networks and fires the
   // OnNetworkListChanged event and user callbacks.
-  void OnAccessPointsFound(scoped_ptr<NetworkMap> network_map,
+  void OnAccessPointsFound(std::unique_ptr<NetworkMap> network_map,
                            const NetworkListCallback& success_callback,
                            const FailureCallback& failure_callback);
 
   // Reply callback accepts the map of networks and fires the
   // OnNetworkListChanged event.
-  void OnAccessPointsFoundViaScan(scoped_ptr<NetworkMap> network_map);
+  void OnAccessPointsFoundViaScan(std::unique_ptr<NetworkMap> network_map);
 
   // Helper function for OnAccessPointsFound and OnAccessPointsFoundViaScan to
   // fire the OnNetworkListChangedEvent.
   void SendNetworkListChangedEvent(const base::ListValue& network_list);
 
   // Gets a dictionary of information about the access point.
   // Returns false if there is an error getting information about the
   // supplied |access_point_path|.
   bool GetAccessPointInfo(
       const dbus::ObjectPath& access_point_path,
-      const scoped_ptr<base::DictionaryValue>& access_point_info);
+      const std::unique_ptr<base::DictionaryValue>& access_point_info);
 
   // Helper function to extract a property from a device.
   // Returns the dbus::Response object from calling Get on the supplied
   // |property_name|.
-  scoped_ptr<dbus::Response> GetAccessPointProperty(
+  std::unique_ptr<dbus::Response> GetAccessPointProperty(
       dbus::ObjectProxy* access_point_proxy,
       const std::string& property_name);
 
   // If the access_point is not already in the map it is added. Otherwise
   // the access point is updated (eg. with the max of the signal
   // strength).
-  void AddOrUpdateAccessPoint(NetworkMap* network_map,
-                              const std::string& network_guid,
-                              scoped_ptr<base::DictionaryValue>& access_point);
+  void AddOrUpdateAccessPoint(
+      NetworkMap* network_map,
+      const std::string& network_guid,
+      std::unique_ptr<base::DictionaryValue>& access_point);
 
   // Maps the WPA security flags to a human readable string.
   void MapSecurityFlagsToString(uint32_t securityFlags, std::string* security);
 
   // Gets the connected access point path on the given device. Internally gets
   // all active connections then checks if the device matches the requested
   // device, then gets the access point associated with the connection.
   // Returns false if there is an error getting the connected access point.
   bool GetConnectedAccessPoint(dbus::ObjectPath device_path,
                                dbus::ObjectPath* access_point_path);
@@ skipping 12 matching lines @@
                                    dbus::ObjectPath* access_point_path);
 
   // Helper method to set the connection state in the |network_map_| and post
   // a change event.
   bool SetConnectionStateAndPostEvent(const std::string& guid,
                                       const std::string& ssid,
                                       const std::string& connection_state);
 
   // Helper method to post an OnNetworkChanged event to the UI thread from the
   // dbus thread. Used for connection status progress during |StartConnect|.
-  void PostOnNetworksChangedToUIThread(scoped_ptr<GuidList> guid_list);
+  void PostOnNetworksChangedToUIThread(std::unique_ptr<GuidList> guid_list);
 
   // Helper method to be called from the UI thread and manage ownership of the
   // passed vector from the |dbus_thread_|.
-  void OnNetworksChangedEventTask(scoped_ptr<GuidList> guid_list);
+  void OnNetworksChangedEventTask(std::unique_ptr<GuidList> guid_list);
 
   void GetCachedNetworkProperties(const std::string& guid,
                                   base::DictionaryValue* properties,
                                   std::string* error);
 
   void OnNetworksChangedEventOnUIThread(const GuidList& network_guids);
 
   void OnNetworkListChangedEventOnUIThread(const GuidList& network_guids);
 
   // Browser context.
   content::BrowserContext* browser_context_;
   // Thread used for DBus actions.
   base::Thread dbus_thread_;
   // DBus instance. Only access on |dbus_thread_|.
   scoped_refptr<dbus::Bus> dbus_;
   // Task runner used by the |dbus_| object.
   scoped_refptr<base::SequencedTaskRunner> dbus_task_runner_;
   // This is owned by |dbus_| object. Only access on |dbus_thread_|.
   dbus::ObjectProxy* network_manager_proxy_;
   // Holds the current mapping of known networks. Only access on |dbus_thread_|.
-  scoped_ptr<NetworkMap> network_map_;
+  std::unique_ptr<NetworkMap> network_map_;
   // Observers to Network Events.
   base::ObserverList<NetworkingPrivateDelegateObserver>
       network_events_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateLinux);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_LINUX_H_