bluetooth: Expose service data from BlueZ

device/bluetooth/bluez/bluetooth_device_bluez.cc

 // 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/bluez/bluetooth_device_bluez.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 357 matching lines @@
   UUIDSet uuids;
   const std::vector<std::string>& dbus_uuids = properties->uuids.value();
   for (const std::string& dbus_uuid : dbus_uuids) {
     device::BluetoothUUID uuid(dbus_uuid);
     DCHECK(uuid.IsValid());
     uuids.insert(std::move(uuid));
   }
   return uuids;
 }
 
+BluetoothDevice::UUIDSet BluetoothDeviceBlueZ::GetServiceDataUUIDs() const {
+  bluez::BluetoothDeviceClient::Properties* properties =
+      bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
+          object_path_);
+  DCHECK(properties);
+
+  UUIDSet uuids;
+
+  if (!properties->service_data.is_valid())
+    return uuids;
+
+  for (const auto& pair : properties->service_data.value()) {
+    device::BluetoothUUID uuid(pair.first);
+    DCHECK(uuid.IsValid());
+    uuids.insert(std::move(uuid));
+  }
+
+  return uuids;
+}
+
+const std::vector<uint8_t>* BluetoothDeviceBlueZ::GetServiceDataForUUID(
+    const BluetoothUUID& uuid) const {
+  bluez::BluetoothDeviceClient::Properties* properties =
+      bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
+          object_path_);
+  DCHECK(properties);
+
+  if (!properties->service_data.is_valid())
+    return nullptr;
+
+  const auto& dbus_service_data = properties->service_data.value();
+  auto it = std::find_if(
+      dbus_service_data.begin(), dbus_service_data.end(),
+      [&uuid](const std::pair<std::string, std::vector<uint8_t>>& entry) {
+        return uuid.canonical_value() ==
+               device::BluetoothUUID(entry.first).canonical_value();
+      });
+
+  if (it == dbus_service_data.end())
+    return nullptr;
+
+  return &it->second;
+}
+
 base::Optional<int8_t> BluetoothDeviceBlueZ::GetInquiryRSSI() const {
   bluez::BluetoothDeviceClient::Properties* properties =
       bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
           object_path_);
   DCHECK(properties);
 
   if (!properties->rssi.is_valid())
     return base::nullopt;
 
   // BlueZ uses int16_t because there is no int8_t for DBus, so we should never
@@ skipping 360 matching lines @@
       base::Bind(&BluetoothDeviceBlueZ::OnConnectError,
                  weak_ptr_factory_.GetWeakPtr(), after_pairing,
                  error_callback));
 }
 
 void BluetoothDeviceBlueZ::OnConnect(bool after_pairing,
                                      const base::Closure& callback) {
   if (--num_connecting_calls_ == 0)
     adapter()->NotifyDeviceChanged(this);
 
-  DCHECK(num_connecting_calls_ >= 0);
+  DCHECK_GE(num_connecting_calls_, 0);

[Rahul Chaturvedi, 2016/09/27 20:52:59]

Cleanup should be in its own CL. Usually conflating cleanup with functionality
can lead to a confusing history.

[puthik_chromium, 2016/09/27 21:04:07]

Acknowledged.
Will fix this once I got your full comment

[puthik_chromium, 2016/10/06 01:49:56]

Done.

   VLOG(1) << object_path_.value() << ": Connected, " << num_connecting_calls_
           << " still in progress";
 
   SetTrusted();
 
   if (after_pairing)
     UMA_HISTOGRAM_ENUMERATION("Bluetooth.PairingResult",
                               UMA_PAIRING_RESULT_SUCCESS,
                               UMA_PAIRING_RESULT_COUNT);
 
   callback.Run();
 }
 
 void BluetoothDeviceBlueZ::OnCreateGattConnection(
     const GattConnectionCallback& callback) {
   std::unique_ptr<device::BluetoothGattConnection> conn(
       new BluetoothGattConnectionBlueZ(adapter_, GetAddress(), object_path_));
   callback.Run(std::move(conn));
 }
 
 void BluetoothDeviceBlueZ::OnConnectError(
     bool after_pairing,
     const ConnectErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   if (--num_connecting_calls_ == 0)
     adapter()->NotifyDeviceChanged(this);
 
-  DCHECK(num_connecting_calls_ >= 0);
+  DCHECK_GE(num_connecting_calls_, 0);
   LOG(WARNING) << object_path_.value()
                << ": Failed to connect device: " << error_name << ": "
                << error_message;
   VLOG(1) << object_path_.value() << ": " << num_connecting_calls_
           << " still in progress";
 
   // Determine the error code from error_name.
   ConnectErrorCode error_code = ERROR_UNKNOWN;
   if (error_name == bluetooth_device::kErrorFailed) {
     error_code = ERROR_FAILED;
@@ skipping 18 matching lines @@
   ConnectInternal(true, callback, error_callback);
 }
 
 void BluetoothDeviceBlueZ::OnPairDuringConnectError(
     const ConnectErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   if (--num_connecting_calls_ == 0)
     adapter()->NotifyDeviceChanged(this);
 
-  DCHECK(num_connecting_calls_ >= 0);
+  DCHECK_GE(num_connecting_calls_, 0);
   LOG(WARNING) << object_path_.value()
                << ": Failed to pair device: " << error_name << ": "
                << error_message;
   VLOG(1) << object_path_.value() << ": " << num_connecting_calls_
           << " still in progress";
 
   EndPairing();
 
   // Determine the error code from error_name.
   ConnectErrorCode error_code = DBusErrorToConnectError(error_name);
@@ skipping 64 matching lines @@
 void BluetoothDeviceBlueZ::OnForgetError(const ErrorCallback& error_callback,
                                          const std::string& error_name,
                                          const std::string& error_message) {
   LOG(WARNING) << object_path_.value()
                << ": Failed to remove device: " << error_name << ": "
                << error_message;
   error_callback.Run();
 }
 
 }  // namespace bluez