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

chromeos/dbus/fake_bluetooth_gatt_characteristic_client.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 "chromeos/dbus/fake_bluetooth_gatt_characteristic_client.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "base/time/time.h"
@@ skipping 158 matching lines @@
     delayed->delay_--;
     error_callback.Run("org.bluez.Error.InProgress",
                        "Another read is currenty in progress");
     if (delayed->delay_ == 0) {
       delayed->callback_.Run();
       action_extra_requests_.erase("ReadValue");
       delete delayed;
     }
     return;
   }
+
   base::Closure completed_callback;
   if (!IsHeartRateVisible()) {
     completed_callback =
         base::Bind(error_callback, kUnknownCharacteristicError, "");
   } else {
-    std::vector<uint8> value;
-    value.push_back(0x06);  // Location is "foot".
-    completed_callback = base::Bind(callback, value);
+    std::vector<uint8> value = {0x06};  // Location is "foot".
+    completed_callback = base::Bind(
+        &FakeBluetoothGattCharacteristicClient::DelayedReadValueCallback,
+        weak_ptr_factory_.GetWeakPtr(), object_path, callback, value);
   }
 
   if (extra_requests_ > 0) {
     action_extra_requests_["ReadValue"] =
         new DelayedCallback(completed_callback, extra_requests_);
     return;
   }
+
   completed_callback.Run();
 }
 
 void FakeBluetoothGattCharacteristicClient::WriteValue(
     const dbus::ObjectPath& object_path,
     const std::vector<uint8>& value,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   if (!authenticated_) {
     error_callback.Run("org.bluez.Error.NotPaired", "Please login");
@@ skipping 277 matching lines @@
     ScheduleHeartRateMeasurementValueChange() {
   if (!IsHeartRateVisible())
     return;
 
   // Don't send updates if the characteristic is not notifying.
   if (!heart_rate_measurement_properties_->notifying.value())
     return;
 
   VLOG(2) << "Updating heart rate value.";
   std::vector<uint8> measurement = GetHeartRateMeasurementValue();
-
-  FOR_EACH_OBSERVER(
-      BluetoothGattCharacteristicClient::Observer,
-      observers_,
-      GattCharacteristicValueUpdated(
-          dbus::ObjectPath(heart_rate_measurement_path_), measurement));
+  heart_rate_measurement_properties_->value.ReplaceValue(measurement);
 
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeBluetoothGattCharacteristicClient::
                      ScheduleHeartRateMeasurementValueChange,
                  weak_ptr_factory_.GetWeakPtr()),
                  base::TimeDelta::FromMilliseconds(
                      kHeartRateMeasurementNotificationIntervalMs));
 }
 
+void FakeBluetoothGattCharacteristicClient::DelayedReadValueCallback(
+    const dbus::ObjectPath& object_path,
+    const ValueCallback& callback,
+    const std::vector<uint8_t>& value) {
+  Properties* properties = GetProperties(object_path);
+  DCHECK(properties);
+
+  properties->value.ReplaceValue(value);
+  callback.Run(value);
+}
+
 std::vector<uint8>
 FakeBluetoothGattCharacteristicClient::GetHeartRateMeasurementValue() {
   // TODO(armansito): We should make sure to properly pack this struct to ensure
   // correct byte alignment and endianness. It doesn't matter too much right now
   // as this is a fake and GCC on Linux seems to do the right thing.
   struct {
     uint8 flags;
     uint8 bpm;
     uint16 energy_expanded;
     uint16 rr_interval;
@@ skipping 33 matching lines @@
   DCHECK(heart_rate_visible_ != heart_rate_measurement_path_.empty());
   DCHECK(heart_rate_visible_ != body_sensor_location_path_.empty());
   DCHECK(heart_rate_visible_ != heart_rate_control_point_path_.empty());
   DCHECK(heart_rate_visible_ == !!heart_rate_measurement_properties_.get());
   DCHECK(heart_rate_visible_ == !!body_sensor_location_properties_.get());
   DCHECK(heart_rate_visible_ == !!heart_rate_control_point_properties_.get());
   return heart_rate_visible_;
 }
 
 }  // namespace chromeos