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

chrome/browser/ui/webui/chromeos/emulator/device_emulator_message_handler.cc

 // Copyright 2015 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/emulator/device_emulator_message_handler.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "ash/shell.h"
@@ skipping 83 matching lines @@
   void DeviceRemoved(const dbus::ObjectPath& object_path) override;
 
  private:
   DeviceEmulatorMessageHandler* owner_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothObserver);
 };
 
 void DeviceEmulatorMessageHandler::BluetoothObserver::DeviceAdded(
     const dbus::ObjectPath& object_path) {
-  scoped_ptr<base::DictionaryValue> device = owner_->GetDeviceInfo(
-      object_path);
+  std::unique_ptr<base::DictionaryValue> device =
+      owner_->GetDeviceInfo(object_path);
 
   // Request to add the device to the view's list of devices.
   owner_->web_ui()->CallJavascriptFunction(kAddBluetoothDeviceJSCallback,
       *device);
 }
 
 void DeviceEmulatorMessageHandler::BluetoothObserver::DevicePropertyChanged(
   const dbus::ObjectPath& object_path,
   const std::string& property_name) {
   if (property_name == kPairedPropertyName) {
@@ skipping 116 matching lines @@
     const base::ListValue* args) {
   // Get a list containing paths of the devices which are connected to
   // the main adapter.
   std::vector<dbus::ObjectPath> paths =
       fake_bluetooth_device_client_->GetDevicesForAdapter(
           dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath));
 
   base::ListValue devices;
   // Get each device's properties.
   for (const dbus::ObjectPath& path : paths) {
-    scoped_ptr<base::DictionaryValue> device = GetDeviceInfo(path);
+    std::unique_ptr<base::DictionaryValue> device = GetDeviceInfo(path);
     devices.Append(std::move(device));
   }
 
-  scoped_ptr<base::ListValue> predefined_devices =
+  std::unique_ptr<base::ListValue> predefined_devices =
       fake_bluetooth_device_client_->GetBluetoothDevicesAsDictionaries();
 
   base::ListValue pairing_method_options;
   pairing_method_options.AppendString(
       bluez::FakeBluetoothDeviceClient::kPairingMethodNone);
   pairing_method_options.AppendString(
       bluez::FakeBluetoothDeviceClient::kPairingMethodPinCode);
   pairing_method_options.AppendString(
       bluez::FakeBluetoothDeviceClient::kPairingMethodPassKey);
 
@@ skipping 29 matching lines @@
         base::StringValue(path));
   }
 }
 
 void DeviceEmulatorMessageHandler::HandleRequestAudioNodes(
     const base::ListValue* args) {
   // Get every active audio node and create a dictionary to
   // send it to JavaScript.
   base::ListValue audio_nodes;
   for (const AudioNode& node : fake_cras_audio_client_->node_list()) {
-    scoped_ptr<base::DictionaryValue> audio_node(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> audio_node(
+        new base::DictionaryValue());
 
     audio_node->SetBoolean("isInput", node.is_input);
     audio_node->SetString("id", base::Uint64ToString(node.id));
     audio_node->SetString("deviceName", node.device_name);
     audio_node->SetString("type", node.type);
     audio_node->SetString("name", node.name);
     audio_node->SetBoolean("active", node.active);
 
     audio_nodes.Append(std::move(audio_node));
   }
@@ skipping 217 matching lines @@
   CHECK(device_dict->GetBoolean("incoming", &props.incoming));
 
   // Create the device and store it in the FakeBluetoothDeviceClient's observed
   // list of devices.
   fake_bluetooth_device_client_->CreateDeviceWithProperties(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath), props);
 
   return props.device_path;
 }
 
-scoped_ptr<base::DictionaryValue> DeviceEmulatorMessageHandler::GetDeviceInfo(
+std::unique_ptr<base::DictionaryValue>
+DeviceEmulatorMessageHandler::GetDeviceInfo(
     const dbus::ObjectPath& object_path) {
   // Get the device's properties.
   bluez::FakeBluetoothDeviceClient::Properties* props =
       fake_bluetooth_device_client_->GetProperties(object_path);
-  scoped_ptr<base::DictionaryValue> device(new base::DictionaryValue());
-  scoped_ptr<base::ListValue> uuids(new base::ListValue);
+  std::unique_ptr<base::DictionaryValue> device(new base::DictionaryValue());
+  std::unique_ptr<base::ListValue> uuids(new base::ListValue);
   bluez::FakeBluetoothDeviceClient::SimulatedPairingOptions* options =
       fake_bluetooth_device_client_->GetPairingOptions(object_path);
 
   device->SetString("path", object_path.value());
   device->SetString("name", props->name.value());
   device->SetString("alias", props->alias.value());
   device->SetString("address", props->address.value());
   if (options) {
     device->SetString("pairingMethod", options->pairing_method);
     device->SetString("pairingAuthToken", options->pairing_auth_token);
@@ skipping 10 matching lines @@
   for (const std::string& uuid : props->uuids.value()) {
     uuids->AppendString(uuid);
   }
 
   device->Set("uuids", std::move(uuids));
 
   return device;
 }
 
 }  // namespace chromeos