Remove base::ScopedPtrHashMap from device/.

BUG=579229

Review-Url: https://codereview.chromium.org/2606823002
Cr-Commit-Position: refs/heads/master@{#440902}

device/bluetooth/bluetooth_adapter.cc

@@ -9,7 +9,6 @@
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/stl_util.h"
 #include "build/build_config.h"
 #include "device/bluetooth/bluetooth_common.h"
 #include "device/bluetooth/bluetooth_device.h"
@@ -110,10 +109,8 @@ BluetoothAdapter::DeviceList BluetoothAdapter::GetDevices() {
 
 BluetoothAdapter::ConstDeviceList BluetoothAdapter::GetDevices() const {
   ConstDeviceList devices;
-  for (DevicesMap::const_iterator iter = devices_.begin();
-       iter != devices_.end();
-       ++iter)
-    devices.push_back(iter->second);
+  for (const auto& device : devices_)
+    devices.push_back(device.second.get());
 
   return devices;
 }
@@ -130,9 +127,9 @@ const BluetoothDevice* BluetoothAdapter::GetDevice(
   if (canonicalized_address.empty())
     return nullptr;
 
-  DevicesMap::const_iterator iter = devices_.find(canonicalized_address);
+  auto iter = devices_.find(canonicalized_address);
   if (iter != devices_.end())
-    return iter->second;
+    return iter->second.get();
 
   return nullptr;
 }
@@ -376,8 +373,8 @@ BluetoothAdapter::GetMergedDiscoveryFilterHelper(
 }
 
 void BluetoothAdapter::RemoveTimedOutDevices() {
-  for (DevicesMap::iterator it = devices_.begin(); it != devices_.end();) {
-    BluetoothDevice* device = it->second;
+  for (auto it = devices_.begin(); it != devices_.end();) {
+    BluetoothDevice* device = it->second.get();
     if (device->IsPaired() || device->IsConnected() ||
         device->IsGattConnected()) {
       ++it;
@@ -398,10 +395,10 @@ void BluetoothAdapter::RemoveTimedOutDevices() {
     }
 
     VLOG(1) << "Removing device: " << device->GetAddress();
-    DevicesMap::iterator next = it;
+    auto next = it;
     next++;
-    std::unique_ptr<BluetoothDevice> removed_device =
-        devices_.take_and_erase(it);
+    std::unique_ptr<BluetoothDevice> removed_device = std::move(it->second);
+    devices_.erase(it);
     it = next;
 
     for (auto& observer : observers_)

device/bluetooth/bluetooth_adapter.h

@@ -16,7 +16,6 @@
 #include <vector>
 
 #include "base/callback.h"
-#include "base/containers/scoped_ptr_hash_map.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
@@ -501,12 +500,12 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothAdapter
   friend class BluetoothDiscoverySession;
   friend class BluetoothTestBase;
 
-  typedef base::ScopedPtrHashMap<std::string, std::unique_ptr<BluetoothDevice>>
-      DevicesMap;
-  typedef std::pair<BluetoothDevice::PairingDelegate*, PairingDelegatePriority>
-      PairingDelegatePair;
-  typedef base::Callback<void(UMABluetoothDiscoverySessionOutcome)>
-      DiscoverySessionErrorCallback;
+  using DevicesMap =
+      std::unordered_map<std::string, std::unique_ptr<BluetoothDevice>>;
+  using PairingDelegatePair =
+      std::pair<BluetoothDevice::PairingDelegate*, PairingDelegatePriority>;
+  using DiscoverySessionErrorCallback =
+      base::Callback<void(UMABluetoothDiscoverySessionOutcome)>;
 
   BluetoothAdapter();
   virtual ~BluetoothAdapter();

device/bluetooth/bluetooth_adapter_android.cc

@@ -183,7 +183,7 @@ void BluetoothAdapterAndroid::CreateOrUpdateDeviceOnScan(
     const JavaParamRef<jobjectArray>& advertised_uuids,  // Java Type: String[]
     int32_t tx_power) {
   std::string device_address = ConvertJavaStringToUTF8(env, address);
-  DevicesMap::const_iterator iter = devices_.find(device_address);
+  auto iter = devices_.find(device_address);
 
   bool is_new_device = false;
   std::unique_ptr<BluetoothDeviceAndroid> device_android_owner;
@@ -197,7 +197,7 @@ void BluetoothAdapterAndroid::CreateOrUpdateDeviceOnScan(
     device_android = device_android_owner.get();
   } else {
     // Existing device.
-    device_android = static_cast<BluetoothDeviceAndroid*>(iter->second);
+    device_android = static_cast<BluetoothDeviceAndroid*>(iter->second.get());
   }
   DCHECK(device_android);
 
@@ -219,7 +219,7 @@ void BluetoothAdapterAndroid::CreateOrUpdateDeviceOnScan(
       tx_power == INT32_MIN ? nullptr : &clamped_tx_power);
 
   if (is_new_device) {
-    devices_.add(device_address, std::move(device_android_owner));
+    devices_[device_address] = std::move(device_android_owner);
     for (auto& observer : observers_)
       observer.DeviceAdded(this, device_android);
   } else {

device/bluetooth/bluetooth_adapter_mac.mm

@@ -502,7 +502,7 @@ void BluetoothAdapterMac::ClassicDeviceAdded(IOBluetoothDevice* device) {
   }
 
   device_classic = new BluetoothClassicDeviceMac(this, device);
-  devices_.set(device_address, base::WrapUnique(device_classic));
+  devices_[device_address] = base::WrapUnique(device_classic);
   VLOG(1) << "Adding new classic device: " << device_classic->GetAddress();
 
   for (auto& observer : observers_)
@@ -566,7 +566,7 @@ void BluetoothAdapterMac::LowEnergyDeviceUpdated(
   if (is_new_device) {
     std::string device_address =
         BluetoothLowEnergyDeviceMac::GetPeripheralHashAddress(peripheral);
-    devices_.add(device_address, std::unique_ptr<BluetoothDevice>(device_mac));
+    devices_[device_address] = base::WrapUnique(device_mac);
     for (auto& observer : observers_)
       observer.DeviceAdded(this, device_mac);
   } else {
@@ -620,8 +620,7 @@ BluetoothAdapterMac::RetrieveGattConnectedDevicesWithService(
       device_mac = new BluetoothLowEnergyDeviceMac(this, peripheral);
       std::string device_address =
           BluetoothLowEnergyDeviceMac::GetPeripheralHashAddress(peripheral);
-      devices_.add(device_address,
-                   std::unique_ptr<BluetoothDevice>(device_mac));
+      devices_[device_address] = base::WrapUnique(device_mac);
       for (auto& observer : observers_) {
         observer.DeviceAdded(this, device_mac);
       }
@@ -694,11 +693,11 @@ BluetoothLowEnergyDeviceMac*
 BluetoothAdapterMac::GetBluetoothLowEnergyDeviceMac(CBPeripheral* peripheral) {
   std::string device_address =
       BluetoothLowEnergyDeviceMac::GetPeripheralHashAddress(peripheral);
-  DevicesMap::const_iterator iter = devices_.find(device_address);
+  auto 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(

device/bluetooth/bluetooth_adapter_mac_unittest.mm

@@ -7,6 +7,7 @@
 #include <memory>
 
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/test/test_simple_task_runner.h"
 #include "build/build_config.h"
@@ -83,11 +84,6 @@ class BluetoothAdapterMacTest : public testing::Test {
     return BluetoothLowEnergyDeviceMac::GetPeripheralHashAddress(peripheral);
   }
 
-  void AddLowEnergyDevice(BluetoothLowEnergyDeviceMac* device) {
-    adapter_mac_->devices_.set(device->GetAddress(),
-                               std::unique_ptr<BluetoothDevice>(device));
-  }
-
   int NumDevices() { return adapter_mac_->devices_.size(); }
 
   bool DevicePresent(CBPeripheral* peripheral) {

device/bluetooth/bluetooth_adapter_win.cc

@@ -10,6 +10,7 @@
 
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
@@ -234,58 +235,46 @@ void BluetoothAdapterWin::DevicesPolled(
   // new list with the list we know of (|devices_|) and raise corresponding
   // DeviceAdded, DeviceRemoved and DeviceChanged events.
 
-  typedef std::set<std::string> DeviceAddressSet;
+  using DeviceAddressSet = std::set<std::string>;
   DeviceAddressSet known_devices;
-  for (DevicesMap::const_iterator iter = devices_.begin();
-       iter != devices_.end();
-       ++iter) {
-    known_devices.insert((*iter).first);
-  }
+  for (const auto& device : devices_)
+    known_devices.insert(device.first);
 
   DeviceAddressSet new_devices;
-  for (ScopedVector<BluetoothTaskManagerWin::DeviceState>::const_iterator iter =
-           devices.begin();
-       iter != devices.end();
-       ++iter) {
+  for (auto iter = devices.begin(); iter != devices.end(); ++iter)
     new_devices.insert((*iter)->address);
-  }
 
-  // Process device removal first
+  // Process device removal first.
   DeviceAddressSet removed_devices =
       base::STLSetDifference<DeviceAddressSet>(known_devices, new_devices);
-  for (DeviceAddressSet::const_iterator iter = removed_devices.begin();
-       iter != removed_devices.end();
-       ++iter) {
-    std::unique_ptr<BluetoothDevice> device_win =
-        devices_.take_and_erase(*iter);
+  for (const auto& device : removed_devices) {
+    auto it = devices_.find(device);
+    std::unique_ptr<BluetoothDevice> device_win = std::move(it->second);
+    devices_.erase(it);
     for (auto& observer : observers_)
       observer.DeviceRemoved(this, device_win.get());
   }
 
-  // Process added and (maybe) changed devices in one pass
+  // Process added and (maybe) changed devices in one pass.
   DeviceAddressSet added_devices =
       base::STLSetDifference<DeviceAddressSet>(new_devices, known_devices);
   DeviceAddressSet changed_devices =
       base::STLSetIntersection<DeviceAddressSet>(known_devices, new_devices);
-  for (ScopedVector<BluetoothTaskManagerWin::DeviceState>::const_iterator iter =
-           devices.begin();
-       iter != devices.end();
-       ++iter) {
+  for (auto iter = devices.begin(); iter != devices.end(); ++iter) {
     BluetoothTaskManagerWin::DeviceState* device_state = (*iter);
     if (added_devices.find(device_state->address) != added_devices.end()) {
       BluetoothDeviceWin* device_win =
           new BluetoothDeviceWin(this, *device_state, ui_task_runner_,
                                  socket_thread_, NULL, net::NetLogSource());
-      devices_.set(device_state->address,
-                   std::unique_ptr<BluetoothDevice>(device_win));
+      devices_[device_state->address] = base::WrapUnique(device_win);
       for (auto& observer : observers_)
         observer.DeviceAdded(this, device_win);
     } else if (changed_devices.find(device_state->address) !=
                changed_devices.end()) {
-      DevicesMap::const_iterator iter = devices_.find(device_state->address);
+      auto iter = devices_.find(device_state->address);
       DCHECK(iter != devices_.end());
       BluetoothDeviceWin* device_win =
-          static_cast<BluetoothDeviceWin*>(iter->second);
+          static_cast<BluetoothDeviceWin*>(iter->second.get());
       if (!device_win->IsEqual(*device_state)) {
         device_win->Update(*device_state);
         for (auto& observer : observers_)

device/bluetooth/bluetooth_device.cc

@@ -9,7 +9,6 @@
 #include <string>
 
 #include "base/memory/ptr_util.h"
-#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
@@ -23,9 +22,14 @@
 
 namespace device {
 
-BluetoothDevice::DeviceUUIDs::DeviceUUIDs() {}
+BluetoothDevice::DeviceUUIDs::DeviceUUIDs() = default;
 
-BluetoothDevice::DeviceUUIDs::~DeviceUUIDs() {}
+BluetoothDevice::DeviceUUIDs::~DeviceUUIDs() = default;
+
+BluetoothDevice::DeviceUUIDs::DeviceUUIDs(const DeviceUUIDs& other) = default;
+
+BluetoothDevice::DeviceUUIDs& BluetoothDevice::DeviceUUIDs::operator=(
+    const DeviceUUIDs& other) = default;
 
 void BluetoothDevice::DeviceUUIDs::ReplaceAdvertisedUUIDs(
     UUIDList new_advertised_uuids) {
@@ -44,9 +48,8 @@ void BluetoothDevice::DeviceUUIDs::ClearAdvertisedUUIDs() {
 void BluetoothDevice::DeviceUUIDs::ReplaceServiceUUIDs(
     const GattServiceMap& gatt_services) {
   service_uuids_.clear();
-  for (const auto& gatt_service_pair : gatt_services) {
+  for (const auto& gatt_service_pair : gatt_services)
     service_uuids_.insert(gatt_service_pair.second->GetUUID());
-  }
   UpdateDeviceUUIDs();
 }
 
@@ -371,13 +374,16 @@ std::vector<BluetoothRemoteGattService*> BluetoothDevice::GetGattServices()
     const {
   std::vector<BluetoothRemoteGattService*> services;
   for (const auto& iter : gatt_services_)
-    services.push_back(iter.second);
+    services.push_back(iter.second.get());
   return services;
 }
 
 BluetoothRemoteGattService* BluetoothDevice::GetGattService(
     const std::string& identifier) const {
-  return gatt_services_.get(identifier);
+  auto it = gatt_services_.find(identifier);
+  if (it == gatt_services_.end())
+    return nullptr;
+  return it->second.get();
 }
 
 // static

device/bluetooth/bluetooth_device.h

@@ -16,21 +16,21 @@
 #include <vector>
 
 #include "base/callback.h"
-#include "base/containers/scoped_ptr_hash_map.h"
 #include "base/gtest_prod_util.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/optional.h"
 #include "base/strings/string16.h"
 #include "base/time/time.h"
 #include "device/bluetooth/bluetooth_common.h"
 #include "device/bluetooth/bluetooth_export.h"
+#include "device/bluetooth/bluetooth_remote_gatt_service.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
 namespace device {
 
 class BluetoothAdapter;
 class BluetoothGattConnection;
-class BluetoothRemoteGattService;
 class BluetoothSocket;
 class BluetoothUUID;
 
@@ -106,8 +106,8 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothDevice {
 
   // Mapping from the platform-specific GATT service identifiers to
   // BluetoothRemoteGattService objects.
-  typedef base::ScopedPtrHashMap<std::string,
-                                 std::unique_ptr<BluetoothRemoteGattService>>
+  typedef std::unordered_map<std::string,
+                             std::unique_ptr<BluetoothRemoteGattService>>
       GattServiceMap;
 
   // Interface for negotiating pairing of bluetooth devices.
@@ -579,6 +579,9 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothDevice {
     DeviceUUIDs();
     ~DeviceUUIDs();
 
+    DeviceUUIDs(const DeviceUUIDs& other);
+    DeviceUUIDs& operator=(const DeviceUUIDs& other);
+
     // Advertised Service UUIDs functions
     void ReplaceAdvertisedUUIDs(UUIDList new_advertised_uuids);
 
@@ -601,7 +604,7 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothDevice {
     BluetoothDevice::UUIDSet device_uuids_;
   };
 
-  BluetoothDevice(BluetoothAdapter* adapter);
+  explicit BluetoothDevice(BluetoothAdapter* adapter);
 
   // Implements platform specific operations to initiate a GATT connection.
   // Subclasses must also call DidConnectGatt, DidFailToConnectGatt, or
@@ -673,6 +676,8 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothDevice {
   // Returns a localized string containing the device's bluetooth address and
   // a device type for display when |name_| is empty.
   base::string16 GetAddressWithLocalizedDeviceTypeName() const;
+
+  DISALLOW_COPY_AND_ASSIGN(BluetoothDevice);
 };
 
 }  // namespace device

device/bluetooth/bluetooth_device_android.cc

@@ -246,17 +246,17 @@ void BluetoothDeviceAndroid::CreateGattRemoteService(
   std::string instance_id_string =
       base::android::ConvertJavaStringToUTF8(env, instance_id);
 
-  if (gatt_services_.contains(instance_id_string))
+  if (gatt_services_.find(instance_id_string) != gatt_services_.end())
     return;
 
-  BluetoothDevice::GattServiceMap::iterator service_iterator =
-      gatt_services_.set(
-          instance_id_string,
-          BluetoothRemoteGattServiceAndroid::Create(
-              GetAndroidAdapter(), this, bluetooth_gatt_service_wrapper,
-              instance_id_string, j_device_));
+  std::unique_ptr<BluetoothRemoteGattServiceAndroid> service =
+      BluetoothRemoteGattServiceAndroid::Create(GetAndroidAdapter(), this,
+                                                bluetooth_gatt_service_wrapper,
+                                                instance_id_string, j_device_);
+  BluetoothRemoteGattServiceAndroid* service_ptr = service.get();
+  gatt_services_[instance_id_string] = std::move(service);
 
-  adapter_->NotifyGattServiceAdded(service_iterator->second);
+  adapter_->NotifyGattServiceAdded(service_ptr);
 }
 
 BluetoothDeviceAndroid::BluetoothDeviceAndroid(BluetoothAdapterAndroid* adapter)

device/bluetooth/bluetooth_device_win.cc

@@ -7,8 +7,8 @@
 #include <memory>
 #include <string>
 
-#include "base/containers/scoped_ptr_hash_map.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/stringprintf.h"
@@ -51,7 +51,9 @@ BluetoothDeviceWin::~BluetoothDeviceWin() {
     service_keys.push_back(gatt_service.first);
   }
   for (const auto& key : service_keys) {
-    gatt_services_.take_and_erase(key);
+    std::unique_ptr<BluetoothRemoteGattService> service =
+        std::move(gatt_services_[key]);
+    gatt_services_.erase(key);
   }
 }
 
@@ -213,9 +215,8 @@ void BluetoothDeviceWin::CreateGattConnection(
 
 const BluetoothServiceRecordWin* BluetoothDeviceWin::GetServiceRecord(
     const device::BluetoothUUID& uuid) const {
-  for (ServiceRecordList::const_iterator iter = service_record_list_.begin();
-       iter != service_record_list_.end();
-       ++iter) {
+  for (auto iter = service_record_list_.begin();
+       iter != service_record_list_.end(); ++iter) {
     if ((*iter)->uuid() == uuid)
       return *iter;
   }
@@ -233,21 +234,17 @@ bool BluetoothDeviceWin::IsEqual(
   }
 
   // Checks service collection
-  typedef base::ScopedPtrHashMap<std::string,
-                                 std::unique_ptr<BluetoothServiceRecordWin>>
-      ServiceRecordMap;
-
   UUIDSet new_services;
-  ServiceRecordMap new_service_records;
-  for (ScopedVector<BluetoothTaskManagerWin::ServiceRecordState>::const_iterator
-           iter = device_state.service_record_states.begin();
+  std::unordered_map<std::string, std::unique_ptr<BluetoothServiceRecordWin>>
+      new_service_records;
+  for (auto iter = device_state.service_record_states.begin();
        iter != device_state.service_record_states.end(); ++iter) {
-    BluetoothServiceRecordWin* service_record = new BluetoothServiceRecordWin(
-        address_, (*iter)->name, (*iter)->sdp_bytes, (*iter)->gatt_uuid);
+    std::unique_ptr<BluetoothServiceRecordWin> service_record =
+        base::MakeUnique<BluetoothServiceRecordWin>(
+            address_, (*iter)->name, (*iter)->sdp_bytes, (*iter)->gatt_uuid);
     new_services.insert(service_record->uuid());
-    new_service_records.set(
-        service_record->uuid().canonical_value(),
-        std::unique_ptr<BluetoothServiceRecordWin>(service_record));
+    new_service_records[service_record->uuid().canonical_value()] =
+        std::move(service_record);
   }
 
   // Check that no new services have been added or removed.
@@ -255,11 +252,11 @@ bool BluetoothDeviceWin::IsEqual(
     return false;
   }
 
-  for (ServiceRecordList::const_iterator iter = service_record_list_.begin();
+  for (auto iter = service_record_list_.begin();
        iter != service_record_list_.end(); ++iter) {
     BluetoothServiceRecordWin* service_record = (*iter);
     BluetoothServiceRecordWin* new_service_record =
-        new_service_records.get((*iter)->uuid().canonical_value());
+        new_service_records[(*iter)->uuid().canonical_value()].get();
     if (!service_record->IsEqual(*new_service_record))
       return false;
   }
@@ -300,8 +297,7 @@ void BluetoothDeviceWin::UpdateServices(
   uuids_.clear();
   service_record_list_.clear();
 
-  for (ScopedVector<BluetoothTaskManagerWin::ServiceRecordState>::const_iterator
-           iter = device_state.service_record_states.begin();
+  for (auto iter = device_state.service_record_states.begin();
        iter != device_state.service_record_states.end(); ++iter) {
     BluetoothServiceRecordWin* service_record =
         new BluetoothServiceRecordWin(device_state.address, (*iter)->name,
@@ -316,12 +312,11 @@ void BluetoothDeviceWin::UpdateServices(
 
 bool BluetoothDeviceWin::IsGattServiceDiscovered(BluetoothUUID& uuid,
                                                  uint16_t attribute_handle) {
-  GattServiceMap::iterator it = gatt_services_.begin();
-  for (; it != gatt_services_.end(); it++) {
+  for (const auto& gatt_service : gatt_services_) {
     uint16_t it_att_handle =
-        static_cast<BluetoothRemoteGattServiceWin*>(it->second)
+        static_cast<BluetoothRemoteGattServiceWin*>(gatt_service.second.get())
             ->GetAttributeHandle();
-    BluetoothUUID it_uuid = it->second->GetUUID();
+    BluetoothUUID it_uuid = gatt_service.second->GetUUID();
     if (attribute_handle == it_att_handle && uuid == it_uuid) {
       return true;
     }
@@ -337,8 +332,7 @@ bool BluetoothDeviceWin::DoesGattServiceExist(
       static_cast<BluetoothRemoteGattServiceWin*>(service)
           ->GetAttributeHandle();
   BluetoothUUID uuid = service->GetUUID();
-  ScopedVector<BluetoothTaskManagerWin::ServiceRecordState>::const_iterator it =
-      service_state.begin();
+  auto it = service_state.begin();
   for (; it != service_state.end(); ++it) {
     if (attribute_handle == (*it)->attribute_handle && uuid == (*it)->gatt_uuid)
       return true;
@@ -353,16 +347,18 @@ void BluetoothDeviceWin::UpdateGattServices(
   {
     std::vector<std::string> to_be_removed_services;
     for (const auto& gatt_service : gatt_services_) {
-      if (!DoesGattServiceExist(service_state, gatt_service.second)) {
+      if (!DoesGattServiceExist(service_state, gatt_service.second.get())) {
         to_be_removed_services.push_back(gatt_service.first);
       }
     }
     for (const auto& service : to_be_removed_services) {
-      gatt_services_.take_and_erase(service);
+      std::unique_ptr<BluetoothRemoteGattService> service_ptr =
+          std::move(gatt_services_[service]);
+      gatt_services_.erase(service);
     }
     // Update previously discovered services.
-    for (auto gatt_service : gatt_services_) {
-      static_cast<BluetoothRemoteGattServiceWin*>(gatt_service.second)
+    for (const auto& gatt_service : gatt_services_) {
+      static_cast<BluetoothRemoteGattServiceWin*>(gatt_service.second.get())
           ->Update();
     }
   }
@@ -372,17 +368,14 @@ void BluetoothDeviceWin::UpdateGattServices(
     return;
 
   // Add new services.
-  for (ScopedVector<BluetoothTaskManagerWin::ServiceRecordState>::const_iterator
-           it = service_state.begin();
-       it != service_state.end(); ++it) {
+  for (auto it = service_state.begin(); it != service_state.end(); ++it) {
     if (!IsGattServiceDiscovered((*it)->gatt_uuid, (*it)->attribute_handle)) {
       BluetoothRemoteGattServiceWin* primary_service =
           new BluetoothRemoteGattServiceWin(this, (*it)->path, (*it)->gatt_uuid,
                                             (*it)->attribute_handle, true,
                                             nullptr, ui_task_runner_);
-      gatt_services_.add(
-          primary_service->GetIdentifier(),
-          std::unique_ptr<BluetoothRemoteGattService>(primary_service));
+      gatt_services_[primary_service->GetIdentifier()] =
+          base::WrapUnique(primary_service);
       adapter_->NotifyGattServiceAdded(primary_service);
     }
   }

device/bluetooth/bluetooth_low_energy_device_mac.mm

@@ -206,15 +206,14 @@ void BluetoothLowEnergyDeviceMac::DidDiscoverPrimaryServices(NSError* error) {
     if (!gatt_service) {
       gatt_service = new BluetoothRemoteGattServiceMac(this, cb_service,
                                                        true /* is_primary */);
-      auto result_iter = gatt_services_.add(gatt_service->GetIdentifier(),
-                                            base::WrapUnique(gatt_service));
+      auto result_iter = gatt_services_.insert(std::make_pair(
+          gatt_service->GetIdentifier(), base::WrapUnique(gatt_service)));
       DCHECK(result_iter.second);
       adapter_->NotifyGattServiceAdded(gatt_service);
     }
   }
-  for (GattServiceMap::const_iterator it = gatt_services_.begin();
-       it != gatt_services_.end(); ++it) {
-    device::BluetoothRemoteGattService* gatt_service = it->second;
+  for (auto it = gatt_services_.begin(); it != gatt_services_.end(); ++it) {
+    device::BluetoothRemoteGattService* gatt_service = it->second.get();
     device::BluetoothRemoteGattServiceMac* gatt_service_mac =
         static_cast<BluetoothRemoteGattServiceMac*>(gatt_service);
     gatt_service_mac->DiscoverCharacteristics();
@@ -248,8 +247,8 @@ void BluetoothLowEnergyDeviceMac::DidDiscoverCharacteristics(
   bool discovery_complete =
       std::find_if_not(
           gatt_services_.begin(), gatt_services_.end(),
-          [](std::pair<std::string, BluetoothRemoteGattService*> pair) {
-            BluetoothRemoteGattService* gatt_service = pair.second;
+          [](GattServiceMap::value_type& pair) {
+            BluetoothRemoteGattService* gatt_service = pair.second.get();
             return static_cast<BluetoothRemoteGattServiceMac*>(gatt_service)
                 ->IsDiscoveryComplete();
           }) == gatt_services_.end();
@@ -270,7 +269,8 @@ void BluetoothLowEnergyDeviceMac::DidModifyServices(
     DCHECK(gatt_service);
     VLOG(1) << gatt_service->GetUUID().canonical_value();
     std::unique_ptr<BluetoothRemoteGattService> scoped_service =
-        gatt_services_.take_and_erase(gatt_service->GetIdentifier());
+        std::move(gatt_services_[gatt_service->GetIdentifier()]);
+    gatt_services_.erase(gatt_service->GetIdentifier());
     adapter_->NotifyGattServiceRemoved(scoped_service.get());
   }
   device_uuids_.ClearServiceUUIDs();
@@ -340,9 +340,8 @@ CBPeripheral* BluetoothLowEnergyDeviceMac::GetPeripheral() {
 device::BluetoothRemoteGattServiceMac*
 BluetoothLowEnergyDeviceMac::GetBluetoothRemoteGattService(
     CBService* cb_service) const {
-  for (GattServiceMap::const_iterator it = gatt_services_.begin();
-       it != gatt_services_.end(); ++it) {
-    device::BluetoothRemoteGattService* gatt_service = it->second;
+  for (auto it = gatt_services_.begin(); it != gatt_services_.end(); ++it) {
+    device::BluetoothRemoteGattService* gatt_service = it->second.get();
     device::BluetoothRemoteGattServiceMac* gatt_service_mac =
         static_cast<BluetoothRemoteGattServiceMac*>(gatt_service);
     if (gatt_service_mac->GetService() == cb_service)

device/bluetooth/bluetooth_remote_gatt_characteristic_android.cc

@@ -113,7 +113,7 @@ BluetoothRemoteGattCharacteristicAndroid::GetDescriptors() const {
   EnsureDescriptorsCreated();
   std::vector<BluetoothRemoteGattDescriptor*> descriptors;
   for (const auto& map_iter : descriptors_)
-    descriptors.push_back(map_iter.second);
+    descriptors.push_back(map_iter.second.get());
   return descriptors;
 }
 
@@ -124,7 +124,7 @@ BluetoothRemoteGattCharacteristicAndroid::GetDescriptor(
   const auto& iter = descriptors_.find(identifier);
   if (iter == descriptors_.end())
     return nullptr;
-  return iter->second;
+  return iter->second.get();
 }
 
 void BluetoothRemoteGattCharacteristicAndroid::ReadRemoteCharacteristic(
@@ -241,12 +241,11 @@ void BluetoothRemoteGattCharacteristicAndroid::CreateGattRemoteDescriptor(
   std::string instanceIdString =
       base::android::ConvertJavaStringToUTF8(env, instanceId);
 
-  DCHECK(!descriptors_.contains(instanceIdString));
+  DCHECK(descriptors_.find(instanceIdString) == descriptors_.end());
 
-  descriptors_.set(instanceIdString,
-                   BluetoothRemoteGattDescriptorAndroid::Create(
-                       instanceIdString, bluetooth_gatt_descriptor_wrapper,
-                       chrome_bluetooth_device));
+  descriptors_[instanceIdString] = BluetoothRemoteGattDescriptorAndroid::Create(
+      instanceIdString, bluetooth_gatt_descriptor_wrapper,
+      chrome_bluetooth_device);
 }
 
 void BluetoothRemoteGattCharacteristicAndroid::SubscribeToNotifications(

device/bluetooth/bluetooth_remote_gatt_characteristic_android.h

@@ -8,10 +8,10 @@
 #include <stdint.h>
 
 #include <memory>
+#include <unordered_map>
 
 #include "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
-#include "base/containers/scoped_ptr_hash_map.h"
 #include "base/macros.h"
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service.h"
@@ -142,8 +142,8 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothRemoteGattCharacteristicAndroid
   std::vector<uint8_t> value_;
 
   // Map of descriptors, keyed by descriptor identifier.
-  base::ScopedPtrHashMap<std::string,
-                         std::unique_ptr<BluetoothRemoteGattDescriptorAndroid>>
+  std::unordered_map<std::string,
+                     std::unique_ptr<BluetoothRemoteGattDescriptorAndroid>>
       descriptors_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothRemoteGattCharacteristicAndroid);

device/bluetooth/bluetooth_remote_gatt_service_android.cc

@@ -135,7 +135,7 @@ BluetoothRemoteGattServiceAndroid::GetCharacteristics() const {
   EnsureCharacteristicsCreated();
   std::vector<device::BluetoothRemoteGattCharacteristic*> characteristics;
   for (const auto& map_iter : characteristics_)
-    characteristics.push_back(map_iter.second);
+    characteristics.push_back(map_iter.second.get());
   return characteristics;
 }
 
@@ -152,7 +152,7 @@ BluetoothRemoteGattServiceAndroid::GetCharacteristic(
   const auto& iter = characteristics_.find(identifier);
   if (iter == characteristics_.end())
     return nullptr;
-  return iter->second;
+  return iter->second.get();
 }
 
 void BluetoothRemoteGattServiceAndroid::CreateGattRemoteCharacteristic(
@@ -166,13 +166,12 @@ void BluetoothRemoteGattServiceAndroid::CreateGattRemoteCharacteristic(
   std::string instance_id_string =
       base::android::ConvertJavaStringToUTF8(env, instance_id);
 
-  DCHECK(!characteristics_.contains(instance_id_string));
+  DCHECK(characteristics_.find(instance_id_string) == characteristics_.end());
 
-  characteristics_.set(
-      instance_id_string,
+  characteristics_[instance_id_string] =
       BluetoothRemoteGattCharacteristicAndroid::Create(
           adapter_, this, instance_id_string,
-          bluetooth_gatt_characteristic_wrapper, chrome_bluetooth_device));
+          bluetooth_gatt_characteristic_wrapper, chrome_bluetooth_device);
 }
 
 BluetoothRemoteGattServiceAndroid::BluetoothRemoteGattServiceAndroid(

device/bluetooth/bluetooth_remote_gatt_service_android.h

@@ -8,11 +8,11 @@
 #include <map>
 #include <memory>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #include "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
-#include "base/containers/scoped_ptr_hash_map.h"
 #include "base/macros.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service.h"
 #include "device/bluetooth/bluetooth_uuid.h"
@@ -109,9 +109,8 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothRemoteGattServiceAndroid
   std::string instance_id_;
 
   // Map of characteristics, keyed by characteristic identifier.
-  base::ScopedPtrHashMap<
-      std::string,
-      std::unique_ptr<BluetoothRemoteGattCharacteristicAndroid>>
+  std::unordered_map<std::string,
+                     std::unique_ptr<BluetoothRemoteGattCharacteristicAndroid>>
       characteristics_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothRemoteGattServiceAndroid);

device/bluetooth/bluez/bluetooth_adapter_bluez.cc

@@ -15,6 +15,7 @@
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
@@ -509,10 +510,9 @@ 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 iter = devices_.begin(); iter != devices_.end(); ++iter) {
     BluetoothDeviceBlueZ* device_bluez =
-        static_cast<BluetoothDeviceBlueZ*>(iter->second);
+        static_cast<BluetoothDeviceBlueZ*>(iter->second.get());
 
     BluetoothPairingBlueZ* pairing = device_bluez->GetPairing();
     if (pairing && pairing->GetPairingDelegate() == pairing_delegate)
@@ -566,21 +566,19 @@ void BluetoothAdapterBlueZ::DeviceAdded(const dbus::ObjectPath& object_path) {
       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));
+  devices_[device_bluez->GetAddress()] = base::WrapUnique(device_bluez);
 
   for (auto& observer : observers_)
     observer.DeviceAdded(this, device_bluez);
 }
 
 void BluetoothAdapterBlueZ::DeviceRemoved(const dbus::ObjectPath& object_path) {
-  for (DevicesMap::const_iterator iter = devices_.begin();
-       iter != devices_.end(); ++iter) {
+  for (auto 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);
+      std::unique_ptr<BluetoothDevice> scoped_device = std::move(iter->second);
+      devices_.erase(iter);
 
       for (auto& observer : observers_)
         observer.DeviceRemoved(this, device_bluez);
@@ -601,19 +599,17 @@ void BluetoothAdapterBlueZ::DevicePropertyChanged(
           object_path);
 
   if (property_name == properties->address.name()) {
-    for (DevicesMap::iterator iter = devices_.begin(); iter != devices_.end();
-         ++iter) {
+    for (auto 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));
+        devices_[device_bluez->GetAddress()] = std::move(scoped_device);
         NotifyDeviceAddressChanged(device_bluez, old_address);
         break;
       }
@@ -670,8 +666,7 @@ void BluetoothAdapterBlueZ::DevicePropertyChanged(
 
     int count = 0;
 
-    for (DevicesMap::const_iterator iter = devices_.begin();
-         iter != devices_.end(); ++iter) {
+    for (auto iter = devices_.begin(); iter != devices_.end(); ++iter) {
       if (iter->second->IsPaired() && iter->second->IsConnected())
         ++count;
     }
@@ -903,10 +898,9 @@ BluetoothDeviceBlueZ* BluetoothAdapterBlueZ::GetDeviceWithPath(
   if (!IsPresent())
     return nullptr;
 
-  for (DevicesMap::const_iterator iter = devices_.begin();
-       iter != devices_.end(); ++iter) {
+  for (auto 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;
   }
@@ -1041,7 +1035,7 @@ void BluetoothAdapterBlueZ::RemoveAdapter() {
 
   for (auto& iter : devices_swapped) {
     for (auto& observer : observers_)
-      observer.DeviceRemoved(this, iter.second);
+      observer.DeviceRemoved(this, iter.second.get());
   }
 
   PresentChanged(false);

device/bluetooth/bluez/bluetooth_device_bluez.cc

@@ -11,6 +11,7 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ -180,7 +181,7 @@ BluetoothDeviceBlueZ::~BluetoothDeviceBlueZ() {
   for (const auto& iter : gatt_services_swapped) {
     DCHECK(adapter());
     adapter()->NotifyGattServiceRemoved(
-        static_cast<BluetoothRemoteGattServiceBlueZ*>(iter.second));
+        static_cast<BluetoothRemoteGattServiceBlueZ*>(iter.second.get()));
   }
 }
 
@@ -678,8 +679,7 @@ void BluetoothDeviceBlueZ::GattServiceAdded(
   BluetoothRemoteGattServiceBlueZ* service =
       new BluetoothRemoteGattServiceBlueZ(adapter(), this, object_path);
 
-  gatt_services_.set(service->GetIdentifier(),
-                     std::unique_ptr<BluetoothRemoteGattService>(service));
+  gatt_services_[service->GetIdentifier()] = base::WrapUnique(service);
   DCHECK(service->object_path() == object_path);
   DCHECK(service->GetUUID().IsValid());
 
@@ -689,15 +689,14 @@ void BluetoothDeviceBlueZ::GattServiceAdded(
 
 void BluetoothDeviceBlueZ::GattServiceRemoved(
     const dbus::ObjectPath& object_path) {
-  GattServiceMap::const_iterator iter =
-      gatt_services_.find(object_path.value());
+  auto iter = gatt_services_.find(object_path.value());
   if (iter == gatt_services_.end()) {
     VLOG(3) << "Unknown GATT service removed: " << object_path.value();
     return;
   }
 
   BluetoothRemoteGattServiceBlueZ* service =
-      static_cast<BluetoothRemoteGattServiceBlueZ*>(iter->second);
+      static_cast<BluetoothRemoteGattServiceBlueZ*>(iter->second.get());
 
   VLOG(1) << "Removing remote GATT service with UUID: '"
           << service->GetUUID().canonical_value()
@@ -705,7 +704,8 @@ void BluetoothDeviceBlueZ::GattServiceRemoved(
 
   DCHECK(service->object_path() == object_path);
   std::unique_ptr<BluetoothRemoteGattService> scoped_service =
-      gatt_services_.take_and_erase(iter->first);
+      std::move(gatt_services_[object_path.value()]);
+  gatt_services_.erase(iter);
 
   DCHECK(adapter());
   discovery_complete_notified_.erase(service);

device/bluetooth/bluez/bluetooth_device_bluez.h

@@ -49,6 +49,8 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothDeviceBlueZ
   using GetServiceRecordsErrorCallback =
       base::Callback<void(BluetoothServiceRecordBlueZ::ErrorCode)>;
 
+  ~BluetoothDeviceBlueZ() override;
+
   // BluetoothDevice override
   uint32_t GetBluetoothClass() const override;
   device::BluetoothTransport GetType() const override;
@@ -164,7 +166,6 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothDeviceBlueZ
       const dbus::ObjectPath& object_path,
       scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
       scoped_refptr<device::BluetoothSocketThread> socket_thread);
-  ~BluetoothDeviceBlueZ() override;
 
   // bluez::BluetoothGattServiceClient::Observer overrides
   void GattServiceAdded(const dbus::ObjectPath& object_path) override;

device/bluetooth/bluez/bluetooth_remote_gatt_service_bluez.h

@@ -42,6 +42,8 @@ class BluetoothRemoteGattServiceBlueZ
       public BluetoothGattCharacteristicClient::Observer,
       public device::BluetoothRemoteGattService {
  public:
+  ~BluetoothRemoteGattServiceBlueZ() override;
+
   // device::BluetoothRemoteGattService overrides.
   device::BluetoothUUID GetUUID() const override;
   device::BluetoothDevice* GetDevice() const override;
@@ -83,7 +85,6 @@ class BluetoothRemoteGattServiceBlueZ
   BluetoothRemoteGattServiceBlueZ(BluetoothAdapterBlueZ* adapter,
                                   BluetoothDeviceBlueZ* device,
                                   const dbus::ObjectPath& object_path);
-  ~BluetoothRemoteGattServiceBlueZ() override;
 
   // bluez::BluetoothGattServiceClient::Observer override.
   void GattServicePropertyChanged(const dbus::ObjectPath& object_path,