Implementing GATT connection/disconnect on OS X.

device/bluetooth/test/bluetooth_test_mac.mm

 // Copyright 2015 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 "device/bluetooth/test/bluetooth_test_mac.h"
 
 #include <stdint.h>
 
+#include "base/mac/foundation_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "device/bluetooth/bluetooth_adapter_mac.h"
+#include "device/bluetooth/test/mock_bluetooth_cbperipheral_mac.h"
 #include "device/bluetooth/test/mock_bluetooth_central_manager_mac.h"
 #include "device/bluetooth/test/test_bluetooth_adapter_observer.h"
 #include "third_party/ocmock/OCMock/OCMock.h"
 
-#if defined(OS_IOS)
 #import <CoreBluetooth/CoreBluetooth.h>
-#else  // !defined(OS_IOS)
-#import <IOBluetooth/IOBluetooth.h>
-#endif  // defined(OS_IOS)
+
+using base::mac::ObjCCast;
 
 namespace device {
 
 namespace {
 
 CBPeripheral* CreateMockPeripheral(NSString* peripheral_identifier) {
   Class peripheral_class = NSClassFromString(@"CBPeripheral");
   id mock_peripheral = [OCMockObject mockForClass:[peripheral_class class]];
   [[[mock_peripheral stub] andReturnValue:@(CBPeripheralStateDisconnected)]
       performSelector:@selector(state)];
@@ skipping 25 matching lines @@
 }  // namespace
 
 // UUID1 hashes to kTestDeviceAddress1, and UUID2 to kTestDeviceAddress2.
 const std::string BluetoothTestMac::kTestPeripheralUUID1 =
     "34045B00-0000-0000-0000-000000000000";
 const std::string BluetoothTestMac::kTestPeripheralUUID2 =
     "EC1B8F00-0000-0000-0000-000000000000";
 
 BluetoothTestMac::BluetoothTestMac() {}
 
-BluetoothTestMac::~BluetoothTestMac() {}
+BluetoothTestMac::~BluetoothTestMac() {
+  [mock_central_manager_ release];
+}
 
 void BluetoothTestMac::SetUp() {}
 
 bool BluetoothTestMac::PlatformSupportsLowEnergy() {
   return BluetoothAdapterMac::IsLowEnergyAvailable();
 }
 
 void BluetoothTestMac::InitWithDefaultAdapter() {
   adapter_mac_ = BluetoothAdapterMac::CreateAdapter().get();
   adapter_ = adapter_mac_;
 }
 
 void BluetoothTestMac::InitWithoutDefaultAdapter() {
   adapter_mac_ = BluetoothAdapterMac::CreateAdapterForTest(
                      "", "", message_loop_.task_runner())
                      .get();
   adapter_ = adapter_mac_;
 
   if (BluetoothAdapterMac::IsLowEnergyAvailable()) {
-    id low_energy_central_manager = [[MockCentralManager alloc] init];
-    [low_energy_central_manager setState:CBCentralManagerStateUnsupported];
-    adapter_mac_->SetCentralManagerForTesting(low_energy_central_manager);
+    mock_central_manager_ = [[MockCentralManager alloc] init];
+    [mock_central_manager_ setBluetoothTestMac:this];
+    [mock_central_manager_ setState:CBCentralManagerStateUnsupported];
+    adapter_mac_->SetCentralManagerForTesting((id)mock_central_manager_);
   }
 }
 
 void BluetoothTestMac::InitWithFakeAdapter() {
   adapter_mac_ =
       BluetoothAdapterMac::CreateAdapterForTest(
           kTestAdapterName, kTestAdapterAddress, message_loop_.task_runner())
           .get();
   adapter_ = adapter_mac_;
 
   if (BluetoothAdapterMac::IsLowEnergyAvailable()) {
-    id low_energy_central_manager = [[MockCentralManager alloc] init];
-    [low_energy_central_manager setState:CBCentralManagerStatePoweredOn];
-    adapter_mac_->SetCentralManagerForTesting(low_energy_central_manager);
+    mock_central_manager_ = [[MockCentralManager alloc] init];
+    mock_central_manager_.bluetoothTestMac = this;
+    [mock_central_manager_ setState:CBCentralManagerStatePoweredOn];
+    adapter_mac_->SetCentralManagerForTesting((id)mock_central_manager_);
   }
 }
 
 BluetoothDevice* BluetoothTestMac::DiscoverLowEnergyDevice(int device_ordinal) {
   TestBluetoothAdapterObserver observer(adapter_);
   CBCentralManager* central_manager = adapter_mac_->low_energy_central_manager_;
   BluetoothLowEnergyCentralManagerDelegate* central_manager_delegate =
       adapter_mac_->low_energy_central_manager_delegate_;
   Class cbuuid_class = NSClassFromString(@"CBUUID");
   switch (device_ordinal) {
@@ skipping 31 matching lines @@
                                stringWithUTF8String:kTestUUIDLinkLoss.c_str()]]
       ];
       NSDictionary* advertisement_data = CreateAdvertisementData(name, uuids);
       [central_manager_delegate centralManager:central_manager
                          didDiscoverPeripheral:peripheral
                              advertisementData:advertisement_data
                                           RSSI:@(0)];
       break;
     }
     case 3: {
-      CBPeripheral* peripheral = CreateMockPeripheral(
-          [NSString stringWithUTF8String:kTestPeripheralUUID1.c_str()]);
-      NSString* name =
-          [NSString stringWithUTF8String:kTestDeviceNameEmpty.c_str()];
-      NSArray* uuids = nil;
-      NSDictionary* advertisement_data = CreateAdvertisementData(name, uuids);
+      base::scoped_nsobject<NSString> uuid_string(
+          [[NSString alloc] initWithUTF8String:kTestPeripheralUUID1.c_str()]);
+      base::scoped_nsobject<NSUUID> identifier(
+          [[NSUUID alloc] initWithUUIDString:uuid_string]);
+      base::scoped_nsobject<CBPeripheral> peripheral;
+      peripheral.reset((CBPeripheral*)[[MockCBPeripheral alloc]
+          initWithIdentifier:identifier]);
+      base::scoped_nsobject<NSString> name(
+          [[NSString alloc] initWithUTF8String:kTestDeviceNameEmpty.c_str()]);
+      base::scoped_nsobject<NSDictionary> advertisement_data(
+          [CreateAdvertisementData(name, nil) retain]);
       [central_manager_delegate centralManager:central_manager
                          didDiscoverPeripheral:peripheral
                              advertisementData:advertisement_data
                                           RSSI:@(0)];
       break;
     }
     case 4: {
       CBPeripheral* peripheral = CreateMockPeripheral(
           [NSString stringWithUTF8String:kTestPeripheralUUID2.c_str()]);
       NSString* name =
           [NSString stringWithUTF8String:kTestDeviceNameEmpty.c_str()];
       NSArray* uuids = nil;
       NSDictionary* advertisement_data = CreateAdvertisementData(name, uuids);
       [central_manager_delegate centralManager:central_manager
                          didDiscoverPeripheral:peripheral
                              advertisementData:advertisement_data
                                           RSSI:@(0)];
       break;
     }
   }
   return observer.last_device();
 }
 
+void BluetoothTestMac::SimulateGattConnection(BluetoothDevice* device) {
+  BluetoothLowEnergyDeviceMac* lowEnergyDeviceMac =
+      static_cast<BluetoothLowEnergyDeviceMac*>(device);
+  CBPeripheral* peripheral = lowEnergyDeviceMac->GetPeripheral();
+  MockCBPeripheral* mockPeripheral = (MockCBPeripheral*)peripheral;
+  [mockPeripheral setState:CBPeripheralStateConnected];
+  CBCentralManager* centralManager = (CBCentralManager*)mock_central_manager_;
+  [centralManager.delegate centralManager:centralManager
+                     didConnectPeripheral:peripheral];
+}
+
+void BluetoothTestMac::SimulateGattDisconnection(BluetoothDevice* device) {
+  BluetoothLowEnergyDeviceMac* lowEnergyDeviceMac =
+      static_cast<BluetoothLowEnergyDeviceMac*>(device);
+  CBPeripheral* peripheral = lowEnergyDeviceMac->GetPeripheral();
+  MockCBPeripheral* mockPeripheral = (MockCBPeripheral*)peripheral;
+  [mockPeripheral setState:CBPeripheralStateDisconnected];
+  CBCentralManager* centralManager = (CBCentralManager*)mock_central_manager_;
+  [centralManager.delegate centralManager:centralManager
+                  didDisconnectPeripheral:peripheral
+                                    error:nil];
+}
+
+void BluetoothTestMac::SimulateGattConnectionError(
+    BluetoothDevice* device,
+    BluetoothDevice::ConnectErrorCode errorCode) {
+  BluetoothLowEnergyDeviceMac* lowEnergyDeviceMac =
+      static_cast<BluetoothLowEnergyDeviceMac*>(device);
+  CBPeripheral* peripheral = lowEnergyDeviceMac->GetPeripheral();
+  MockCBPeripheral* mockPeripheral = (MockCBPeripheral*)peripheral;
+  [mockPeripheral setState:CBPeripheralStateDisconnected];
+  CBCentralManager* centralManager = (CBCentralManager*)mock_central_manager_;
+  // TODO(http://crbug.com/585894): Need to convert the connect error code into
+  // NSError
+  NSError* error = [NSError errorWithDomain:@"BluetoothDevice::ConnectErrorCode"
+                                       code:-1
+                                   userInfo:nil];
+  [centralManager.delegate centralManager:centralManager
+               didFailToConnectPeripheral:peripheral
+                                    error:error];
+}
+
+void BluetoothTestMac::OnFakeBluetoothDeviceConnectGattCalled() {
+  gatt_connection_attempts_++;
+}
+
+void BluetoothTestMac::OnFakeBluetoothGattDisconnect() {
+  gatt_disconnection_attempts_++;
+}
+
 // Utility function for generating new (CBUUID, address) pairs where CBUUID
 // hashes to address. For use when adding a new device address to the testing
 // suite because CoreBluetooth peripherals have CBUUIDs in place of addresses,
 // and we construct fake addresses for them by hashing the CBUUID. By changing
 // |target| the user can generate sequentially numbered test addresses.
 //
 // std::string BluetoothTestMac::FindCBUUIDForHashTarget() {
 //   // The desired first 6 digits of the hash.  For example 0100000, 020000,
 //   // 030000, ...
 //   const std::string target = "010000";
@@ skipping 16 matching lines @@
 //     crypto::SHA256HashString(input_str, raw, sizeof(raw));
 //     if (base::HexEncode(raw, sizeof(raw)) == target) {
 //       return input_str;
 //     }
 //     ++input[0];
 //   }
 //   return "";
 // }
 
 }  // namespace device