Implement support for the OOB Pairing APIs.

chrome/browser/chromeos/bluetooth/bluetooth_adapter.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 "chrome/browser/chromeos/bluetooth/bluetooth_adapter.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/values.h"
@@ skipping 58 matching lines @@
 
 void BluetoothAdapter::AdapterCallback(const dbus::ObjectPath& adapter_path,
                                        bool success) {
   if (success) {
     ChangeAdapter(adapter_path);
   } else if (!object_path_.value().empty()) {
     RemoveAdapter();
   }
 }
 
+void BluetoothAdapter::AdapterCallbackToResultCallback(
+    const ResultCallback& callback,
+    const dbus::ObjectPath& adapter_path,
+    bool success) {
+  callback.Run(success);
+}
+
 void BluetoothAdapter::DefaultAdapterChanged(
     const dbus::ObjectPath& adapter_path) {
   if (track_default_)
     ChangeAdapter(adapter_path);
 }
 
 void BluetoothAdapter::AdapterRemoved(const dbus::ObjectPath& adapter_path) {
   if (adapter_path == object_path_)
     RemoveAdapter();
 }
@@ skipping 155 matching lines @@
       GetProperties(object_path_);
 
   if (property_name == properties->powered.name()) {
     PoweredChanged(properties->powered.value());
 
   } else if (property_name == properties->discovering.name()) {
     DiscoveringChanged(properties->discovering.value());
 
   } else if (property_name == properties->devices.name()) {
     DevicesChanged(properties->devices.value());
-
   }
 }
 
 void BluetoothAdapter::DevicePropertyChanged(
     const dbus::ObjectPath& device_path,
     const std::string& property_name) {
   UpdateDevice(device_path);
 }
 
 void BluetoothAdapter::UpdateDevice(const dbus::ObjectPath& device_path) {
   BluetoothDeviceClient::Properties* properties =
       DBusThreadManager::Get()->GetBluetoothDeviceClient()->
       GetProperties(device_path);
 
   // When we first see a device, we may not know the address yet and need to
   // wait for the DevicePropertyChanged signal before adding the device.
   const std::string address = properties->address.value();
   if (address.empty())
     return;
 
   // If the device is already known this may be just an update to properties,
   // or it may be the device going from discovered to connected and gaining
   // an object path. Update the existing object and notify observers.
   DevicesMap::iterator iter = devices_.find(address);
-  if (iter != devices_.end()){
+  if (iter != devices_.end()) {
     BluetoothDevice* device = iter->second;
 
     if (!device->IsPaired())
       device->SetObjectPath(device_path);
     device->Update(properties, true);
 
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       DeviceChanged(this, device));
     return;
   }
@@ skipping 36 matching lines @@
 
 const BluetoothDevice* BluetoothAdapter::GetDevice(
     const std::string& address) const {
   DevicesMap::const_iterator iter = devices_.find(address);
   if (iter != devices_.end())
     return iter->second;
 
   return NULL;
 }
 
+void BluetoothAdapter::ReadLocalOutOfBandPairingData(
+    const OutOfBandPairingDataCallback& callback) const {
+  DBusThreadManager::Get()->GetBluetoothAdapterClient()->
+      ReadLocalOutOfBandPairingData(object_path_, callback);
+}
+
+void BluetoothAdapter::SetOutOfBandPairingData(const std::string& address,
+    const chromeos::OutOfBandPairingData& data,
+    const ResultCallback& callback) {
+  DBusThreadManager::Get()->GetBluetoothAdapterClient()->
+      AddRemoteOutOfBandPairingData(
+          object_path_,
+          address,
+          data,
+          base::Bind(&BluetoothAdapter::AdapterCallbackToResultCallback,
+              weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
+void BluetoothAdapter::ClearOutOfBandPairingData(const std::string& address,
+    const ResultCallback& callback) {
+  DBusThreadManager::Get()->GetBluetoothAdapterClient()->
+      RemoveRemoteOutOfBandPairingData(
+          object_path_,
+          address,
+          base::Bind(&BluetoothAdapter::AdapterCallbackToResultCallback,
+              weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
 void BluetoothAdapter::ClearDevices() {
   for (DevicesMap::iterator iter = devices_.begin();
        iter != devices_.end(); ++iter) {
     BluetoothDevice* device = iter->second;
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       DeviceRemoved(this, device));
 
     delete device;
   }
   devices_.clear();
@@ skipping 115 matching lines @@
 }
 
 // static
 BluetoothAdapter* BluetoothAdapter::Create(const std::string& address) {
   BluetoothAdapter* adapter = new BluetoothAdapter;
   adapter->FindAdapter(address);
   return adapter;
 }
 
 }  // namespace chromeos