Bluetooth: macOS: DidModifyServices can happens while scanning

device/bluetooth/bluetooth_device_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 "device/bluetooth/bluetooth_device.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/run_loop.h"
@@ skipping 465 matching lines @@
   base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(device->IsGattConnected());
 
   EXPECT_EQ(1, observer.device_changed_count());
   EXPECT_TRUE(device->GetUUIDs().empty());
 }
 #endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
 
 #if defined(OS_MACOSX)
 // Tests that receiving 2 notifications in a row from macOS that services has
-// changed is handled correctly. Each notification should generate a notfication
-// that the gatt device has changed, and each notification should ask to macOS
-// to scan for services. Only after the second service scan is received, the
-// device changed notification should be sent and the characteristic discovery
-// procedure should be started.
+// changed is handled correctly. Each notification should generate a
+// notification that the gatt device has changed, and each notification should
+// ask to macOS to scan for services. Only after the second service scan is
+// received, the device changed notification should be sent and the
+// characteristic discovery procedure should be started.
 // Android: This test doesn't apply to Android because there is no services
 // changed event that could arrive during a discovery procedure.
 TEST_F(BluetoothTest, TwoPendingServiceDiscoveryRequests) {
   if (!PlatformSupportsLowEnergy()) {
     LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
     return;
   }
 
   InitWithFakeAdapter();
   TestBluetoothAdapterObserver observer(adapter_);
 
   BluetoothDevice* device = SimulateLowEnergyDevice(1);
   device->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
                                GetConnectErrorCallback(Call::NOT_EXPECTED));
   SimulateGattConnection(device);
   EXPECT_EQ(1, observer.device_changed_count());
   EXPECT_FALSE(device->IsGattServicesDiscoveryComplete());
 
   observer.Reset();
   SimulateGattServicesChanged(device);
   EXPECT_EQ(1, observer.device_changed_count());
   EXPECT_FALSE(device->IsGattServicesDiscoveryComplete());
 
   // Fist system call to

[scheib, 2017/05/01 17:20:33]

'First'

[jlebel, 2017/05/01 21:27:14]

Done.

-  // -[id<CBPeripheralDelegate> peripheral:didDiscoverServices:]
+  // -[id<CBPeripheralDelegate> peripheral:didDiscoverServices:] using
+  // SimulateDidDiscoverServicesMac().
   observer.Reset();
-  SimulateDidDiscoverServices(device, {kTestUUIDHeartRate});
+  AddServicesToDevice(device, {kTestUUIDHeartRate});
+  SimulateDidDiscoverServicesMac(device);
   EXPECT_EQ(0, observer.device_changed_count());
   EXPECT_FALSE(device->IsGattServicesDiscoveryComplete());
   EXPECT_EQ(gatt_characteristic_discovery_attempts_, 0);
 
   // Second system call to
-  // -[id<CBPeripheralDelegate> peripheral:didDiscoverServices:]
+  // -[id<CBPeripheralDelegate> peripheral:didDiscoverServices:] using the
+  // generic call to SimulateGattServicesDiscovered(). This method triggers
+  // the full discovery cycles (services, characteristics and descriptors),
+  // which includes -[id<CBPeripheralDelegate> peripheral:didDiscoverServices:].
   SimulateGattServicesDiscovered(
       device, std::vector<std::string>({kTestUUIDImmediateAlert}));
   EXPECT_EQ(1, observer.device_changed_count());
   EXPECT_TRUE(device->IsGattServicesDiscoveryComplete());
   // Characteristics are discovered once for each service.
   EXPECT_EQ(gatt_characteristic_discovery_attempts_, 2);
 
   EXPECT_EQ(2u, device->GetGattServices().size());
 }
 
@@ skipping 10 matching lines @@
   TestBluetoothAdapterObserver observer(adapter_);
 
   BluetoothDevice* device = SimulateLowEnergyDevice(1);
   device->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
                                GetConnectErrorCallback(Call::NOT_EXPECTED));
   SimulateGattConnection(device);
   EXPECT_EQ(1, observer.device_changed_count());
   EXPECT_FALSE(device->IsGattServicesDiscoveryComplete());
 
   // Legitimate system call to
-  // -[id<CBPeripheralDelegate> peripheral:didDiscoverServices:]
+  // -[id<CBPeripheralDelegate> peripheral:didDiscoverServices:].
   observer.Reset();
   SimulateGattServicesDiscovered(
       device, std::vector<std::string>({kTestUUIDHeartRate}));
   EXPECT_EQ(1, observer.device_changed_count());
   EXPECT_TRUE(device->IsGattServicesDiscoveryComplete());
   EXPECT_EQ(gatt_characteristic_discovery_attempts_, 1);
   EXPECT_EQ(1u, device->GetGattServices().size());
 
   // Unexpected system call to
-  // -[id<CBPeripheralDelegate> peripheral:didDiscoverServices:]
-  SimulateDidDiscoverServices(device, {kTestUUIDImmediateAlert});
+  // -[id<CBPeripheralDelegate> peripheral:didDiscoverServices:]:
+  // This system call is expected only once after -[CBCentralManager
+  // discoverServices:]. The call to -[CBCentralManager discoverServices:] and
+  // its answer with -[id<CBPeripheralDelegate> peripheral:didDiscoverServices:]
+  // is done with SimulateGattServicesDiscovered(). So a second system call to
+  // -[id<CBPeripheralDelegate> peripheral:didDiscoverServices:] is not expected
+  // and should be ignored.
+  AddServicesToDevice(device, {kTestUUIDImmediateAlert});
+  SimulateDidDiscoverServicesMac(device);
   EXPECT_EQ(1, observer.device_changed_count());
   EXPECT_TRUE(device->IsGattServicesDiscoveryComplete());
 
   EXPECT_EQ(1u, device->GetGattServices().size());
 }
 #endif  // defined(OS_MACOSX)
 
 #if defined(OS_ANDROID) || defined(OS_MACOSX)
 // Tests Advertisement Data is updated correctly when we start discovery
 // during a connection.
@@ skipping 1022 matching lines @@
                     ->GetPrimaryServicesByUUID(BluetoothUUID(
                         BluetoothTestBase::kTestUUIDGenericAttribute))
                     .empty());
 
     EXPECT_NE(services[0]->GetIdentifier(), services[1]->GetIdentifier());
   }
 }
 #endif  // defined(OS_ANDROID) || defined(OS_MACOSX) || defined(OS_WIN)
 
 }  // namespace device