Convert //components/[u-z]* from scoped_ptr to std::unique_ptr

components/wifi/wifi_service_mac.mm

 // 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 "components/wifi/wifi_service.h"
 
 #import <CoreWLAN/CoreWLAN.h>
 #import <netinet/in.h>
 #import <SystemConfiguration/SystemConfiguration.h>
 
@@ skipping 29 matching lines @@
 
   void GetManagedProperties(const std::string& network_guid,
                             base::DictionaryValue* managed_properties,
                             std::string* error) override;
 
   void GetState(const std::string& network_guid,
                 base::DictionaryValue* properties,
                 std::string* error) override;
 
   void SetProperties(const std::string& network_guid,
-                     scoped_ptr<base::DictionaryValue> properties,
+                     std::unique_ptr<base::DictionaryValue> properties,
                      std::string* error) override;
 
   void CreateNetwork(bool shared,
-                     scoped_ptr<base::DictionaryValue> properties,
+                     std::unique_ptr<base::DictionaryValue> properties,
                      std::string* network_guid,
                      std::string* error) override;
 
   void GetVisibleNetworks(const std::string& network_type,
                           base::ListValue* network_list,
                           bool include_details) override;
 
   void RequestNetworkScan() override;
 
   void StartConnect(const std::string& network_guid,
@@ skipping 120 matching lines @@
                                    base::DictionaryValue* properties,
                                    std::string* error) {
   NetworkList::iterator it = FindNetwork(network_guid);
   if (it == networks_.end()) {
     DVLOG(1) << "Network not found:" << network_guid;
     *error = kErrorNotFound;
     return;
   }
 
   it->connection_state = GetNetworkConnectionState(network_guid);
-  scoped_ptr<base::DictionaryValue> network(it->ToValue(false));
+  std::unique_ptr<base::DictionaryValue> network(it->ToValue(false));
   properties->Swap(network.get());
   DVLOG(1) << *properties;
 }
 
 void WiFiServiceMac::GetManagedProperties(
     const std::string& network_guid,
     base::DictionaryValue* managed_properties,
     std::string* error) {
   *error = kErrorNotImplemented;
 }
 
 void WiFiServiceMac::GetState(const std::string& network_guid,
                               base::DictionaryValue* properties,
                               std::string* error) {
   *error = kErrorNotImplemented;
 }
 
 void WiFiServiceMac::SetProperties(
     const std::string& network_guid,
-    scoped_ptr<base::DictionaryValue> properties,
+    std::unique_ptr<base::DictionaryValue> properties,
     std::string* error) {
   base::DictionaryValue* existing_properties;
   // If the network properties already exist, don't override previously set
   // properties, unless they are set in |properties|.
   if (network_properties_.GetDictionaryWithoutPathExpansion(
           network_guid, &existing_properties)) {
     existing_properties->MergeDictionary(properties.get());
   } else {
     network_properties_.SetWithoutPathExpansion(network_guid,
                                                 properties.release());
   }
 }
 
 void WiFiServiceMac::CreateNetwork(
     bool shared,
-    scoped_ptr<base::DictionaryValue> properties,
+    std::unique_ptr<base::DictionaryValue> properties,
     std::string* network_guid,
     std::string* error) {
   NetworkProperties network_properties;
   if (!network_properties.UpdateFromValue(*properties)) {
     *error = kErrorInvalidData;
     return;
   }
 
   std::string guid = network_properties.ssid;
   if (FindNetwork(guid) != networks_.end()) {
@@ skipping 13 matching lines @@
       network_type != onc::network_type::kWiFi) {
     return;
   }
 
   if (networks_.empty())
     UpdateNetworks();
 
   for (NetworkList::const_iterator it = networks_.begin();
        it != networks_.end();
        ++it) {
-    scoped_ptr<base::DictionaryValue> network(it->ToValue(!include_details));
+    std::unique_ptr<base::DictionaryValue> network(
+        it->ToValue(!include_details));
     network_list->Append(network.release());
   }
 }
 
 void WiFiServiceMac::RequestNetworkScan() {
   DVLOG(1) << "*** RequestNetworkScan";
   UpdateNetworks();
 }
 
 void WiFiServiceMac::StartConnect(const std::string& network_guid,
@@ skipping 337 matching lines @@
   DVLOG(1) << "NotifyNetworkChanged: " << network_guid;
   NetworkGuidList changed_networks(1, network_guid);
   event_task_runner_->PostTask(
       FROM_HERE, base::Bind(networks_changed_observer_, changed_networks));
 }
 
 // static
 WiFiService* WiFiService::Create() { return new WiFiServiceMac(); }
 
 }  // namespace wifi