Add functionality to Bluetooth settings UI.

chromeos/dbus/fake_bluetooth_device_client.h

 // Copyright (c) 2013 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.
 
 #ifndef CHROMEOS_DBUS_FAKE_BLUETOOTH_DEVICE_CLIENT_H_
 #define CHROMEOS_DBUS_FAKE_BLUETOOTH_DEVICE_CLIENT_H_
 
 #include <map>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/containers/scoped_ptr_map.h"
 #include "base/observer_list.h"
 #include "chromeos/chromeos_export.h"
 #include "chromeos/dbus/bluetooth_agent_service_provider.h"
 #include "chromeos/dbus/bluetooth_device_client.h"
 #include "chromeos/dbus/bluetooth_profile_service_provider.h"
 #include "dbus/object_path.h"
 #include "dbus/property.h"
 
 namespace chromeos {
 
 // FakeBluetoothDeviceClient simulates the behavior of the Bluetooth Daemon
 // device objects and is used both in test cases in place of a mock and on
 // the Linux desktop.
 class CHROMEOS_EXPORT FakeBluetoothDeviceClient
     : public BluetoothDeviceClient {
  public:
   struct Properties : public BluetoothDeviceClient::Properties {
     explicit Properties(const PropertyChangedCallback & callback);
     ~Properties() override;
 
     // dbus::PropertySet override
     void Get(dbus::PropertyBase* property,
              dbus::PropertySet::GetCallback callback) override;
     void GetAll() override;
     void Set(dbus::PropertyBase* property,
              dbus::PropertySet::SetCallback callback) override;
   };
 
+  struct SimulatedPairingOptions {
+    std::string pairing_method;
+    std::string pairing_auth_token;
+  };
+
+  // Stores properties of a device that is about to be created.
+  struct IncomingDeviceProperties {
+    IncomingDeviceProperties();
+    ~IncomingDeviceProperties();
+
+    std::string device_name;
+    std::string device_alias;
+    std::string device_address;
+    std::string device_path;
+    std::string pairing_method;
+    std::string pairing_auth_token;
+    int device_class = 0;
+    bool is_trusted = true;
+  };
+
   FakeBluetoothDeviceClient();
   ~FakeBluetoothDeviceClient() override;
 
   // BluetoothDeviceClient overrides
   void Init(dbus::Bus* bus) override;
   void AddObserver(Observer* observer) override;
   void RemoveObserver(Observer* observer) override;
   std::vector<dbus::ObjectPath> GetDevicesForAdapter(
       const dbus::ObjectPath& adapter_path) override;
   Properties* GetProperties(const dbus::ObjectPath& object_path) override;
@@ skipping 28 matching lines @@
   void EndDiscoverySimulation(const dbus::ObjectPath& adapter_path);
 
   // Simulates incoming pairing of devices for the given adapter.
   void BeginIncomingPairingSimulation(const dbus::ObjectPath& adapter_path);
   void EndIncomingPairingSimulation(const dbus::ObjectPath& adapter_path);
 
   // Creates a device from the set we return for the given adapter.
   void CreateDevice(const dbus::ObjectPath& adapter_path,
                     const dbus::ObjectPath& device_path);
 
+  // Creates a device with the given properties.
+  void CreateDeviceWithProperties(const dbus::ObjectPath& adapter_path,
+                                  const IncomingDeviceProperties& props);
+
+  SimulatedPairingOptions* GetPairingOptions(
+      const dbus::ObjectPath& object_path);
+
   // Removes a device from the set we return for the given adapter.
   void RemoveDevice(const dbus::ObjectPath& adapter_path,
                     const dbus::ObjectPath& device_path);
 
   // Simulates a pairing for the device with the given D-Bus object path,
   // |object_path|. Set |incoming_request| to true if simulating an incoming
   // pairing request, false for an outgoing one. On successful completion
   // |callback| will be called, on failure, |error_callback| is called.
   void SimulatePairing(const dbus::ObjectPath& object_path,
                        bool incoming_request,
@@ skipping 140 matching lines @@
       BluetoothProfileServiceProvider::Delegate::Status status);
   void DisconnectionCallback(
       const dbus::ObjectPath& object_path,
       const base::Closure& callback,
       const ErrorCallback& error_callback,
       BluetoothProfileServiceProvider::Delegate::Status status);
 
   // List of observers interested in event notifications from us.
   base::ObserverList<Observer> observers_;
 
-  // Static properties we return.
-  typedef std::map<const dbus::ObjectPath, Properties *> PropertiesMap;
+  using PropertiesMap =
+      base::ScopedPtrMap<const dbus::ObjectPath, scoped_ptr<Properties>>;
   PropertiesMap properties_map_;
   std::vector<dbus::ObjectPath> device_list_;
 
+  // Properties which are used to decied which method of pairing should
+  // be done on request.
+  using PairingOptionsMap =
+      base::ScopedPtrMap<const dbus::ObjectPath,
+                         scoped_ptr<SimulatedPairingOptions>>;
+  PairingOptionsMap pairing_options_map_;
+
   int simulation_interval_ms_;
   uint32_t discovery_simulation_step_;
   uint32_t incoming_pairing_simulation_step_;
   bool pairing_cancelled_;
 
   int16 connection_rssi_;
   int16 transmit_power_;
   int16 max_transmit_power_;
 };
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_DBUS_FAKE_BLUETOOTH_DEVICE_CLIENT_H_