Bluetooth class changes for implementing local GATT attributes.

device/bluetooth/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 "device/bluetooth/dbus/fake_bluetooth_gatt_characteristic_client.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 116 matching lines @@
     return heart_rate_control_point_properties_.get();
   }
   return NULL;
 }
 
 void FakeBluetoothGattCharacteristicClient::ReadValue(
     const dbus::ObjectPath& object_path,
     const ValueCallback& callback,
     const ErrorCallback& error_callback) {
   if (!authenticated_) {
-    error_callback.Run("org.bluez.Error.NotPaired", "Please login");
+    error_callback.Run(bluetooth_gatt_service::kErrorNotPaired, "Please login");
     return;
   }
 
   if (!authorized_) {
-    error_callback.Run("org.bluez.Error.NotAuthorized", "Authorize first");
+    error_callback.Run(bluetooth_gatt_service::kErrorNotAuthorized,
+                       "Authorize first");
     return;
   }
 
   if (object_path.value() == heart_rate_control_point_path_) {
-    error_callback.Run("org.bluez.Error.NotPermitted",
+    error_callback.Run(bluetooth_gatt_service::kErrorReadNotPermitted,
                        "Reads of this value are not allowed");
     return;
   }
 
   if (object_path.value() == heart_rate_measurement_path_) {
-    error_callback.Run("org.bluez.Error.NotSupported",
+    error_callback.Run(bluetooth_gatt_service::kErrorNotSupported,
                        "Action not supported on this characteristic");
     return;
   }
 
   if (object_path.value() != body_sensor_location_path_) {
     error_callback.Run(kUnknownCharacteristicError, "");
     return;
   }
 
   if (action_extra_requests_.find("ReadValue") !=
       action_extra_requests_.end()) {
     DelayedCallback* delayed = action_extra_requests_["ReadValue"];
     delayed->delay_--;
-    error_callback.Run("org.bluez.Error.InProgress",
+    error_callback.Run(bluetooth_gatt_service::kErrorInProgress,
                        "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;
@@ skipping 15 matching lines @@
 
   completed_callback.Run();
 }
 
 void FakeBluetoothGattCharacteristicClient::WriteValue(
     const dbus::ObjectPath& object_path,
     const std::vector<uint8_t>& value,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   if (!authenticated_) {
-    error_callback.Run("org.bluez.Error.NotPaired", "Please login");
+    error_callback.Run(bluetooth_gatt_service::kErrorNotPaired, "Please login");
     return;
   }
 
   if (!authorized_) {
-    error_callback.Run("org.bluez.Error.NotAuthorized", "Authorize first");
+    error_callback.Run(bluetooth_gatt_service::kErrorNotAuthorized,
+                       "Authorize first");
     return;
   }
 
   if (!IsHeartRateVisible()) {
     error_callback.Run(kUnknownCharacteristicError, "");
     return;
   }
 
   if (object_path.value() == heart_rate_measurement_path_) {
-    error_callback.Run("org.bluez.Error.NotSupported",
+    error_callback.Run(bluetooth_gatt_service::kErrorNotSupported,
                        "Action not supported on this characteristic");
     return;
   }
 
   if (object_path.value() != heart_rate_control_point_path_) {
-    error_callback.Run("org.bluez.Error.NotPermitted",
+    error_callback.Run(bluetooth_gatt_service::kErrorWriteNotPermitted,
                        "Writes of this value are not allowed");
     return;
   }
 
   DCHECK(heart_rate_control_point_properties_.get());
   if (action_extra_requests_.find("WriteValue") !=
       action_extra_requests_.end()) {
     DelayedCallback* delayed = action_extra_requests_["WriteValue"];
     delayed->delay_--;
-    error_callback.Run("org.bluez.Error.InProgress",
+    error_callback.Run(bluetooth_gatt_service::kErrorInProgress,
                        "Another write is in progress");
     if (delayed->delay_ == 0) {
       delayed->callback_.Run();
       action_extra_requests_.erase("WriteValue");
       delete delayed;
     }
     return;
   }
   base::Closure completed_callback;
   if (value.size() != 1) {
+    completed_callback = base::Bind(
+        error_callback, bluetooth_gatt_service::kErrorInvalidValueLength,
+        "Invalid length for write");
+  } else if (value[0] > 1) {
     completed_callback =
-        base::Bind(error_callback, "org.bluez.Error.InvalidValueLength",
-                   "Invalid length for write");
-  } else if (value[0] > 1) {
-    completed_callback = base::Bind(error_callback, "org.bluez.Error.Failed",
-                                    "Invalid value given for write");
+        base::Bind(error_callback, bluetooth_gatt_service::kErrorFailed,
+                   "Invalid value given for write");
   } else if (value[0] == 1) {
     // TODO(jamuraa): make this happen when the callback happens
     calories_burned_ = 0;
     completed_callback = callback;
   }
 
   if (extra_requests_ > 0) {
     action_extra_requests_["WriteValue"] =
         new DelayedCallback(completed_callback, extra_requests_);
     return;
   }
   completed_callback.Run();
 }
 
 void FakeBluetoothGattCharacteristicClient::StartNotify(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   if (!IsHeartRateVisible()) {
     error_callback.Run(kUnknownCharacteristicError, "");
     return;
   }
 
   if (object_path.value() != heart_rate_measurement_path_) {
-    error_callback.Run("org.bluez.Error.NotSupported",
+    error_callback.Run(bluetooth_gatt_service::kErrorNotSupported,
                        "This characteristic does not support notifications");
     return;
   }
 
   if (heart_rate_measurement_properties_->notifying.value()) {
-    error_callback.Run("org.bluez.Error.InProgress",
+    error_callback.Run(bluetooth_gatt_service::kErrorInProgress,
                        "Characteristic already notifying");
     return;
   }
 
   heart_rate_measurement_properties_->notifying.ReplaceValue(true);
   ScheduleHeartRateMeasurementValueChange();
 
   // Respond asynchronously.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, callback,
       base::TimeDelta::FromMilliseconds(kStartNotifyResponseIntervalMs));
 }
 
 void FakeBluetoothGattCharacteristicClient::StopNotify(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   if (!IsHeartRateVisible()) {
     error_callback.Run(kUnknownCharacteristicError, "");
     return;
   }
 
   if (object_path.value() != heart_rate_measurement_path_) {
-    error_callback.Run("org.bluez.Error.NotSupported",
+    error_callback.Run(bluetooth_gatt_service::kErrorNotSupported,
                        "This characteristic does not support notifications");
     return;
   }
 
   if (!heart_rate_measurement_properties_->notifying.value()) {
-    error_callback.Run("org.bluez.Error.Failed", "Not notifying");
+    error_callback.Run(bluetooth_gatt_service::kErrorFailed, "Not notifying");
     return;
   }
 
   heart_rate_measurement_properties_->notifying.ReplaceValue(false);
 
   callback.Run();
 }
 
 void FakeBluetoothGattCharacteristicClient::ExposeHeartRateCharacteristics(
     const dbus::ObjectPath& service_path) {
@@ skipping 231 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 bluez