Bluetooth: macOS: DidModifyServices can happens while scanning

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 359 matching lines @@
   NSError* error = BluetoothDeviceMac::GetNSErrorFromGattErrorCode(error_code);
   [characteristic_mock simulateWriteWithError:error];
 }
 
 void BluetoothTestMac::SimulateGattDescriptor(
     BluetoothRemoteGattCharacteristic* characteristic,
     const std::string& uuid) {
   MockCBCharacteristic* characteristic_mock =
       GetCBMockCharacteristic(characteristic);
   CBUUID* cb_uuid = [CBUUID UUIDWithString:@(uuid.c_str())];
-  [characteristic_mock simulateDescriptorWithUUID:cb_uuid];
+  [characteristic_mock addDescriptorWithUUID:cb_uuid];
   MockCBPeripheral* peripheral_mock = GetMockCBPeripheral(characteristic);
   [peripheral_mock didModifyServices:@[]];
   // After -[MockCBPeripheral didModifyServices:], BluetoothLowEnergyDeviceMac
   // is expected to call -[CBPeripheral discoverServices:]
   [peripheral_mock mockDidDiscoverEvents];
 }
 
 void BluetoothTestMac::SimulateGattNotifySessionStarted(
     BluetoothRemoteGattCharacteristic* characteristic) {
   MockCBCharacteristic* characteristic_mock =
@@ skipping 65 matching lines @@
     case NotifyValueState::NONE:
       EXPECT_FALSE(last_notify_value_);
       break;
     case NotifyValueState::NOTIFY:
     case NotifyValueState::INDICATE:
       EXPECT_TRUE(last_notify_value_);
       break;
   }
 }
 
-void BluetoothTestMac::SimulateDidDiscoverServices(
-    BluetoothDevice* device,
-    const std::vector<std::string>& uuids) {
-  AddServicesToDevice(device, uuids);
+void BluetoothTestMac::SimulateDidDiscoverServices(BluetoothDevice* device) {
   [GetMockCBPeripheral(device) mockDidDiscoverServices];
 }
 
+void BluetoothTestMac::SimulateDidDiscoverCharacteristics(
+    BluetoothRemoteGattService* service) {
+  BluetoothRemoteGattServiceMac* mac_gatt_service =
+      static_cast<BluetoothRemoteGattServiceMac*>(service);
+  CBService* cb_service = mac_gatt_service->GetService();
+  [GetMockCBPeripheral(service)
+      mockDidDiscoverCharacteristicsForService:cb_service];
+}
+
+void BluetoothTestMac::SimulateDidDiscoverDescriptors(
+    BluetoothRemoteGattCharacteristic* characteristic) {
+  BluetoothRemoteGattCharacteristicMac* mac_gatt_characteristic =
+      static_cast<BluetoothRemoteGattCharacteristicMac*>(characteristic);
+  CBCharacteristic* cb_characteristic =
+      mac_gatt_characteristic->GetCBCharacteristic();
+  [GetMockCBPeripheral(characteristic)
+      mockDidDiscoverDescriptorsForCharacteristic:cb_characteristic];
+}
+
+void BluetoothTest::AddServicesToDevice(BluetoothDevice* device,
+                                        const std::vector<std::string>& uuids) {
+  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];
+  }
+  [GetMockCBPeripheral(device) addServices:services];
+}
+
+void BluetoothTestMac::AddCharacteristicToService(
+    BluetoothRemoteGattService* service,
+    const std::string& characteristic_uuid,
+    int properties) {
+  BluetoothRemoteGattServiceMac* mac_gatt_service =
+      static_cast<BluetoothRemoteGattServiceMac*>(service);
+  CBService* cb_service = mac_gatt_service->GetService();
+  MockCBService* service_mock = ObjCCast<MockCBService>(cb_service);
+  CBUUID* cb_uuid = [CBUUID UUIDWithString:@(characteristic_uuid.c_str())];
+  [service_mock addCharacteristicWithUUID:cb_uuid properties:properties];
+}
+
+void BluetoothTestMac::AddDescriptorToCharacteristic(
+    BluetoothRemoteGattCharacteristic* characteristic,
+    const std::string& uuid) {
+  BluetoothRemoteGattCharacteristicMac* mac_gatt_characteristic =
+      static_cast<BluetoothRemoteGattCharacteristicMac*>(characteristic);
+  CBCharacteristic* cb_characteristic =
+      mac_gatt_characteristic->GetCBCharacteristic();
+  MockCBCharacteristic* characteristic_mock =
+      ObjCCast<MockCBCharacteristic>(cb_characteristic);
+  CBUUID* cb_uuid = [CBUUID UUIDWithString:@(uuid.c_str())];
+  [characteristic_mock addDescriptorWithUUID:cb_uuid];
+}
+
 void BluetoothTestMac::OnFakeBluetoothDeviceConnectGattCalled() {
   gatt_connection_attempts_++;
 }
 
 void BluetoothTestMac::OnFakeBluetoothGattDisconnect() {
   gatt_disconnection_attempts_++;
 }
 
 void BluetoothTestMac::OnFakeBluetoothServiceDiscovery() {
   gatt_discovery_attempts_++;
@@ skipping 60 matching lines @@
 MockCBCharacteristic* BluetoothTest::GetCBMockCharacteristic(
     BluetoothRemoteGattCharacteristic* characteristic) const {
   device::BluetoothRemoteGattCharacteristicMac* mac_gatt_characteristic =
       static_cast<device::BluetoothRemoteGattCharacteristicMac*>(
           characteristic);
   CBCharacteristic* cb_characteristic =
       mac_gatt_characteristic->GetCBCharacteristic();
   return ObjCCast<MockCBCharacteristic>(cb_characteristic);
 }
 
-void BluetoothTest::AddServicesToDevice(BluetoothDevice* device,
-                                        const std::vector<std::string>& uuids) {
-  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];
-  }
-  [GetMockCBPeripheral(device) addServices:services];
-}
-
 // 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