Implement support for the OOB Pairing APIs.

chrome/browser/chromeos/bluetooth/bluetooth_adapter.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_ADAPTER_H_
 #define CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_ADAPTER_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/observer_list.h"
 #include "chromeos/dbus/bluetooth_adapter_client.h"
 #include "chromeos/dbus/bluetooth_device_client.h"
 #include "chromeos/dbus/bluetooth_manager_client.h"
+#include "chromeos/dbus/bluetooth_out_of_band_pairing_data.h"
 #include "dbus/object_path.h"
 
 namespace chromeos {
 
 class BluetoothDevice;
 
 // The BluetoothAdapter class represents a local Bluetooth adapter which
 // may be used to interact with remote Bluetooth devices. As well as
 // providing support for determining whether an adapter is present, and
 // whether the radio is powered, this class also provides support for
@@ skipping 55 matching lines @@
   // Adds and removes observers for events on this bluetooth adapter,
   // if monitoring multiple adapters check the |adapter| parameter of
   // observer methods to determine which adapter is issuing the event.
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   // The ErrorCallback is used for methods that can fail in which case it
   // is called, in the success case the callback is simply not called.
   typedef base::Callback<void()> ErrorCallback;
 
+  // The ResultCallback is used for methods that return a boolean value
+  // indicating success (true) or failure (false).
+  typedef base::Callback<void(bool result)> ResultCallback;
+
   // The address of this adapter.  The address format is "XX:XX:XX:XX:XX:XX",
   // where each XX is a hexadecimal number.
   const std::string& address() const { return address_; }
 
   // Indicates whether the adapter is actually present on the system, for
   // the default adapter this indicates whether any adapter is present.
   virtual bool IsPresent() const;
 
   // Indicates whether the adapter radio is powered.
   virtual bool IsPowered() const;
@@ skipping 20 matching lines @@
   typedef std::vector<BluetoothDevice*> DeviceList;
   virtual DeviceList GetDevices();
   typedef std::vector<const BluetoothDevice*> ConstDeviceList;
   virtual ConstDeviceList GetDevices() const;
 
   // Returns a pointer to the device with the given address |address| or
   // NULL if no such device is known.
   BluetoothDevice* GetDevice(const std::string& address);
   const BluetoothDevice* GetDevice(const std::string& address) const;
 
+  // Requests the local Out Of Band pairing data.
+  virtual void ReadLocalOutOfBandPairingData(
+      const OutOfBandPairingDataCallback& callback) const;
+
+  // Sets the Out Of Band pairing data for the device at |address| to |data|.
+  void SetOutOfBandPairingData(const std::string& address,
+      const chromeos::OutOfBandPairingData& data,
+      const ResultCallback& callback);
+
+  // Clears the Out Of Band pairing data for the device at |address|.
+  virtual void ClearOutOfBandPairingData(const std::string& address,
+      const ResultCallback& callback);
+
   // Creates the instance for the default adapter, whichever that may
   // be at the time. Use IsPresent() and the AdapterPresentChanged() observer
   // method to determine whether an adapter is actually available or not.
   static BluetoothAdapter* CreateDefaultAdapter();
 
   // Creates an instance for a specific adapter named by |address|, which
   // may be the bluetooth address of the adapter or a device name such as
   // "hci0".
   static BluetoothAdapter* Create(const std::string& address);
 
  private:
   friend class BluetoothDevice;
   friend class MockBluetoothAdapter;
 
   BluetoothAdapter();
 
   // Obtains the default adapter object path from the Bluetooth Daemon
   // and tracks future changes to it.
   void DefaultAdapter();
 
   // Obtains the object paht for the adapter named by |address| from the
   // Bluetooth Daemon.
   void FindAdapter(const std::string& address);
 
   // Called by dbus:: in response to the method call sent by both
   // DefaultAdapter() and FindAdapter(), |object_path| will contain the
   // dbus object path of the requested adapter when |success| is true.
   void AdapterCallback(const dbus::ObjectPath& adapter_path, bool success);
 
+  // Translates from an AdapterCallback to a ResultCallback, by ignoring the
+  // |adapter_path| and passing |success| on to |callback|.
+  void AdapterCallbackToResultCallback(
+      const ResultCallback& callback,
+      const dbus::ObjectPath& adapter_path,
+      bool success);
+
   // BluetoothManagerClient::Observer override.
   //
   // Called when the default local bluetooth adapter changes.
   // |object_path| is the dbus object path of the new default adapter.
   // Not called if all adapters are removed.
   virtual void DefaultAdapterChanged(const dbus::ObjectPath& adapter_path)
       OVERRIDE;
 
   // BluetoothManagerClient::Observer override.
   //
@@ skipping 123 matching lines @@
   // instance.
   typedef std::map<const std::string, BluetoothDevice*> DevicesMap;
   DevicesMap devices_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothAdapter);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_ADAPTER_H_