Remove ScopedVector from bluetooth.

device/bluetooth/bluez/bluetooth_gatt_bluez_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
+#include <vector>
 
-#include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "dbus/object_path.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_filter.h"
 #include "device/bluetooth/bluetooth_gatt_connection.h"
 #include "device/bluetooth/bluetooth_gatt_notify_session.h"
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
@@ skipping 230 matching lines @@
   }
 
   void GattConnectionCallback(std::unique_ptr<BluetoothGattConnection> conn) {
     ++success_callback_count_;
     gatt_conn_ = std::move(conn);
   }
 
   void NotifySessionCallback(
       std::unique_ptr<BluetoothGattNotifySession> session) {
     ++success_callback_count_;
-    update_sessions_.push_back(session.release());
+    update_sessions_.push_back(std::move(session));
     QuitMessageLoop();
   }
 
   void ServiceErrorCallback(BluetoothRemoteGattService::GattErrorCode err) {
     ++error_callback_count_;
     last_service_error_ = err;
   }
 
   void ErrorCallback() { ++error_callback_count_; }
 
@@ skipping 15 matching lines @@
 
   base::MessageLoop message_loop_;
 
   bluez::FakeBluetoothDeviceClient* fake_bluetooth_device_client_;
   bluez::FakeBluetoothGattServiceClient* fake_bluetooth_gatt_service_client_;
   bluez::FakeBluetoothGattCharacteristicClient*
       fake_bluetooth_gatt_characteristic_client_;
   bluez::FakeBluetoothGattDescriptorClient*
       fake_bluetooth_gatt_descriptor_client_;
   std::unique_ptr<device::BluetoothGattConnection> gatt_conn_;
-  ScopedVector<BluetoothGattNotifySession> update_sessions_;
+  std::vector<std::unique_ptr<BluetoothGattNotifySession>> update_sessions_;
   scoped_refptr<BluetoothAdapter> adapter_;
 
   int success_callback_count_;
   int error_callback_count_;
   std::vector<uint8_t> last_read_value_;
   BluetoothRemoteGattService::GattErrorCode last_service_error_;
 };
 
 TEST_F(BluetoothGattBlueZTest,
        RetrieveGattConnectedDevicesWithDiscoveryFilter_NoFilter) {
@@ skipping 1118 matching lines @@
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_EQ(3U, update_sessions_.size());
 
   // Notifications should be getting sent regularly now.
   base::RunLoop().Run();
   EXPECT_GT(observer.gatt_characteristic_value_changed_count(), 1);
 
   // Stop one of the sessions. The session should become inactive but the
   // characteristic should still be notifying.
-  BluetoothGattNotifySession* session = update_sessions_[0];
+  BluetoothGattNotifySession* session = update_sessions_[0].get();
   EXPECT_TRUE(session->IsActive());
   session->Stop(base::Bind(&BluetoothGattBlueZTest::SuccessCallback,
                            base::Unretained(this)));
 
   // Run message loop to stop the notify session.
   base::RunLoop().Run();
 
   EXPECT_EQ(4, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(session->IsActive());
@@ skipping 189 matching lines @@
 
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(1, observer.gatt_characteristic_value_changed_count());
   EXPECT_TRUE(characteristic->IsNotifying());
   EXPECT_EQ(1U, update_sessions_.size());
   EXPECT_TRUE(update_sessions_[0]->IsActive());
 }
 
 }  // namespace bluez