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

device/bluetooth/bluetooth_adapter_win.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_win.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 209 matching lines @@
     for (auto& observer : observers_)
       observer.AdapterPoweredChanged(this, powered_);
   }
   if (!initialized_) {
     initialized_ = true;
     init_callback_.Run();
   }
 }
 
 void BluetoothAdapterWin::DevicesPolled(
-    const ScopedVector<BluetoothTaskManagerWin::DeviceState>& devices) {
+    const std::vector<std::unique_ptr<BluetoothTaskManagerWin::DeviceState>>&
+        devices) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // We are receiving a new list of all devices known to the system. Merge this
   // 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);
   }
 
   DeviceAddressSet new_devices;
-  for (ScopedVector<BluetoothTaskManagerWin::DeviceState>::const_iterator iter =
-           devices.begin();
-       iter != devices.end();
-       ++iter) {
-    new_devices.insert((*iter)->address);
+  for (auto& device : devices) {
+    new_devices.insert(device->address);
   }
 
   // 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);
+    auto found = devices_.find(*iter);
+    if (found == devices_.end())
+      continue;
+    auto device_win = std::move(found->second);
+    devices_.erase(*iter);
     for (auto& observer : observers_)
       observer.DeviceRemoved(this, device_win.get());
   }
 
   // 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) {
-    BluetoothTaskManagerWin::DeviceState* device_state = (*iter);
+  for (auto& device_state : devices) {
     if (added_devices.find(device_state->address) != added_devices.end()) {
-      BluetoothDeviceWin* device_win =
+      auto* 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));
+      auto insertion = devices_.insert(
+          std::make_pair(device_state->address, std::move(device_win)));
+      if (!insertion.second)
+        continue;
       for (auto& observer : observers_)
-        observer.DeviceAdded(this, device_win);
+        observer.DeviceAdded(this, insertion.first->second.get());
     } else if (changed_devices.find(device_state->address) !=
                changed_devices.end()) {
       DevicesMap::const_iterator 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_)
           observer.DeviceChanged(this, device_win);
       }
       // Above IsEqual returns true if device name, address, status and services
       // (primary services of BLE device) are the same. However, in BLE tests,
       // we may simulate characteristic, descriptor and secondary GATT service
       // after device has been initialized.
       if (force_update_device_for_test_)
@@ skipping 81 matching lines @@
     num_discovery_listeners_ -= on_stop_discovery_callbacks_.size();
     on_stop_discovery_callbacks_.clear();
     return;
   }
 
   discovery_status_ = DISCOVERY_STOPPING;
   task_manager_->PostStopDiscoveryTask();
 }
 
 }  // namespace device