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

extensions/browser/api/networking_private/networking_private_linux.cc

 // 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.
 
 #include "extensions/browser/api/networking_private/networking_private_linux.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 61 matching lines @@
 
 // Simplified helper to parse the SSID from the GUID.
 bool GuidToSsid(const std::string& guid, std::string* ssid) {
   std::string unused_1;
   std::string unused_2;
   return ParseNetworkGuid(guid, &unused_1, &unused_2, ssid);
 }
 
 // Iterates over the map cloning the contained networks to a
 // list then returns the list.
-scoped_ptr<base::ListValue> CopyNetworkMapToList(
+std::unique_ptr<base::ListValue> CopyNetworkMapToList(
     const NetworkingPrivateLinux::NetworkMap& network_map) {
-  scoped_ptr<base::ListValue> network_list(new base::ListValue);
+  std::unique_ptr<base::ListValue> network_list(new base::ListValue);
 
   for (const auto& network : network_map) {
     network_list->Append(network.second->DeepCopy());
   }
 
   return network_list;
 }
 
 // Constructs a network guid from its constituent parts.
 std::string ConstructNetworkGuid(const dbus::ObjectPath& device_path,
                                  const dbus::ObjectPath& access_point_path,
                                  const std::string& ssid) {
   return device_path.value() + "|" + access_point_path.value() + "|" + ssid;
 }
 
 // Logs that the method is not implemented and reports |kErrorNotSupported|
 // to the failure callback.
 void ReportNotSupported(
     const std::string& method_name,
     const NetworkingPrivateDelegate::FailureCallback& failure_callback) {
   LOG(WARNING) << method_name << " is not supported";
   failure_callback.Run(extensions::networking_private::kErrorNotSupported);
 }
 
 // Fires the appropriate callback when the network connect operation succeeds
 // or fails.
 void OnNetworkConnectOperationCompleted(
-    scoped_ptr<std::string> error,
+    std::unique_ptr<std::string> error,
     const NetworkingPrivateDelegate::VoidCallback& success_callback,
     const NetworkingPrivateDelegate::FailureCallback& failure_callback) {
   if (!error->empty()) {
     failure_callback.Run(*error);
     return;
   }
   success_callback.Run();
 }
 
 // Fires the appropriate callback when the network properties are returned
 // from the |dbus_thread_|.
 void GetCachedNetworkPropertiesCallback(
-    scoped_ptr<std::string> error,
-    scoped_ptr<base::DictionaryValue> properties,
+    std::unique_ptr<std::string> error,
+    std::unique_ptr<base::DictionaryValue> properties,
     const NetworkingPrivateDelegate::DictionaryCallback& success_callback,
     const NetworkingPrivateDelegate::FailureCallback& failure_callback) {
   if (!error->empty()) {
     failure_callback.Run(*error);
     return;
   }
   success_callback.Run(std::move(properties));
 }
 
 }  // namespace
 
 NetworkingPrivateLinux::NetworkingPrivateLinux(
     content::BrowserContext* browser_context,
-    scoped_ptr<VerifyDelegate> verify_delegate)
+    std::unique_ptr<VerifyDelegate> verify_delegate)
     : NetworkingPrivateDelegate(std::move(verify_delegate)),
       browser_context_(browser_context),
       dbus_thread_("Networking Private DBus"),
       network_manager_proxy_(NULL) {
   base::Thread::Options thread_options(base::MessageLoop::Type::TYPE_IO, 0);
 
   dbus_thread_.StartWithOptions(thread_options);
   dbus_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&NetworkingPrivateLinux::Initialize, base::Unretained(this)));
@@ skipping 53 matching lines @@
   ReportNotSupported("GetManagedProperties", failure_callback);
 }
 
 void NetworkingPrivateLinux::GetState(
     const std::string& guid,
     const DictionaryCallback& success_callback,
     const FailureCallback& failure_callback) {
   if (!CheckNetworkManagerSupported(failure_callback))
     return;
 
-  scoped_ptr<std::string> error(new std::string);
-  scoped_ptr<base::DictionaryValue> network_properties(
+  std::unique_ptr<std::string> error(new std::string);
+  std::unique_ptr<base::DictionaryValue> network_properties(
       new base::DictionaryValue);
 
   // Runs GetCachedNetworkProperties on |dbus_thread|.
   dbus_thread_.task_runner()->PostTaskAndReply(
       FROM_HERE, base::Bind(&NetworkingPrivateLinux::GetCachedNetworkProperties,
                             base::Unretained(this), guid,
                             base::Unretained(network_properties.get()),
                             base::Unretained(error.get())),
       base::Bind(&GetCachedNetworkPropertiesCallback, base::Passed(&error),
                  base::Passed(&network_properties), success_callback,
@@ skipping 13 matching lines @@
   }
 
   NetworkMap::const_iterator network_iter =
       network_map_->find(base::UTF8ToUTF16(ssid));
   if (network_iter == network_map_->end()) {
     *error = "Unknown network GUID";
     return;
   }
 
   // Make a copy of the properties out of the cached map.
-  scoped_ptr<base::DictionaryValue> temp_properties(
+  std::unique_ptr<base::DictionaryValue> temp_properties(
       network_iter->second->DeepCopy());
 
   // Swap the new copy into the dictionary that is shared with the reply.
   properties->Swap(temp_properties.get());
 }
 
 void NetworkingPrivateLinux::SetProperties(
     const std::string& guid,
-    scoped_ptr<base::DictionaryValue> properties,
+    std::unique_ptr<base::DictionaryValue> properties,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback) {
   ReportNotSupported("SetProperties", failure_callback);
 }
 
 void NetworkingPrivateLinux::CreateNetwork(
     bool shared,
-    scoped_ptr<base::DictionaryValue> properties,
+    std::unique_ptr<base::DictionaryValue> properties,
     const StringCallback& success_callback,
     const FailureCallback& failure_callback) {
   ReportNotSupported("CreateNetwork", failure_callback);
 }
 
 void NetworkingPrivateLinux::ForgetNetwork(
     const std::string& guid,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback) {
   // TODO(zentaro): Implement for Linux.
   ReportNotSupported("ForgetNetwork", failure_callback);
 }
 
 void NetworkingPrivateLinux::GetNetworks(
     const std::string& network_type,
     bool configured_only,
     bool visible_only,
     int limit,
     const NetworkListCallback& success_callback,
     const FailureCallback& failure_callback) {
   if (!CheckNetworkManagerSupported(failure_callback)) {
     return;
   }
 
-  scoped_ptr<NetworkMap> network_map(new NetworkMap);
+  std::unique_ptr<NetworkMap> network_map(new NetworkMap);
 
   if (!(network_type == ::onc::network_type::kWiFi ||
         network_type == ::onc::network_type::kWireless ||
         network_type == ::onc::network_type::kAllTypes)) {
     // Only enumerating WiFi networks is supported on linux.
     ReportNotSupported("GetNetworks with network_type=" + network_type,
                        failure_callback);
     return;
   }
 
   // Runs GetAllWiFiAccessPoints on the dbus_thread and returns the
   // results back to OnAccessPointsFound where the callback is fired.
   dbus_thread_.task_runner()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&NetworkingPrivateLinux::GetAllWiFiAccessPoints,
                  base::Unretained(this), configured_only, visible_only, limit,
                  base::Unretained(network_map.get())),
       base::Bind(&NetworkingPrivateLinux::OnAccessPointsFound,
                  base::Unretained(this), base::Passed(&network_map),
                  success_callback, failure_callback));
 }
 
 bool NetworkingPrivateLinux::GetNetworksForScanRequest() {
   if (!network_manager_proxy_) {
     return false;
   }
 
-  scoped_ptr<NetworkMap> network_map(new NetworkMap);
+  std::unique_ptr<NetworkMap> network_map(new NetworkMap);
 
   // Runs GetAllWiFiAccessPoints on the dbus_thread and returns the
   // results back to SendNetworkListChangedEvent to fire the event. No
   // callbacks are used in this case.
   dbus_thread_.task_runner()->PostTaskAndReply(
       FROM_HERE, base::Bind(&NetworkingPrivateLinux::GetAllWiFiAccessPoints,
                             base::Unretained(this), false /* configured_only */,
                             false /* visible_only */, 0 /* limit */,
                             base::Unretained(network_map.get())),
       base::Bind(&NetworkingPrivateLinux::OnAccessPointsFoundViaScan,
@@ skipping 65 matching lines @@
   // Close all the arrays and dicts.
   wifi_dict_writer.CloseContainer(&variant_writer);
   wifi_array.CloseContainer(&wifi_dict_writer);
   dict_writer.CloseContainer(&wifi_array);
   array_writer.CloseContainer(&dict_writer);
   builder.CloseContainer(&array_writer);
 
   builder.AppendObjectPath(device_path);
   builder.AppendObjectPath(access_point_path);
 
-  scoped_ptr<dbus::Response> response(
+  std::unique_ptr<dbus::Response> response(
       network_manager_proxy_->CallMethodAndBlock(
           &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
   if (!response) {
     LOG(ERROR) << "Failed to add a new connection";
     *error = "Failed to connect.";
 
     // Set the connection state to NotConnected in the map.
     SetConnectionStateAndPostEvent(guid, ssid,
                                    ::onc::connection_state::kNotConnected);
     return;
@@ skipping 38 matching lines @@
   std::string access_point_path_str;
   std::string ssid;
   DVLOG(1) << "Disconnecting from network GUID " << guid;
 
   if (!ParseNetworkGuid(guid, &device_path_str, &access_point_path_str,
                         &ssid)) {
     *error = "Invalid Network GUID format";
     return;
   }
 
-  scoped_ptr<NetworkMap> network_map(new NetworkMap);
+  std::unique_ptr<NetworkMap> network_map(new NetworkMap);
   GetAllWiFiAccessPoints(false /* configured_only */, false /* visible_only */,
                          0 /* limit */, network_map.get());
 
   NetworkMap::const_iterator network_iter =
       network_map->find(base::UTF8ToUTF16(ssid));
   if (network_iter == network_map->end()) {
     // This network doesn't exist so there's nothing to do.
     return;
   }
 
   std::string connection_state;
   network_iter->second->GetString(kAccessPointInfoConnectionState,
                                   &connection_state);
   if (connection_state == ::onc::connection_state::kNotConnected) {
     // Already disconnected so nothing to do.
     return;
   }
 
   // It's not disconnected so disconnect it.
   dbus::ObjectProxy* device_proxy =
       dbus_->GetObjectProxy(networking_private::kNetworkManagerNamespace,
                             dbus::ObjectPath(device_path_str));
   dbus::MethodCall method_call(
       networking_private::kNetworkManagerDeviceNamespace,
       networking_private::kNetworkManagerDisconnectMethod);
-  scoped_ptr<dbus::Response> response(device_proxy->CallMethodAndBlock(
+  std::unique_ptr<dbus::Response> response(device_proxy->CallMethodAndBlock(
       &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
 
   if (!response) {
     LOG(WARNING) << "Failed to disconnect network on device "
                  << device_path_str;
     *error = "Failed to disconnect network";
   }
 }
 
 void NetworkingPrivateLinux::StartConnect(
     const std::string& guid,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback) {
   if (!CheckNetworkManagerSupported(failure_callback))
     return;
 
-  scoped_ptr<std::string> error(new std::string);
+  std::unique_ptr<std::string> error(new std::string);
 
   // Runs ConnectToNetwork on |dbus_thread|.
   dbus_thread_.task_runner()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&NetworkingPrivateLinux::ConnectToNetwork,
                  base::Unretained(this), guid, base::Unretained(error.get())),
       base::Bind(&OnNetworkConnectOperationCompleted, base::Passed(&error),
                  success_callback, failure_callback));
 }
 
 void NetworkingPrivateLinux::StartDisconnect(
     const std::string& guid,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback) {
   if (!CheckNetworkManagerSupported(failure_callback))
     return;
 
-  scoped_ptr<std::string> error(new std::string);
+  std::unique_ptr<std::string> error(new std::string);
 
   // Runs DisconnectFromNetwork on |dbus_thread|.
   dbus_thread_.task_runner()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&NetworkingPrivateLinux::DisconnectFromNetwork,
                  base::Unretained(this), guid, base::Unretained(error.get())),
       base::Bind(&OnNetworkConnectOperationCompleted, base::Passed(&error),
                  success_callback, failure_callback));
 }
 
@@ skipping 31 matching lines @@
 void NetworkingPrivateLinux::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) {
   ReportNotSupported("SetCellularSimState", failure_callback);
 }
 
-scoped_ptr<base::ListValue> NetworkingPrivateLinux::GetEnabledNetworkTypes() {
-  scoped_ptr<base::ListValue> network_list(new base::ListValue);
+std::unique_ptr<base::ListValue>
+NetworkingPrivateLinux::GetEnabledNetworkTypes() {
+  std::unique_ptr<base::ListValue> network_list(new base::ListValue);
   network_list->AppendString(::onc::network_type::kWiFi);
   return network_list;
 }
 
-scoped_ptr<NetworkingPrivateDelegate::DeviceStateList>
+std::unique_ptr<NetworkingPrivateDelegate::DeviceStateList>
 NetworkingPrivateLinux::GetDeviceStateList() {
-  scoped_ptr<DeviceStateList> device_state_list(new DeviceStateList);
-  scoped_ptr<api::networking_private::DeviceStateProperties> properties(
+  std::unique_ptr<DeviceStateList> device_state_list(new DeviceStateList);
+  std::unique_ptr<api::networking_private::DeviceStateProperties> properties(
       new api::networking_private::DeviceStateProperties);
   properties->type = api::networking_private::NETWORK_TYPE_WIFI;
   properties->state = api::networking_private::DEVICE_STATE_TYPE_ENABLED;
   device_state_list->push_back(std::move(properties));
   return device_state_list;
 }
 
 bool NetworkingPrivateLinux::EnableNetworkType(const std::string& type) {
   return false;
 }
@@ skipping 10 matching lines @@
     NetworkingPrivateDelegateObserver* observer) {
   network_events_observers_.AddObserver(observer);
 }
 
 void NetworkingPrivateLinux::RemoveObserver(
     NetworkingPrivateDelegateObserver* observer) {
   network_events_observers_.RemoveObserver(observer);
 }
 
 void NetworkingPrivateLinux::OnAccessPointsFound(
-    scoped_ptr<NetworkMap> network_map,
+    std::unique_ptr<NetworkMap> network_map,
     const NetworkListCallback& success_callback,
     const FailureCallback& failure_callback) {
-  scoped_ptr<base::ListValue> network_list = CopyNetworkMapToList(*network_map);
+  std::unique_ptr<base::ListValue> network_list =
+      CopyNetworkMapToList(*network_map);
   // Give ownership to the member variable.
   network_map_.swap(network_map);
   SendNetworkListChangedEvent(*network_list);
   success_callback.Run(std::move(network_list));
 }
 
 void NetworkingPrivateLinux::OnAccessPointsFoundViaScan(
-    scoped_ptr<NetworkMap> network_map) {
-  scoped_ptr<base::ListValue> network_list = CopyNetworkMapToList(*network_map);
+    std::unique_ptr<NetworkMap> network_map) {
+  std::unique_ptr<base::ListValue> network_list =
+      CopyNetworkMapToList(*network_map);
   // Give ownership to the member variable.
   network_map_.swap(network_map);
   SendNetworkListChangedEvent(*network_list);
 }
 
 void NetworkingPrivateLinux::SendNetworkListChangedEvent(
     const base::ListValue& network_list) {
   GuidList guidsForEventCallback;
 
   for (const auto& network : network_list) {
     std::string guid;
     base::DictionaryValue* dict;
     if (network->GetAsDictionary(&dict)) {
       if (dict->GetString(kAccessPointInfoGuid, &guid)) {
         guidsForEventCallback.push_back(guid);
       }
     }
   }
 
   OnNetworkListChangedEventOnUIThread(guidsForEventCallback);
 }
 
 bool NetworkingPrivateLinux::GetNetworkDevices(
     std::vector<dbus::ObjectPath>* device_paths) {
   AssertOnDBusThread();
   dbus::MethodCall method_call(
       networking_private::kNetworkManagerNamespace,
       networking_private::kNetworkManagerGetDevicesMethod);
 
-  scoped_ptr<dbus::Response> device_response(
+  std::unique_ptr<dbus::Response> device_response(
       network_manager_proxy_->CallMethodAndBlock(
           &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
 
   if (!device_response) {
     return false;
   }
 
   dbus::MessageReader reader(device_response.get());
   if (!reader.PopArrayOfObjectPaths(device_paths)) {
     LOG(WARNING) << "Unexpected response: " << device_response->ToString();
     return false;
   }
 
   return true;
 }
 
 NetworkingPrivateLinux::DeviceType NetworkingPrivateLinux::GetDeviceType(
     const dbus::ObjectPath& device_path) {
   AssertOnDBusThread();
   dbus::ObjectProxy* device_proxy = dbus_->GetObjectProxy(
       networking_private::kNetworkManagerNamespace, device_path);
   dbus::MethodCall method_call(DBUS_INTERFACE_PROPERTIES,
                                networking_private::kNetworkManagerGetMethod);
   dbus::MessageWriter builder(&method_call);
   builder.AppendString(networking_private::kNetworkManagerDeviceNamespace);
   builder.AppendString(networking_private::kNetworkManagerDeviceType);
 
-  scoped_ptr<dbus::Response> response(device_proxy->CallMethodAndBlock(
+  std::unique_ptr<dbus::Response> response(device_proxy->CallMethodAndBlock(
       &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
 
   if (!response) {
     LOG(ERROR) << "Failed to get the device type for device "
                << device_path.value();
     return NetworkingPrivateLinux::NM_DEVICE_TYPE_UNKNOWN;
   }
 
   dbus::MessageReader reader(response.get());
   uint32_t device_type = 0;
@@ skipping 28 matching lines @@
 
     // Found a wlan adapter
     if (!AddAccessPointsFromDevice(device_path, network_map)) {
       // Ignore devices we can't enumerate.
       LOG(WARNING) << "Failed to add access points from device "
                    << device_path.value();
     }
   }
 }
 
-scoped_ptr<dbus::Response> NetworkingPrivateLinux::GetAccessPointProperty(
+std::unique_ptr<dbus::Response> NetworkingPrivateLinux::GetAccessPointProperty(
     dbus::ObjectProxy* access_point_proxy,
     const std::string& property_name) {
   AssertOnDBusThread();
   dbus::MethodCall method_call(DBUS_INTERFACE_PROPERTIES,
                                networking_private::kNetworkManagerGetMethod);
   dbus::MessageWriter builder(&method_call);
   builder.AppendString(networking_private::kNetworkManagerAccessPointNamespace);
   builder.AppendString(property_name);
-  scoped_ptr<dbus::Response> response = access_point_proxy->CallMethodAndBlock(
-      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT);
+  std::unique_ptr<dbus::Response> response =
+      access_point_proxy->CallMethodAndBlock(
+          &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT);
   if (!response) {
     LOG(ERROR) << "Failed to get property for " << property_name;
   }
   return response;
 }
 
 bool NetworkingPrivateLinux::GetAccessPointInfo(
     const dbus::ObjectPath& access_point_path,
-    const scoped_ptr<base::DictionaryValue>& access_point_info) {
+    const std::unique_ptr<base::DictionaryValue>& access_point_info) {
   AssertOnDBusThread();
   dbus::ObjectProxy* access_point_proxy = dbus_->GetObjectProxy(
       networking_private::kNetworkManagerNamespace, access_point_path);
 
   // Read the SSID. The GUID is derived from the Ssid.
   {
-    scoped_ptr<dbus::Response> response(GetAccessPointProperty(
+    std::unique_ptr<dbus::Response> response(GetAccessPointProperty(
         access_point_proxy, networking_private::kNetworkManagerSsidProperty));
 
     if (!response) {
       return false;
     }
 
     // The response should contain a variant that contains an array of bytes.
     dbus::MessageReader reader(response.get());
     dbus::MessageReader variant_reader(response.get());
     if (!reader.PopVariant(&variant_reader)) {
@@ skipping 11 matching lines @@
     }
 
     std::string ssidUTF8(ssid_bytes, ssid_bytes + ssid_length);
     base::string16 ssid = base::UTF8ToUTF16(ssidUTF8);
 
     access_point_info->SetString(kAccessPointInfoName, ssid);
   }
 
   // Read signal strength.
   {
-    scoped_ptr<dbus::Response> response(GetAccessPointProperty(
+    std::unique_ptr<dbus::Response> response(GetAccessPointProperty(
         access_point_proxy,
         networking_private::kNetworkManagerStrengthProperty));
     if (!response) {
       return false;
     }
 
     dbus::MessageReader reader(response.get());
     uint8_t strength = 0;
     if (!reader.PopVariantOfByte(&strength)) {
       LOG(ERROR) << "Unexpected response for " << access_point_path.value()
                  << ": " << response->ToString();
       return false;
     }
 
     access_point_info->SetInteger(kAccessPointInfoWifiSignalStrengthDotted,
                                   strength);
   }
 
   // Read the security type. This is from the WpaFlags and RsnFlags property
   // which are of the same type and can be OR'd together to find all supported
   // security modes.
 
   uint32_t wpa_security_flags = 0;
   {
-    scoped_ptr<dbus::Response> response(GetAccessPointProperty(
+    std::unique_ptr<dbus::Response> response(GetAccessPointProperty(
         access_point_proxy,
         networking_private::kNetworkManagerWpaFlagsProperty));
     if (!response) {
       return false;
     }
 
     dbus::MessageReader reader(response.get());
 
     if (!reader.PopVariantOfUint32(&wpa_security_flags)) {
       LOG(ERROR) << "Unexpected response for " << access_point_path.value()
                  << ": " << response->ToString();
       return false;
     }
   }
 
   uint32_t rsn_security_flags = 0;
   {
-    scoped_ptr<dbus::Response> response(GetAccessPointProperty(
+    std::unique_ptr<dbus::Response> response(GetAccessPointProperty(
         access_point_proxy,
         networking_private::kNetworkManagerRsnFlagsProperty));
     if (!response) {
       return false;
     }
 
     dbus::MessageReader reader(response.get());
 
     if (!reader.PopVariantOfUint32(&rsn_security_flags)) {
       LOG(ERROR) << "Unexpected response for " << access_point_path.value()
@@ skipping 17 matching lines @@
   dbus::ObjectPath connected_access_point;
   if (!GetConnectedAccessPoint(device_path, &connected_access_point)) {
     return false;
   }
 
   dbus::ObjectProxy* device_proxy = dbus_->GetObjectProxy(
       networking_private::kNetworkManagerNamespace, device_path);
   dbus::MethodCall method_call(
       networking_private::kNetworkManagerWirelessDeviceNamespace,
       networking_private::kNetworkManagerGetAccessPointsMethod);
-  scoped_ptr<dbus::Response> response(device_proxy->CallMethodAndBlock(
+  std::unique_ptr<dbus::Response> response(device_proxy->CallMethodAndBlock(
       &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
 
   if (!response) {
     LOG(WARNING) << "Failed to get access points data for "
                  << device_path.value();
     return false;
   }
 
   dbus::MessageReader reader(response.get());
   std::vector<dbus::ObjectPath> access_point_paths;
   if (!reader.PopArrayOfObjectPaths(&access_point_paths)) {
     LOG(ERROR) << "Unexpected response for " << device_path.value() << ": "
                << response->ToString();
     return false;
   }
 
   for (const auto& access_point_path : access_point_paths) {
-    scoped_ptr<base::DictionaryValue> access_point(new base::DictionaryValue);
+    std::unique_ptr<base::DictionaryValue> access_point(
+        new base::DictionaryValue);
 
     if (GetAccessPointInfo(access_point_path, access_point)) {
       std::string connection_state =
           (access_point_path == connected_access_point)
               ? ::onc::connection_state::kConnected
               : ::onc::connection_state::kNotConnected;
 
       access_point->SetString(kAccessPointInfoConnectionState,
                               connection_state);
       std::string ssid;
       access_point->GetString(kAccessPointInfoName, &ssid);
 
       std::string network_guid =
           ConstructNetworkGuid(device_path, access_point_path, ssid);
 
       // Adds the network to the map. Since each SSID can actually have multiple
       // access point paths, this consolidates them. If it is already
       // in the map it updates the signal strength and GUID paths if this
       // network is stronger or the one that is connected.
       AddOrUpdateAccessPoint(network_map, network_guid, access_point);
     }
   }
 
   return true;
 }
 
 void NetworkingPrivateLinux::AddOrUpdateAccessPoint(
     NetworkMap* network_map,
     const std::string& network_guid,
-    scoped_ptr<base::DictionaryValue>& access_point) {
+    std::unique_ptr<base::DictionaryValue>& access_point) {
   base::string16 ssid;
   std::string connection_state;
   int signal_strength;
 
   access_point->GetString(kAccessPointInfoConnectionState, &connection_state);
   access_point->GetInteger(kAccessPointInfoWifiSignalStrengthDotted,
                            &signal_strength);
   access_point->GetString(kAccessPointInfoName, &ssid);
   access_point->SetString(kAccessPointInfoGuid, network_guid);
 
@@ skipping 51 matching lines @@
 bool NetworkingPrivateLinux::GetConnectedAccessPoint(
     dbus::ObjectPath device_path,
     dbus::ObjectPath* access_point_path) {
   AssertOnDBusThread();
   dbus::MethodCall method_call(DBUS_INTERFACE_PROPERTIES,
                                networking_private::kNetworkManagerGetMethod);
   dbus::MessageWriter builder(&method_call);
   builder.AppendString(networking_private::kNetworkManagerNamespace);
   builder.AppendString(networking_private::kNetworkManagerActiveConnections);
 
-  scoped_ptr<dbus::Response> response(
+  std::unique_ptr<dbus::Response> response(
       network_manager_proxy_->CallMethodAndBlock(
           &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
 
   if (!response) {
     LOG(WARNING) << "Failed to get a list of active connections";
     return false;
   }
 
   dbus::MessageReader reader(response.get());
   dbus::MessageReader variant_reader(response.get());
@@ skipping 37 matching lines @@
     return false;
   }
 
   dbus::MethodCall method_call(DBUS_INTERFACE_PROPERTIES,
                                networking_private::kNetworkManagerGetMethod);
   dbus::MessageWriter builder(&method_call);
   builder.AppendString(
       networking_private::kNetworkManagerActiveConnectionNamespace);
   builder.AppendString("Devices");
 
-  scoped_ptr<dbus::Response> response(connection_proxy->CallMethodAndBlock(
+  std::unique_ptr<dbus::Response> response(connection_proxy->CallMethodAndBlock(
       &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
 
   if (!response) {
     LOG(ERROR) << "Failed to get devices";
     return false;
   }
 
   dbus::MessageReader reader(response.get());
   dbus::MessageReader variant_reader(response.get());
   if (!reader.PopVariant(&variant_reader)) {
@@ skipping 27 matching lines @@
     return false;
   }
 
   dbus::MethodCall method_call(DBUS_INTERFACE_PROPERTIES,
                                networking_private::kNetworkManagerGetMethod);
   dbus::MessageWriter builder(&method_call);
   builder.AppendString(
       networking_private::kNetworkManagerActiveConnectionNamespace);
   builder.AppendString(networking_private::kNetworkManagerSpecificObject);
 
-  scoped_ptr<dbus::Response> response(connection_proxy->CallMethodAndBlock(
+  std::unique_ptr<dbus::Response> response(connection_proxy->CallMethodAndBlock(
       &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
 
   if (!response) {
     LOG(WARNING) << "Failed to get access point from active connection";
     return false;
   }
 
   dbus::MessageReader reader(response.get());
   dbus::MessageReader variant_reader(response.get());
   if (!reader.PopVariant(&variant_reader)) {
@@ skipping 40 matching lines @@
                                     ::onc::connection_state::kNotConnected);
         }
       }
     }
   }
 
   // Set the status.
   network_iter->second->SetString(kAccessPointInfoConnectionState,
                                   connection_state);
 
-  scoped_ptr<GuidList> changed_networks(new GuidList());
+  std::unique_ptr<GuidList> changed_networks(new GuidList());
   changed_networks->push_back(guid);
 
   // Only add a second network if it exists and it is not the same as the
   // network already being added to the list.
   if (!connected_network_guid.empty() && connected_network_guid != guid) {
     changed_networks->push_back(connected_network_guid);
   }
 
   PostOnNetworksChangedToUIThread(std::move(changed_networks));
   return true;
 }
 
 void NetworkingPrivateLinux::OnNetworksChangedEventOnUIThread(
     const GuidList& network_guids) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   FOR_EACH_OBSERVER(NetworkingPrivateDelegateObserver,
                     network_events_observers_,
                     OnNetworksChangedEvent(network_guids));
 }
 
 void NetworkingPrivateLinux::OnNetworkListChangedEventOnUIThread(
     const GuidList& network_guids) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   FOR_EACH_OBSERVER(NetworkingPrivateDelegateObserver,
                     network_events_observers_,
                     OnNetworkListChangedEvent(network_guids));
 }
 
 void NetworkingPrivateLinux::PostOnNetworksChangedToUIThread(
-    scoped_ptr<GuidList> guid_list) {
+    std::unique_ptr<GuidList> guid_list) {
   AssertOnDBusThread();
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&NetworkingPrivateLinux::OnNetworksChangedEventTask,
                  base::Unretained(this), base::Passed(&guid_list)));
 }
 
 void NetworkingPrivateLinux::OnNetworksChangedEventTask(
-    scoped_ptr<GuidList> guid_list) {
+    std::unique_ptr<GuidList> guid_list) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   OnNetworksChangedEventOnUIThread(*guid_list);
 }
 
 }  // namespace extensions