Remove base::ScopedPtrHashMap from device/.

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>
 #include <set>
 #include <string>
 #include <utility>
 
 #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"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "device/bluetooth/bluetooth_common.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session_outcome.h"
@@ skipping 474 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 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)
       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 33 matching lines @@
       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_);
   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);
       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) {
+    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;
       }
     }
   }
 
   if (property_name == properties->service_data.name())
     device_bluez->UpdateServiceData();
   else if (property_name == properties->manufacturer_data.name())
     device_bluez->UpdateManufacturerData();
@@ skipping 36 matching lines @@
     // PlayStation joystick tries to reconnect after disconnection from USB.
     // If it is still not trusted, set it, so it becomes available on the
     // list of known devices.
     if (properties->connected.value()) {
       if (device_bluez->IsTrustable() && !properties->trusted.value())
         device_bluez->SetTrusted();
     }
 
     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;
     }
 
     UMA_HISTOGRAM_COUNTS_100("Bluetooth.ConnectedDeviceCount", count);
   }
 }
 
 void BluetoothAdapterBlueZ::InputPropertyChanged(
     const dbus::ObjectPath& object_path,
@@ skipping 211 matching lines @@
           object_path_, handle, callback,
           base::Bind(&BluetoothAdapterBlueZ::ServiceRecordErrorConnector,
                      weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 BluetoothDeviceBlueZ* BluetoothAdapterBlueZ::GetDeviceWithPath(
     const dbus::ObjectPath& object_path) {
   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;
   }
 
   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