device/bluetooth: Implement BluetoothGattConnection on Chrome OS.

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/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "chromeos/dbus/fake_bluetooth_adapter_client.h"
 #include "chromeos/dbus/fake_bluetooth_agent_manager_client.h"
 #include "chromeos/dbus/fake_bluetooth_device_client.h"
 #include "chromeos/dbus/fake_bluetooth_gatt_characteristic_client.h"
 #include "chromeos/dbus/fake_bluetooth_gatt_descriptor_client.h"
 #include "chromeos/dbus/fake_bluetooth_gatt_service_client.h"
 #include "chromeos/dbus/fake_bluetooth_input_client.h"
 #include "chromeos/dbus/fake_dbus_thread_manager.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_gatt_characteristic.h"
+#include "device/bluetooth/bluetooth_gatt_connection.h"
 #include "device/bluetooth/bluetooth_gatt_descriptor.h"
 #include "device/bluetooth/bluetooth_gatt_service.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
 using device::BluetoothGattCharacteristic;
+using device::BluetoothGattConnection;
 using device::BluetoothGattDescriptor;
 using device::BluetoothGattService;
 using device::BluetoothUUID;
 
 namespace chromeos {
 
 namespace {
 
 const BluetoothUUID kHeartRateMeasurementUUID(
     FakeBluetoothGattCharacteristicClient::kHeartRateMeasurementUUID);
@@ skipping 296 matching lines @@
 
     adapter_->SetPowered(
         true,
         base::Bind(&base::DoNothing),
         base::Bind(&base::DoNothing));
     ASSERT_TRUE(adapter_->IsPowered());
   }
 
   virtual void TearDown() {
     adapter_ = NULL;
+    gatt_conn_.reset();
     DBusThreadManager::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 ErrorCallback() {
     ++error_callback_count_;
   }
 
+  void ConnectErrorCallback(BluetoothDevice::ConnectErrorCode error) {
+    ++error_callback_count_;
+  }
+
  protected:
   base::MessageLoop message_loop_;
 
   FakeBluetoothDeviceClient* fake_bluetooth_device_client_;
   FakeBluetoothGattServiceClient* fake_bluetooth_gatt_service_client_;
   FakeBluetoothGattCharacteristicClient*
       fake_bluetooth_gatt_characteristic_client_;
   FakeBluetoothGattDescriptorClient* fake_bluetooth_gatt_descriptor_client_;
+  scoped_ptr<device::BluetoothGattConnection> gatt_conn_;
   scoped_refptr<BluetoothAdapter> adapter_;
 
   int success_callback_count_;
   int error_callback_count_;
   std::vector<uint8> last_read_value_;
 };
 
+TEST_F(BluetoothGattChromeOSTest, GattConnection) {
+  fake_bluetooth_device_client_->CreateDevice(
+      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
+  BluetoothDevice* device = adapter_->GetDevice(
+      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(
+      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_EQ(FakeBluetoothDeviceClient::kLowEnergyAddress,
+            gatt_conn_->GetDeviceAddress());
+
+  gatt_conn_->Disconnect(
+      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
+                 base::Unretained(this)));
+  EXPECT_EQ(2, success_callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+  EXPECT_TRUE(device->IsConnected());
+  EXPECT_FALSE(gatt_conn_->IsConnected());
+
+  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_.get());
+  EXPECT_TRUE(gatt_conn_->IsConnected());
+
+  device->Disconnect(
+      base::Bind(&BluetoothGattChromeOSTest::SuccessCallback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothGattChromeOSTest::ErrorCallback,
+                 base::Unretained(this)));
+
+  EXPECT_EQ(4, success_callback_count_);
+  EXPECT_EQ(0, error_callback_count_);
+  ASSERT_TRUE(gatt_conn_.get());
+  EXPECT_FALSE(gatt_conn_->IsConnected());
+
+  device->CreateGattConnection(
+      base::Bind(&BluetoothGattChromeOSTest::GattConnectionCallback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothGattChromeOSTest::ConnectErrorCallback,
+                 base::Unretained(this)));
+
+  EXPECT_EQ(5, 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(FakeBluetoothAdapterClient::kAdapterPath),
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
+  ASSERT_TRUE(gatt_conn_.get());
+  EXPECT_FALSE(gatt_conn_->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(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kLowEnergyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kLowEnergyAddress);
   ASSERT_TRUE(device);
 
@@ skipping 594 matching lines @@
                  base::Unretained(this)));
   EXPECT_EQ(2, success_callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_TRUE(ValuesEqual(last_read_value_, descriptor->GetValue()));
   EXPECT_FALSE(ValuesEqual(desc_value, descriptor->GetValue()));
   EXPECT_EQ(4, service_observer.gatt_service_changed_count_);
   EXPECT_EQ(2, service_observer.gatt_descriptor_value_changed_count_);
 }
 
 }  // namespace chromeos