Replace ScopedVector/ScopedPtrHashMap with std::vector and std::unordered_map

device/bluetooth/bluez/bluetooth_adapter_bluez.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 "device/bluetooth/bluez/bluetooth_adapter_bluez.h"
 
 #include <algorithm>
 #include <cstdint>
 #include <limits>
 #include <memory>
@@ skipping 491 matching lines @@
     const std::string& identifier) const {
   const auto& service = owned_gatt_services_.find(dbus::ObjectPath(identifier));
   return service == owned_gatt_services_.end() ? nullptr
                                                : service->second.get();
 }
 
 void BluetoothAdapterBlueZ::RemovePairingDelegateInternal(
     BluetoothDevice::PairingDelegate* pairing_delegate) {
   // Check if any device is using the pairing delegate.
   // If so, clear the pairing context which will make any responses no-ops.
-  for (DevicesMap::const_iterator iter = devices_.begin();
-       iter != devices_.end(); ++iter) {
+  for (auto& item : devices_) {
     BluetoothDeviceBlueZ* device_bluez =
-        static_cast<BluetoothDeviceBlueZ*>(iter->second);
+        static_cast<BluetoothDeviceBlueZ*>(item.second.get());
 
     BluetoothPairingBlueZ* pairing = device_bluez->GetPairing();
     if (pairing && pairing->GetPairingDelegate() == pairing_delegate)
       device_bluez->EndPairing();
   }
 }
 
 void BluetoothAdapterBlueZ::AdapterAdded(const dbus::ObjectPath& object_path) {
   // Set the adapter to the newly added adapter only if no adapter is present.
   if (!IsPresent())
@@ skipping 29 matching lines @@
 
 void BluetoothAdapterBlueZ::DeviceAdded(const dbus::ObjectPath& object_path) {
   DCHECK(bluez::BluezDBusManager::Get());
   bluez::BluetoothDeviceClient::Properties* properties =
       bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
           object_path);
   if (!properties || properties->adapter.value() != object_path_)
     return;
   DCHECK(IsPresent());
 
-  BluetoothDeviceBlueZ* device_bluez = new BluetoothDeviceBlueZ(
-      this, object_path, ui_task_runner_, socket_thread_);
+  std::unique_ptr<BluetoothDeviceBlueZ> device_bluez(new BluetoothDeviceBlueZ(
+      this, object_path, ui_task_runner_, socket_thread_));
   DCHECK(devices_.find(device_bluez->GetAddress()) == devices_.end());
 
-  devices_.set(device_bluez->GetAddress(),
-               std::unique_ptr<BluetoothDevice>(device_bluez));
+  auto insertion = devices_.insert(
+      std::make_pair(device_bluez->GetAddress(), std::move(device_bluez)));
+  if (!insertion.second) {
+    return;
+  }
 
   for (auto& observer : observers_)
-    observer.DeviceAdded(this, device_bluez);
+    observer.DeviceAdded(this, insertion.first->second.get());
 }
 
 void BluetoothAdapterBlueZ::DeviceRemoved(const dbus::ObjectPath& object_path) {
   for (DevicesMap::const_iterator iter = devices_.begin();
        iter != devices_.end(); ++iter) {
     BluetoothDeviceBlueZ* device_bluez =
-        static_cast<BluetoothDeviceBlueZ*>(iter->second);
+        static_cast<BluetoothDeviceBlueZ*>(iter->second.get());
     if (device_bluez->object_path() == object_path) {
-      std::unique_ptr<BluetoothDevice> scoped_device =
-          devices_.take_and_erase(iter->first);
 
       for (auto& observer : observers_)
         observer.DeviceRemoved(this, device_bluez);
+
+      devices_.erase(iter);
+
       return;
     }
   }
 }
 
 void BluetoothAdapterBlueZ::DevicePropertyChanged(
     const dbus::ObjectPath& object_path,
     const std::string& property_name) {
   BluetoothDeviceBlueZ* device_bluez = GetDeviceWithPath(object_path);
   if (!device_bluez)
     return;
 
   bluez::BluetoothDeviceClient::Properties* properties =
       bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
           object_path);
 
   if (property_name == properties->address.name()) {
     for (DevicesMap::iterator iter = devices_.begin(); iter != devices_.end();
          ++iter) {
       if (iter->second->GetAddress() == device_bluez->GetAddress()) {
         std::string old_address = iter->first;
         VLOG(1) << "Device changed address, old: " << old_address
                 << " new: " << device_bluez->GetAddress();
         std::unique_ptr<BluetoothDevice> scoped_device =
-            devices_.take_and_erase(iter);
-        ignore_result(scoped_device.release());
+            std::move(iter->second);
+        devices_.erase(iter);
 
-        DCHECK(devices_.find(device_bluez->GetAddress()) == devices_.end());
-        devices_.set(device_bluez->GetAddress(),
-                     std::unique_ptr<BluetoothDevice>(device_bluez));
-        NotifyDeviceAddressChanged(device_bluez, old_address);
+        DCHECK(devices_.find(scoped_device->GetAddress()) == devices_.end());
+        auto insertion = devices_.insert(std::make_pair(
+            scoped_device->GetAddress(), std::move(scoped_device)));
+        if (!insertion.second) {
+          return;
+        }
+        BluetoothDeviceBlueZ* bluez =
+            static_cast<BluetoothDeviceBlueZ*>(insertion.first->second.get());
+        NotifyDeviceAddressChanged(bluez, old_address);
         break;
       }
     }
   }
 
   if (property_name == properties->service_data.name())
     device_bluez->UpdateServiceData();
   else if (property_name == properties->manufacturer_data.name())
     device_bluez->UpdateManufacturerData();
   else if (property_name == properties->advertising_data_flags.name())
@@ skipping 271 matching lines @@
 }
 
 BluetoothDeviceBlueZ* BluetoothAdapterBlueZ::GetDeviceWithPath(
     const dbus::ObjectPath& object_path) {
   if (!IsPresent())
     return nullptr;
 
   for (DevicesMap::const_iterator iter = devices_.begin();
        iter != devices_.end(); ++iter) {
     BluetoothDeviceBlueZ* device_bluez =
-        static_cast<BluetoothDeviceBlueZ*>(iter->second);
+        static_cast<BluetoothDeviceBlueZ*>(iter->second.get());
     if (device_bluez->object_path() == object_path)
       return device_bluez;
   }
 
   return nullptr;
 }
 
 BluetoothPairingBlueZ* BluetoothAdapterBlueZ::GetPairing(
     const dbus::ObjectPath& object_path) {
   DCHECK(IsPresent());
@@ skipping 114 matching lines @@
     DiscoveringChanged(false);
 
   // Move all elements of the original devices list to a new list here,
   // leaving the original list empty so that when we send DeviceRemoved(),
   // GetDevices() returns no devices.
   DevicesMap devices_swapped;
   devices_swapped.swap(devices_);
 
   for (auto& iter : devices_swapped) {
     for (auto& observer : observers_)
-      observer.DeviceRemoved(this, iter.second);
+      observer.DeviceRemoved(this, iter.second.get());
   }
 
   PresentChanged(false);
 }
 
 void BluetoothAdapterBlueZ::DiscoverableChanged(bool discoverable) {
   for (auto& observer : observers_)
     observer.AdapterDiscoverableChanged(this, discoverable);
 }
 
@@ skipping 679 matching lines @@
   } else if (error_name == bluetooth_adapter::kErrorAlreadyExists) {
     code = BluetoothServiceRecordBlueZ::ErrorCode::ERROR_RECORD_ALREADY_EXISTS;
   } else if (error_name == bluetooth_adapter::kErrorNotReady) {
     code = BluetoothServiceRecordBlueZ::ErrorCode::ERROR_ADAPTER_NOT_READY;
   }
 
   error_callback.Run(code);
 }
 
 }  // namespace bluez