Bluetooth: treat unpairable devices as Trusted/Paired

device/bluetooth/bluetooth_device_experimental_chromeos.cc

 // Copyright (c) 2013 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_experimental_chromeos.h"
 
 #include "base/bind.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/experimental_bluetooth_adapter_client.h"
 #include "chromeos/dbus/experimental_bluetooth_agent_manager_client.h"
@@ skipping 56 matching lines @@
 
   return properties->address.value();
 }
 
 bool BluetoothDeviceExperimentalChromeOS::IsPaired() const {
   ExperimentalBluetoothDeviceClient::Properties* properties =
       DBusThreadManager::Get()->GetExperimentalBluetoothDeviceClient()->
           GetProperties(object_path_);
   DCHECK(properties);
 
-  return properties->paired.value();
+  // Trusted devices are devices that don't support pairing but that the
+  // user has explicitly connected; it makes no sense for UI purposes to
+  // treat them differently from each other.
+  return properties->paired.value() || properties->trusted.value();
 }
 
 bool BluetoothDeviceExperimentalChromeOS::IsConnected() const {
   ExperimentalBluetoothDeviceClient::Properties* properties =
       DBusThreadManager::Get()->GetExperimentalBluetoothDeviceClient()->
           GetProperties(object_path_);
   DCHECK(properties);
 
   return properties->connected.value();
 }
@@ skipping 44 matching lines @@
 }
 
 void BluetoothDeviceExperimentalChromeOS::Connect(
     BluetoothDevice::PairingDelegate* pairing_delegate,
     const base::Closure& callback,
     const ConnectErrorCallback& error_callback) {
   ++num_connecting_calls_;
   VLOG(1) << object_path_.value() << ": Connecting, " << num_connecting_calls_
           << " in progress";
 
-  if (IsPaired() || IsConnected() || !pairing_delegate) {
-    // No need to pair, skip straight to connection.
+  if (IsPaired() || IsConnected() || !pairing_delegate || !IsPairable()) {
+    // No need to pair, or unable to, skip straight to connection.
     ConnectInternal(callback, error_callback);
   } else {
     // Initiate high-security connection with pairing.
     DCHECK(!pairing_delegate_);
     DCHECK(agent_.get() == NULL);
 
     pairing_delegate_ = pairing_delegate;
 
     // The agent path is relatively meaningless since BlueZ only supports
     // one per application at a time.
@@ skipping 76 matching lines @@
           base::Bind(
               &BluetoothDeviceExperimentalChromeOS::OnDisconnectError,
               weak_ptr_factory_.GetWeakPtr(),
               error_callback));
 }
 
 void BluetoothDeviceExperimentalChromeOS::Forget(
    const ErrorCallback& error_callback) {
   VLOG(1) << object_path_.value() << ": Removing device";
   DBusThreadManager::Get()->GetExperimentalBluetoothAdapterClient()->
-      RemoveDevice(
-          adapter_->object_path_,
-          object_path_,
-          base::Bind(&base::DoNothing),
-          base::Bind(
-              &BluetoothDeviceExperimentalChromeOS::OnForgetError,
-              weak_ptr_factory_.GetWeakPtr(),
-              error_callback));
+       RemoveDevice(

[deymo, 2013/04/18 18:41:11]

This block should have 4-space indentation instead f 5.

+           adapter_->object_path_,
+           object_path_,
+           base::Bind(&base::DoNothing),
+           base::Bind(
+               &BluetoothDeviceExperimentalChromeOS::OnForgetError,
+               weak_ptr_factory_.GetWeakPtr(),
+               error_callback));
 }
 
 void BluetoothDeviceExperimentalChromeOS::ConnectToService(
     const std::string& service_uuid,
     const SocketCallback& callback) {
   // TODO(keybuk): implement
   callback.Run(scoped_refptr<device::BluetoothSocket>());
 }
 
 void BluetoothDeviceExperimentalChromeOS::SetOutOfBandPairingData(
@@ skipping 131 matching lines @@
               error_callback));
 }
 
 void BluetoothDeviceExperimentalChromeOS::OnConnect(
     const base::Closure& callback) {
   --num_connecting_calls_;
   DCHECK(num_connecting_calls_ >= 0);
   VLOG(1) << object_path_.value() << ": Connected, " << num_connecting_calls_
         << " still in progress";
 
+  SetTrusted();
+
   callback.Run();
 }
 
 void BluetoothDeviceExperimentalChromeOS::OnConnectError(
     const ConnectErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   --num_connecting_calls_;
   DCHECK(num_connecting_calls_ >= 0);
   LOG(WARNING) << object_path_.value() << ": Failed to connect device: "
@@ skipping 49 matching lines @@
   if (error_name == bluetooth_adapter::kErrorAlreadyExists)
     error_code = ERROR_INPROGRESS;
 
   error_callback.Run(error_code);
 }
 
 void BluetoothDeviceExperimentalChromeOS::OnPair(
     const base::Closure& callback,
     const ConnectErrorCallback& error_callback) {
   VLOG(1) << object_path_.value() << ": Paired";
-
-  // Now that we're paired, we need to set the device as trusted so that
-  // incoming connections will be accepted. This should only ever fail if
-  // the device is removed mid-pairing, so do it in the background while
-  // we connect and don't worry about errors.
-  DBusThreadManager::Get()->GetExperimentalBluetoothDeviceClient()->
-      GetProperties(object_path_)->trusted.Set(
-          true,
-          base::Bind(
-              &BluetoothDeviceExperimentalChromeOS::OnSetTrusted,
-              weak_ptr_factory_.GetWeakPtr()));
-
   UnregisterAgent();
-
-  // Now we can connect to the device!
+  SetTrusted();
   ConnectInternal(callback, error_callback);
 }
 
 void BluetoothDeviceExperimentalChromeOS::OnPairError(
     const ConnectErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
   --num_connecting_calls_;
   DCHECK(num_connecting_calls_ >= 0);
   LOG(WARNING) << object_path_.value() << ": Failed to pair device: "
@@ skipping 20 matching lines @@
   error_callback.Run(error_code);
 }
 
 void BluetoothDeviceExperimentalChromeOS::OnCancelPairingError(
     const std::string& error_name,
     const std::string& error_message) {
   LOG(WARNING) << object_path_.value() << ": Failed to cancel pairing: "
                << error_name << ": " << error_message;
 }
 
+void BluetoothDeviceExperimentalChromeOS::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()->GetExperimentalBluetoothDeviceClient()->
+      GetProperties(object_path_)->trusted.Set(
+          true,
+          base::Bind(
+              &BluetoothDeviceExperimentalChromeOS::OnSetTrusted,
+              weak_ptr_factory_.GetWeakPtr()));
+}
+
 void BluetoothDeviceExperimentalChromeOS::OnSetTrusted(bool success) {
   LOG_IF(WARNING, !success) << object_path_.value()
-                            << ": Failed to set device as trusted";
+                            << "Failed to set device as trusted";

[deymo, 2013/04/18 18:41:11]

Please insert a space before "Failed ..." in the output stream.

 }
 
 void BluetoothDeviceExperimentalChromeOS::UnregisterAgent() {
   DCHECK(agent_.get());
   DCHECK(pairing_delegate_);
 
   DCHECK(pincode_callback_.is_null());
   DCHECK(passkey_callback_.is_null());
   DCHECK(confirmation_callback_.is_null());
 
@@ skipping 64 matching lines @@
   if (!confirmation_callback_.is_null()) {
     confirmation_callback_.Run(status);
     confirmation_callback_.Reset();
     callback_run = true;
   }
 
   return callback_run;
 }
 
 }  // namespace chromeos