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

device/bluetooth/bluetooth_task_manager_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_task_manager_win.h"
 
 #include <stddef.h>
 #include <winsock2.h>
 
 #include <memory>
@@ skipping 360 matching lines @@
     observer.DiscoveryStarted(success);
 }
 
 void BluetoothTaskManagerWin::OnDiscoveryStopped() {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   for (auto& observer : observers_)
     observer.DiscoveryStopped();
 }
 
 void BluetoothTaskManagerWin::OnDevicesPolled(
-    const ScopedVector<DeviceState>* devices) {
+    const std::vector<std::unique_ptr<DeviceState>>& devices) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   for (auto& observer : observers_)
     observer.DevicesPolled(*devices);
 }
 
 void BluetoothTaskManagerWin::PollAdapter() {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
 
   // Skips updating the adapter info if the adapter is in discovery mode.
   if (!discovering_) {
@@ skipping 77 matching lines @@
 
 void BluetoothTaskManagerWin::DiscoverDevices(int timeout_multiplier) {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
   if (!discovering_ || !adapter_handle_) {
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStopped, this));
     return;
   }
 
-  std::unique_ptr<ScopedVector<DeviceState>> device_list(
-      new ScopedVector<DeviceState>());
+  std::unique_ptr<std::vector<std::unique_ptr<DeviceState>>> device_list(
+      new std::vector<std::unique_ptr<DeviceState>>());
   if (SearchDevices(timeout_multiplier, false, device_list.get())) {
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&BluetoothTaskManagerWin::OnDevicesPolled,
                    this,
                    base::Owned(device_list.release())));
   }
 
   if (timeout_multiplier < kMaxDeviceDiscoveryTimeoutMultiplier)
     ++timeout_multiplier;
   bluetooth_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &BluetoothTaskManagerWin::DiscoverDevices, this, timeout_multiplier));
 }
 
 void BluetoothTaskManagerWin::GetKnownDevices() {
-  std::unique_ptr<ScopedVector<DeviceState>> device_list(
-      new ScopedVector<DeviceState>());
+  std::unique_ptr<std::vector<std::unique_ptr<DeviceState>>> device_list(
+      new std::vector<std::unique_ptr<DeviceState>>());
   if (SearchDevices(1, true, device_list.get())) {
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&BluetoothTaskManagerWin::OnDevicesPolled,
                    this,
                    base::Owned(device_list.release())));
   }
 }
 
 bool BluetoothTaskManagerWin::SearchDevices(
     int timeout_multiplier,
     bool search_cached_devices_only,
-    ScopedVector<DeviceState>* device_list) {
+    std::vector<std::unique_ptr<DeviceState>>& device_list) {
   return SearchClassicDevices(
              timeout_multiplier, search_cached_devices_only, device_list) &&
          SearchLowEnergyDevices(device_list) &&
          DiscoverServices(device_list, search_cached_devices_only);
 }
 
 bool BluetoothTaskManagerWin::SearchClassicDevices(
     int timeout_multiplier,
     bool search_cached_devices_only,
-    ScopedVector<DeviceState>* device_list) {
+    std::vector<std::unique_ptr<DeviceState>>& device_list) {
   // Issues a device inquiry and waits for |timeout_multiplier| * 1.28 seconds.
   BLUETOOTH_DEVICE_SEARCH_PARAMS device_search_params;
   ZeroMemory(&device_search_params, sizeof(device_search_params));
   device_search_params.dwSize = sizeof(BLUETOOTH_DEVICE_SEARCH_PARAMS);
   device_search_params.fReturnAuthenticated = 1;
   device_search_params.fReturnRemembered = 1;
   device_search_params.fReturnUnknown = (search_cached_devices_only ? 0 : 1);
   device_search_params.fReturnConnected = 1;
   device_search_params.fIssueInquiry = (search_cached_devices_only ? 0 : 1);
   device_search_params.cTimeoutMultiplier = timeout_multiplier;
@@ skipping 35 matching lines @@
 
   if (!win::BluetoothClassicWrapper::GetInstance()->FindDeviceClose(handle)) {
     LogPollingError("Error calling BluetoothFindDeviceClose",
                     win::BluetoothClassicWrapper::GetInstance()->LastError());
     return false;
   }
   return true;
 }
 
 bool BluetoothTaskManagerWin::SearchLowEnergyDevices(
-    ScopedVector<DeviceState>* device_list) {
+    std::vector<std::unique_ptr<DeviceState>>& device_list) {
   if (!win::BluetoothLowEnergyWrapper::GetInstance()
            ->IsBluetoothLowEnergySupported()) {
     return true;  // Bluetooth LE not supported is not an error.
   }
 
-  ScopedVector<win::BluetoothLowEnergyDeviceInfo> btle_devices;
+  std::vector<std::unique_ptr<win::BluetoothLowEnergyDeviceInfo>> btle_devices;
   std::string error;
   bool success =
       win::BluetoothLowEnergyWrapper::GetInstance()
           ->EnumerateKnownBluetoothLowEnergyDevices(&btle_devices, &error);
   if (!success) {
     LogPollingError(error.c_str(), 0);
     return false;
   }
 
-  for (ScopedVector<win::BluetoothLowEnergyDeviceInfo>::iterator iter =
-           btle_devices.begin();
-       iter != btle_devices.end();
-       ++iter) {
-    win::BluetoothLowEnergyDeviceInfo* device_info = (*iter);
+  for (auto& device : btle_devices) {
+    win::BluetoothLowEnergyDeviceInfo* device_info = device;
     DeviceState* device_state = new DeviceState();
     device_state->name = device_info->friendly_name;
     device_state->address =
         BluetoothAddressToCanonicalString(device_info->address);
     device_state->visible = device_info->visible;
     device_state->authenticated = device_info->authenticated;
     device_state->connected = device_info->connected;
     device_state->path = device_info->path;
     device_list->push_back(device_state);
   }
   return true;
 }
 
 bool BluetoothTaskManagerWin::DiscoverServices(
-    ScopedVector<DeviceState>* device_list,
+    std::vector<std::unique_ptr<DeviceState>>& device_list,
     bool search_cached_services_only) {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
   net::EnsureWinsockInit();
-  for (ScopedVector<DeviceState>::iterator iter = device_list->begin();
-      iter != device_list->end();
-      ++iter) {
-    DeviceState* device = (*iter);
-    ScopedVector<ServiceRecordState>* service_record_states =
-        &(*iter)->service_record_states;
+  for (auto& device : device_list) {
+    std::vector<std::unique_ptr<ServiceRecordState>>& service_record_states =
+        &device->service_record_states;
 
     if ((*iter)->is_bluetooth_classic()) {
       if (!DiscoverClassicDeviceServices(device->address,
                                          L2CAP_PROTOCOL_UUID,
                                          search_cached_services_only,
                                          service_record_states)) {
         return false;
       }
     } else {
       if (!DiscoverLowEnergyDeviceServices(device->path,
                                            service_record_states)) {
         return false;
       }
       if (!SearchForGattServiceDevicePaths(device->address,
                                            service_record_states)) {
         return false;
       }
     }
   }
   return true;
 }
 
 bool BluetoothTaskManagerWin::DiscoverClassicDeviceServices(
     const std::string& device_address,
     const GUID& protocol_uuid,
     bool search_cached_services_only,
-    ScopedVector<ServiceRecordState>* service_record_states) {
+    std::vector<std::unique_ptr<ServiceRecordState>>& service_record_states) {
   int error_code =
       DiscoverClassicDeviceServicesWorker(device_address,
                                           protocol_uuid,
                                           search_cached_services_only,
                                           service_record_states);
   // If the device is "offline", no services are returned when specifying
   // "LUP_FLUSHCACHE". Try again without flushing the cache so that the list
   // of previously known services is returned.
   if (!search_cached_services_only &&
       (error_code == WSASERVICE_NOT_FOUND || error_code == WSANO_DATA)) {
     error_code = DiscoverClassicDeviceServicesWorker(
         device_address, protocol_uuid, true, service_record_states);
   }
 
   return (error_code == ERROR_SUCCESS);
 }
 
 int BluetoothTaskManagerWin::DiscoverClassicDeviceServicesWorker(
     const std::string& device_address,
     const GUID& protocol_uuid,
     bool search_cached_services_only,
-    ScopedVector<ServiceRecordState>* service_record_states) {
+    Sstd::vector<std::unique_ptr<ServiceRecordState>>& service_record_states) {
   // Bluetooth and WSAQUERYSET for Service Inquiry. See http://goo.gl/2v9pyt.
   WSAQUERYSET sdp_query;
   ZeroMemory(&sdp_query, sizeof(sdp_query));
   sdp_query.dwSize = sizeof(sdp_query);
   GUID protocol = protocol_uuid;
   sdp_query.lpServiceClassId = &protocol;
   sdp_query.dwNameSpace = NS_BTH;
   wchar_t device_address_context[kMaxNumDeviceAddressChar];
   std::size_t length = base::SysUTF8ToWide("(" + device_address + ")").copy(
       device_address_context, kMaxNumDeviceAddressChar);
@@ skipping 50 matching lines @@
     int last_error = WSAGetLastError();
     LogPollingError("Error calling WSALookupServiceEnd", last_error);
     return last_error;
   }
 
   return ERROR_SUCCESS;
 }
 
 bool BluetoothTaskManagerWin::DiscoverLowEnergyDeviceServices(
     const base::FilePath& device_path,
-    ScopedVector<ServiceRecordState>* service_record_states) {
+    std::vector<std::unique_ptr<ServiceRecordState>>& service_record_states) {
   if (!win::BluetoothLowEnergyWrapper::GetInstance()
            ->IsBluetoothLowEnergySupported()) {
     return true;  // Bluetooth LE not supported is not an error.
   }
 
   std::string error;
-  ScopedVector<win::BluetoothLowEnergyServiceInfo> services;
+  std::vector<std::unique_ptr<win::BluetoothLowEnergyServiceInfo>> services;
   bool success = win::BluetoothLowEnergyWrapper::GetInstance()
                      ->EnumerateKnownBluetoothLowEnergyServices(
                          device_path, &services, &error);
   if (!success) {
     LogPollingError(error.c_str(), 0);
     return false;
   }
 
-  for (ScopedVector<win::BluetoothLowEnergyServiceInfo>::iterator iter2 =
-           services.begin();
-       iter2 != services.end();
-       ++iter2) {
+  for (auto& service : services) {
     ServiceRecordState* service_state = new ServiceRecordState();
     service_state->gatt_uuid =
-        BluetoothLowEnergyUuidToBluetoothUuid((*iter2)->uuid);
-    service_state->attribute_handle = (*iter2)->attribute_handle;
+        BluetoothLowEnergyUuidToBluetoothUuid(service->uuid);
+    service_state->attribute_handle = service->attribute_handle;
     service_record_states->push_back(service_state);
   }
   return true;
 }
 
 // Each GATT service of a BLE device will be listed on the machine as a BLE
 // device interface with a matching service attribute handle. This interface
 // lists all GATT service devices and matches them back to correspond GATT
 // service of the BLE device according to their address and included service
 // attribute handles, as we did not find a more neat way to bond them.
 bool BluetoothTaskManagerWin::SearchForGattServiceDevicePaths(
     const std::string device_address,
-    ScopedVector<ServiceRecordState>* service_record_states) {
+    std::vector<std::unique_ptr<ServiceRecordState>>& service_record_states) {
   std::string error;
 
   // List all known GATT service devices on the machine.
-  ScopedVector<win::BluetoothLowEnergyDeviceInfo> gatt_service_devices;
+  std::vector<std::unqiue_ptr<win::BluetoothLowEnergyDeviceInfo>>
+      gatt_service_devices;
   bool success = win::BluetoothLowEnergyWrapper::GetInstance()
                      ->EnumerateKnownBluetoothLowEnergyGattServiceDevices(
                          &gatt_service_devices, &error);
   if (!success) {
     LogPollingError(error.c_str(), 0);
     return false;
   }
 
-  for (auto* gatt_service_device : gatt_service_devices) {
+  for (auto& gatt_service_device : gatt_service_devices) {
     // Only care about the service devices with |device_address|.
     if (BluetoothAddressToCanonicalString(gatt_service_device->address) !=
         device_address) {
       continue;
     }
 
     // Discover this service device's contained services.
-    ScopedVector<win::BluetoothLowEnergyServiceInfo> gatt_services;
+    std::vector<std::unqiue_ptr<win::BluetoothLowEnergyServiceInfo>>
+        gatt_services;
     if (!win::BluetoothLowEnergyWrapper::GetInstance()
              ->EnumerateKnownBluetoothLowEnergyServices(
                  gatt_service_device->path, &gatt_services, &error)) {
       LogPollingError(error.c_str(), 0);
       continue;
     }
 
     // Usually each service device correspond to one Gatt service.
     if (gatt_services.size() > 1) {
       LOG(WARNING) << "This GATT service device contains more than one ("
                    << gatt_services.size() << ") services";
     }
 
     // Associate service device to corresponding service record. Attribute
     // handle is unique on one device.
-    for (auto* gatt_service : gatt_services) {
-      for (auto* service_record_state : *service_record_states) {
+    for (auto& gatt_service : gatt_services) {
+      for (auto& service_record_state : service_record_states) {
         if (service_record_state->attribute_handle ==
             gatt_service->attribute_handle) {
           service_record_state->path = gatt_service_device->path;
           break;
         }
       }
     }
   }
 
   return true;
@@ skipping 207 matching lines @@
 void BluetoothTaskManagerWin::PostUnregisterGattCharacteristicValueChangedEvent(
     PVOID event_handle) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   bluetooth_task_runner_->PostTask(
       FROM_HERE, base::Bind(&BluetoothTaskManagerWin::
                                 UnregisterGattCharacteristicValueChangedEvent,
                             this, event_handle));
 }
 
 }  // namespace device