bluetooth: Refactor how we update based on Advertising Data

device/bluetooth/bluetooth_adapter_mac.mm

 // Copyright 2013 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_adapter_mac.h"
 
 #import <IOBluetooth/objc/IOBluetoothDevice.h>
 #import <IOBluetooth/objc/IOBluetoothHostController.h>
 #include <stddef.h>
 
@@ skipping 312 matching lines @@
 
   if (transport & BLUETOOTH_TRANSPORT_CLASSIC) {
     if (!classic_discovery_manager_->StopDiscovery()) {
       DVLOG(1) << "Failed to stop classic discovery";
       // TODO: Provide a more precise error here.
       error_callback.Run(UMABluetoothDiscoverySessionOutcome::UNKNOWN);
       return;
     }
   }
   if (transport & BLUETOOTH_TRANSPORT_LE) {
-    if (IsLowEnergyAvailable())
+    if (IsLowEnergyAvailable()) {
       low_energy_discovery_manager_->StopDiscovery();
+      for (const auto& device_id_object_pair : devices_) {
+        device_id_object_pair.second->ClearAdvertisementData();
+      }
+    }
   }
 
   DVLOG(1) << "Discovery stopped";
   num_discovery_sessions_--;
   callback.Run();
 }
 
 void BluetoothAdapterMac::SetDiscoveryFilter(
     std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter,
     const base::Closure& callback,
@@ skipping 129 matching lines @@
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                     DeviceAdded(this, device_classic));
 }
 
 void BluetoothAdapterMac::LowEnergyDeviceUpdated(
     CBPeripheral* peripheral,
     NSDictionary* advertisement_data,
     int rssi) {
   BluetoothLowEnergyDeviceMac* device_mac =
       GetBluetoothLowEnergyDeviceMac(peripheral);
-  // if has no entry in the map, create new device and insert into |devices_|,
+  // If has no entry in the map, create new device and insert into |devices_|,
   // otherwise update the existing device.
-  if (!device_mac) {
+  const bool is_new_device = device_mac == nullptr;
+  if (is_new_device) {
     VLOG(1) << "LowEnergyDeviceUpdated new device";
     // A new device has been found.
-    device_mac = new BluetoothLowEnergyDeviceMac(this, peripheral,
-                                                 advertisement_data, rssi);
+    device_mac = new BluetoothLowEnergyDeviceMac(this, peripheral);
+  } else {
+    // Check that there are no collisions.
+    std::string stored_device_id = device_mac->GetIdentifier();
+    std::string updated_device_id =
+        BluetoothLowEnergyDeviceMac::GetPeripheralIdentifier(peripheral);
+    if (stored_device_id != updated_device_id) {
+      VLOG(1)
+          << "LowEnergyDeviceUpdated stored_device_id != updated_device_id: "
+          << std::endl
+          << "  " << stored_device_id << std::endl
+          << "  " << updated_device_id;
+      // Collision, two identifiers map to the same hash address.  With a 48 bit
+      // hash the probability of this occuring with 10,000 devices
+      // simultaneously present is 1e-6 (see
+      // https://en.wikipedia.org/wiki/Birthday_problem#Probability_table).  We
+      // ignore the second device by returning.
+      return;
+    }
+  }
+
+  DCHECK(device_mac);
+
+  // Get Advertised UUIDs
+  BluetoothDevice::UUIDList advertised_uuids;
+  NSArray* service_uuids =
+      [advertisement_data objectForKey:CBAdvertisementDataServiceUUIDsKey];
+  for (CBUUID* uuid in service_uuids) {
+    advertised_uuids.push_back(BluetoothUUID([[uuid UUIDString] UTF8String]));
+  }
+  NSArray* overflow_service_uuids = [advertisement_data
+      objectForKey:CBAdvertisementDataOverflowServiceUUIDsKey];
+  for (CBUUID* uuid in overflow_service_uuids) {
+    advertised_uuids.push_back(BluetoothUUID([[uuid UUIDString] UTF8String]));
+  }
+
+  // Get Service Data.
+  BluetoothDevice::ServiceDataMap service_data_map;
+  NSDictionary* service_data =
+      [advertisement_data objectForKey:CBAdvertisementDataServiceDataKey];
+  for (CBUUID* uuid in service_data) {
+    NSData* data = [service_data objectForKey:uuid];
+    const uint8_t* bytes = static_cast<const uint8_t*>([data bytes]);
+    size_t length = [data length];
+    service_data_map.emplace(BluetoothUUID([[uuid UUIDString] UTF8String]),
+                             std::vector<uint8_t>(bytes, bytes + length));
+  }
+
+  device_mac->UpdateAdvertisementData(std::move(advertised_uuids),
+                                      std::move(service_data_map));
+
+  if (is_new_device) {
     std::string device_address =
         BluetoothLowEnergyDeviceMac::GetPeripheralHashAddress(peripheral);
     devices_.add(device_address, std::unique_ptr<BluetoothDevice>(device_mac));
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       DeviceAdded(this, device_mac));
-    return;
+  } else {
+    FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
+                      DeviceChanged(this, device_mac));
   }
-
-  std::string stored_device_id = device_mac->GetIdentifier();
-  std::string updated_device_id =
-      BluetoothLowEnergyDeviceMac::GetPeripheralIdentifier(peripheral);
-  if (stored_device_id != updated_device_id) {
-    VLOG(1) << "LowEnergyDeviceUpdated stored_device_id != updated_device_id: "
-            << std::endl
-            << "  " << stored_device_id << std::endl
-            << "  " << updated_device_id;
-    // Collision, two identifiers map to the same hash address.  With a 48 bit
-    // hash the probability of this occuring with 10,000 devices
-    // simultaneously present is 1e-6 (see
-    // https://en.wikipedia.org/wiki/Birthday_problem#Probability_table).  We
-    // ignore the second device by returning.
-    return;
-  }
-
-  // A device has an update.
-  VLOG(2) << "LowEnergyDeviceUpdated";
-  device_mac->Update(advertisement_data, rssi);
-
-  FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
-                    DeviceChanged(this, device_mac));
 }
 
 // TODO(krstnmnlsn): Implement. crbug.com/511025
 void BluetoothAdapterMac::LowEnergyCentralManagerUpdatedState() {}
 
 void BluetoothAdapterMac::AddPairedDevices() {
   // Add any new paired devices.
   for (IOBluetoothDevice* device in [IOBluetoothDevice pairedDevices]) {
     ClassicDeviceAdded(device);
   }
@@ skipping 60 matching lines @@
   std::string device_address =
       BluetoothLowEnergyDeviceMac::GetPeripheralHashAddress(peripheral);
   DevicesMap::const_iterator iter = devices_.find(device_address);
   if (iter == devices_.end()) {
     return nil;
   }
   return static_cast<BluetoothLowEnergyDeviceMac*>(iter->second);
 }
 
 }  // namespace device