Home | History | Annotate | Download | only in bluetooth 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "device/bluetooth/bluetooth_adapter_chromeos.h"
      6 
      7 #include <string>
      8 
      9 #include "base/bind.h"
     10 #include "base/logging.h"
     11 #include "base/metrics/histogram.h"
     12 #include "base/sequenced_task_runner.h"
     13 #include "base/single_thread_task_runner.h"
     14 #include "base/sys_info.h"
     15 #include "base/thread_task_runner_handle.h"
     16 #include "chromeos/dbus/bluetooth_adapter_client.h"
     17 #include "chromeos/dbus/bluetooth_agent_manager_client.h"
     18 #include "chromeos/dbus/bluetooth_agent_service_provider.h"
     19 #include "chromeos/dbus/bluetooth_device_client.h"
     20 #include "chromeos/dbus/bluetooth_input_client.h"
     21 #include "chromeos/dbus/dbus_thread_manager.h"
     22 #include "device/bluetooth/bluetooth_device.h"
     23 #include "device/bluetooth/bluetooth_device_chromeos.h"
     24 #include "device/bluetooth/bluetooth_pairing_chromeos.h"
     25 #include "device/bluetooth/bluetooth_remote_gatt_characteristic_chromeos.h"
     26 #include "device/bluetooth/bluetooth_remote_gatt_descriptor_chromeos.h"
     27 #include "device/bluetooth/bluetooth_remote_gatt_service_chromeos.h"
     28 #include "device/bluetooth/bluetooth_socket_chromeos.h"
     29 #include "device/bluetooth/bluetooth_socket_thread.h"
     30 #include "device/bluetooth/bluetooth_uuid.h"
     31 #include "third_party/cros_system_api/dbus/service_constants.h"
     32 
     33 using device::BluetoothAdapter;
     34 using device::BluetoothDevice;
     35 using device::BluetoothSocket;
     36 using device::BluetoothUUID;
     37 
     38 namespace {
     39 
     40 // The agent path is relatively meaningless since BlueZ only permits one to
     41 // exist per D-Bus connection, it just has to be unique within Chromium.
     42 const char kAgentPath[] = "/org/chromium/bluetooth_agent";
     43 
     44 void OnUnregisterAgentError(const std::string& error_name,
     45                             const std::string& error_message) {
     46   // It's okay if the agent didn't exist, it means we never saw an adapter.
     47   if (error_name == bluetooth_agent_manager::kErrorDoesNotExist)
     48     return;
     49 
     50   LOG(WARNING) << "Failed to unregister pairing agent: "
     51                << error_name << ": " << error_message;
     52 }
     53 
     54 }  // namespace
     55 
     56 namespace device {
     57 
     58 // static
     59 base::WeakPtr<BluetoothAdapter> BluetoothAdapter::CreateAdapter(
     60     const InitCallback& init_callback) {
     61   return chromeos::BluetoothAdapterChromeOS::CreateAdapter();
     62 }
     63 
     64 }
     65 
     66 namespace chromeos {
     67 
     68 // static
     69 base::WeakPtr<BluetoothAdapter> BluetoothAdapterChromeOS::CreateAdapter() {
     70   BluetoothAdapterChromeOS* adapter = new BluetoothAdapterChromeOS();
     71   return adapter->weak_ptr_factory_.GetWeakPtr();
     72 }
     73 
     74 BluetoothAdapterChromeOS::BluetoothAdapterChromeOS()
     75     : num_discovery_sessions_(0),
     76       discovery_request_pending_(false),
     77       weak_ptr_factory_(this) {
     78   ui_task_runner_ = base::ThreadTaskRunnerHandle::Get();
     79   socket_thread_ = device::BluetoothSocketThread::Get();
     80 
     81   DBusThreadManager::Get()->GetBluetoothAdapterClient()->AddObserver(this);
     82   DBusThreadManager::Get()->GetBluetoothDeviceClient()->AddObserver(this);
     83   DBusThreadManager::Get()->GetBluetoothInputClient()->AddObserver(this);
     84 
     85   // Register the pairing agent.
     86   dbus::Bus* system_bus = DBusThreadManager::Get()->GetSystemBus();
     87   agent_.reset(BluetoothAgentServiceProvider::Create(
     88       system_bus, dbus::ObjectPath(kAgentPath), this));
     89   DCHECK(agent_.get());
     90 
     91   std::vector<dbus::ObjectPath> object_paths =
     92       DBusThreadManager::Get()->GetBluetoothAdapterClient()->GetAdapters();
     93 
     94   if (!object_paths.empty()) {
     95     VLOG(1) << object_paths.size() << " Bluetooth adapter(s) available.";
     96     SetAdapter(object_paths[0]);
     97   }
     98 }
     99 
    100 BluetoothAdapterChromeOS::~BluetoothAdapterChromeOS() {
    101   DBusThreadManager::Get()->GetBluetoothAdapterClient()->RemoveObserver(this);
    102   DBusThreadManager::Get()->GetBluetoothDeviceClient()->RemoveObserver(this);
    103   DBusThreadManager::Get()->GetBluetoothInputClient()->RemoveObserver(this);
    104 
    105   VLOG(1) << "Unregistering pairing agent";
    106   DBusThreadManager::Get()->GetBluetoothAgentManagerClient()->
    107       UnregisterAgent(
    108           dbus::ObjectPath(kAgentPath),
    109           base::Bind(&base::DoNothing),
    110           base::Bind(&OnUnregisterAgentError));
    111 }
    112 
    113 void BluetoothAdapterChromeOS::AddObserver(
    114     BluetoothAdapter::Observer* observer) {
    115   DCHECK(observer);
    116   observers_.AddObserver(observer);
    117 }
    118 
    119 void BluetoothAdapterChromeOS::RemoveObserver(
    120     BluetoothAdapter::Observer* observer) {
    121   DCHECK(observer);
    122   observers_.RemoveObserver(observer);
    123 }
    124 
    125 std::string BluetoothAdapterChromeOS::GetAddress() const {
    126   if (!IsPresent())
    127     return std::string();
    128 
    129   BluetoothAdapterClient::Properties* properties =
    130       DBusThreadManager::Get()->GetBluetoothAdapterClient()->
    131           GetProperties(object_path_);
    132   DCHECK(properties);
    133 
    134   return BluetoothDevice::CanonicalizeAddress(properties->address.value());
    135 }
    136 
    137 std::string BluetoothAdapterChromeOS::GetName() const {
    138   if (!IsPresent())
    139     return std::string();
    140 
    141   BluetoothAdapterClient::Properties* properties =
    142       DBusThreadManager::Get()->GetBluetoothAdapterClient()->
    143           GetProperties(object_path_);
    144   DCHECK(properties);
    145 
    146   return properties->alias.value();
    147 }
    148 
    149 void BluetoothAdapterChromeOS::SetName(const std::string& name,
    150                                        const base::Closure& callback,
    151                                        const ErrorCallback& error_callback) {
    152   if (!IsPresent())
    153     error_callback.Run();
    154 
    155   DBusThreadManager::Get()->GetBluetoothAdapterClient()->
    156       GetProperties(object_path_)->alias.Set(
    157           name,
    158           base::Bind(&BluetoothAdapterChromeOS::OnPropertyChangeCompleted,
    159                      weak_ptr_factory_.GetWeakPtr(),
    160                      callback,
    161                      error_callback));
    162 }
    163 
    164 bool BluetoothAdapterChromeOS::IsInitialized() const {
    165   return true;
    166 }
    167 
    168 bool BluetoothAdapterChromeOS::IsPresent() const {
    169   return !object_path_.value().empty();
    170 }
    171 
    172 bool BluetoothAdapterChromeOS::IsPowered() const {
    173   if (!IsPresent())
    174     return false;
    175 
    176   BluetoothAdapterClient::Properties* properties =
    177       DBusThreadManager::Get()->GetBluetoothAdapterClient()->
    178           GetProperties(object_path_);
    179 
    180   return properties->powered.value();
    181 }
    182 
    183 void BluetoothAdapterChromeOS::SetPowered(
    184     bool powered,
    185     const base::Closure& callback,
    186     const ErrorCallback& error_callback) {
    187   if (!IsPresent())
    188     error_callback.Run();
    189 
    190   DBusThreadManager::Get()->GetBluetoothAdapterClient()->
    191       GetProperties(object_path_)->powered.Set(
    192           powered,
    193           base::Bind(&BluetoothAdapterChromeOS::OnPropertyChangeCompleted,
    194                      weak_ptr_factory_.GetWeakPtr(),
    195                      callback,
    196                      error_callback));
    197 }
    198 
    199 bool BluetoothAdapterChromeOS::IsDiscoverable() const {
    200   if (!IsPresent())
    201     return false;
    202 
    203   BluetoothAdapterClient::Properties* properties =
    204       DBusThreadManager::Get()->GetBluetoothAdapterClient()->
    205           GetProperties(object_path_);
    206 
    207   return properties->discoverable.value();
    208 }
    209 
    210 void BluetoothAdapterChromeOS::SetDiscoverable(
    211     bool discoverable,
    212     const base::Closure& callback,
    213     const ErrorCallback& error_callback) {
    214   if (!IsPresent())
    215     error_callback.Run();
    216 
    217   DBusThreadManager::Get()->GetBluetoothAdapterClient()->
    218       GetProperties(object_path_)->discoverable.Set(
    219           discoverable,
    220           base::Bind(&BluetoothAdapterChromeOS::OnSetDiscoverable,
    221                      weak_ptr_factory_.GetWeakPtr(),
    222                      callback,
    223                      error_callback));
    224 }
    225 
    226 bool BluetoothAdapterChromeOS::IsDiscovering() const {
    227   if (!IsPresent())
    228     return false;
    229 
    230   BluetoothAdapterClient::Properties* properties =
    231       DBusThreadManager::Get()->GetBluetoothAdapterClient()->
    232           GetProperties(object_path_);
    233 
    234   return properties->discovering.value();
    235 }
    236 
    237 void BluetoothAdapterChromeOS::CreateRfcommService(
    238     const BluetoothUUID& uuid,
    239     const ServiceOptions& options,
    240     const CreateServiceCallback& callback,
    241     const CreateServiceErrorCallback& error_callback) {
    242   VLOG(1) << object_path_.value() << ": Creating RFCOMM service: "
    243           << uuid.canonical_value();
    244   scoped_refptr<BluetoothSocketChromeOS> socket =
    245       BluetoothSocketChromeOS::CreateBluetoothSocket(
    246           ui_task_runner_, socket_thread_);
    247   socket->Listen(this,
    248                  BluetoothSocketChromeOS::kRfcomm,
    249                  uuid,
    250                  options,
    251                  base::Bind(callback, socket),
    252                  error_callback);
    253 }
    254 
    255 void BluetoothAdapterChromeOS::CreateL2capService(
    256     const BluetoothUUID& uuid,
    257     const ServiceOptions& options,
    258     const CreateServiceCallback& callback,
    259     const CreateServiceErrorCallback& error_callback) {
    260   VLOG(1) << object_path_.value() << ": Creating L2CAP service: "
    261           << uuid.canonical_value();
    262   scoped_refptr<BluetoothSocketChromeOS> socket =
    263       BluetoothSocketChromeOS::CreateBluetoothSocket(
    264           ui_task_runner_, socket_thread_);
    265   socket->Listen(this,
    266                  BluetoothSocketChromeOS::kL2cap,
    267                  uuid,
    268                  options,
    269                  base::Bind(callback, socket),
    270                  error_callback);
    271 }
    272 
    273 void BluetoothAdapterChromeOS::RemovePairingDelegateInternal(
    274     BluetoothDevice::PairingDelegate* pairing_delegate) {
    275   // Before removing a pairing delegate make sure that there aren't any devices
    276   // currently using it; if there are, clear the pairing context which will
    277   // make any responses no-ops.
    278   for (DevicesMap::iterator iter = devices_.begin();
    279        iter != devices_.end(); ++iter) {
    280     BluetoothDeviceChromeOS* device_chromeos =
    281         static_cast<BluetoothDeviceChromeOS*>(iter->second);
    282 
    283     BluetoothPairingChromeOS* pairing = device_chromeos->GetPairing();
    284     if (pairing && pairing->GetPairingDelegate() == pairing_delegate)
    285       device_chromeos->EndPairing();
    286   }
    287 }
    288 
    289 void BluetoothAdapterChromeOS::AdapterAdded(
    290     const dbus::ObjectPath& object_path) {
    291   // Set the adapter to the newly added adapter only if no adapter is present.
    292   if (!IsPresent())
    293     SetAdapter(object_path);
    294 }
    295 
    296 void BluetoothAdapterChromeOS::AdapterRemoved(
    297     const dbus::ObjectPath& object_path) {
    298   if (object_path == object_path_)
    299     RemoveAdapter();
    300 }
    301 
    302 void BluetoothAdapterChromeOS::AdapterPropertyChanged(
    303     const dbus::ObjectPath& object_path,
    304     const std::string& property_name) {
    305   if (object_path != object_path_)
    306     return;
    307 
    308   BluetoothAdapterClient::Properties* properties =
    309       DBusThreadManager::Get()->GetBluetoothAdapterClient()->
    310           GetProperties(object_path_);
    311 
    312   if (property_name == properties->powered.name())
    313     PoweredChanged(properties->powered.value());
    314   else if (property_name == properties->discoverable.name())
    315     DiscoverableChanged(properties->discoverable.value());
    316   else if (property_name == properties->discovering.name())
    317     DiscoveringChanged(properties->discovering.value());
    318 }
    319 
    320 void BluetoothAdapterChromeOS::DeviceAdded(
    321   const dbus::ObjectPath& object_path) {
    322   BluetoothDeviceClient::Properties* properties =
    323       DBusThreadManager::Get()->GetBluetoothDeviceClient()->
    324           GetProperties(object_path);
    325   if (properties->adapter.value() != object_path_)
    326     return;
    327 
    328   BluetoothDeviceChromeOS* device_chromeos =
    329       new BluetoothDeviceChromeOS(this,
    330                                   object_path,
    331                                   ui_task_runner_,
    332                                   socket_thread_);
    333   DCHECK(devices_.find(device_chromeos->GetAddress()) == devices_.end());
    334 
    335   devices_[device_chromeos->GetAddress()] = device_chromeos;
    336 
    337   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
    338                     DeviceAdded(this, device_chromeos));
    339 }
    340 
    341 void BluetoothAdapterChromeOS::DeviceRemoved(
    342     const dbus::ObjectPath& object_path) {
    343   for (DevicesMap::iterator iter = devices_.begin();
    344        iter != devices_.end(); ++iter) {
    345     BluetoothDeviceChromeOS* device_chromeos =
    346         static_cast<BluetoothDeviceChromeOS*>(iter->second);
    347     if (device_chromeos->object_path() == object_path) {
    348       devices_.erase(iter);
    349 
    350       FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
    351                         DeviceRemoved(this, device_chromeos));
    352       delete device_chromeos;
    353       return;
    354     }
    355   }
    356 }
    357 
    358 void BluetoothAdapterChromeOS::DevicePropertyChanged(
    359     const dbus::ObjectPath& object_path,
    360     const std::string& property_name) {
    361   BluetoothDeviceChromeOS* device_chromeos = GetDeviceWithPath(object_path);
    362   if (!device_chromeos)
    363     return;
    364 
    365   BluetoothDeviceClient::Properties* properties =
    366       DBusThreadManager::Get()->GetBluetoothDeviceClient()->
    367           GetProperties(object_path);
    368 
    369   if (property_name == properties->bluetooth_class.name() ||
    370       property_name == properties->address.name() ||
    371       property_name == properties->alias.name() ||
    372       property_name == properties->paired.name() ||
    373       property_name == properties->trusted.name() ||
    374       property_name == properties->connected.name() ||
    375       property_name == properties->uuids.name() ||
    376       property_name == properties->rssi.name() ||
    377       property_name == properties->connection_rssi.name() ||
    378       property_name == properties->connection_tx_power.name())
    379     NotifyDeviceChanged(device_chromeos);
    380 
    381   // When a device becomes paired, mark it as trusted so that the user does
    382   // not need to approve every incoming connection
    383   if (property_name == properties->paired.name() &&
    384       properties->paired.value() && !properties->trusted.value())
    385     device_chromeos->SetTrusted();
    386 
    387   // UMA connection counting
    388   if (property_name == properties->connected.name()) {
    389     // PlayStation joystick tries to reconnect after disconnection from USB.
    390     // If it is still not trusted, set it, so it becomes available on the
    391     // list of known devices.
    392     if (properties->connected.value() && device_chromeos->IsTrustable() &&
    393         !properties->trusted.value())
    394       device_chromeos->SetTrusted();
    395 
    396     int count = 0;
    397 
    398     for (DevicesMap::iterator iter = devices_.begin();
    399          iter != devices_.end(); ++iter) {
    400       if (iter->second->IsPaired() && iter->second->IsConnected())
    401         ++count;
    402     }
    403 
    404     UMA_HISTOGRAM_COUNTS_100("Bluetooth.ConnectedDeviceCount", count);
    405   }
    406 }
    407 
    408 void BluetoothAdapterChromeOS::InputPropertyChanged(
    409     const dbus::ObjectPath& object_path,
    410     const std::string& property_name) {
    411   BluetoothDeviceChromeOS* device_chromeos = GetDeviceWithPath(object_path);
    412   if (!device_chromeos)
    413     return;
    414 
    415   BluetoothInputClient::Properties* properties =
    416       DBusThreadManager::Get()->GetBluetoothInputClient()->
    417           GetProperties(object_path);
    418 
    419   // Properties structure can be removed, which triggers a change in the
    420   // BluetoothDevice::IsConnectable() property, as does a change in the
    421   // actual reconnect_mode property.
    422   if (!properties ||
    423       property_name == properties->reconnect_mode.name())
    424     NotifyDeviceChanged(device_chromeos);
    425 }
    426 
    427 void BluetoothAdapterChromeOS::Released() {
    428   DCHECK(agent_.get());
    429   VLOG(1) << "Release";
    430 
    431   // Called after we unregister the pairing agent, e.g. when changing I/O
    432   // capabilities. Nothing much to be done right now.
    433 }
    434 
    435 void BluetoothAdapterChromeOS::RequestPinCode(
    436     const dbus::ObjectPath& device_path,
    437     const PinCodeCallback& callback) {
    438   DCHECK(agent_.get());
    439   VLOG(1) << device_path.value() << ": RequestPinCode";
    440 
    441   BluetoothPairingChromeOS* pairing = GetPairing(device_path);
    442   if (!pairing) {
    443     callback.Run(REJECTED, "");
    444     return;
    445   }
    446 
    447   pairing->RequestPinCode(callback);
    448 }
    449 
    450 void BluetoothAdapterChromeOS::DisplayPinCode(
    451     const dbus::ObjectPath& device_path,
    452     const std::string& pincode) {
    453   DCHECK(agent_.get());
    454   VLOG(1) << device_path.value() << ": DisplayPinCode: " << pincode;
    455 
    456   BluetoothPairingChromeOS* pairing = GetPairing(device_path);
    457   if (!pairing)
    458     return;
    459 
    460   pairing->DisplayPinCode(pincode);
    461 }
    462 
    463 void BluetoothAdapterChromeOS::RequestPasskey(
    464     const dbus::ObjectPath& device_path,
    465     const PasskeyCallback& callback) {
    466   DCHECK(agent_.get());
    467   VLOG(1) << device_path.value() << ": RequestPasskey";
    468 
    469   BluetoothPairingChromeOS* pairing = GetPairing(device_path);
    470   if (!pairing) {
    471     callback.Run(REJECTED, 0);
    472     return;
    473   }
    474 
    475   pairing->RequestPasskey(callback);
    476 }
    477 
    478 void BluetoothAdapterChromeOS::DisplayPasskey(
    479     const dbus::ObjectPath& device_path,
    480     uint32 passkey,
    481     uint16 entered) {
    482   DCHECK(agent_.get());
    483   VLOG(1) << device_path.value() << ": DisplayPasskey: " << passkey
    484           << " (" << entered << " entered)";
    485 
    486   BluetoothPairingChromeOS* pairing = GetPairing(device_path);
    487   if (!pairing)
    488     return;
    489 
    490   if (entered == 0)
    491     pairing->DisplayPasskey(passkey);
    492 
    493   pairing->KeysEntered(entered);
    494 }
    495 
    496 void BluetoothAdapterChromeOS::RequestConfirmation(
    497     const dbus::ObjectPath& device_path,
    498     uint32 passkey,
    499     const ConfirmationCallback& callback) {
    500   DCHECK(agent_.get());
    501   VLOG(1) << device_path.value() << ": RequestConfirmation: " << passkey;
    502 
    503   BluetoothPairingChromeOS* pairing = GetPairing(device_path);
    504   if (!pairing) {
    505     callback.Run(REJECTED);
    506     return;
    507   }
    508 
    509   pairing->RequestConfirmation(passkey, callback);
    510 }
    511 
    512 void BluetoothAdapterChromeOS::RequestAuthorization(
    513     const dbus::ObjectPath& device_path,
    514     const ConfirmationCallback& callback) {
    515   DCHECK(agent_.get());
    516   VLOG(1) << device_path.value() << ": RequestAuthorization";
    517 
    518   BluetoothPairingChromeOS* pairing = GetPairing(device_path);
    519   if (!pairing) {
    520     callback.Run(REJECTED);
    521     return;
    522   }
    523 
    524   pairing->RequestAuthorization(callback);
    525 }
    526 
    527 void BluetoothAdapterChromeOS::AuthorizeService(
    528     const dbus::ObjectPath& device_path,
    529     const std::string& uuid,
    530     const ConfirmationCallback& callback) {
    531   DCHECK(agent_.get());
    532   VLOG(1) << device_path.value() << ": AuthorizeService: " << uuid;
    533 
    534   BluetoothDeviceChromeOS* device_chromeos = GetDeviceWithPath(device_path);
    535   if (!device_chromeos) {
    536     callback.Run(CANCELLED);
    537     return;
    538   }
    539 
    540   // We always set paired devices to Trusted, so the only reason that this
    541   // method call would ever be called is in the case of a race condition where
    542   // our "Set('Trusted', true)" method call is still pending in the Bluetooth
    543   // daemon because it's busy handling the incoming connection.
    544   if (device_chromeos->IsPaired()) {
    545     callback.Run(SUCCESS);
    546     return;
    547   }
    548 
    549   // TODO(keybuk): reject service authorizations when not paired, determine
    550   // whether this is acceptable long-term.
    551   LOG(WARNING) << "Rejecting service connection from unpaired device "
    552                << device_chromeos->GetAddress() << " for UUID " << uuid;
    553   callback.Run(REJECTED);
    554 }
    555 
    556 void BluetoothAdapterChromeOS::Cancel() {
    557   DCHECK(agent_.get());
    558   VLOG(1) << "Cancel";
    559 }
    560 
    561 void BluetoothAdapterChromeOS::OnRegisterAgent() {
    562   VLOG(1) << "Pairing agent registered, requesting to be made default";
    563 
    564   DBusThreadManager::Get()->GetBluetoothAgentManagerClient()->
    565       RequestDefaultAgent(
    566           dbus::ObjectPath(kAgentPath),
    567           base::Bind(&BluetoothAdapterChromeOS::OnRequestDefaultAgent,
    568                      weak_ptr_factory_.GetWeakPtr()),
    569           base::Bind(&BluetoothAdapterChromeOS::OnRequestDefaultAgentError,
    570                      weak_ptr_factory_.GetWeakPtr()));
    571 
    572 }
    573 
    574 void BluetoothAdapterChromeOS::OnRegisterAgentError(
    575     const std::string& error_name,
    576     const std::string& error_message) {
    577   // Our agent being already registered isn't an error.
    578   if (error_name == bluetooth_agent_manager::kErrorAlreadyExists)
    579     return;
    580 
    581   LOG(WARNING) << ": Failed to register pairing agent: "
    582                << error_name << ": " << error_message;
    583 }
    584 
    585 void BluetoothAdapterChromeOS::OnRequestDefaultAgent() {
    586   VLOG(1) << "Pairing agent now default";
    587 }
    588 
    589 void BluetoothAdapterChromeOS::OnRequestDefaultAgentError(
    590     const std::string& error_name,
    591     const std::string& error_message) {
    592   LOG(WARNING) << ": Failed to make pairing agent default: "
    593                << error_name << ": " << error_message;
    594 }
    595 
    596 BluetoothDeviceChromeOS*
    597 BluetoothAdapterChromeOS::GetDeviceWithPath(
    598     const dbus::ObjectPath& object_path) {
    599   for (DevicesMap::iterator iter = devices_.begin();
    600        iter != devices_.end(); ++iter) {
    601     BluetoothDeviceChromeOS* device_chromeos =
    602         static_cast<BluetoothDeviceChromeOS*>(iter->second);
    603     if (device_chromeos->object_path() == object_path)
    604       return device_chromeos;
    605   }
    606 
    607   return NULL;
    608 }
    609 
    610 BluetoothPairingChromeOS* BluetoothAdapterChromeOS::GetPairing(
    611     const dbus::ObjectPath& object_path)
    612 {
    613   BluetoothDeviceChromeOS* device_chromeos = GetDeviceWithPath(object_path);
    614   if (!device_chromeos) {
    615     LOG(WARNING) << "Pairing Agent request for unknown device: "
    616                  << object_path.value();
    617     return NULL;
    618   }
    619 
    620   BluetoothPairingChromeOS* pairing = device_chromeos->GetPairing();
    621   if (pairing)
    622     return pairing;
    623 
    624   // The device doesn't have its own pairing context, so this is an incoming
    625   // pairing request that should use our best default delegate (if we have one).
    626   BluetoothDevice::PairingDelegate* pairing_delegate = DefaultPairingDelegate();
    627   if (!pairing_delegate)
    628     return NULL;
    629 
    630   return device_chromeos->BeginPairing(pairing_delegate);
    631 }
    632 
    633 void BluetoothAdapterChromeOS::SetAdapter(const dbus::ObjectPath& object_path) {
    634   DCHECK(!IsPresent());
    635   object_path_ = object_path;
    636 
    637   VLOG(1) << object_path_.value() << ": using adapter.";
    638 
    639   VLOG(1) << "Registering pairing agent";
    640   DBusThreadManager::Get()->GetBluetoothAgentManagerClient()->
    641       RegisterAgent(
    642           dbus::ObjectPath(kAgentPath),
    643           bluetooth_agent_manager::kKeyboardDisplayCapability,
    644           base::Bind(&BluetoothAdapterChromeOS::OnRegisterAgent,
    645                      weak_ptr_factory_.GetWeakPtr()),
    646           base::Bind(&BluetoothAdapterChromeOS::OnRegisterAgentError,
    647                      weak_ptr_factory_.GetWeakPtr()));
    648 
    649   SetDefaultAdapterName();
    650 
    651   BluetoothAdapterClient::Properties* properties =
    652       DBusThreadManager::Get()->GetBluetoothAdapterClient()->
    653           GetProperties(object_path_);
    654 
    655   PresentChanged(true);
    656 
    657   if (properties->powered.value())
    658     PoweredChanged(true);
    659   if (properties->discoverable.value())
    660     DiscoverableChanged(true);
    661   if (properties->discovering.value())
    662     DiscoveringChanged(true);
    663 
    664   std::vector<dbus::ObjectPath> device_paths =
    665       DBusThreadManager::Get()->GetBluetoothDeviceClient()->
    666           GetDevicesForAdapter(object_path_);
    667 
    668   for (std::vector<dbus::ObjectPath>::iterator iter = device_paths.begin();
    669        iter != device_paths.end(); ++iter) {
    670     DeviceAdded(*iter);
    671   }
    672 }
    673 
    674 void BluetoothAdapterChromeOS::SetDefaultAdapterName() {
    675   std::string board = base::SysInfo::GetLsbReleaseBoard();
    676   std::string alias;
    677   if (board.substr(0, 6) == "stumpy") {
    678     alias = "Chromebox";
    679   } else if (board.substr(0, 4) == "link") {
    680     alias = "Chromebook Pixel";
    681   } else {
    682     alias = "Chromebook";
    683   }
    684 
    685   SetName(alias, base::Bind(&base::DoNothing), base::Bind(&base::DoNothing));
    686 }
    687 
    688 void BluetoothAdapterChromeOS::RemoveAdapter() {
    689   DCHECK(IsPresent());
    690   VLOG(1) << object_path_.value() << ": adapter removed.";
    691 
    692   BluetoothAdapterClient::Properties* properties =
    693       DBusThreadManager::Get()->GetBluetoothAdapterClient()->
    694           GetProperties(object_path_);
    695 
    696   object_path_ = dbus::ObjectPath("");
    697 
    698   if (properties->powered.value())
    699     PoweredChanged(false);
    700   if (properties->discoverable.value())
    701     DiscoverableChanged(false);
    702   if (properties->discovering.value())
    703     DiscoveringChanged(false);
    704 
    705   // Copy the devices list here and clear the original so that when we
    706   // send DeviceRemoved(), GetDevices() returns no devices.
    707   DevicesMap devices = devices_;
    708   devices_.clear();
    709 
    710   for (DevicesMap::iterator iter = devices.begin();
    711        iter != devices.end(); ++iter) {
    712     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
    713                       DeviceRemoved(this, iter->second));
    714     delete iter->second;
    715   }
    716 
    717   PresentChanged(false);
    718 }
    719 
    720 void BluetoothAdapterChromeOS::PoweredChanged(bool powered) {
    721   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
    722                     AdapterPoweredChanged(this, powered));
    723 }
    724 
    725 void BluetoothAdapterChromeOS::DiscoverableChanged(bool discoverable) {
    726   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
    727                     AdapterDiscoverableChanged(this, discoverable));
    728 }
    729 
    730 void BluetoothAdapterChromeOS::DiscoveringChanged(
    731     bool discovering) {
    732   // If the adapter stopped discovery due to a reason other than a request by
    733   // us, reset the count to 0.
    734   VLOG(1) << "Discovering changed: " << discovering;
    735   if (!discovering && !discovery_request_pending_
    736       && num_discovery_sessions_ > 0) {
    737     VLOG(1) << "Marking sessions as inactive.";
    738     num_discovery_sessions_ = 0;
    739     MarkDiscoverySessionsAsInactive();
    740   }
    741   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
    742                     AdapterDiscoveringChanged(this, discovering));
    743 }
    744 
    745 void BluetoothAdapterChromeOS::PresentChanged(bool present) {
    746   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
    747                     AdapterPresentChanged(this, present));
    748 }
    749 
    750 void BluetoothAdapterChromeOS::NotifyDeviceChanged(
    751     BluetoothDeviceChromeOS* device) {
    752   DCHECK(device->adapter_ == this);
    753 
    754   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
    755                     DeviceChanged(this, device));
    756 }
    757 
    758 void BluetoothAdapterChromeOS::NotifyGattServiceAdded(
    759     BluetoothRemoteGattServiceChromeOS* service) {
    760   DCHECK_EQ(service->GetAdapter(), this);
    761   DCHECK_EQ(
    762       static_cast<BluetoothDeviceChromeOS*>(service->GetDevice())->adapter_,
    763       this);
    764 
    765   FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
    766                     observers_,
    767                     GattServiceAdded(this, service->GetDevice(), service));
    768 }
    769 
    770 void BluetoothAdapterChromeOS::NotifyGattServiceRemoved(
    771     BluetoothRemoteGattServiceChromeOS* service) {
    772   DCHECK_EQ(service->GetAdapter(), this);
    773   DCHECK_EQ(
    774       static_cast<BluetoothDeviceChromeOS*>(service->GetDevice())->adapter_,
    775       this);
    776 
    777   FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
    778                     observers_,
    779                     GattServiceRemoved(this, service->GetDevice(), service));
    780 }
    781 
    782 void BluetoothAdapterChromeOS::NotifyGattServiceChanged(
    783     BluetoothRemoteGattServiceChromeOS* service) {
    784   DCHECK_EQ(service->GetAdapter(), this);
    785 
    786   FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
    787                     observers_,
    788                     GattServiceChanged(this, service));
    789 }
    790 
    791 void BluetoothAdapterChromeOS::NotifyGattDiscoveryComplete(
    792     BluetoothRemoteGattServiceChromeOS* service) {
    793   DCHECK_EQ(service->GetAdapter(), this);
    794 
    795   FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
    796                     observers_,
    797                     GattDiscoveryCompleteForService(this, service));
    798 }
    799 
    800 void BluetoothAdapterChromeOS::NotifyGattCharacteristicAdded(
    801     BluetoothRemoteGattCharacteristicChromeOS* characteristic) {
    802   DCHECK_EQ(static_cast<BluetoothRemoteGattServiceChromeOS*>(
    803                 characteristic->GetService())->GetAdapter(),
    804             this);
    805 
    806   FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
    807                     observers_,
    808                     GattCharacteristicAdded(this, characteristic));
    809 }
    810 
    811 void BluetoothAdapterChromeOS::NotifyGattCharacteristicRemoved(
    812     BluetoothRemoteGattCharacteristicChromeOS* characteristic) {
    813   DCHECK_EQ(static_cast<BluetoothRemoteGattServiceChromeOS*>(
    814                 characteristic->GetService())->GetAdapter(),
    815             this);
    816 
    817   FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
    818                     observers_,
    819                     GattCharacteristicRemoved(this, characteristic));
    820 }
    821 
    822 void BluetoothAdapterChromeOS::NotifyGattDescriptorAdded(
    823     BluetoothRemoteGattDescriptorChromeOS* descriptor) {
    824   DCHECK_EQ(static_cast<BluetoothRemoteGattServiceChromeOS*>(
    825                 descriptor->GetCharacteristic()->GetService())->GetAdapter(),
    826             this);
    827 
    828   FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
    829                     observers_,
    830                     GattDescriptorAdded(this, descriptor));
    831 }
    832 
    833 void BluetoothAdapterChromeOS::NotifyGattDescriptorRemoved(
    834     BluetoothRemoteGattDescriptorChromeOS* descriptor) {
    835   DCHECK_EQ(static_cast<BluetoothRemoteGattServiceChromeOS*>(
    836                 descriptor->GetCharacteristic()->GetService())->GetAdapter(),
    837             this);
    838 
    839   FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
    840                     observers_,
    841                     GattDescriptorRemoved(this, descriptor));
    842 }
    843 
    844 void BluetoothAdapterChromeOS::NotifyGattCharacteristicValueChanged(
    845     BluetoothRemoteGattCharacteristicChromeOS* characteristic,
    846     const std::vector<uint8>& value) {
    847   DCHECK_EQ(static_cast<BluetoothRemoteGattServiceChromeOS*>(
    848                 characteristic->GetService())->GetAdapter(),
    849             this);
    850 
    851   FOR_EACH_OBSERVER(
    852       BluetoothAdapter::Observer,
    853       observers_,
    854       GattCharacteristicValueChanged(this, characteristic, value));
    855 }
    856 
    857 void BluetoothAdapterChromeOS::NotifyGattDescriptorValueChanged(
    858     BluetoothRemoteGattDescriptorChromeOS* descriptor,
    859     const std::vector<uint8>& value) {
    860   DCHECK_EQ(static_cast<BluetoothRemoteGattServiceChromeOS*>(
    861                 descriptor->GetCharacteristic()->GetService())->GetAdapter(),
    862             this);
    863 
    864   FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
    865                     observers_,
    866                     GattDescriptorValueChanged(this, descriptor, value));
    867 }
    868 
    869 void BluetoothAdapterChromeOS::OnSetDiscoverable(
    870     const base::Closure& callback,
    871     const ErrorCallback& error_callback,
    872     bool success) {
    873   // Set the discoverable_timeout property to zero so the adapter remains
    874   // discoverable forever.
    875   DBusThreadManager::Get()->GetBluetoothAdapterClient()->
    876       GetProperties(object_path_)->discoverable_timeout.Set(
    877           0,
    878           base::Bind(&BluetoothAdapterChromeOS::OnPropertyChangeCompleted,
    879                      weak_ptr_factory_.GetWeakPtr(),
    880                      callback,
    881                      error_callback));
    882 }
    883 
    884 void BluetoothAdapterChromeOS::OnPropertyChangeCompleted(
    885     const base::Closure& callback,
    886     const ErrorCallback& error_callback,
    887     bool success) {
    888   if (success)
    889     callback.Run();
    890   else
    891     error_callback.Run();
    892 }
    893 
    894 void BluetoothAdapterChromeOS::AddDiscoverySession(
    895     const base::Closure& callback,
    896     const ErrorCallback& error_callback) {
    897   VLOG(1) << __func__;
    898   if (discovery_request_pending_) {
    899     // The pending request is either to stop a previous session or to start a
    900     // new one. Either way, queue this one.
    901     DCHECK(num_discovery_sessions_ == 1 || num_discovery_sessions_ == 0);
    902     VLOG(1) << "Pending request to start/stop device discovery. Queueing "
    903             << "request to start a new discovery session.";
    904     discovery_request_queue_.push(std::make_pair(callback, error_callback));
    905     return;
    906   }
    907 
    908   // The adapter is already discovering.
    909   if (num_discovery_sessions_ > 0) {
    910     DCHECK(IsDiscovering());
    911     DCHECK(!discovery_request_pending_);
    912     num_discovery_sessions_++;
    913     callback.Run();
    914     return;
    915   }
    916 
    917   // There are no active discovery sessions.
    918   DCHECK(num_discovery_sessions_ == 0);
    919 
    920   // This is the first request to start device discovery.
    921   discovery_request_pending_ = true;
    922   DBusThreadManager::Get()->GetBluetoothAdapterClient()->
    923       StartDiscovery(
    924           object_path_,
    925           base::Bind(&BluetoothAdapterChromeOS::OnStartDiscovery,
    926                      weak_ptr_factory_.GetWeakPtr(),
    927                      callback),
    928           base::Bind(&BluetoothAdapterChromeOS::OnStartDiscoveryError,
    929                      weak_ptr_factory_.GetWeakPtr(),
    930                      callback,
    931                      error_callback));
    932 }
    933 
    934 void BluetoothAdapterChromeOS::RemoveDiscoverySession(
    935     const base::Closure& callback,
    936     const ErrorCallback& error_callback) {
    937   VLOG(1) << __func__;
    938   // There are active sessions other than the one currently being removed.
    939   if (num_discovery_sessions_ > 1) {
    940     DCHECK(IsDiscovering());
    941     DCHECK(!discovery_request_pending_);
    942     num_discovery_sessions_--;
    943     callback.Run();
    944     return;
    945   }
    946 
    947   // If there is a pending request to BlueZ, then queue this request.
    948   if (discovery_request_pending_) {
    949     VLOG(1) << "Pending request to start/stop device discovery. Queueing "
    950             << "request to stop discovery session.";
    951     error_callback.Run();
    952     return;
    953   }
    954 
    955   // There are no active sessions. Return error.
    956   if (num_discovery_sessions_ == 0) {
    957     // TODO(armansito): This should never happen once we have the
    958     // DiscoverySession API. Replace this case with an assert once it's
    959     // the deprecated methods have been removed. (See crbug.com/3445008).
    960     VLOG(1) << "No active discovery sessions. Returning error.";
    961     error_callback.Run();
    962     return;
    963   }
    964 
    965   // There is exactly one active discovery session. Request BlueZ to stop
    966   // discovery.
    967   DCHECK(num_discovery_sessions_ == 1);
    968   discovery_request_pending_ = true;
    969   DBusThreadManager::Get()->GetBluetoothAdapterClient()->
    970       StopDiscovery(
    971           object_path_,
    972           base::Bind(&BluetoothAdapterChromeOS::OnStopDiscovery,
    973                      weak_ptr_factory_.GetWeakPtr(),
    974                      callback),
    975           base::Bind(&BluetoothAdapterChromeOS::OnStopDiscoveryError,
    976                      weak_ptr_factory_.GetWeakPtr(),
    977                      error_callback));
    978 }
    979 
    980 void BluetoothAdapterChromeOS::OnStartDiscovery(const base::Closure& callback) {
    981   // Report success on the original request and increment the count.
    982   VLOG(1) << __func__;
    983   DCHECK(discovery_request_pending_);
    984   DCHECK(num_discovery_sessions_ == 0);
    985   discovery_request_pending_ = false;
    986   num_discovery_sessions_++;
    987   callback.Run();
    988 
    989   // Try to add a new discovery session for each queued request.
    990   ProcessQueuedDiscoveryRequests();
    991 }
    992 
    993 void BluetoothAdapterChromeOS::OnStartDiscoveryError(
    994     const base::Closure& callback,
    995     const ErrorCallback& error_callback,
    996     const std::string& error_name,
    997     const std::string& error_message) {
    998   LOG(WARNING) << object_path_.value() << ": Failed to start discovery: "
    999                << error_name << ": " << error_message;
   1000 
   1001   // Failed to start discovery. This can only happen if the count is at 0.
   1002   DCHECK(num_discovery_sessions_ == 0);
   1003   DCHECK(discovery_request_pending_);
   1004   discovery_request_pending_ = false;
   1005 
   1006   // Discovery request may fail if discovery was previously initiated by Chrome,
   1007   // but the session were invalidated due to the discovery state unexpectedly
   1008   // changing to false and then back to true. In this case, report success.
   1009   if (error_name == bluetooth_device::kErrorInProgress && IsDiscovering()) {
   1010     VLOG(1) << "Discovery previously initiated. Reporting success.";
   1011     num_discovery_sessions_++;
   1012     callback.Run();
   1013   } else {
   1014     error_callback.Run();
   1015   }
   1016 
   1017   // Try to add a new discovery session for each queued request.
   1018   ProcessQueuedDiscoveryRequests();
   1019 }
   1020 
   1021 void BluetoothAdapterChromeOS::OnStopDiscovery(const base::Closure& callback) {
   1022   // Report success on the original request and decrement the count.
   1023   VLOG(1) << __func__;
   1024   DCHECK(discovery_request_pending_);
   1025   DCHECK(num_discovery_sessions_ == 1);
   1026   discovery_request_pending_ = false;
   1027   num_discovery_sessions_--;
   1028   callback.Run();
   1029 
   1030   // Try to add a new discovery session for each queued request.
   1031   ProcessQueuedDiscoveryRequests();
   1032 }
   1033 
   1034 void BluetoothAdapterChromeOS::OnStopDiscoveryError(
   1035     const ErrorCallback& error_callback,
   1036     const std::string& error_name,
   1037     const std::string& error_message) {
   1038   LOG(WARNING) << object_path_.value() << ": Failed to stop discovery: "
   1039                << error_name << ": " << error_message;
   1040 
   1041   // Failed to stop discovery. This can only happen if the count is at 1.
   1042   DCHECK(discovery_request_pending_);
   1043   DCHECK(num_discovery_sessions_ == 1);
   1044   discovery_request_pending_ = false;
   1045   error_callback.Run();
   1046 
   1047   // Try to add a new discovery session for each queued request.
   1048   ProcessQueuedDiscoveryRequests();
   1049 }
   1050 
   1051 void BluetoothAdapterChromeOS::ProcessQueuedDiscoveryRequests() {
   1052   while (!discovery_request_queue_.empty()) {
   1053     VLOG(1) << "Process queued discovery request.";
   1054     DiscoveryCallbackPair callbacks = discovery_request_queue_.front();
   1055     discovery_request_queue_.pop();
   1056     AddDiscoverySession(callbacks.first, callbacks.second);
   1057 
   1058     // If the queued request resulted in a pending call, then let it
   1059     // asynchonously process the remaining queued requests once the pending
   1060     // call returns.
   1061     if (discovery_request_pending_)
   1062       return;
   1063   }
   1064 }
   1065 
   1066 }  // namespace chromeos
   1067