Implement support for the OOB Pairing APIs.

chrome/browser/chromeos/bluetooth/bluetooth_device.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_DEVICE_H_
 #define CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_DEVICE_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/string16.h"
 #include "chromeos/dbus/bluetooth_agent_service_provider.h"
 #include "chromeos/dbus/bluetooth_device_client.h"
+#include "chromeos/dbus/bluetooth_out_of_band_client.h"
 #include "dbus/object_path.h"
 
 namespace chromeos {
 
 class BluetoothAdapter;
 class BluetoothSocket;
 
 // The BluetoothDevice class represents a remote Bluetooth device, both
 // its properties and capabilities as discovered by a local adapter and
 // actions that may be performed on the remove device such as pairing,
@@ skipping 168 matching lines @@
   // Indicates whether the device is currently pairing and expecting
   // confirmation of a displayed passkey.
   bool ExpectingConfirmation() const {
     return !confirmation_callback_.is_null();
   }
 
   // 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 VoidResultCallback is used for methods that do not return any data, to
+  // indicate that the action requested is complete.
+  typedef base::Callback<void()> VoidResultCallback;
+
   // Initiates a connection to the device, pairing first if necessary.
   //
   // Method calls will be made on the supplied object |pairing_delegate|
   // to indicate what display, and in response should make method calls
   // back to the device object. Not all devices require user responses
   // during pairing, so it is normal for |pairing_delegate| to receive no
   // calls. To explicitly force a low-security connection without bonding,
   // pass NULL, though this is ignored if the device is already paired.
   //
   // If the request fails, |error_callback| will be called; otherwise,
@@ skipping 49 matching lines @@
 
   // Attempts to open a socket to a service matching |uuid| on this device.  If
   // the connection is successful, |callback| is called with a BluetoothSocket.
   // Otherwise |callback| is called with NULL.  The socket is closed as soon as
   // all references to the BluetoothSocket are released.  Note that the
   // BluetoothSocket object can outlive both this BluetoothDevice and the
   // BluetoothAdapter for this device.
   void ConnectToService(const std::string& service_uuid,
                         const SocketCallback& callback);
 
+  // Sets the Out Of Band pairing data for this device to |data|.  Exactly one
+  // of |callback| or |error_callback| will be run.
+  virtual void SetOutOfBandPairingData(
+      const chromeos::BluetoothOutOfBandPairingData& data,
+      const base::Closure& callback,
+      const ErrorCallback& error_callback);
+
+  // Clears the Out Of Band pairing data for this device.  Exactly one of
+  // |callback| or |error_callback| will be run.
+  virtual void ClearOutOfBandPairingData(
+      const base::Closure& callback,
+      const ErrorCallback& error_callback);
+
  private:
   friend class BluetoothAdapter;
   friend class MockBluetoothDevice;
 
   explicit BluetoothDevice(BluetoothAdapter* adapter);
 
   // Sets the dbus object path for the device to |object_path|, indicating
   // that the device has gone from being discovered to paired or bonded.
   void SetObjectPath(const dbus::ObjectPath& object_path);
 
@@ skipping 95 matching lines @@
   // initated from ConnectToService completes.  The |callback| is called with
   // true iff a connection was successfully established.  The rest of the
   // parameters are as documented for a BluetoothDeviceClient::ServicesCallback.
   void ConnectToMatchingService(
       const std::string& service_uuid,
       const SocketCallback& callback,
       const dbus::ObjectPath& object_path,
       const BluetoothDeviceClient::ServiceMap& service_map,
       bool success);
 
+  // Called by BlueoothDeviceClient in response to the AddRemoteData and
+  // RemoveRemoteData method calls.
+  void OnRemoteDataCallback(const base::Closure& callback,
+                            const ErrorCallback& error_callback,
+                            bool success);
+
   // BluetoothDeviceClient::Observer override.
   //
   // Called when the device with object path |object_path| is about
   // to be disconnected, giving a chance for application layers to
   // shut down cleanly.
   virtual void DisconnectRequested(
       const dbus::ObjectPath& object_path) OVERRIDE;
 
   // BluetoothAgentServiceProvider::Delegate override.
   //
@@ skipping 163 matching lines @@
 
   // Used to keep track of pending application connection requests.
   int connecting_applications_counter_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothDevice);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_BLUETOOTH_BLUETOOTH_DEVICE_H_