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

components/wifi/fake_wifi_service.cc

 // Copyright 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.
 
 #include "components/wifi/fake_wifi_service.h"
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "components/onc/onc_constants.h"
 
 namespace wifi {
 
 FakeWiFiService::FakeWiFiService() {
   // Populate data expected by unit test.
   {
     NetworkProperties network_properties;
@@ skipping 58 matching lines @@
   NetworkList::iterator network_properties = FindNetwork(network_guid);
   if (network_properties == networks_.end()) {
     *error = "Error.InvalidNetworkGuid";
     return;
   }
   properties->Swap(network_properties->ToValue(true).get());
 }
 
 void FakeWiFiService::SetProperties(
     const std::string& network_guid,
-    scoped_ptr<base::DictionaryValue> properties,
+    std::unique_ptr<base::DictionaryValue> properties,
     std::string* error) {
   NetworkList::iterator network_properties = FindNetwork(network_guid);
   if (network_properties == networks_.end() ||
       !network_properties->UpdateFromValue(*properties)) {
     *error = "Error.DBusFailed";
   }
 }
 
 void FakeWiFiService::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)) {
     network_properties.guid = network_properties.ssid;
     networks_.push_back(network_properties);
     *network_guid = network_properties.guid;
   } else {
     *error = "Error.DBusFailed";
   }
 }
 
 void FakeWiFiService::GetVisibleNetworks(const std::string& network_type,
                                          base::ListValue* network_list,
                                          bool include_details) {
   for (NetworkList::const_iterator it = networks_.begin();
        it != networks_.end();
        ++it) {
     if (network_type.empty() || network_type == onc::network_type::kAllTypes ||
         it->type == network_type) {
-      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 FakeWiFiService::RequestNetworkScan() {
   NotifyNetworkListChanged(networks_);
 }
 
 void FakeWiFiService::StartConnect(const std::string& network_guid,
@@ skipping 82 matching lines @@
       FROM_HERE, base::Bind(network_list_changed_observer_, current_networks));
 }
 
 void FakeWiFiService::NotifyNetworkChanged(const std::string& network_guid) {
   WiFiService::NetworkGuidList changed_networks(1, network_guid);
   task_runner_->PostTask(
       FROM_HERE, base::Bind(networks_changed_observer_, changed_networks));
 }
 
 }  // namespace wifi