Remove base::ScopedPtrHashMap from device/.

device/bluetooth/bluetooth_adapter.cc

 // Copyright (c) 2012 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.h"
 
 #include <memory>
 #include <utility>
 
 #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"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluetooth_discovery_session_outcome.h"
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_remote_gatt_descriptor.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service.h"
 
 namespace device {
@@ skipping 80 matching lines @@
   DeviceList devices;
   for (ConstDeviceList::const_iterator i = const_devices.begin();
        i != const_devices.end(); ++i)
     devices.push_back(const_cast<BluetoothDevice *>(*i));
 
   return devices;
 }
 
 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;
 }
 
 BluetoothDevice* BluetoothAdapter::GetDevice(const std::string& address) {
   return const_cast<BluetoothDevice *>(
       const_cast<const BluetoothAdapter *>(this)->GetDevice(address));
 }
 
 const BluetoothDevice* BluetoothAdapter::GetDevice(
     const std::string& address) const {
   std::string canonicalized_address =
       BluetoothDevice::CanonicalizeAddress(address);
   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;
 }
 
 void BluetoothAdapter::AddPairingDelegate(
     BluetoothDevice::PairingDelegate* pairing_delegate,
     PairingDelegatePriority priority) {
   // Remove the delegate, if it already exists, before inserting to allow a
   // change of priority.
   RemovePairingDelegate(pairing_delegate);
@@ skipping 223 matching lines @@
       continue;
     }
 
     result = BluetoothDiscoveryFilter::Merge(result.get(), curr_filter);
   }
 
   return result;
 }
 
 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;
       continue;
     }
 
     base::Time last_update_time = device->GetLastUpdateTime();
 
     bool device_expired =
         (base::Time::NowFromSystemTime() - last_update_time) > timeoutSec;
     VLOG(3) << "device: " << device->GetAddress()
             << ", last_update: " << last_update_time
             << ", exp: " << device_expired;
 
     if (!device_expired) {
       ++it;
       continue;
     }
 
     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_)
       observer.DeviceRemoved(this, removed_device.get());
   }
 }
 
 // static
 void BluetoothAdapter::RecordBluetoothDiscoverySessionStartOutcome(
     UMABluetoothDiscoverySessionOutcome outcome) {
   UMA_HISTOGRAM_ENUMERATION(
       "Bluetooth.DiscoverySession.Start.Outcome", static_cast<int>(outcome),
       static_cast<int>(UMABluetoothDiscoverySessionOutcome::COUNT));
 }
 
 // static
 void BluetoothAdapter::RecordBluetoothDiscoverySessionStopOutcome(
     UMABluetoothDiscoverySessionOutcome outcome) {
   UMA_HISTOGRAM_ENUMERATION(
       "Bluetooth.DiscoverySession.Stop.Outcome", static_cast<int>(outcome),
       static_cast<int>(UMABluetoothDiscoverySessionOutcome::COUNT));
 }
 
 // static
 const base::TimeDelta BluetoothAdapter::timeoutSec =
     base::TimeDelta::FromSeconds(180);
 
 }  // namespace device