Kill ScopedPtrMap and friends

device/bluetooth/dbus/fake_bluetooth_device_client.cc

 // Copyright (c) 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 "device/bluetooth/dbus/fake_bluetooth_device_client.h"
 
 #include <fcntl.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
@@ skipping 270 matching lines @@
   properties->adapter.ReplaceValue(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
 
   std::vector<std::string> uuids;
   uuids.push_back("00001800-0000-1000-8000-00805f9b34fb");
   uuids.push_back("00001801-0000-1000-8000-00805f9b34fb");
   properties->uuids.ReplaceValue(uuids);
 
   properties->modalias.ReplaceValue("usb:v05ACp030Dd0306");
 
-  properties_map_.insert(dbus::ObjectPath(kPairedDevicePath),
-                         properties.Pass());
+  properties_map_.insert(std::make_pair(dbus::ObjectPath(kPairedDevicePath),
+                                        std::move(properties)));
   device_list_.push_back(dbus::ObjectPath(kPairedDevicePath));
 
   properties.reset(new Properties(base::Bind(
       &FakeBluetoothDeviceClient::OnPropertyChanged, base::Unretained(this),
       dbus::ObjectPath(kPairedUnconnectableDevicePath))));
   properties->address.ReplaceValue(kPairedUnconnectableDeviceAddress);
   properties->bluetooth_class.ReplaceValue(kPairedUnconnectableDeviceClass);
   properties->name.ReplaceValue("Fake Device 2 (Unconnectable)");
   properties->alias.ReplaceValue(kPairedUnconnectableDeviceName);
   properties->paired.ReplaceValue(true);
   properties->trusted.ReplaceValue(true);
   properties->adapter.ReplaceValue(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
 
   properties->uuids.ReplaceValue(uuids);
 
   properties->modalias.ReplaceValue("usb:v05ACp030Dd0306");
 
-  properties_map_.insert(dbus::ObjectPath(kPairedUnconnectableDevicePath),
-                         properties.Pass());
+  properties_map_.insert(std::make_pair(
+      dbus::ObjectPath(kPairedUnconnectableDevicePath), std::move(properties)));
   device_list_.push_back(dbus::ObjectPath(kPairedUnconnectableDevicePath));
 }
 
 FakeBluetoothDeviceClient::~FakeBluetoothDeviceClient() {}
 
 void FakeBluetoothDeviceClient::Init(dbus::Bus* bus) {}
 
 void FakeBluetoothDeviceClient::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void FakeBluetoothDeviceClient::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 std::vector<dbus::ObjectPath> FakeBluetoothDeviceClient::GetDevicesForAdapter(
     const dbus::ObjectPath& adapter_path) {
   if (adapter_path ==
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath))
     return device_list_;
   else
     return std::vector<dbus::ObjectPath>();
 }
 
 FakeBluetoothDeviceClient::Properties* FakeBluetoothDeviceClient::GetProperties(
     const dbus::ObjectPath& object_path) {
   PropertiesMap::const_iterator iter = properties_map_.find(object_path);
   if (iter != properties_map_.end())
-    return iter->second;
+    return iter->second.get();
   return NULL;
 }
 
 FakeBluetoothDeviceClient::SimulatedPairingOptions*
 FakeBluetoothDeviceClient::GetPairingOptions(
     const dbus::ObjectPath& object_path) {
   PairingOptionsMap::const_iterator iter =
       pairing_options_map_.find(object_path);
   if (iter != pairing_options_map_.end())
-    return iter->second;
-  return iter != pairing_options_map_.end() ? iter->second : nullptr;
+    return iter->second.get();
+  return iter != pairing_options_map_.end() ? iter->second.get() : nullptr;
 }
 
 void FakeBluetoothDeviceClient::Connect(const dbus::ObjectPath& object_path,
                                         const base::Closure& callback,
                                         const ErrorCallback& error_callback) {
   VLOG(1) << "Connect: " << object_path.value();
   Properties* properties = GetProperties(object_path);
 
   if (properties->connected.value() == true) {
     // Already connected.
@@ skipping 336 matching lines @@
         kConnectedTrustedNotPairedDeviceClass);
     properties->trusted.ReplaceValue(true);
     properties->connected.ReplaceValue(true);
     properties->paired.ReplaceValue(false);
     properties->name.ReplaceValue("Connected Pairable Device");
     properties->alias.ReplaceValue(kConnectedTrustedNotPairedDeviceName);
   } else {
     NOTREACHED();
   }
 
-  properties_map_.insert(device_path, properties.Pass());
+  properties_map_.insert(std::make_pair(device_path, std::move(properties)));
   device_list_.push_back(device_path);
   FOR_EACH_OBSERVER(BluetoothDeviceClient::Observer, observers_,
                     DeviceAdded(device_path));
 }
 
 void FakeBluetoothDeviceClient::CreateDeviceWithProperties(
     const dbus::ObjectPath& adapter_path,
     const IncomingDeviceProperties& props) {
   dbus::ObjectPath device_path(props.device_path);
   if (std::find(device_list_.begin(), device_list_.end(), device_path) !=
@@ skipping 12 matching lines @@
 
   if (props.is_trusted)
     properties->paired.ReplaceValue(true);
 
   scoped_ptr<SimulatedPairingOptions> options(new SimulatedPairingOptions);
   options->pairing_method = props.pairing_method;
   options->pairing_auth_token = props.pairing_auth_token;
   options->pairing_action = props.pairing_action;
   options->incoming = props.incoming;
 
-  properties_map_.insert(device_path, properties.Pass());
+  properties_map_.insert(std::make_pair(device_path, std::move(properties)));
   device_list_.push_back(device_path);
-  pairing_options_map_.insert(device_path, options.Pass());
+  pairing_options_map_.insert(std::make_pair(device_path, std::move(options)));
   FOR_EACH_OBSERVER(BluetoothDeviceClient::Observer, observers_,
                     DeviceAdded(device_path));
 }
 
 scoped_ptr<base::ListValue>
 FakeBluetoothDeviceClient::GetBluetoothDevicesAsDictionaries() const {
   scoped_ptr<base::ListValue> predefined_devices(new base::ListValue);
   scoped_ptr<base::DictionaryValue> pairedDevice(new base::DictionaryValue);
   pairedDevice->SetString("path", kPairedDevicePath);
   pairedDevice->SetString("address", kPairedDeviceAddress);
@@ skipping 233 matching lines @@
 
 void FakeBluetoothDeviceClient::RemoveDevice(
     const dbus::ObjectPath& adapter_path,
     const dbus::ObjectPath& device_path) {
   std::vector<dbus::ObjectPath>::iterator listiter =
       std::find(device_list_.begin(), device_list_.end(), device_path);
   if (listiter == device_list_.end())
     return;
 
   PropertiesMap::const_iterator iter = properties_map_.find(device_path);
-  Properties* properties = iter->second;
+  Properties* properties = iter->second.get();
 
   VLOG(1) << "removing device: " << properties->alias.value();
   device_list_.erase(listiter);
 
   // Remove the Input interface if it exists. This should be called before the
   // BluetoothDeviceClient::Observer::DeviceRemoved because it deletes the
   // BluetoothDeviceBlueZ object, including the device_path referenced here.
   FakeBluetoothInputClient* fake_bluetooth_input_client =
       static_cast<FakeBluetoothInputClient*>(
           bluez::BluezDBusManager::Get()->GetBluetoothInputClient());
@@ skipping 432 matching lines @@
 }
 
 void FakeBluetoothDeviceClient::UpdateDeviceRSSI(
     const dbus::ObjectPath& object_path,
     int16 rssi) {
   PropertiesMap::const_iterator iter = properties_map_.find(object_path);
   if (iter == properties_map_.end()) {
     VLOG(2) << "Fake device does not exist: " << object_path.value();
     return;
   }
-  Properties* properties = iter->second;
+  Properties* properties = iter->second.get();
   DCHECK(properties);
   properties->rssi.ReplaceValue(rssi);
 }
 
 void FakeBluetoothDeviceClient::UpdateConnectionInfo(
     uint16 connection_rssi,
     uint16 transmit_power,
     uint16 max_transmit_power) {
   connection_rssi_ = connection_rssi;
   transmit_power_ = transmit_power;
@@ skipping 199 matching lines @@
     // TODO(keybuk): tear down this side of the connection
     callback.Run();
   } else if (status == BluetoothProfileServiceProvider::Delegate::CANCELLED) {
     error_callback.Run(bluetooth_device::kErrorFailed, "Canceled");
   } else if (status == BluetoothProfileServiceProvider::Delegate::REJECTED) {
     error_callback.Run(bluetooth_device::kErrorFailed, "Rejected");
   }
 }
 
 }  // namespace bluez