bluetooth: Create stub manager, adapter and device.

chromeos/dbus/bluetooth_device_client.cc

 // Copyright (c) 2012 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/bluetooth_device_client.h"
 
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "chromeos/dbus/bluetooth_adapter_client.h"
 #include "chromeos/dbus/bluetooth_property.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
-BluetoothDeviceClient::Properties::Properties(dbus::ObjectProxy* object_proxy,
-                                              PropertyChangedCallback callback)
+BluetoothDeviceClient::Properties::Properties(
+    dbus::ObjectProxy* object_proxy,
+    const PropertyChangedCallback& callback)
     : BluetoothPropertySet(object_proxy,
                            bluetooth_device::kBluetoothDeviceInterface,
                            callback) {
   RegisterProperty(bluetooth_device::kAddressProperty, &address);
   RegisterProperty(bluetooth_device::kNameProperty, &name);
   RegisterProperty(bluetooth_device::kVendorProperty, &vendor);
   RegisterProperty(bluetooth_device::kProductProperty, &product);
   RegisterProperty(bluetooth_device::kVersionProperty, &version);
   RegisterProperty(bluetooth_device::kIconProperty, &icon);
   RegisterProperty(bluetooth_device::kClassProperty, &bluetooth_class);
@@ skipping 422 matching lines @@
   // List of observers interested in event notifications from us.
   ObserverList<BluetoothDeviceClient::Observer> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothDeviceClientImpl);
 };
 
 // The BluetoothDeviceClient implementation used on Linux desktop, which does
 // nothing.
 class BluetoothDeviceClientStubImpl : public BluetoothDeviceClient {
  public:
+  struct Properties : public BluetoothDeviceClient::Properties {
+    explicit Properties(const PropertyChangedCallback& callback)
+        : BluetoothDeviceClient::Properties(NULL, callback) {
+    }
+
+    virtual ~Properties() {
+    }
+
+    virtual void Get(dbus::PropertyBase* property,
+                     dbus::PropertySet::GetCallback callback) OVERRIDE {
+      VLOG(1) << "Get " << property->name();
+      callback.Run(false);
+    }
+
+    virtual void GetAll() OVERRIDE {
+      VLOG(1) << "GetAll";
+    }
+
+    virtual void Set(dbus::PropertyBase *property,
+                     dbus::PropertySet::SetCallback callback) OVERRIDE {
+      VLOG(1) << "Set " << property->name();
+      callback.Run(false);
+    }
+  };
+
+  BluetoothDeviceClientStubImpl() {
+    dbus::ObjectPath dev0("/fake/hci0/dev0");
+
+    Properties* properties = new Properties(base::Bind(
+        &BluetoothDeviceClientStubImpl::OnPropertyChanged,
+        base::Unretained(this),
+        dev0));
+    properties->address.ReplaceValue("00:11:22:33:44:55");
+    properties->name.ReplaceValue("Fake Device");
+    properties->paired.ReplaceValue(true);
+    properties->trusted.ReplaceValue(true);
+
+    properties_map_[dev0] = properties;
+  }
+
+  virtual ~BluetoothDeviceClientStubImpl() {
+    // Clean up Properties structures
+    STLDeleteValues(&properties_map_);
+  }
+
   // BluetoothDeviceClient override.
   virtual void AddObserver(Observer* observer) OVERRIDE {
+    observers_.AddObserver(observer);
   }
 
   // BluetoothDeviceClient override.
   virtual void RemoveObserver(Observer* observer) OVERRIDE {
+    observers_.RemoveObserver(observer);
   }
 
   // BluetoothDeviceClient override.
   virtual Properties* GetProperties(const dbus::ObjectPath& object_path)
       OVERRIDE {
     VLOG(1) << "GetProperties: " << object_path.value();
+    PropertiesMap::iterator iter = properties_map_.find(object_path);
+    if (iter != properties_map_.end())
+      return iter->second;
     return NULL;
   }
 
   // BluetoothDeviceClient override.
   virtual void DiscoverServices(const dbus::ObjectPath& object_path,
                                 const std::string& pattern,
                                 const ServicesCallback& callback) OVERRIDE {
     VLOG(1) << "DiscoverServices: " << object_path.value() << " " << pattern;
 
     ServiceMap services;
@@ skipping 23 matching lines @@
   }
 
   // BluetoothDeviceClient override.
   virtual void RemoveNode(const dbus::ObjectPath& object_path,
                           const dbus::ObjectPath& node_path,
                           const DeviceCallback& callback) OVERRIDE {
     VLOG(1) << "RemoveNode: " << object_path.value()
             << " " << node_path.value();
     callback.Run(object_path, false);
   }
+
+ private:
+  void OnPropertyChanged(dbus::ObjectPath object_path,
+                         const std::string& property_name) {
+    FOR_EACH_OBSERVER(BluetoothDeviceClient::Observer, observers_,
+                      DevicePropertyChanged(object_path, property_name));
+  }
+
+  // List of observers interested in event notifications from us.
+  ObserverList<Observer> observers_;
+
+  // Static properties we typedef.
+  typedef std::map<const dbus::ObjectPath, Properties *> PropertiesMap;
+  PropertiesMap properties_map_;
 };
 
 BluetoothDeviceClient::BluetoothDeviceClient() {
 }
 
 BluetoothDeviceClient::~BluetoothDeviceClient() {
 }
 
 BluetoothDeviceClient* BluetoothDeviceClient::Create(
     DBusClientImplementationType type,
     dbus::Bus* bus,
     BluetoothAdapterClient* adapter_client) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new BluetoothDeviceClientImpl(bus, adapter_client);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new BluetoothDeviceClientStubImpl();
 }
 
 }  // namespace chromeos