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

device/bluetooth/bluetooth_low_energy_win_fake.cc

 // Copyright 2016 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_fake.h"
 
 #include <memory>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 24 matching lines @@
 
 BluetoothLowEnergyWrapperFake::BluetoothLowEnergyWrapperFake()
     : observer_(nullptr) {}
 BluetoothLowEnergyWrapperFake::~BluetoothLowEnergyWrapperFake() {}
 
 bool BluetoothLowEnergyWrapperFake::IsBluetoothLowEnergySupported() {
   return true;
 }
 
 bool BluetoothLowEnergyWrapperFake::EnumerateKnownBluetoothLowEnergyDevices(
-    ScopedVector<BluetoothLowEnergyDeviceInfo>* devices,
+    std::vector<std::unique_ptr<BluetoothLowEnergyDeviceInfo>>* devices,
     std::string* error) {
   if (!IsBluetoothLowEnergySupported()) {
     *error = kPlatformNotSupported;
     return false;
   }
 
   for (auto& device : simulated_devices_) {
     if (device.second->marked_as_deleted)
       continue;
-    BluetoothLowEnergyDeviceInfo* device_info =
-        new BluetoothLowEnergyDeviceInfo();
+    auto device_info = base::MakeUnique<BluetoothLowEnergyDeviceInfo>();
     *device_info = *(device.second->device_info);
-    devices->push_back(device_info);
+    devices->push_back(std::move(device_info));
   }
   return true;
 }
 
 bool BluetoothLowEnergyWrapperFake::
     EnumerateKnownBluetoothLowEnergyGattServiceDevices(
-        ScopedVector<BluetoothLowEnergyDeviceInfo>* devices,
+        std::vector<std::unique_ptr<BluetoothLowEnergyDeviceInfo>>* devices,
         std::string* error) {
   if (!IsBluetoothLowEnergySupported()) {
     *error = kPlatformNotSupported;
     return false;
   }
 
   for (auto& device : simulated_devices_) {
     for (auto& service : device.second->primary_services) {
-      BluetoothLowEnergyDeviceInfo* device_info =
-          new BluetoothLowEnergyDeviceInfo();
+      auto device_info = base::MakeUnique<BluetoothLowEnergyDeviceInfo>();
       *device_info = *(device.second->device_info);
       base::string16 path = GenerateGattServiceDevicePath(
           device.second->device_info->path.value(),
           service.second->service_info->AttributeHandle);
       device_info->path = base::FilePath(path);
-      devices->push_back(device_info);
+      devices->push_back(std::move(device_info));
     }
   }
   return true;
 }
 
 bool BluetoothLowEnergyWrapperFake::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;
   }
 
   base::string16 device_address =
       ExtractDeviceAddressFromDevicePath(device_path.value());
   std::vector<std::string> service_attribute_handles =
       ExtractServiceAttributeHandlesFromDevicePath(device_path.value());
 
   BLEDevicesMap::iterator it_d = simulated_devices_.find(
       std::string(device_address.begin(), device_address.end()));
   CHECK(it_d != simulated_devices_.end());
 
   // |service_attribute_handles| is empty means |device_path| is a BLE device
   // path, otherwise it is a BLE GATT service device path.
   if (service_attribute_handles.empty()) {
     // Return all primary services for BLE device.
     for (auto& primary_service : it_d->second->primary_services) {
-      BluetoothLowEnergyServiceInfo* service_info =
-          new BluetoothLowEnergyServiceInfo();
+      auto service_info = base::MakeUnique<BluetoothLowEnergyServiceInfo>();
       service_info->uuid = primary_service.second->service_info->ServiceUuid;
       service_info->attribute_handle =
           primary_service.second->service_info->AttributeHandle;
-      services->push_back(service_info);
+      services->push_back(std::move(service_info));
     }
   } else {
     // Return corresponding GATT service for BLE GATT service device.
     GattService* target_service =
         GetSimulatedGattService(it_d->second.get(), service_attribute_handles);
-    BluetoothLowEnergyServiceInfo* service_info =
-        new BluetoothLowEnergyServiceInfo();
+    auto service_info = base::MakeUnique<BluetoothLowEnergyServiceInfo>();
     service_info->uuid = target_service->service_info->ServiceUuid;
     service_info->attribute_handle =
         target_service->service_info->AttributeHandle;
-    services->push_back(service_info);
+    services->push_back(std::move(service_info));
   }
 
   return true;
 }
 
 HRESULT BluetoothLowEnergyWrapperFake::ReadCharacteristicsOfAService(
     base::FilePath& service_path,
     const PBTH_LE_GATT_SERVICE service,
     std::unique_ptr<BTH_LE_GATT_CHARACTERISTIC>* out_included_characteristics,
     USHORT* out_counts) {
@@ skipping 379 matching lines @@
   CHECK(parent_service);
   remembered_characteristic_ =
       parent_service->included_characteristics[attribute_handle].get();
   CHECK(remembered_characteristic_);
 }
 
 void BluetoothLowEnergyWrapperFake::SimulateGattDescriptor(
     std::string device_address,
     GattCharacteristic* characteristic,
     const BTH_LE_UUID& uuid) {
-  std::unique_ptr<GattDescriptor> descriptor(new GattDescriptor());
+  auto descriptor = base::MakeUnique<GattDescriptor>();
   descriptor->descriptor_info.reset(new BTH_LE_GATT_DESCRIPTOR[1]);
   descriptor->descriptor_info->DescriptorUuid = uuid;
   descriptor->descriptor_info->AttributeHandle =
       GenerateAUniqueAttributeHandle(device_address);
   characteristic->included_descriptors[std::to_string(
       descriptor->descriptor_info->AttributeHandle)] = std::move(descriptor);
 }
 
 void BluetoothLowEnergyWrapperFake::AddObserver(Observer* observer) {
   observer_ = observer;
@@ skipping 99 matching lines @@
 std::string BluetoothLowEnergyWrapperFake::BluetoothAddressToCanonicalString(
     const BLUETOOTH_ADDRESS& btha) {
   std::string result = base::StringPrintf(
       "%02X:%02X:%02X:%02X:%02X:%02X", btha.rgBytes[5], btha.rgBytes[4],
       btha.rgBytes[3], btha.rgBytes[2], btha.rgBytes[1], btha.rgBytes[0]);
   return result;
 }
 
 }  // namespace win
 }  // namespace device