Adding support for service scan 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"
@@ skipping 100 matching lines @@
 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_;
   switch (device_ordinal) {
     case 1: {
       scoped_nsobject<MockCBPeripheral> mock_peripheral(
           [[MockCBPeripheral alloc]
               initWithUTF8StringIdentifier:kTestPeripheralUUID1.c_str()]);
+      mock_peripheral.get().bluetoothTestMac = this;

[ortuno, 2016/05/06 16:03:34]

Why do you need to do this?

[jlebel, 2016/05/07 00:16:12]

I need to do this so the mock peripheral can call:
BluetoothTestMac::OnFakeBluetoothDeviceConnectGattCalled() and
BluetoothTestMac::OnFakeBluetoothGattDisconnect().

[ortuno, 2016/05/09 19:54:00]

Ah ok.

       NSArray* uuids = @[
         [CBUUID UUIDWithString:@(kTestUUIDGenericAccess.c_str())],
         [CBUUID UUIDWithString:@(kTestUUIDGenericAttribute.c_str())]
       ];
       scoped_nsobject<NSDictionary> advertisement_data =
           CreateAdvertisementData(@(kTestDeviceName.c_str()), uuids);
       [central_manager_delegate centralManager:central_manager
                          didDiscoverPeripheral:mock_peripheral.get().peripheral
                              advertisementData:advertisement_data
                                           RSSI:@(0)];
       break;
     }
     case 2: {
       scoped_nsobject<MockCBPeripheral> mock_peripheral(
           [[MockCBPeripheral alloc]
               initWithUTF8StringIdentifier:kTestPeripheralUUID1.c_str()]);
+      mock_peripheral.get().bluetoothTestMac = this;
       NSArray* uuids = @[
         [CBUUID UUIDWithString:@(kTestUUIDImmediateAlert.c_str())],
         [CBUUID UUIDWithString:@(kTestUUIDLinkLoss.c_str())]
       ];
       scoped_nsobject<NSDictionary> advertisement_data =
           CreateAdvertisementData(@(kTestDeviceName.c_str()), uuids);
       [central_manager_delegate centralManager:central_manager
                          didDiscoverPeripheral:mock_peripheral.get().peripheral
                              advertisementData:advertisement_data
                                           RSSI:@(0)];
       break;
     }
     case 3: {
       scoped_nsobject<MockCBPeripheral> mock_peripheral(
           [[MockCBPeripheral alloc]
               initWithUTF8StringIdentifier:kTestPeripheralUUID1.c_str()]);
+      mock_peripheral.get().bluetoothTestMac = this;
       scoped_nsobject<NSDictionary> advertisement_data(
           CreateAdvertisementData(@(kTestDeviceNameEmpty.c_str()), nil));
       [central_manager_delegate centralManager:central_manager
                          didDiscoverPeripheral:mock_peripheral.get().peripheral
                              advertisementData:advertisement_data
                                           RSSI:@(0)];
       break;
     }
     case 4: {
       scoped_nsobject<MockCBPeripheral> mock_peripheral(
           [[MockCBPeripheral alloc]
               initWithUTF8StringIdentifier:kTestPeripheralUUID2.c_str()]);
+      mock_peripheral.get().bluetoothTestMac = this;
       NSArray* uuids = nil;
       scoped_nsobject<NSDictionary> advertisement_data =
           CreateAdvertisementData(@(kTestDeviceNameEmpty.c_str()), uuids);
       [central_manager_delegate centralManager:central_manager
                          didDiscoverPeripheral:mock_peripheral.get().peripheral
                              advertisementData:advertisement_data
                                           RSSI:@(0)];
       break;
     }
   }
@@ skipping 35 matching lines @@
   CBPeripheral* peripheral = lowEnergyDeviceMac->GetPeripheral();
   MockCBPeripheral* mockPeripheral = (MockCBPeripheral*)peripheral;
   [mockPeripheral setState:CBPeripheralStateDisconnected];
   CBCentralManager* centralManager =
       ObjCCast<CBCentralManager>(mock_central_manager_->get());
   [centralManager.delegate centralManager:centralManager
                   didDisconnectPeripheral:peripheral
                                     error:nil];
 }
 
+void BluetoothTestMac::SimulateGattServicesDiscovered(
+    BluetoothDevice* device,
+    const std::vector<std::string>& uuids) {
+  BluetoothLowEnergyDeviceMac* device_mac =
+      static_cast<BluetoothLowEnergyDeviceMac*>(device);
+  CBPeripheral* peripheral = device_mac->GetPeripheral();
+  MockCBPeripheral* peripheral_mock = ObjCCast<MockCBPeripheral>(peripheral);
+  scoped_nsobject<NSMutableArray> services = [[NSMutableArray alloc] init];
+  for (auto uuid : uuids) {
+    CBUUID* cb_service_uuid = [CBUUID UUIDWithString:@(uuid.c_str())];
+    [services addObject:cb_service_uuid];

[ortuno, 2016/05/06 16:03:34]

Does the ownership of cb_service_uuid get transfered to the services array?

[jlebel, 2016/05/07 00:16:12]

There is no real ownership in objective-c. The |services| is going to retain
|cb_service_uuid|. So the instance will be kept alive at least as long as
|services| needs it.
The instance of CBUUID has been created without calling explicitely |alloc|.
Therefore the retain count value is set to 1, and will be decreased
automatically by 1 when this method will be finished.
So the retain count is set to 1 after |[CBUUID UUIDWithString:@(uuid.c_str())]|.
Then it is increased after |[services addObject:cb_service_uuid]|. And after
this method, the retain count value is will be set back to 1. 

[ortuno, 2016/05/09 19:54:00]

Got it. Thanks for the explanation!

+  }
+  [peripheral_mock removeAllServices];
+  [peripheral_mock addServices:services];
+  [peripheral_mock didDiscoverWithError:nil];
+}
+
+void BluetoothTestMac::SimulateGattServiceRemoved(
+    BluetoothRemoteGattService* service) {
+  BluetoothUUID bluetooth_service_uuid = service->GetUUID();
+  std::string service_uuid_string = bluetooth_service_uuid.canonical_value();
+  CBUUID* cb_service_uuid =
+      [CBUUID UUIDWithString:@(service_uuid_string.c_str())];
+  BluetoothDevice* device = service->GetDevice();
+  BluetoothLowEnergyDeviceMac* device_mac =
+      static_cast<BluetoothLowEnergyDeviceMac*>(device);
+  CBPeripheral* peripheral = device_mac->GetPeripheral();
+  MockCBPeripheral* peripheral_mock = ObjCCast<MockCBPeripheral>(peripheral);
+  [peripheral_mock removeServiceWithCBUUID:cb_service_uuid];

[ortuno, 2016/05/06 16:03:34]

I don't think we should use the UUID to remove services since there could be two
services with the same UUID

[jlebel, 2016/05/07 00:16:12]

Done.

+  [peripheral_mock didDiscoverWithError:nil];
+}
+
 void BluetoothTestMac::OnFakeBluetoothDeviceConnectGattCalled() {
   gatt_connection_attempts_++;
 }
 
 void BluetoothTestMac::OnFakeBluetoothGattDisconnect() {
   gatt_disconnection_attempts_++;
 }
 
+void BluetoothTestMac::OnFakeBluetoothServiceDiscovery() {
+  gatt_discovery_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