Bluetooth: treat unpairable devices as Trusted/Paired

device/bluetooth/bluetooth_device_chromeos.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 "device/bluetooth/bluetooth_device_chromeos.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 145 matching lines @@
       callback);
   ConnectErrorCallback wrapped_error_callback = base::Bind(
       &BluetoothDeviceChromeOS::OnConnectErrorCallbackCalled,
       weak_ptr_factory_.GetWeakPtr(),
       error_callback);
 
   if (IsPaired() || IsConnected()) {
     // Connection to already paired or connected device.
     ConnectApplications(wrapped_callback, wrapped_error_callback);
 
-  } else if (!pairing_delegate) {
-    // No pairing delegate supplied, initiate low-security connection only.
+  } else if (!pairing_delegate || !IsPairable()) {
+    // No pairing delegate supplied, or unpairable device; initiate
+    // low-security connection only.
     DBusThreadManager::Get()->GetBluetoothAdapterClient()->
         CreateDevice(adapter_->object_path_,
                      address_,
                      base::Bind(&BluetoothDeviceChromeOS::OnCreateDevice,
                                 weak_ptr_factory_.GetWeakPtr(),
                                 wrapped_callback,
                                 wrapped_error_callback),
                      base::Bind(&BluetoothDeviceChromeOS::OnCreateDeviceError,
                                 weak_ptr_factory_.GetWeakPtr(),
                                 wrapped_error_callback));
@@ skipping 225 matching lines @@
   VLOG(1) << "Connection successful: " << device_path.value();
   if (object_path_.value().empty()) {
     object_path_ = device_path;
   } else {
     LOG_IF(WARNING, object_path_ != device_path)
         << "Conflicting device paths for objects, result gave: "
         << device_path.value() << " but signal gave: "
         << object_path_.value();
   }
 
-  // Mark the device trusted so it can connect to us automatically, and
-  // we can connect after rebooting. This information is part of the
-  // pairing information of the device, and is unique to the combination
-  // of our bluetooth address and the device's bluetooth address. A
-  // different host needs a new pairing, so it's not useful to sync.
-  DBusThreadManager::Get()->GetBluetoothDeviceClient()->
-      GetProperties(object_path_)->trusted.Set(
-          true,
-          base::Bind(&BluetoothDeviceChromeOS::OnSetTrusted,
-                     weak_ptr_factory_.GetWeakPtr()));
+  SetTrusted();
 
   // In parallel with the |trusted| property change, call GetServiceRecords to
   // retrieve the SDP from the device and then, either on success or failure,
   // call ConnectApplications.
   GetServiceRecords(
       base::Bind(&BluetoothDeviceChromeOS::OnInitialGetServiceRecords,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback,
                  error_callback),
       base::Bind(&BluetoothDeviceChromeOS::OnInitialGetServiceRecordsError,
@@ skipping 50 matching lines @@
   for (BluetoothDeviceClient::ServiceMap::const_iterator i =
       service_map.begin(); i != service_map.end(); ++i) {
     service_records_.push_back(
         new BluetoothServiceRecordChromeOS(address_, i->second));
   }
   service_records_loaded_ = true;
 
   callback.Run(service_records_);
 }
 
+void BluetoothDeviceChromeOS::SetTrusted() {
+  // Unconditionally send the property change, rather than checking the value
+  // first; there's no harm in doing this and it solves any race conditions
+  // with the property becoming true or false and this call happening before
+  // we get the D-Bus signal about the earlier change.
+  DBusThreadManager::Get()->GetBluetoothDeviceClient()->
+      GetProperties(object_path_)->trusted.Set(
+          true,
+          base::Bind(
+              &BluetoothDeviceChromeOS::OnSetTrusted,
+              weak_ptr_factory_.GetWeakPtr()));
+}
+
 void BluetoothDeviceChromeOS::OnSetTrusted(bool success) {
   LOG_IF(WARNING, !success) << "Failed to set device as trusted: " << address_;
 }
 
 void BluetoothDeviceChromeOS::OnInitialGetServiceRecords(
     const base::Closure& callback,
     const ConnectErrorCallback& error_callback,
     const ServiceRecordList& list) {
   // Connect application-layer protocols.
   ConnectApplications(callback, error_callback);
@@ skipping 103 matching lines @@
           << ": " << interface_name;
 
   connecting_applications_counter_--;
   // |callback| should only be called once, meaning it cannot be called before
   // all requests have been started.  The extra decrement after all requests
   // have been started, and the check for -1 instead of 0 below, insure only a
   // single call to |callback| will occur (provided OnConnect and OnIntrospect
   // run on the same thread, which is true).
   if (connecting_applications_counter_ == -1) {
     connecting_applications_counter_ = 0;
+    SetTrusted();
     callback.Run();
   }
 }
 
 void BluetoothDeviceChromeOS::OnConnectError(
     const ConnectErrorCallback& error_callback,
     const std::string& interface_name,
     const dbus::ObjectPath& device_path,
     const std::string& error_name,
     const std::string& error_message) {
@@ skipping 224 matching lines @@
 }
 
 
 // static
 BluetoothDeviceChromeOS* BluetoothDeviceChromeOS::Create(
     BluetoothAdapterChromeOS* adapter) {
   return new BluetoothDeviceChromeOS(adapter);
 }
 
 }  // namespace chromeos