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

device/bluetooth/bluetooth_low_energy_win.cc

 // Copyright 2014 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_low_energy_win.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/files/file.h"
@@ skipping 354 matching lines @@
   // Windows 8 exposes BLE devices only if they are visible and paired. This
   // might change in the future if Windows offers a public API for discovering
   // and pairing BLE devices.
   device_info->visible = true;
   device_info->authenticated = true;
   return true;
 }
 
 bool CollectBluetoothLowEnergyDeviceServices(
     const base::FilePath& device_path,
-    ScopedVector<BluetoothLowEnergyServiceInfo>* services,
+    std::vector<std::unique_ptr<BluetoothLowEnergyServiceInfo>>* services,
     std::string* error) {
   base::File file(device_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
   if (!file.IsValid()) {
     *error = file.ErrorToString(file.error_details());
     return false;
   }
 
   USHORT required_length;
   HRESULT hr = BluetoothGATTGetServices(file.GetPlatformFile(),
                                         0,
@@ skipping 15 matching lines @@
                                 BLUETOOTH_GATT_FLAG_NONE);
   if (!CheckHResult(hr, kDeviceInfoError, error))
     return false;
   if (!CheckExpectedLength(
           actual_length, required_length, kDeviceInfoError, error)) {
     return false;
   }
 
   for (USHORT i = 0; i < actual_length; ++i) {
     BTH_LE_GATT_SERVICE& gatt_service(gatt_services.get()[i]);
-    BluetoothLowEnergyServiceInfo* service_info =
-        new BluetoothLowEnergyServiceInfo();
+    std::unique_ptr<BluetoothLowEnergyServiceInfo> service_info(
+        new BluetoothLowEnergyServiceInfo());
     service_info->uuid = gatt_service.ServiceUuid;
     service_info->attribute_handle = gatt_service.AttributeHandle;
-    services->push_back(service_info);
+    services->push_back(std::move(service_info));
   }
 
   return true;
 }
 
 bool CollectBluetoothLowEnergyDeviceInfo(
     const ScopedDeviceInfoSetHandle& device_info_handle,
     PSP_DEVICE_INTERFACE_DATA device_interface_data,
     std::unique_ptr<device::win::BluetoothLowEnergyDeviceInfo>* device_info,
     std::string* error) {
@@ skipping 109 matching lines @@
 }
 
 // Enumerate known Bluetooth low energy devices or Bluetooth low energy GATT
 // service devices according to |device_interface_guid|.
 // Note: |device_interface_guid| = GUID_BLUETOOTHLE_DEVICE_INTERFACE corresponds
 // Bluetooth low energy devices. |device_interface_guid| =
 // GUID_BLUETOOTH_GATT_SERVICE_DEVICE_INTERFACE corresponds Bluetooth low energy
 // Gatt service devices.
 bool EnumerateKnownBLEOrBLEGattServiceDevices(
     GUID guid,
-    ScopedVector<BluetoothLowEnergyDeviceInfo>* devices,
+    std::vector<std::unique_ptr<BluetoothLowEnergyDeviceInfo>>* devices,
     std::string* error) {
   ScopedDeviceInfoSetHandle info_set_handle;
   HRESULT hr = OpenBluetoothLowEnergyDevices(guid, &info_set_handle);
   if (FAILED(hr)) {
     *error = FormatBluetoothError(kDeviceEnumError, hr);
     return false;
   }
 
   for (DWORD i = 0;; ++i) {
     std::unique_ptr<BluetoothLowEnergyDeviceInfo> device_info;
@@ skipping 115 matching lines @@
 }
 
 BluetoothLowEnergyWrapper::BluetoothLowEnergyWrapper() {}
 BluetoothLowEnergyWrapper::~BluetoothLowEnergyWrapper() {}
 
 bool BluetoothLowEnergyWrapper::IsBluetoothLowEnergySupported() {
   return base::win::GetVersion() >= base::win::VERSION_WIN8;
 }
 
 bool BluetoothLowEnergyWrapper::EnumerateKnownBluetoothLowEnergyDevices(
-    ScopedVector<BluetoothLowEnergyDeviceInfo>* devices,
+    std::vector<std::unique_ptr<BluetoothLowEnergyDeviceInfo>>* devices,
     std::string* error) {
   if (!IsBluetoothLowEnergySupported()) {
     *error = kPlatformNotSupported;
     return false;
   }
 
   return EnumerateKnownBLEOrBLEGattServiceDevices(
       GUID_BLUETOOTHLE_DEVICE_INTERFACE, devices, error);
 }
 
 bool BluetoothLowEnergyWrapper::
     EnumerateKnownBluetoothLowEnergyGattServiceDevices(
-        ScopedVector<BluetoothLowEnergyDeviceInfo>* devices,
+        std::vector<std::unique_ptr<BluetoothLowEnergyDeviceInfo>>* devices,
         std::string* error) {
   if (!IsBluetoothLowEnergySupported()) {
     *error = kPlatformNotSupported;
     return false;
   }
 
   return EnumerateKnownBLEOrBLEGattServiceDevices(
       GUID_BLUETOOTH_GATT_SERVICE_DEVICE_INTERFACE, devices, error);
 }
 
 bool BluetoothLowEnergyWrapper::EnumerateKnownBluetoothLowEnergyServices(
     const base::FilePath& device_path,
-    ScopedVector<BluetoothLowEnergyServiceInfo>* services,
+    std::vector<std::unique_ptr<BluetoothLowEnergyServiceInfo>>* services,
     std::string* error) {
   if (!IsBluetoothLowEnergySupported()) {
     *error = kPlatformNotSupported;
     return false;
   }
 
   return CollectBluetoothLowEnergyDeviceServices(device_path, services, error);
 }
 
 HRESULT BluetoothLowEnergyWrapper::ReadCharacteristicsOfAService(
@@ skipping 146 matching lines @@
   base::File file(service_path, base::File::FLAG_OPEN | base::File::FLAG_READ |
                                     base::File::FLAG_WRITE);
   if (!file.IsValid())
     return HRESULT_FROM_WIN32(ERROR_OPEN_FAILED);
   return BluetoothGATTSetDescriptorValue(file.GetPlatformFile(), descriptor,
                                          new_value, BLUETOOTH_GATT_FLAG_NONE);
 }
 
 }  // namespace win
 }  // namespace device