Refactor DBusThreadManager to split away BT clients.

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 "chromeos/dbus/fake_bluetooth_gatt_characteristic_client.h"
+#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"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/fake_bluetooth_gatt_descriptor_client.h"
+#include "device/bluetooth/dbus/bluez_dbus_manager.h"
+#include "device/bluetooth/dbus/fake_bluetooth_gatt_descriptor_client.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
-namespace chromeos {
+namespace bluez {
 
 namespace {
 
 const int kStartNotifyResponseIntervalMs = 200;
 const int kHeartRateMeasurementNotificationIntervalMs = 2000;
 
 }  // namespace
 
 FakeBluetoothGattCharacteristicClient::DelayedCallback::DelayedCallback(
     base::Closure callback,
     size_t delay)
-    : callback_(callback), delay_(delay) {
-}
+    : callback_(callback), delay_(delay) {}
 
-FakeBluetoothGattCharacteristicClient::DelayedCallback::~DelayedCallback() {
-}
+FakeBluetoothGattCharacteristicClient::DelayedCallback::~DelayedCallback() {}
 
 // static
 const char FakeBluetoothGattCharacteristicClient::
     kHeartRateMeasurementPathComponent[] = "char0000";
-const char FakeBluetoothGattCharacteristicClient::
-    kBodySensorLocationPathComponent[] = "char0001";
+const char
+    FakeBluetoothGattCharacteristicClient::kBodySensorLocationPathComponent[] =
+        "char0001";
 const char FakeBluetoothGattCharacteristicClient::
     kHeartRateControlPointPathComponent[] = "char0002";
 
 // static
 const char FakeBluetoothGattCharacteristicClient::kHeartRateMeasurementUUID[] =
     "00002a37-0000-1000-8000-00805f9b34fb";
 const char FakeBluetoothGattCharacteristicClient::kBodySensorLocationUUID[] =
     "00002a38-0000-1000-8000-00805f9b34fb";
 const char FakeBluetoothGattCharacteristicClient::kHeartRateControlPointUUID[] =
     "00002a39-0000-1000-8000-00805f9b34fb";
 
 FakeBluetoothGattCharacteristicClient::Properties::Properties(
     const PropertyChangedCallback& callback)
     : BluetoothGattCharacteristicClient::Properties(
           NULL,
           bluetooth_gatt_characteristic::kBluetoothGattCharacteristicInterface,
-          callback) {
-}
+          callback) {}
 
-FakeBluetoothGattCharacteristicClient::Properties::~Properties() {
-}
+FakeBluetoothGattCharacteristicClient::Properties::~Properties() {}
 
 void FakeBluetoothGattCharacteristicClient::Properties::Get(
     dbus::PropertyBase* property,
     dbus::PropertySet::GetCallback callback) {
   VLOG(1) << "Get " << property->name();
   callback.Run(true);
 }
 
 void FakeBluetoothGattCharacteristicClient::Properties::GetAll() {
   VLOG(1) << "GetAll";
 }
 
 void FakeBluetoothGattCharacteristicClient::Properties::Set(
     dbus::PropertyBase* property,
     dbus::PropertySet::SetCallback callback) {
   VLOG(1) << "Set " << property->name();
   callback.Run(false);
 }
 
 FakeBluetoothGattCharacteristicClient::FakeBluetoothGattCharacteristicClient()
     : heart_rate_visible_(false),
       authorized_(true),
       authenticated_(true),
       calories_burned_(0),
       extra_requests_(0),
-      weak_ptr_factory_(this) {
-}
+      weak_ptr_factory_(this) {}
 
 FakeBluetoothGattCharacteristicClient::
     ~FakeBluetoothGattCharacteristicClient() {
   for (const auto& it : action_extra_requests_) {
     delete it.second;
   }
   action_extra_requests_.clear();
 }
 
-void FakeBluetoothGattCharacteristicClient::Init(dbus::Bus* bus) {
-}
+void FakeBluetoothGattCharacteristicClient::Init(dbus::Bus* bus) {}
 
 void FakeBluetoothGattCharacteristicClient::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void FakeBluetoothGattCharacteristicClient::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 std::vector<dbus::ObjectPath>
@@ skipping 131 matching lines @@
                        "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,
-                                    "org.bluez.Error.InvalidValueLength",
-                                    "Invalid length for write");
+    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",
+    completed_callback = base::Bind(error_callback, "org.bluez.Error.Failed",
                                     "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_);
@@ skipping 64 matching lines @@
     return;
   }
 
   VLOG(2) << "Exposing fake Heart Rate characteristics.";
 
   std::vector<std::string> flags;
 
   // ==== Heart Rate Measurement Characteristic ====
   heart_rate_measurement_path_ =
       service_path.value() + "/" + kHeartRateMeasurementPathComponent;
-  heart_rate_measurement_properties_.reset(new Properties(base::Bind(
-      &FakeBluetoothGattCharacteristicClient::OnPropertyChanged,
-      weak_ptr_factory_.GetWeakPtr(),
-      dbus::ObjectPath(heart_rate_measurement_path_))));
+  heart_rate_measurement_properties_.reset(new Properties(
+      base::Bind(&FakeBluetoothGattCharacteristicClient::OnPropertyChanged,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 dbus::ObjectPath(heart_rate_measurement_path_))));
   heart_rate_measurement_properties_->uuid.ReplaceValue(
       kHeartRateMeasurementUUID);
   heart_rate_measurement_properties_->service.ReplaceValue(service_path);
   flags.push_back(bluetooth_gatt_characteristic::kFlagNotify);
   heart_rate_measurement_properties_->flags.ReplaceValue(flags);
 
   // ==== Body Sensor Location Characteristic ====
   body_sensor_location_path_ =
       service_path.value() + "/" + kBodySensorLocationPathComponent;
-  body_sensor_location_properties_.reset(new Properties(base::Bind(
-      &FakeBluetoothGattCharacteristicClient::OnPropertyChanged,
-      weak_ptr_factory_.GetWeakPtr(),
-      dbus::ObjectPath(body_sensor_location_path_))));
+  body_sensor_location_properties_.reset(new Properties(
+      base::Bind(&FakeBluetoothGattCharacteristicClient::OnPropertyChanged,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 dbus::ObjectPath(body_sensor_location_path_))));
   body_sensor_location_properties_->uuid.ReplaceValue(kBodySensorLocationUUID);
   body_sensor_location_properties_->service.ReplaceValue(service_path);
   flags.clear();
   flags.push_back(bluetooth_gatt_characteristic::kFlagRead);
   body_sensor_location_properties_->flags.ReplaceValue(flags);
 
   // ==== Heart Rate Control Point Characteristic ====
   heart_rate_control_point_path_ =
       service_path.value() + "/" + kHeartRateControlPointPathComponent;
-  heart_rate_control_point_properties_.reset(new Properties(base::Bind(
-      &FakeBluetoothGattCharacteristicClient::OnPropertyChanged,
-      weak_ptr_factory_.GetWeakPtr(),
-      dbus::ObjectPath(heart_rate_control_point_path_))));
+  heart_rate_control_point_properties_.reset(new Properties(
+      base::Bind(&FakeBluetoothGattCharacteristicClient::OnPropertyChanged,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 dbus::ObjectPath(heart_rate_control_point_path_))));
   heart_rate_control_point_properties_->uuid.ReplaceValue(
       kHeartRateControlPointUUID);
   heart_rate_control_point_properties_->service.ReplaceValue(service_path);
   flags.clear();
   flags.push_back(bluetooth_gatt_characteristic::kFlagWrite);
   heart_rate_control_point_properties_->flags.ReplaceValue(flags);
 
   heart_rate_visible_ = true;
 
   NotifyCharacteristicAdded(dbus::ObjectPath(heart_rate_measurement_path_));
   NotifyCharacteristicAdded(dbus::ObjectPath(body_sensor_location_path_));
   NotifyCharacteristicAdded(dbus::ObjectPath(heart_rate_control_point_path_));
 
   // Expose CCC descriptor for Heart Rate Measurement characteristic.
   FakeBluetoothGattDescriptorClient* descriptor_client =
       static_cast<FakeBluetoothGattDescriptorClient*>(
-          DBusThreadManager::Get()->GetBluetoothGattDescriptorClient());
+          bluez::BluezDBusManager::Get()->GetBluetoothGattDescriptorClient());
   dbus::ObjectPath ccc_path(descriptor_client->ExposeDescriptor(
       dbus::ObjectPath(heart_rate_measurement_path_),
       FakeBluetoothGattDescriptorClient::
           kClientCharacteristicConfigurationUUID));
   DCHECK(ccc_path.IsValid());
   heart_rate_measurement_ccc_desc_path_ = ccc_path.value();
 
   std::vector<dbus::ObjectPath> desc_paths;
   desc_paths.push_back(ccc_path);
 
   heart_rate_measurement_properties_->descriptors.ReplaceValue(desc_paths);
 }
 
 void FakeBluetoothGattCharacteristicClient::HideHeartRateCharacteristics() {
   VLOG(2) << "Hiding fake Heart Rate characteristics.";
 
   // Hide the descriptors.
   FakeBluetoothGattDescriptorClient* descriptor_client =
       static_cast<FakeBluetoothGattDescriptorClient*>(
-          DBusThreadManager::Get()->GetBluetoothGattDescriptorClient());
+          bluez::BluezDBusManager::Get()->GetBluetoothGattDescriptorClient());
   descriptor_client->HideDescriptor(
       dbus::ObjectPath(heart_rate_measurement_ccc_desc_path_));
 
   // Notify the observers before deleting the properties structures so that they
   // can be accessed from the observer method.
   NotifyCharacteristicRemoved(dbus::ObjectPath(heart_rate_measurement_path_));
   NotifyCharacteristicRemoved(dbus::ObjectPath(body_sensor_location_path_));
   NotifyCharacteristicRemoved(dbus::ObjectPath(heart_rate_control_point_path_));
 
   heart_rate_measurement_properties_.reset();
@@ skipping 35 matching lines @@
 }
 
 dbus::ObjectPath
 FakeBluetoothGattCharacteristicClient::GetHeartRateControlPointPath() const {
   return dbus::ObjectPath(heart_rate_control_point_path_);
 }
 
 void FakeBluetoothGattCharacteristicClient::OnPropertyChanged(
     const dbus::ObjectPath& object_path,
     const std::string& property_name) {
-  VLOG(2) << "Characteristic property changed: " << object_path.value()
-          << ": " << property_name;
+  VLOG(2) << "Characteristic property changed: " << object_path.value() << ": "
+          << property_name;
 
-  FOR_EACH_OBSERVER(BluetoothGattCharacteristicClient::Observer, observers_,
-                    GattCharacteristicPropertyChanged(
-                        object_path, property_name));
+  FOR_EACH_OBSERVER(
+      BluetoothGattCharacteristicClient::Observer, observers_,
+      GattCharacteristicPropertyChanged(object_path, property_name));
 }
 
 void FakeBluetoothGattCharacteristicClient::NotifyCharacteristicAdded(
     const dbus::ObjectPath& object_path) {
   VLOG(2) << "GATT characteristic added: " << object_path.value();
   FOR_EACH_OBSERVER(BluetoothGattCharacteristicClient::Observer, observers_,
                     GattCharacteristicAdded(object_path));
 }
 
 void FakeBluetoothGattCharacteristicClient::NotifyCharacteristicRemoved(
@@ skipping 61 matching lines @@
 
   // Pick a value between 117 bpm and 153 bpm for heart rate.
   value.bpm = static_cast<uint8>(base::RandInt(117, 153));
 
   // Total calories burned in kJoules since the last reset. Increment this by 1
   // every time. It's fine if it overflows: it becomes 0 when the user resets
   // the heart rate monitor (or pretend that he had a lot of cheeseburgers).
   value.energy_expanded = calories_burned_++;
 
   // Include one RR-Interval value, in seconds.
-  value.rr_interval = 60/value.bpm;
+  value.rr_interval = 60 / value.bpm;
 
   // Return the bytes in an array.
   uint8* bytes = reinterpret_cast<uint8*>(&value);
   std::vector<uint8> return_value;
   return_value.assign(bytes, bytes + sizeof(value));
   return return_value;
 }
 
 bool FakeBluetoothGattCharacteristicClient::IsHeartRateVisible() const {
   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
+}  // namespace bluez