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

device/bluetooth/bluez/bluetooth_bluez_unittest.cc

 // Copyright 2013 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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
@@ skipping 196 matching lines @@
 
     fake_bluetooth_adapter_client_->SetSimulationIntervalMs(10);
 
     callback_count_ = 0;
     error_callback_count_ = 0;
     last_connect_error_ = BluetoothDevice::ERROR_UNKNOWN;
     last_client_error_ = "";
   }
 
   void TearDown() override {
-    for (ScopedVector<BluetoothDiscoverySession>::iterator iter =
-             discovery_sessions_.begin();
-         iter != discovery_sessions_.end(); ++iter) {
-      BluetoothDiscoverySession* session = *iter;
+    for (auto& session : discovery_sessions_) {
       if (!session->IsActive())
         continue;
       callback_count_ = 0;
       session->Stop(GetCallback(), GetErrorCallback());
       base::RunLoop().Run();
       ASSERT_EQ(1, callback_count_);
     }
     discovery_sessions_.clear();
     adapter_ = nullptr;
     bluez::BluezDBusManager::Shutdown();
   }
 
   // Generic callbacks
   void Callback() {
     ++callback_count_;
     QuitMessageLoop();
   }
 
   base::Closure GetCallback() {
     return base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this));
   }
 
   void AdapterCallback() { QuitMessageLoop(); }
 
   void DiscoverySessionCallback(
       std::unique_ptr<BluetoothDiscoverySession> discovery_session) {
     ++callback_count_;
-    discovery_sessions_.push_back(discovery_session.release());
+    discovery_sessions_.push_back(std::move(discovery_session));
     QuitMessageLoop();
   }
 
   void ProfileRegisteredCallback(BluetoothAdapterProfileBlueZ* profile) {
     adapter_profile_ = profile;
     ++callback_count_;
     QuitMessageLoop();
   }
 
   void ErrorCallback() {
@@ skipping 92 matching lines @@
  protected:
   base::MessageLoop message_loop_;
   bluez::FakeBluetoothAdapterClient* fake_bluetooth_adapter_client_;
   bluez::FakeBluetoothDeviceClient* fake_bluetooth_device_client_;
   scoped_refptr<BluetoothAdapter> adapter_;
 
   int callback_count_;
   int error_callback_count_;
   enum BluetoothDevice::ConnectErrorCode last_connect_error_;
   std::string last_client_error_;
-  ScopedVector<BluetoothDiscoverySession> discovery_sessions_;
+
+  std::vector<std::unique_ptr<BluetoothDiscoverySession>> discovery_sessions_;
   BluetoothAdapterProfileBlueZ* adapter_profile_;
 
  private:
   // Some tests use a message loop since background processing is simulated;
   // break out of those loops.
   void QuitMessageLoop() {
     if (base::MessageLoop::current() &&
         base::MessageLoop::current()->is_running()) {
       base::MessageLoop::current()->QuitWhenIdle();
     }
@@ skipping 4270 matching lines @@
 
   // Check that we can update advertising data flags.
   properties->advertising_data_flags.ReplaceValue(std::vector<uint8_t>({0x23}));
   EXPECT_EQ(2, observer.device_changed_count());
   EXPECT_EQ(device, observer.last_device());
   EXPECT_TRUE(device->GetAdvertisingDataFlags().has_value());
   EXPECT_EQ(0x23u, device->GetAdvertisingDataFlags().value());
 }
 
 }  // namespace bluez