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

device/bluetooth/bluetooth_adapter_mac.mm

 // 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/bluetooth_adapter_mac.h"
 
 #import <IOBluetooth/objc/IOBluetoothDevice.h>
 #import <IOBluetooth/objc/IOBluetoothHostController.h>
 #include <stddef.h>
 
@@ skipping 484 matching lines @@
   BluetoothDevice* device_classic = GetDevice(device_address);
 
   // Only notify observers once per device.
   if (device_classic != nullptr) {
     VLOG(3) << "Updating classic device: " << device_classic->GetAddress();
     device_classic->UpdateTimestamp();
     return;
   }
 
   device_classic = new BluetoothClassicDeviceMac(this, device);
-  devices_.set(device_address, base::WrapUnique(device_classic));
   VLOG(1) << "Adding new classic device: " << device_classic->GetAddress();
+  auto insertion = devices_.insert(
+      std::make_pair(device_address, std::move(device_classic)));
+  if (!insertion.second) {
+    VLOG(1) << "Insertion of device_classic failed.";
+    return;
+  }
 
   for (auto& observer : observers_)
-    observer.DeviceAdded(this, device_classic);
+    observer.DeviceAdded(this, insertion.first->second.get());
 }
 
 void BluetoothAdapterMac::LowEnergyDeviceUpdated(
     CBPeripheral* peripheral,
     NSDictionary* advertisement_data,
     int rssi) {
   BluetoothLowEnergyDeviceMac* device_mac =
       GetBluetoothLowEnergyDeviceMac(peripheral);
   // If has no entry in the map, create new device and insert into |devices_|,
   // otherwise update the existing device.
@@ skipping 39 matching lines @@
   int8_t clamped_tx_power = BluetoothDevice::ClampPower([tx_power intValue]);
 
   device_mac->UpdateAdvertisementData(
       BluetoothDevice::ClampPower(rssi), std::move(advertised_uuids),
       std::move(service_data_map),
       tx_power == nil ? nullptr : &clamped_tx_power);
 
   if (is_new_device) {
     std::string device_address =
         BluetoothLowEnergyDeviceMac::GetPeripheralHashAddress(peripheral);
-    devices_.add(device_address, std::unique_ptr<BluetoothDevice>(device_mac));
+    auto insertion =
+        devices_.insert(std::make_pair(device_address, std::move(device_mac)));
+
+    if (!insertion.second) {
+      VLOG(1) << "Insertion of device_mac failed.";
+      return;
+    }
     for (auto& observer : observers_)
-      observer.DeviceAdded(this, device_mac);
+      observer.DeviceAdded(this, insertion.first->second.get());
   } else {
     for (auto& observer : observers_)
       observer.DeviceChanged(this, device_mac);
   }
 }
 
 // TODO(krstnmnlsn): Implement. crbug.com/511025
 void BluetoothAdapterMac::LowEnergyCentralManagerUpdatedState() {}
 
 void BluetoothAdapterMac::AddPairedDevices() {
@@ skipping 31 matching lines @@
         GetBluetoothLowEnergyDeviceMac(peripheral);
     const bool is_new_device = device_mac == nullptr;
 
     if (!is_new_device && DoesCollideWithKnownDevice(peripheral, device_mac)) {
       continue;
     }
     if (is_new_device) {
       device_mac = new BluetoothLowEnergyDeviceMac(this, peripheral);
       std::string device_address =
           BluetoothLowEnergyDeviceMac::GetPeripheralHashAddress(peripheral);
-      devices_.add(device_address,
-                   std::unique_ptr<BluetoothDevice>(device_mac));
+      devices_.insert(std::make_pair(device_address, std::move(device_mac)));
       for (auto& observer : observers_) {
         observer.DeviceAdded(this, device_mac);
       }
     }
     connected_devices.push_back(device_mac);
   }
   return connected_devices;
 }
 
 void BluetoothAdapterMac::CreateGattConnection(
@@ skipping 56 matching lines @@
 }
 
 BluetoothLowEnergyDeviceMac*
 BluetoothAdapterMac::GetBluetoothLowEnergyDeviceMac(CBPeripheral* peripheral) {
   std::string device_address =
       BluetoothLowEnergyDeviceMac::GetPeripheralHashAddress(peripheral);
   DevicesMap::const_iterator iter = devices_.find(device_address);
   if (iter == devices_.end()) {
     return nil;
   }
-  return static_cast<BluetoothLowEnergyDeviceMac*>(iter->second);
+  return static_cast<BluetoothLowEnergyDeviceMac*>(iter->second.get());
 }
 
 bool BluetoothAdapterMac::DoesCollideWithKnownDevice(
     CBPeripheral* peripheral,
     BluetoothLowEnergyDeviceMac* device_mac) {
   // Check that there are no collisions.
   std::string stored_device_id = device_mac->GetIdentifier();
   std::string updated_device_id =
       BluetoothLowEnergyDeviceMac::GetPeripheralIdentifier(peripheral);
   if (stored_device_id != updated_device_id) {
     VLOG(1) << "LowEnergyDeviceUpdated stored_device_id != updated_device_id: "
             << std::endl
             << "  " << stored_device_id << std::endl
             << "  " << updated_device_id;
     // Collision, two identifiers map to the same hash address.  With a 48 bit
     // hash the probability of this occuring with 10,000 devices
     // simultaneously present is 1e-6 (see
     // https://en.wikipedia.org/wiki/Birthday_problem#Probability_table).  We
     // ignore the second device by returning.
     return true;
   }
   return false;
 }
 
 }  // namespace device