arc: bluetooth: Send missing advertise data to Android.

components/arc/bluetooth/arc_bluetooth_bridge.cc

 // Copyright 2016 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 "components/arc/bluetooth/arc_bluetooth_bridge.h"
 
 #include <bluetooth/bluetooth.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/socket.h>
@@ skipping 1989 matching lines @@
     le_features->total_trackable_advertisers = 0;
     le_features->extended_scan_support = false;
     le_features->debug_logging_supported = false;
     btp->set_local_le_features(std::move(le_features));
     properties.push_back(std::move(btp));
   }
 
   return properties;
 }
 
-// Android support 5 types of Advertising Data.
-// However Chrome didn't expose AdvertiseFlag and ManufacturerData.
-// So we will only expose local_name, service_uuids and service_data.
-// Note that we need to use UUID 16 bits in service_data section
-// because Android does not support UUID 128 bits there.
-// TODO(crbug.com/618442) Make Chrome expose missing data.
+// Android support 6 types of Advertising Data which are Advertising Data Flags,
+// Local Name, Service UUIDs, Tx Power Level, Service Data, and Manufacturer
+// Data. Note that we need to use 16-bit UUID in Service Data section because
+// Android does not support 128-bit UUID there.
 mojo::Array<mojom::BluetoothAdvertisingDataPtr>
 ArcBluetoothBridge::GetAdvertisingData(const BluetoothDevice* device) const {
   mojo::Array<mojom::BluetoothAdvertisingDataPtr> advertising_data;
 
-  // LocalName
+  // Advertising Data Flags
+  if (device->GetAdvertisingDataFlags().has_value()) {
+    mojom::BluetoothAdvertisingDataPtr flags =
+        mojom::BluetoothAdvertisingData::New();
+    flags->set_flags(device->GetAdvertisingDataFlags().value());
+    advertising_data.push_back(std::move(flags));
+  }
+
+  // Local Name
   mojom::BluetoothAdvertisingDataPtr local_name =
       mojom::BluetoothAdvertisingData::New();
   local_name->set_local_name(device->GetName() ? device->GetName().value()
                                                : nullptr);
   advertising_data.push_back(std::move(local_name));
 
-  // ServiceUuid
+  // Service UUIDs
   const BluetoothDevice::UUIDSet& uuid_set = device->GetUUIDs();
   if (uuid_set.size() > 0) {
     mojom::BluetoothAdvertisingDataPtr service_uuids =
         mojom::BluetoothAdvertisingData::New();
     service_uuids->set_service_uuids(mojo::Array<BluetoothUUID>::From(
         std::vector<BluetoothUUID>(uuid_set.begin(), uuid_set.end())));
     advertising_data.push_back(std::move(service_uuids));
   }
 
-  // Service data
+  // Tx Power Level
+  if (device->GetInquiryTxPower().has_value()) {
+    mojom::BluetoothAdvertisingDataPtr tx_power_level_element =
+        mojom::BluetoothAdvertisingData::New();
+    tx_power_level_element->set_tx_power_level(
+        device->GetInquiryTxPower().value());
+    advertising_data.push_back(std::move(tx_power_level_element));
+  }
+
+  // Service Data
   for (const BluetoothUUID& uuid : device->GetServiceDataUUIDs()) {
     mojom::BluetoothAdvertisingDataPtr service_data_element =
         mojom::BluetoothAdvertisingData::New();
     mojom::BluetoothServiceDataPtr service_data =
         mojom::BluetoothServiceData::New();
 
     // Android only supports UUID 16 bit here.
     service_data->uuid_16bit = GetUUID16(uuid);
 
     const std::vector<uint8_t>* data = device->GetServiceDataForUUID(uuid);
     DCHECK(data != nullptr);
 
     std::vector<uint8_t> data_copy = *data;
     service_data->data.Swap(&data_copy);
 
     service_data_element->set_service_data(std::move(service_data));
     advertising_data.push_back(std::move(service_data_element));
   }
 
+  // Manufacturer Data
+  if (!device->GetManufacturerData().empty()) {
+    std::vector<uint8_t> manufacturer_data;
+    for (const auto& pair : device->GetManufacturerData()) {
+      uint16_t id = pair.first;
+      // Use little endian here.
+      manufacturer_data.push_back(id & 0xff);
+      manufacturer_data.push_back(id >> 8);
+      manufacturer_data.insert(manufacturer_data.end(), pair.second.begin(),
+                               pair.second.end());
+    }
+    mojom::BluetoothAdvertisingDataPtr manufacturer_data_element =
+        mojom::BluetoothAdvertisingData::New();
+    manufacturer_data_element->set_manufacturer_data(manufacturer_data);
+    advertising_data.push_back(std::move(manufacturer_data_element));
+  }
+
   return advertising_data;
 }
 
 void ArcBluetoothBridge::SendCachedDevicesFound() const {
   DCHECK(bluetooth_adapter_);
 
   // Send devices that have already been discovered, but aren't connected.
   BluetoothAdapter::DeviceList devices = bluetooth_adapter_->GetDevices();
   for (auto* device : devices) {
     if (device->IsPaired())
@@ skipping 67 matching lines @@
   sdp_bluetooth_instance->OnGetSdpRecords(
       status, std::move(remote_addr), target_uuid,
       mojo::Array<mojom::BluetoothSdpRecordPtr>::New(0));
 }
 
 bool ArcBluetoothBridge::CalledOnValidThread() {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace arc