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 281 matching lines @@
   CBCentralManager* central_manager =
       ObjCCast<CBCentralManager>(mock_central_manager_->get());
   [central_manager.delegate centralManager:central_manager
                    didDisconnectPeripheral:peripheral_mock.peripheral
                                      error:nil];
 }
 
 void BluetoothTestMac::SimulateGattServicesDiscovered(
     BluetoothDevice* device,
     const std::vector<std::string>& uuids) {
-  AddServicesToDevice(device, uuids);
+  AddServicesToDeviceMac(device, uuids);
   [GetMockCBPeripheral(device) mockDidDiscoverEvents];
 }
 
 void BluetoothTestMac::SimulateGattServicesChanged(BluetoothDevice* device) {
   [GetMockCBPeripheral(device) didModifyServices:@[]];
 }
 
 void BluetoothTestMac::SimulateGattServiceRemoved(
     BluetoothRemoteGattService* service) {
   BluetoothUUID bluetooth_service_uuid = service->GetUUID();
@@ skipping 59 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 51 matching lines @@
   MockCBCharacteristic* characteristic_mock =
       ObjCCast<MockCBCharacteristic>(cb_characteristic);
   [service_mock removeCharacteristicMock:characteristic_mock];
   [peripheral_mock didModifyServices:@[]];
   [peripheral_mock mockDidDiscoverEvents];
 }
 
 void BluetoothTestMac::SimulateGattDescriptorRead(
     BluetoothRemoteGattDescriptor* descriptor,
     const std::vector<uint8_t>& value) {
-  SimulateGattDescriptorReadNSData(descriptor, value);
+  SimulateGattDescriptorReadNSDataMac(descriptor, value);
 }
 
 void BluetoothTestMac::SimulateGattDescriptorReadError(
     BluetoothRemoteGattDescriptor* descriptor,
     BluetoothRemoteGattService::GattErrorCode error_code) {
   NSError* error = BluetoothDeviceMac::GetNSErrorFromGattErrorCode(error_code);
   [GetCBMockDescriptor(descriptor) simulateReadWithValue:nil error:error];
 }
 
 void BluetoothTestMac::SimulateGattDescriptorWrite(
@@ skipping 18 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::SimulateDidDiscoverServicesMac(BluetoothDevice* device) {
   [GetMockCBPeripheral(device) mockDidDiscoverServices];
 }
 
-void BluetoothTestMac::SimulateGattDescriptorReadNSData(
+void BluetoothTestMac::SimulateDidDiscoverCharacteristicsMac(
+    BluetoothRemoteGattService* service) {
+  BluetoothRemoteGattServiceMac* mac_gatt_service =
+      static_cast<BluetoothRemoteGattServiceMac*>(service);
+  CBService* cb_service = mac_gatt_service->GetService();
+  [GetMockCBPeripheral(service)
+      mockDidDiscoverCharacteristicsForService:cb_service];
+}
+
+void BluetoothTestMac::SimulateDidDiscoverDescriptorsMac(
+    BluetoothRemoteGattCharacteristic* characteristic) {
+  BluetoothRemoteGattCharacteristicMac* mac_gatt_characteristic =
+      static_cast<BluetoothRemoteGattCharacteristicMac*>(characteristic);
+  CBCharacteristic* cb_characteristic =
+      mac_gatt_characteristic->GetCBCharacteristic();
+  [GetMockCBPeripheral(characteristic)
+      mockDidDiscoverDescriptorsForCharacteristic:cb_characteristic];
+}
+
+void BluetoothTestMac::SimulateGattDescriptorReadNSDataMac(
     BluetoothRemoteGattDescriptor* descriptor,
     const std::vector<uint8_t>& value) {
   scoped_nsobject<NSData> data(
       [[NSData alloc] initWithBytes:value.data() length:value.size()]);
   [GetCBMockDescriptor(descriptor) simulateReadWithValue:data error:nil];
 }
 
-void BluetoothTestMac::SimulateGattDescriptorReadNSString(
+void BluetoothTestMac::SimulateGattDescriptorReadNSStringMac(
     BluetoothRemoteGattDescriptor* descriptor,
     const std::string& value) {
   NSString* string = base::SysUTF8ToNSString(value);
   [GetCBMockDescriptor(descriptor) simulateReadWithValue:string error:nil];
 }
 
-void BluetoothTestMac::SimulateGattDescriptorReadNSNumber(
+void BluetoothTestMac::SimulateGattDescriptorReadNSNumberMac(
     BluetoothRemoteGattDescriptor* descriptor,
     short value) {
   NSNumber* number = [NSNumber numberWithShort:value];
   [GetCBMockDescriptor(descriptor) simulateReadWithValue:number error:nil];
 }
 
+void BluetoothTest::AddServicesToDeviceMac(
+    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::AddCharacteristicToServiceMac(
+    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::AddDescriptorToCharacteristicMac(
+    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 82 matching lines @@
   return ObjCCast<MockCBCharacteristic>(cb_characteristic);
 }
 
 MockCBDescriptor* BluetoothTest::GetCBMockDescriptor(
     BluetoothRemoteGattDescriptor* descriptor) const {
   device::BluetoothRemoteGattDescriptorMac* mac_gatt_descriptor =
       static_cast<device::BluetoothRemoteGattDescriptorMac*>(descriptor);
   CBDescriptor* cb_descriptor = mac_gatt_descriptor->GetCBDescriptor();
   return ObjCCast<MockCBDescriptor>(cb_descriptor);
 }
-
-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