Add support for local services/characteristics/descriptors.

device/bluetooth/bluetooth_gatt_descriptor_bluez.h

 // Copyright 2014 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_BLUETOOTH_REMOTE_GATT_DESCRIPTOR_BLUEZ_H_
-#define DEVICE_BLUETOOTH_BLUETOOTH_REMOTE_GATT_DESCRIPTOR_BLUEZ_H_
+#ifndef DEVICE_BLUETOOTH_BLUETOOTH_GATT_DESCRIPTOR_BLUEZ_H_
+#define DEVICE_BLUETOOTH_BLUETOOTH_GATT_DESCRIPTOR_BLUEZ_H_
 
 #include <stdint.h>
 
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "dbus/object_path.h"
 #include "device/bluetooth/bluetooth_gatt_descriptor.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
 namespace device {
 
 class BluetoothGattCharacteristic;
 
 }  // namespace device
 
 namespace bluez {
 
-class BluetoothRemoteGattCharacteristicBlueZ;
+class BluetoothGattCharacteristicBlueZ;
 
-// The BluetoothRemoteGattDescriptorBlueZ class implements
-// BluetoothGattDescriptor for remote GATT characteristic descriptors for
-// platforms that use BlueZ.
-class BluetoothRemoteGattDescriptorBlueZ
-    : public device::BluetoothGattDescriptor {
+// The BluetoothGattDescriptorBlueZ class implements
+// BluetoothGattDescriptor for remote and local GATT characteristic descriptors
+// for platforms that use BlueZ.
+class BluetoothGattDescriptorBlueZ : public device::BluetoothGattDescriptor {
  public:
   // device::BluetoothGattDescriptor overrides.
   std::string GetIdentifier() const override;
   device::BluetoothUUID GetUUID() const override;
   bool IsLocal() const override;
   const std::vector<uint8_t>& GetValue() const override;
   device::BluetoothGattCharacteristic* GetCharacteristic() const override;
   device::BluetoothGattCharacteristic::Permissions GetPermissions()
       const override;
   void ReadRemoteDescriptor(const ValueCallback& callback,
                             const ErrorCallback& error_callback) override;
   void WriteRemoteDescriptor(const std::vector<uint8_t>& new_value,

[ortuno, 2016/04/14 17:42:35]

I think you need a separate class for local and remote. I count 4 methods that
will have different implementations (5 if you include GetPermissions which will
also have a different implementation).

[rkc, 2016/04/14 19:27:27]

This class is small enough that leaving some remote functionality in the base
class seems fine. If the functionality does start to get quite a bit, I'll
refactor it then.

[ortuno, 2016/04/14 21:17:38]

I have two particular problems in mind:

1. GetUUID and GetValue (and probably GetPermissions) will have different
implementations. How are the two implementations going to live in the same file?
2. ReadRemoteDescriptor and WriteRemoteDescriptor should probably call the error
callback on local characteristics. How are you going to do this?

Anyway nothing to do here but those two issues point to there being two
different implementations.

[rkc, 2016/04/14 21:59:38]

We can have two implementations by branching based on the value of the is_local_
variable.

                              const base::Closure& callback,
                              const ErrorCallback& error_callback) override;
 
   // Object path of the underlying D-Bus characteristic.
   const dbus::ObjectPath& object_path() const { return object_path_; }
 
  private:
   friend class BluetoothRemoteGattCharacteristicBlueZ;
 
-  BluetoothRemoteGattDescriptorBlueZ(
-      BluetoothRemoteGattCharacteristicBlueZ* characteristic,
-      const dbus::ObjectPath& object_path);
-  ~BluetoothRemoteGattDescriptorBlueZ() override;
+  BluetoothGattDescriptorBlueZ(BluetoothGattCharacteristicBlueZ* characteristic,
+                               const dbus::ObjectPath& object_path,
+                               bool is_local);
+  ~BluetoothGattDescriptorBlueZ() override;
 
   // Called by dbus:: on unsuccessful completion of a request to read or write
   // the descriptor value.
   void OnError(const ErrorCallback& error_callback,
                const std::string& error_name,
                const std::string& error_message);
 
   // Object path of the D-Bus descriptor object.
   dbus::ObjectPath object_path_;
 
   // The GATT characteristic this descriptor belongs to.
-  BluetoothRemoteGattCharacteristicBlueZ* characteristic_;
+  BluetoothGattCharacteristicBlueZ* characteristic_;
+
+  // Is this a remote or local descriptor.
+  bool is_local_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
-  base::WeakPtrFactory<BluetoothRemoteGattDescriptorBlueZ> weak_ptr_factory_;
+  base::WeakPtrFactory<BluetoothGattDescriptorBlueZ> weak_ptr_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(BluetoothRemoteGattDescriptorBlueZ);
+  DISALLOW_COPY_AND_ASSIGN(BluetoothGattDescriptorBlueZ);
 };
 
 }  // namespace bluez
 
-#endif  // DEVICE_BLUETOOTH_BLUETOOTH_REMOTE_GATT_DESCRIPTOR_BLUEZ_H_
+#endif  // DEVICE_BLUETOOTH_BLUETOOTH_GATT_DESCRIPTOR_BLUEZ_H_