Bluetooth class changes for implementing local GATT attributes.

device/bluetooth/bluez/bluetooth_gatt_service_bluez.h

 // 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.
 
 #ifndef DEVICE_BLUETOOTH_BLUEZ_BLUETOOTH_GATT_SERVICE_BLUEZ_H_
 #define DEVICE_BLUETOOTH_BLUEZ_BLUETOOTH_GATT_SERVICE_BLUEZ_H_
 
-#include <map>
+#include <cstdint>
 #include <string>
 #include <vector>
 
+#include "base/callback_forward.h"
 #include "base/macros.h"
 #include "dbus/object_path.h"
-#include "device/bluetooth/bluetooth_gatt_service.h"
+#include "device/bluetooth/bluetooth_local_gatt_service.h"
 
 namespace bluez {
 
 class BluetoothAdapterBlueZ;
 class BluetoothDeviceBlueZ;
 
 // The BluetoothGattServiceBlueZ class implements BluetootGattService
 // for GATT services on platforms that use BlueZ.
 class BluetoothGattServiceBlueZ : public virtual device::BluetoothGattService {
  public:
+  // A simpler interface for reacting to GATT attribute value requests by the
+  // DBus attribute service providers.
+  class AttributeValueDelegate {

[scheib, 2016/04/26 06:03:32]

Usually the delegate interface is defined on the class that needs to use the
delegate interface (BluetoothGattCharacteristicServiceProvider)? Is this a
better home for a reason I don't see yet?

[rkc, 2016/04/26 18:23:59]

This delegate is used by both characteristics and descriptors and forwards calls
to the delegate on the local GATT service, hence it made sense to keep it in
BluetoothLocalGattServiceBlueZ.

Even though the references to it use BluetoothLocalGattServiceBlueZ, I am not
sure how this ended up here. It is supposed to be in the local GATT service
bluez class. Moved.

[scheib, 2016/04/27 05:12:59]

I see that it is a delegate used by two dbus classes. Perhaps it should live in
a stand alone file in dbus subdir. Or, just place it in
BluetoothGattCharacteristicServiceProvider and reuse it from Descriptor.

BluetoothLocalGattServiceBlueZ seems a strange place, though I understand the
implementation of the delegate results in calling into
BluetoothLocalGattServiceBlueZ and then onwards via the
BluetoothLocalGattService::Delegate. 

I think that's all the more justification to use the Delegate pattern more
consistently, with the Delegate interface being declared at the location code
needs to reach out elsewhere. Having 2 delegates defined on
BluetoothLocalGattService* confuse the delegating directions. (in other words,
BluetoothLocalGattServiceBlueZ is not using AttributeValueDelegate to delegate
work elsewhere.)

[rkc, 2016/04/27 19:41:06]

Moving to its own class in bluez/dbus.
Done.

+   public:
+    virtual ~AttributeValueDelegate() {}
+
+    // This method will be called when a remote device requests to read the
+    // value of the exported GATT attribute. Invoke |callback| with a value
+    // to return that value to the requester. Invoke |error_callback| to report
+    // a failure to read the value. This can happen, for example, if the
+    // attribute has no read permission set. Either callback should be
+    // invoked after a reasonable amount of time, since the request will time
+    // out if left pending for too long causing a disconnection.
+    virtual void GetValue(
+        const device::BluetoothLocalGattService::Delegate::ValueCallback&
+            callback,
+        const device::BluetoothLocalGattService::Delegate::ErrorCallback&
+            error_callback) = 0;
+
+    // This method will be called, when a remote device requests to write the
+    // value of the exported GATT attribute. Invoke |callback| to report
+    // that the value was successfully written. Invoke |error_callback| to
+    // report a failure to write the value. This can happen, for example, if the
+    // attribute has no write permission set. Either callback should be
+    // invoked after a reasonable amount of time, since the request will time
+    // out if left pending for too long causing a disconnection.
+    virtual void SetValue(
+        const std::vector<uint8_t>& value,
+        const base::Closure& callback,
+        const device::BluetoothLocalGattService::Delegate::ErrorCallback&
+            error_callback) = 0;
+  };
+
   // device::BluetoothGattService overrides.
   std::string GetIdentifier() const override;
 
   // Object path of the underlying service.
   const dbus::ObjectPath& object_path() const { return object_path_; }
 
   // Parses a named D-Bus error into a service error code.
   static device::BluetoothGattService::GattErrorCode DBusErrorToServiceError(
       const std::string error_name);
 
@@ skipping 13 matching lines @@
   // The adapter associated with this service. It's ok to store a raw pointer
   // here since |adapter_| indirectly owns this instance.
   BluetoothAdapterBlueZ* adapter_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothGattServiceBlueZ);
 };
 
 }  // namespace bluez
 
 #endif  // DEVICE_BLUETOOTH_BLUEZ_BLUETOOTH_GATT_SERVICE_BLUEZ_H_