Convert //chrome/browser/ui from scoped_ptr to std::unique_ptr

chrome/browser/ui/webui/chromeos/network_ui.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 "chrome/browser/ui/webui/chromeos/network_ui.h"
 
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 30 matching lines @@
 }
 
 void SetDeviceProperties(base::DictionaryValue* dictionary) {
   std::string device;
   dictionary->GetStringWithoutPathExpansion(shill::kDeviceProperty, &device);
   const DeviceState* device_state =
       NetworkHandler::Get()->network_state_handler()->GetDeviceState(device);
   if (!device_state)
     return;
 
-  scoped_ptr<base::DictionaryValue> device_dictionary(
+  std::unique_ptr<base::DictionaryValue> device_dictionary(
       device_state->properties().DeepCopy());
 
   if (!device_state->ip_configs().empty()) {
     // Convert IPConfig dictionary to a ListValue.
-    scoped_ptr<base::ListValue> ip_configs(new base::ListValue);
+    std::unique_ptr<base::ListValue> ip_configs(new base::ListValue);
     for (base::DictionaryValue::Iterator iter(device_state->ip_configs());
          !iter.IsAtEnd(); iter.Advance()) {
       ip_configs->Append(iter.value().DeepCopy());
     }
     device_dictionary->SetWithoutPathExpansion(shill::kIPConfigsProperty,
                                                ip_configs.release());
   }
   if (!device_dictionary->empty())
     dictionary->Set(shill::kDeviceProperty, device_dictionary.release());
 }
@@ skipping 28 matching lines @@
         service_path,
         base::Bind(&NetworkConfigMessageHandler::GetShillPropertiesSuccess,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&NetworkConfigMessageHandler::ErrorCallback,
                    weak_ptr_factory_.GetWeakPtr(), guid));
   }
 
   void GetShillPropertiesSuccess(
       const std::string& service_path,
       const base::DictionaryValue& dictionary) const {
-    scoped_ptr<base::DictionaryValue> dictionary_copy(dictionary.DeepCopy());
+    std::unique_ptr<base::DictionaryValue> dictionary_copy(
+        dictionary.DeepCopy());
 
     // Set the 'ServicePath' property for debugging.
     dictionary_copy->SetStringWithoutPathExpansion("ServicePath", service_path);
     // Set the device properties for debugging.
     SetDeviceProperties(dictionary_copy.get());
 
     base::ListValue return_arg_list;
     return_arg_list.Append(dictionary_copy.release());
     web_ui()->CallJavascriptFunction("NetworkUI.getShillPropertiesResult",
                                      return_arg_list);
   }
 
   void ErrorCallback(
       const std::string& guid,
       const std::string& error_name,
-      scoped_ptr<base::DictionaryValue> /* error_data */) const {
+      std::unique_ptr<base::DictionaryValue> /* error_data */) const {
     NET_LOG(ERROR) << "Shill Error: " << error_name << " guid=" << guid;
     base::ListValue return_arg_list;
-    scoped_ptr<base::DictionaryValue> dictionary;
+    std::unique_ptr<base::DictionaryValue> dictionary;
     dictionary->SetStringWithoutPathExpansion(shill::kGuidProperty, guid);
     dictionary->SetStringWithoutPathExpansion("ShillError", error_name);
     return_arg_list.Append(dictionary.release());
     web_ui()->CallJavascriptFunction("NetworkUI.getShillPropertiesResult",
                                      return_arg_list);
   }
 
   base::WeakPtrFactory<NetworkConfigMessageHandler> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkConfigMessageHandler);
@@ skipping 53 matching lines @@
   html->SetDefaultResource(IDR_NETWORK_UI_HTML);
 
   content::WebUIDataSource::Add(web_ui->GetWebContents()->GetBrowserContext(),
                                 html);
 }
 
 NetworkUI::~NetworkUI() {
 }
 
 }  // namespace chromeos