Implement BluetoothDeviceBlueZ::GetServiceRecords.

device/bluetooth/dbus/bluetooth_device_client.h

 // 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.
 
 #ifndef DEVICE_BLUETOOTH_DBUS_BLUETOOTH_DEVICE_CLIENT_H_
 #define DEVICE_BLUETOOTH_DBUS_BLUETOOTH_DEVICE_CLIENT_H_
 
 #include <stdint.h>
 
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "base/values.h"
 #include "dbus/object_path.h"
 #include "dbus/property.h"
 #include "device/bluetooth/bluetooth_export.h"
+#include "device/bluetooth/bluez/bluetooth_service_record_bluez.h"
 #include "device/bluetooth/dbus/bluez_dbus_client.h"
 
 namespace bluez {
 
 // BluetoothDeviceClient is used to communicate with objects representing
 // remote Bluetooth Devices.
 class DEVICE_BLUETOOTH_EXPORT BluetoothDeviceClient : public BluezDBusClient {
  public:
+  using ServiceRecordList = std::vector<BluetoothServiceRecordBlueZ>;
+
+  // This callback invoked for a successful GetConnInfo API call with the
+  // RSSI, TX power, and maximum TX power of the current connection.
+  using ConnInfoCallback = base::Callback<
+      void(int16_t rssi, int16_t transmit_power, int16_t max_transmit_power)>;
+
+  // This callback invoked for a successful GetServiceRecords API call with the
+  // currently discovered service records.
+  using ServiceRecordsCallback = base::Callback<void(const ServiceRecordList&)>;
+
+  // The ErrorCallback is used by device methods to indicate failure.
+  // It receives two arguments: the name of the error in |error_name| and
+  // an optional message in |error_message|.
+  using ErrorCallback = base::Callback<void(const std::string& error_name,
+                                            const std::string& error_message)>;
+
   // Structure of properties associated with bluetooth devices.
   struct Properties : public dbus::PropertySet {
     // The Bluetooth device address of the device. Read-only.
     dbus::Property<std::string> address;
 
     // The Bluetooth friendly name of the device. Read-only, to give a
     // different local name, use the |alias| property.
     dbus::Property<std::string> name;
 
     // Proposed icon name for the device according to the freedesktop.org
@@ skipping 90 matching lines @@
 
   // Returns the list of device object paths associated with the given adapter
   // identified by the D-Bus object path |adapter_path|.
   virtual std::vector<dbus::ObjectPath> GetDevicesForAdapter(
       const dbus::ObjectPath& adapter_path) = 0;
 
   // Obtain the properties for the device with object path |object_path|,
   // any values should be copied if needed.
   virtual Properties* GetProperties(const dbus::ObjectPath& object_path) = 0;
 
-  // The ErrorCallback is used by device methods to indicate failure.
-  // It receives two arguments: the name of the error in |error_name| and
-  // an optional message in |error_message|.
-  typedef base::Callback<void(const std::string& error_name,
-                              const std::string& error_message)> ErrorCallback;
-
   // Connects to the device with object path |object_path|, connecting any
   // profiles that can be connected to and have been flagged as auto-connected;
   // may be used to connect additional profiles for an already connected device,
   // and succeeds if at least one profile is connected.
   virtual void Connect(const dbus::ObjectPath& object_path,
                        const base::Closure& callback,
                        const ErrorCallback& error_callback) = 0;
 
   // Disconnects the device with object path |object_path|, terminating
   // the low-level ACL connection and any profiles using it.
@@ skipping 22 matching lines @@
   virtual void Pair(const dbus::ObjectPath& object_path,
                     const base::Closure& callback,
                     const ErrorCallback& error_callback) = 0;
 
   // Cancels an in-progress pairing with the device with object path
   // |object_path| initiated by Pair().
   virtual void CancelPairing(const dbus::ObjectPath& object_path,
                              const base::Closure& callback,
                              const ErrorCallback& error_callback) = 0;
 
-  // The callback invoked for a successful GetConnInfo API call with the
-  // RSSI, TX power, and maximum TX power of the current connection.
-  typedef base::Callback<void(int16_t rssi,
-                              int16_t transmit_power,
-                              int16_t max_transmit_power)> ConnInfoCallback;
-
   // Returns the RSSI, TX power, and maximum TX power of a connection to the
   // device with object path |object_path|. If the device is not connected, then
   // an error will be returned.
   virtual void GetConnInfo(const dbus::ObjectPath& object_path,
                            const ConnInfoCallback& callback,
                            const ErrorCallback& error_callback) = 0;
 
+  // Returns the currently discovered service records for the device with
+  // object path |object_path|. If the device is not connected, then an error
+  // will be returned.
+  virtual void GetServiceRecords(const dbus::ObjectPath& object_path,
+                                 const ServiceRecordsCallback& callback,
+                                 const ErrorCallback& error_callback) = 0;
+
   // Creates the instance.
   static BluetoothDeviceClient* Create();
 
   // Constants used to indicate exceptional error conditions.
   static const char kNoResponseError[];
   static const char kUnknownDeviceError[];
 
   // Strings used by BlueZ for the transport type of the remote device.
   // See https://chromium-review.googlesource.com/c/351512/
   static const char kTypeBredr[];
   static const char kTypeLe[];
   static const char kTypeDual[];
 
  protected:
   BluetoothDeviceClient();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BluetoothDeviceClient);
 };
 
 }  // namespace bluez
 
 #endif  // DEVICE_BLUETOOTH_DBUS_BLUETOOTH_DEVICE_CLIENT_H_