DBus support for attribute properties and permissions.

device/bluetooth/dbus/bluetooth_gatt_descriptor_service_provider_impl.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 "device/bluetooth/dbus/bluetooth_gatt_descriptor_service_provider_impl.h"
 
-#include <stddef.h>
+#include <cstddef>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace bluez {
 
 namespace {
 
 const char kErrorInvalidArgs[] = "org.freedesktop.DBus.Error.InvalidArgs";
 const char kErrorPropertyReadOnly[] =
     "org.freedesktop.DBus.Error.PropertyReadOnly";
 const char kErrorFailed[] = "org.freedesktop.DBus.Error.Failed";
 
 }  // namespace
 
 // The BluetoothGattDescriptorServiceProvider implementation used in production.
 BluetoothGattDescriptorServiceProviderImpl::
     BluetoothGattDescriptorServiceProviderImpl(
         dbus::Bus* bus,
         const dbus::ObjectPath& object_path,
         std::unique_ptr<BluetoothGattAttributeValueDelegate> delegate,
         const std::string& uuid,
-        const std::vector<std::string>& permissions,
+        const std::vector<std::string>& flags,
         const dbus::ObjectPath& characteristic_path)
     : origin_thread_id_(base::PlatformThread::CurrentId()),
       uuid_(uuid),
+      flags_(flags),
       bus_(bus),
       delegate_(std::move(delegate)),
       object_path_(object_path),
       characteristic_path_(characteristic_path),
       weak_ptr_factory_(this) {
   VLOG(1) << "Created Bluetooth GATT characteristic descriptor: "
           << object_path.value() << " UUID: " << uuid;
-  DCHECK(bus_);
+
+  // If we have a null bus, this means that this is being initialized for a
+  // test, hence we shouldn't do any other setup.
+  if (!bus_)
+    return;
+
   DCHECK(delegate_);
   DCHECK(!uuid_.empty());
   DCHECK(object_path_.IsValid());
   DCHECK(characteristic_path_.IsValid());
   DCHECK(base::StartsWith(object_path_.value(),
                           characteristic_path_.value() + "/",
                           base::CompareCase::SENSITIVE));
 
   exported_object_ = bus_->GetExportedObject(object_path_);
 
@@ skipping 20 matching lines @@
 }
 
 BluetoothGattDescriptorServiceProviderImpl::
     ~BluetoothGattDescriptorServiceProviderImpl() {
   VLOG(1) << "Cleaning up Bluetooth GATT characteristic descriptor: "
           << object_path_.value();
   if (bus_)
     bus_->UnregisterExportedObject(object_path_);
 }
 
-BluetoothGattDescriptorServiceProviderImpl::
-    BluetoothGattDescriptorServiceProviderImpl(
-        const dbus::ObjectPath& object_path,
-        const std::string& uuid,
-        const dbus::ObjectPath& characteristic_path)
-    : origin_thread_id_(base::PlatformThread::CurrentId()),
-      uuid_(uuid),
-      bus_(nullptr),
-      delegate_(nullptr),
-      object_path_(object_path),
-      characteristic_path_(characteristic_path),
-      weak_ptr_factory_(this) {}
-
 void BluetoothGattDescriptorServiceProviderImpl::SendValueChanged(
     const std::vector<uint8_t>& value) {
   VLOG(2) << "Emitting a PropertiesChanged signal for descriptor value.";
   dbus::Signal signal(dbus::kDBusPropertiesInterface,
                       dbus::kDBusPropertiesChangedSignal);
   dbus::MessageWriter writer(&signal);
   dbus::MessageWriter array_writer(NULL);
   dbus::MessageWriter dict_entry_writer(NULL);
   dbus::MessageWriter variant_writer(NULL);
 
@@ skipping 64 matching lines @@
                    weak_ptr_factory_.GetWeakPtr(), method_call,
                    response_sender));
     return;
   }
 
   std::unique_ptr<dbus::Response> response =
       dbus::Response::FromMethodCall(method_call);
   dbus::MessageWriter writer(response.get());
   dbus::MessageWriter variant_writer(NULL);
 
-  // TODO(armansito): Process the "Permissions" property below.
   if (property_name == bluetooth_gatt_descriptor::kUUIDProperty) {
     writer.OpenVariant("s", &variant_writer);
     variant_writer.AppendString(uuid_);
     writer.CloseContainer(&variant_writer);
   } else if (property_name ==
              bluetooth_gatt_descriptor::kCharacteristicProperty) {
     writer.OpenVariant("o", &variant_writer);
     variant_writer.AppendObjectPath(characteristic_path_);
     writer.CloseContainer(&variant_writer);
+  } else if (property_name == bluetooth_gatt_descriptor::kFlagsProperty) {
+    writer.OpenVariant("as", &variant_writer);
+    variant_writer.AppendArrayOfStrings(flags_);
+    writer.CloseContainer(&variant_writer);
   } else {
     response = dbus::ErrorResponse::FromMethodCall(
         method_call, kErrorInvalidArgs,
         "No such property: '" + property_name + "'.");
   }
 
   response_sender.Run(std::move(response));
 }
 
 void BluetoothGattDescriptorServiceProviderImpl::Set(
@@ skipping 133 matching lines @@
 
 void BluetoothGattDescriptorServiceProviderImpl::WriteProperties(
     dbus::MessageWriter* writer,
     const std::vector<uint8_t>* value) {
   dbus::MessageWriter array_writer(NULL);
   dbus::MessageWriter dict_entry_writer(NULL);
   dbus::MessageWriter variant_writer(NULL);
 
   writer->OpenArray("{sv}", &array_writer);
 
+  // UUID:
   array_writer.OpenDictEntry(&dict_entry_writer);
   dict_entry_writer.AppendString(bluetooth_gatt_descriptor::kUUIDProperty);
   dict_entry_writer.AppendVariantOfString(uuid_);
   array_writer.CloseContainer(&dict_entry_writer);
 
+  // Characteristic:
   array_writer.OpenDictEntry(&dict_entry_writer);
   dict_entry_writer.AppendString(
       bluetooth_gatt_descriptor::kCharacteristicProperty);
   dict_entry_writer.AppendVariantOfObjectPath(characteristic_path_);
   array_writer.CloseContainer(&dict_entry_writer);
 
   if (value) {
+    // Value:
     array_writer.OpenDictEntry(&dict_entry_writer);
     dict_entry_writer.AppendString(bluetooth_gatt_descriptor::kValueProperty);
     dict_entry_writer.OpenVariant("ay", &variant_writer);
     variant_writer.AppendArrayOfBytes(value->data(), value->size());
     dict_entry_writer.CloseContainer(&variant_writer);
     array_writer.CloseContainer(&dict_entry_writer);
   }
 
-  // TODO(armansito): Process "Permissions" property.
+  // Flags:
+  array_writer.OpenDictEntry(&dict_entry_writer);
+  dict_entry_writer.AppendString(bluetooth_gatt_descriptor::kFlagsProperty);
+  dict_entry_writer.OpenVariant("as", &variant_writer);
+  variant_writer.AppendArrayOfStrings(flags_);
+  dict_entry_writer.CloseContainer(&variant_writer);
+  array_writer.CloseContainer(&dict_entry_writer);
+
   writer->CloseContainer(&array_writer);
 }
 
 // Called by the Delegate in response to a successful method call to get the
 // descriptor value.
 void BluetoothGattDescriptorServiceProviderImpl::OnGet(
     dbus::MethodCall* method_call,
     dbus::ExportedObject::ResponseSender response_sender,
     const std::vector<uint8_t>& value) {
   VLOG(2) << "Returning descriptor value obtained from delegate.";
@@ skipping 25 matching lines @@
           method_call, kErrorFailed, "Failed to get/set descriptor value.");
   response_sender.Run(std::move(error_response));
 }
 
 const dbus::ObjectPath&
 BluetoothGattDescriptorServiceProviderImpl::object_path() const {
   return object_path_;
 }
 
 }  // namespace bluez