Handle change of BLE address after pairing

device/bluetooth/bluetooth_gatt_chromeos_unittest.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 "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"
@@ skipping 95 matching lines @@
     adapter_->SetPowered(
         true,
         base::Bind(&base::DoNothing),
         base::Bind(&base::DoNothing));
     ASSERT_TRUE(adapter_->IsPowered());
   }
 
   void TearDown() override {
     adapter_ = NULL;
     update_sessions_.clear();
-    gatt_conn_.reset();
     bluez::BluezDBusManager::Shutdown();
   }
 
   void GetAdapter() {
     device::BluetoothAdapterFactory::GetAdapter(
         base::Bind(&BluetoothGattChromeOSTest::AdapterCallback,
                    base::Unretained(this)));
     ASSERT_TRUE(adapter_.get() != NULL);
     ASSERT_TRUE(adapter_->IsInitialized());
     ASSERT_TRUE(adapter_->IsPresent());
   }
 
   void AdapterCallback(scoped_refptr<BluetoothAdapter> adapter) {
     adapter_ = adapter;
   }
 
   void SuccessCallback() {
     ++success_callback_count_;
   }
 
   void ValueCallback(const std::vector<uint8>& value) {
     ++success_callback_count_;
     last_read_value_ = value;
   }
 
-  void GattConnectionCallback(scoped_ptr<BluetoothGattConnection> conn) {
-    ++success_callback_count_;
-    gatt_conn_ = conn.Pass();
-  }
+  void GattConnectionCallback() { ++success_callback_count_; }
 
   void NotifySessionCallback(scoped_ptr<BluetoothGattNotifySession> session) {
     ++success_callback_count_;
     update_sessions_.push_back(session.release());
     QuitMessageLoop();
   }
 
   void ServiceErrorCallback(BluetoothGattService::GattErrorCode err) {
     ++error_callback_count_;
     last_service_error_ = err;
@@ skipping 20 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_;
-  scoped_ptr<device::BluetoothGattConnection> gatt_conn_;
   ScopedVector<BluetoothGattNotifySession> update_sessions_;
   scoped_refptr<BluetoothAdapter> adapter_;
 
   int success_callback_count_;
   int error_callback_count_;
   std::vector<uint8> last_read_value_;
   BluetoothGattService::GattErrorCode last_service_error_;
 };
 
 TEST_F(BluetoothGattChromeOSTest, GattConnection) {
+  scoped_ptr<device::BluetoothGattConnection> gatt_conn_;
+
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
   ASSERT_FALSE(device->IsConnected());
   ASSERT_FALSE(gatt_conn_.get());
   ASSERT_EQ(0, success_callback_count_);
   ASSERT_EQ(0, error_callback_count_);
 
-  device->CreateGattConnection(
+  gatt_conn_ = device->CreateGattConnection(
       base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(1, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(device->IsConnected());
   ASSERT_TRUE(gatt_conn_.get());
   EXPECT_TRUE(gatt_conn_->IsConnected());
+  EXPECT_FALSE(gatt_conn_->InProgress());
   EXPECT_EQ(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress,
             gatt_conn_->GetDeviceAddress());
 
   gatt_conn_->Disconnect();
-  EXPECT_TRUE(device->IsConnected());
+  EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(gatt_conn_->IsConnected());
 
-  device->CreateGattConnection(
+  gatt_conn_ = device->CreateGattConnection(
       base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(2, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(device->IsConnected());
   ASSERT_TRUE(gatt_conn_.get());
   EXPECT_TRUE(gatt_conn_->IsConnected());
 
   device->Disconnect(
       base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(3, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
+  EXPECT_FALSE(device->IsConnected());
   ASSERT_TRUE(gatt_conn_.get());
   EXPECT_FALSE(gatt_conn_->IsConnected());
 
-  device->CreateGattConnection(
+  gatt_conn_ = device->CreateGattConnection(
       base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(4, success_callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(device->IsConnected());
   EXPECT_TRUE(gatt_conn_->IsConnected());
 
   fake_bluetooth_device_client_->RemoveDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   ASSERT_TRUE(gatt_conn_.get());
   EXPECT_FALSE(gatt_conn_->IsConnected());
 }
 
+TEST_F(BluetoothGattChromeOSTest, MultipleGattConnections) {
+  scoped_ptr<device::BluetoothGattConnection> gatt_conn_1;
+  scoped_ptr<device::BluetoothGattConnection> gatt_conn_2;
+
+  fake_bluetooth_device_client_->CreateDevice(
+      dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
+      dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
+  BluetoothDevice* device =
+      adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
+  ASSERT_TRUE(device);
+  ASSERT_FALSE(device->IsConnected());
+  ASSERT_FALSE(gatt_conn_1.get());
+  ASSERT_FALSE(gatt_conn_2.get());
+  ASSERT_EQ(0, success_callback_count_);
+  ASSERT_EQ(0, error_callback_count_);
+
+  // Connect first gatt client
+  gatt_conn_1 = device->CreateGattConnection(
+      base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
+                 base::Unretained(this)));
+
+  EXPECT_EQ(1, success_callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+  EXPECT_TRUE(device->IsConnected());
+  ASSERT_TRUE(gatt_conn_1.get());
+  EXPECT_TRUE(gatt_conn_1->IsConnected());
+  EXPECT_FALSE(gatt_conn_1->InProgress());
+  EXPECT_EQ(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress,
+            gatt_conn_1->GetDeviceAddress());
+
+  // Connect second gatt client
+  gatt_conn_2 = device->CreateGattConnection(
+      base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
+                 base::Unretained(this)));
+
+  EXPECT_EQ(2, success_callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+  EXPECT_TRUE(device->IsConnected());
+  ASSERT_TRUE(gatt_conn_2.get());
+  EXPECT_TRUE(gatt_conn_2->IsConnected());
+  EXPECT_FALSE(gatt_conn_2->InProgress());
+  EXPECT_EQ(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress,
+            gatt_conn_2->GetDeviceAddress());
+
+  // Disconnect first client
+  gatt_conn_1->Disconnect();
+  EXPECT_TRUE(device->IsConnected());
+  EXPECT_FALSE(gatt_conn_1->IsConnected());
+  EXPECT_TRUE(gatt_conn_2->IsConnected());
+
+  // Connect firt client again
+  gatt_conn_1 = device->CreateGattConnection(
+      base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
+                 base::Unretained(this)));
+
+  EXPECT_EQ(3, success_callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+  EXPECT_TRUE(device->IsConnected());
+  ASSERT_TRUE(gatt_conn_1.get());
+  EXPECT_TRUE(gatt_conn_1->IsConnected());
+  EXPECT_TRUE(gatt_conn_2->IsConnected());
+
+  gatt_conn_1->Disconnect();
+  EXPECT_TRUE(device->IsConnected());
+  EXPECT_FALSE(gatt_conn_1->IsConnected());
+  EXPECT_TRUE(gatt_conn_2->IsConnected());
+
+  gatt_conn_2->Disconnect();
+  EXPECT_FALSE(device->IsConnected());
+  EXPECT_FALSE(gatt_conn_1->IsConnected());
+  EXPECT_FALSE(gatt_conn_2->IsConnected());
+
+  // Connect both clients again
+  gatt_conn_1 = device->CreateGattConnection(
+      base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
+                 base::Unretained(this)));
+  gatt_conn_2 = device->CreateGattConnection(
+      base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
+                 base::Unretained(this)));
+
+  EXPECT_EQ(5, success_callback_count_);
+  EXPECT_TRUE(device->IsConnected());
+  EXPECT_TRUE(gatt_conn_1->IsConnected());
+  EXPECT_TRUE(gatt_conn_2->IsConnected());
+
+  // Disconnect whole device
+  device->Disconnect(base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
+                                base::Unretained(this)),
+                     base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
+                                base::Unretained(this)));
+
+  EXPECT_EQ(6, success_callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+  EXPECT_FALSE(device->IsConnected());
+  ASSERT_TRUE(gatt_conn_1.get());
+  EXPECT_FALSE(gatt_conn_1->IsConnected());
+  ASSERT_TRUE(gatt_conn_1.get());
+  EXPECT_FALSE(gatt_conn_1->IsConnected());
+
+  // Connect both clients again
+  gatt_conn_1 = device->CreateGattConnection(
+      base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
+                 base::Unretained(this)));
+  gatt_conn_2 = device->CreateGattConnection(
+      base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
+                 base::Unretained(this)));
+
+  EXPECT_EQ(8, success_callback_count_);
+  EXPECT_TRUE(device->IsConnected());
+  EXPECT_TRUE(gatt_conn_1->IsConnected());
+  EXPECT_TRUE(gatt_conn_2->IsConnected());
+
+  fake_bluetooth_device_client_->RemoveDevice(
+      dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
+      dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
+  ASSERT_TRUE(gatt_conn_1.get());
+  EXPECT_FALSE(gatt_conn_1->IsConnected());
+  ASSERT_TRUE(gatt_conn_2.get());
+  EXPECT_FALSE(gatt_conn_2->IsConnected());
+}
+
 TEST_F(BluetoothGattChromeOSTest, GattServiceAddedAndRemoved) {
   // Create a fake LE device. We store the device pointer here because this is a
   // test. It's unsafe to do this in production as the device might get deleted.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(bluez::FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(bluez::FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device =
       adapter_->GetDevice(bluez::FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
@@ skipping 951 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 chromeos