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

device/bluetooth/bluetooth_adapter_win_unittest.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 <string>
 
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/test_simple_task_runner.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_win.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session_outcome.h"
 #include "device/bluetooth/bluetooth_task_manager_win.h"
 #include "device/bluetooth/test/test_bluetooth_adapter_observer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char kAdapterAddress[] = "A1:B2:C3:D4:E5:F6";
 const char kAdapterName[] = "Bluetooth Adapter Name";
 
 const char kTestAudioSdpName[] = "Audio";
 const char kTestAudioSdpName2[] = "Audio2";
 const char kTestAudioSdpBytes[] =
     "35510900000a00010001090001350319110a09000435103506190100090019350619001909"
     "010209000535031910020900093508350619110d090102090100250c417564696f20536f75"
     "726365090311090001";
 const device::BluetoothUUID kTestAudioSdpUuid("110a");
-
-void MakeDeviceState(const std::string& name,
-                     const std::string& address,
-                     device::BluetoothTaskManagerWin::DeviceState* state) {
-  state->name = name;
-  state->address = address;
-  state->bluetooth_class = 0;
-  state->authenticated = false;
-  state->connected = false;
-}
-
 }  // namespace
 
 namespace device {
 
 class BluetoothAdapterWinTest : public testing::Test {
  public:
   BluetoothAdapterWinTest()
       : ui_task_runner_(new base::TestSimpleTaskRunner()),
         bluetooth_task_runner_(new base::TestSimpleTaskRunner()),
         adapter_(new BluetoothAdapterWin(
@@ skipping 55 matching lines @@
   scoped_refptr<BluetoothAdapter> adapter_;
   BluetoothAdapterWin* adapter_win_;
   TestBluetoothAdapterObserver observer_;
   bool init_callback_called_;
   int num_start_discovery_callbacks_;
   int num_start_discovery_error_callbacks_;
   int num_stop_discovery_callbacks_;
   int num_stop_discovery_error_callbacks_;
 };
 
+BluetoothTaskManagerWin::DeviceState* MakeDeviceState(
+    const std::string& name,
+    const std::string& address) {
+  auto state = new BluetoothTaskManagerWin::DeviceState();
+  state->name = name;
+  state->address = address;
+  state->bluetooth_class = 0;
+  state->authenticated = false;
+  state->connected = false;
+  return state;
+}
+
 TEST_F(BluetoothAdapterWinTest, AdapterNotPresent) {
   BluetoothTaskManagerWin::AdapterState state;
   adapter_win_->AdapterStateChanged(state);
   EXPECT_FALSE(adapter_win_->IsPresent());
 }
 
 TEST_F(BluetoothAdapterWinTest, AdapterPresent) {
   BluetoothTaskManagerWin::AdapterState state;
   state.address = kAdapterAddress;
   state.name = kAdapterName;
@@ skipping 300 matching lines @@
       DiscoverySessionErrorCallback());
   ui_task_runner_->ClearPendingTasks();
   adapter_win_->DiscoveryStarted(false);
   ui_task_runner_->RunPendingTasks();
   EXPECT_EQ(1, num_start_discovery_error_callbacks_);
   EXPECT_EQ(1, num_stop_discovery_callbacks_);
   EXPECT_EQ(0, observer_.discovering_changed_count());
 }
 
 TEST_F(BluetoothAdapterWinTest, DevicesPolled) {
-  BluetoothTaskManagerWin::DeviceState* android_phone_state =
-      new BluetoothTaskManagerWin::DeviceState();
-  MakeDeviceState("phone", "A1:B2:C3:D4:E5:E0", android_phone_state);
-  BluetoothTaskManagerWin::DeviceState* laptop_state =
-      new BluetoothTaskManagerWin::DeviceState();
-  MakeDeviceState("laptop", "A1:B2:C3:D4:E5:E1", laptop_state);
-  BluetoothTaskManagerWin::DeviceState* iphone_state =
-      new BluetoothTaskManagerWin::DeviceState();
-  MakeDeviceState("phone", "A1:B2:C3:D4:E5:E2", iphone_state);
-  ScopedVector<BluetoothTaskManagerWin::DeviceState> devices;
-  devices.push_back(android_phone_state);
-  devices.push_back(laptop_state);
-  devices.push_back(iphone_state);
+  auto* android_phone_state = MakeDeviceState("phone", "A1:B2:C3:D4:E5:E0");
+  auto* laptop_state = MakeDeviceState("laptop", "A1:B2:C3:D4:E5:E1");
+  auto* iphone_state = MakeDeviceState("phone", "A1:B2:C3:D4:E5:E2");
+
+  std::vector<std::unique_ptr<BluetoothTaskManagerWin::DeviceState>> devices;
+
+  devices.push_back(base::WrapUnique(android_phone_state));
+  devices.push_back(base::WrapUnique(laptop_state));
+  devices.push_back(base::WrapUnique(iphone_state));
 
   // Add 3 devices
   observer_.Reset();
   adapter_win_->DevicesPolled(devices);
   EXPECT_EQ(3, observer_.device_added_count());
   EXPECT_EQ(0, observer_.device_removed_count());
   EXPECT_EQ(0, observer_.device_changed_count());
 
   // Change a device name
   android_phone_state->name = std::string("phone2");
@@ skipping 17 matching lines @@
   adapter_win_->DevicesPolled(devices);
   EXPECT_EQ(0, observer_.device_added_count());
   EXPECT_EQ(1, observer_.device_removed_count());
   EXPECT_EQ(0, observer_.device_changed_count());
 
   // Add a service
   BluetoothTaskManagerWin::ServiceRecordState* audio_state =
       new BluetoothTaskManagerWin::ServiceRecordState();
   audio_state->name = kTestAudioSdpName;
   base::HexStringToBytes(kTestAudioSdpBytes, &audio_state->sdp_bytes);
-  laptop_state->service_record_states.push_back(audio_state);
+  laptop_state->service_record_states.push_back(base::WrapUnique(audio_state));
   observer_.Reset();
   adapter_win_->DevicesPolled(devices);
   EXPECT_EQ(0, observer_.device_added_count());
   EXPECT_EQ(0, observer_.device_removed_count());
   EXPECT_EQ(1, observer_.device_changed_count());
 
   // Change a service
   audio_state->name = kTestAudioSdpName2;
   observer_.Reset();
   adapter_win_->DevicesPolled(devices);
   EXPECT_EQ(0, observer_.device_added_count());
   EXPECT_EQ(0, observer_.device_removed_count());
   EXPECT_EQ(1, observer_.device_changed_count());
 
   // Remove a service
   laptop_state->service_record_states.clear();
   observer_.Reset();
   adapter_win_->DevicesPolled(devices);
   EXPECT_EQ(0, observer_.device_added_count());
   EXPECT_EQ(0, observer_.device_removed_count());
   EXPECT_EQ(1, observer_.device_changed_count());
 }
 
 }  // namespace device