chromeos/dbus: Update Bluetooth GATT API clients to upstream definition

device/bluetooth/bluetooth_remote_gatt_characteristic_chromeos.cc

 // 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.
 
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic_chromeos.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "device/bluetooth/bluetooth_adapter_chromeos.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_gatt_notify_session_chromeos.h"
+#include "device/bluetooth/bluetooth_remote_gatt_characteristic_chromeos.h"
 #include "device/bluetooth/bluetooth_remote_gatt_descriptor_chromeos.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service_chromeos.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 // Stream operator for logging vector<uint8>.
 std::ostream& operator<<(std::ostream& out, const std::vector<uint8> bytes) {
@@ skipping 11 matching lines @@
     BluetoothRemoteGattCharacteristicChromeOS(
         BluetoothRemoteGattServiceChromeOS* service,
         const dbus::ObjectPath& object_path)
     : object_path_(object_path),
       service_(service),
       num_notify_sessions_(0),
       notify_call_pending_(false),
       weak_ptr_factory_(this) {
   VLOG(1) << "Creating remote GATT characteristic with identifier: "
           << GetIdentifier() << ", UUID: " << GetUUID().canonical_value();
-  DBusThreadManager::Get()->GetBluetoothGattCharacteristicClient()->
-      AddObserver(this);
   DBusThreadManager::Get()->GetBluetoothGattDescriptorClient()->
       AddObserver(this);
 
   // Add all known GATT characteristic descriptors.
   const std::vector<dbus::ObjectPath>& gatt_descs =
       DBusThreadManager::Get()->GetBluetoothGattDescriptorClient()->
           GetDescriptors();
   for (std::vector<dbus::ObjectPath>::const_iterator iter = gatt_descs.begin();
        iter != gatt_descs.end(); ++iter)
     GattDescriptorAdded(*iter);
 }
 
 BluetoothRemoteGattCharacteristicChromeOS::
     ~BluetoothRemoteGattCharacteristicChromeOS() {
   DBusThreadManager::Get()->GetBluetoothGattDescriptorClient()->
       RemoveObserver(this);
-  DBusThreadManager::Get()->GetBluetoothGattCharacteristicClient()->
-      RemoveObserver(this);
 
   // Clean up all the descriptors. There isn't much point in notifying service
   // observers for each descriptor that gets removed, so just delete them.
   for (DescriptorMap::iterator iter = descriptors_.begin();
        iter != descriptors_.end(); ++iter)
     delete iter->second;
 
   // Report an error for all pending calls to StartNotifySession.
   while (!pending_start_notify_calls_.empty()) {
     PendingStartNotifyCall callbacks = pending_start_notify_calls_.front();
@@ skipping 14 matching lines @@
   DCHECK(properties);
   return device::BluetoothUUID(properties->uuid.value());
 }
 
 bool BluetoothRemoteGattCharacteristicChromeOS::IsLocal() const {
   return false;
 }
 
 const std::vector<uint8>&
 BluetoothRemoteGattCharacteristicChromeOS::GetValue() const {
-  return cached_value_;
+  BluetoothGattCharacteristicClient::Properties* properties =
+      DBusThreadManager::Get()
+          ->GetBluetoothGattCharacteristicClient()
+          ->GetProperties(object_path_);
+
+  DCHECK(properties);
+
+  return properties->value.value();
 }
 
 device::BluetoothGattService*
 BluetoothRemoteGattCharacteristicChromeOS::GetService() const {
   return service_;
 }
 
 device::BluetoothGattCharacteristic::Properties
 BluetoothRemoteGattCharacteristicChromeOS::GetProperties() const {
   BluetoothGattCharacteristicClient::Properties* properties =
@@ skipping 80 matching lines @@
 }
 
 void BluetoothRemoteGattCharacteristicChromeOS::ReadRemoteCharacteristic(
     const ValueCallback& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << "Sending GATT characteristic read request to characteristic: "
           << GetIdentifier() << ", UUID: " << GetUUID().canonical_value()
           << ".";
 
   DBusThreadManager::Get()->GetBluetoothGattCharacteristicClient()->ReadValue(
-      object_path_,
-      base::Bind(&BluetoothRemoteGattCharacteristicChromeOS::OnValueSuccess,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 callback),
+      object_path_, callback,
       base::Bind(&BluetoothRemoteGattCharacteristicChromeOS::OnError,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 error_callback));
+                 weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 void BluetoothRemoteGattCharacteristicChromeOS::WriteRemoteCharacteristic(
     const std::vector<uint8>& new_value,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << "Sending GATT characteristic write request to characteristic: "
           << GetIdentifier() << ", UUID: " << GetUUID().canonical_value()
           << ", with value: " << new_value << ".";
 
@@ skipping 90 matching lines @@
       object_path_,
       base::Bind(
           &BluetoothRemoteGattCharacteristicChromeOS::OnStopNotifySuccess,
           weak_ptr_factory_.GetWeakPtr(),
           callback),
       base::Bind(&BluetoothRemoteGattCharacteristicChromeOS::OnStopNotifyError,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
-void BluetoothRemoteGattCharacteristicChromeOS::GattCharacteristicValueUpdated(
-    const dbus::ObjectPath& object_path,
-    const std::vector<uint8>& value) {
-  if (object_path != object_path_)
-    return;
-
-  cached_value_ = value;
-
-  VLOG(1) << "GATT characteristic value has changed: " << object_path.value()
-          << ": " << value;
-  DCHECK(service_);
-  service_->NotifyCharacteristicValueChanged(this, value);
-}
-
 void BluetoothRemoteGattCharacteristicChromeOS::GattDescriptorAdded(
     const dbus::ObjectPath& object_path) {
   if (descriptors_.find(object_path) != descriptors_.end()) {
     VLOG(1) << "Remote GATT characteristic descriptor already exists: "
             << object_path.value();
     return;
   }
 
   BluetoothGattDescriptorClient::Properties* properties =
       DBusThreadManager::Get()->GetBluetoothGattDescriptorClient()->
@@ skipping 31 matching lines @@
   BluetoothRemoteGattDescriptorChromeOS* descriptor = iter->second;
   DCHECK(descriptor->object_path() == object_path);
   descriptors_.erase(iter);
 
   DCHECK(service_);
   service_->NotifyDescriptorAddedOrRemoved(this, descriptor, false /* added */);
 
   delete descriptor;
 }
 
-void BluetoothRemoteGattCharacteristicChromeOS::OnValueSuccess(
-    const ValueCallback& callback,
-    const std::vector<uint8>& value) {
-  VLOG(1) << "Characteristic value read: " << value;
-  cached_value_ = value;
+void BluetoothRemoteGattCharacteristicChromeOS::GattDescriptorPropertyChanged(
+    const dbus::ObjectPath& object_path,
+    const std::string& property_name) {
+  DescriptorMap::iterator iter = descriptors_.find(object_path);
+  if (iter == descriptors_.end()) {
+    VLOG(2) << "Unknown descriptor removed: " << object_path.value();
+    return;
+  }
+
+  BluetoothGattDescriptorClient::Properties* properties =
+      DBusThreadManager::Get()
+          ->GetBluetoothGattDescriptorClient()
+          ->GetProperties(object_path);
+
+  DCHECK(properties);
+
+  if (property_name != properties->value.name())
+    return;
 
   DCHECK(service_);
-  service_->NotifyCharacteristicValueChanged(this, cached_value_);
-
-  callback.Run(value);
+  service_->NotifyDescriptorValueChanged(this, iter->second,
+                                         properties->value.value());
 }
 
 void BluetoothRemoteGattCharacteristicChromeOS::OnError(
     const ErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   VLOG(1) << "Operation failed: " << error_name << ", message: "
           << error_message;
   error_callback.Run(
       BluetoothRemoteGattServiceChromeOS::DBusErrorToServiceError(error_name));
@@ skipping 68 matching lines @@
 
 void BluetoothRemoteGattCharacteristicChromeOS::ProcessStartNotifyQueue() {
   while (!pending_start_notify_calls_.empty()) {
     PendingStartNotifyCall callbacks = pending_start_notify_calls_.front();
     pending_start_notify_calls_.pop();
     StartNotifySession(callbacks.first, callbacks.second);
   }
 }
 
 }  // namespace chromeos