Fix crash on second failed connect to a paired device

chromeos/dbus/fake_bluetooth_device_client.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 "chromeos/dbus/fake_bluetooth_device_client.h"
 
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/socket.h>
@@ skipping 167 matching lines @@
 
 const char FakeBluetoothDeviceClient::kLowEnergyPath[] =
     "/fake/hci0/devC";
 const char FakeBluetoothDeviceClient::kLowEnergyAddress[] =
     "00:1A:11:00:15:30";
 const char FakeBluetoothDeviceClient::kLowEnergyName[] =
     "Bluetooth 4.0 Heart Rate Monitor";
 const uint32 FakeBluetoothDeviceClient::kLowEnergyClass =
     0x000918;  // Major class "Health", Minor class "Heart/Pulse Rate Monitor."
 
+const char FakeBluetoothDeviceClient::kPairedUnconnectableDevicePath[] =
+    "/fake/hci0/devD";
+const char FakeBluetoothDeviceClient::kPairedUnconnectableDeviceAddress[] =
+    "20:7D:74:00:00:04";
+const char FakeBluetoothDeviceClient::kPairedUnconnectableDeviceName[] =
+    "Paired Unconnectable Device";
+const uint32 FakeBluetoothDeviceClient::kPairedUnconnectableDeviceClass =
+    0x000104;
+
 FakeBluetoothDeviceClient::Properties::Properties(
     const PropertyChangedCallback& callback)
     : BluetoothDeviceClient::Properties(
           NULL,
           bluetooth_device::kBluetoothDeviceInterface,
           callback) {
 }
 
 FakeBluetoothDeviceClient::Properties::~Properties() {
 }
@@ skipping 44 matching lines @@
 
   std::vector<std::string> uuids;
   uuids.push_back("00001800-0000-1000-8000-00805f9b34fb");
   uuids.push_back("00001801-0000-1000-8000-00805f9b34fb");
   properties->uuids.ReplaceValue(uuids);
 
   properties->modalias.ReplaceValue("usb:v05ACp030Dd0306");
 
   properties_map_[dbus::ObjectPath(kPairedDevicePath)] = properties;
   device_list_.push_back(dbus::ObjectPath(kPairedDevicePath));
+
+  properties = new Properties(base::Bind(
+      &FakeBluetoothDeviceClient::OnPropertyChanged, base::Unretained(this),

[armansito, 2015/02/07 00:29:55]

nit: Formatting. Put second argument in its own line.

[Marie Janssen, 2015/02/09 18:58:41]

git cl format chromeos disagrees, and chromeos/ requires clang-formatting.

[armansito, 2015/02/09 20:35:22]

I disagree with git cl format here, it doesn't always produce the best
formatting (especially for unit tests with gmock).

+      dbus::ObjectPath(kPairedUnconnectableDevicePath)));
+  properties->address.ReplaceValue(kPairedUnconnectableDeviceAddress);
+  properties->bluetooth_class.ReplaceValue(kPairedUnconnectableDeviceClass);
+  properties->name.ReplaceValue("Fake Device 2 (Unconnectable)");
+  properties->alias.ReplaceValue(kPairedUnconnectableDeviceName);
+  properties->paired.ReplaceValue(true);
+  properties->trusted.ReplaceValue(true);
+  properties->adapter.ReplaceValue(
+      dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath));
+
+  properties->uuids.ReplaceValue(uuids);
+
+  properties->modalias.ReplaceValue("usb:v05ACp030Dd0306");
+
+  properties_map_[dbus::ObjectPath(kPairedUnconnectableDevicePath)] =
+      properties;
+  device_list_.push_back(dbus::ObjectPath(kPairedUnconnectableDevicePath));
 }
 
 FakeBluetoothDeviceClient::~FakeBluetoothDeviceClient() {
   // Clean up Properties structures
   STLDeleteValues(&properties_map_);
 }
 
 void FakeBluetoothDeviceClient::Init(dbus::Bus* bus) {
 }
 
@@ skipping 35 matching lines @@
     return;
   }
 
   if (properties->paired.value() != true &&
       object_path != dbus::ObjectPath(kConnectUnpairablePath) &&
       object_path != dbus::ObjectPath(kLowEnergyPath)) {
     // Must be paired.
     error_callback.Run(bluetooth_device::kErrorFailed, "Not paired");
     return;
   } else if (properties->paired.value() == true &&
-             object_path == dbus::ObjectPath(kUnconnectableDevicePath)) {
+             (object_path == dbus::ObjectPath(kUnconnectableDevicePath) ||
+              object_path ==
+                  dbus::ObjectPath(kPairedUnconnectableDevicePath))) {
     // Must not be paired
     error_callback.Run(bluetooth_device::kErrorFailed,
                        "Connection fails while paired");
     return;
   }
 
   // The device can be connected.
   properties->connected.ReplaceValue(true);
   callback.Run();
 
@@ skipping 43 matching lines @@
   FakeBluetoothProfileManagerClient* fake_bluetooth_profile_manager_client =
       static_cast<FakeBluetoothProfileManagerClient*>(
           DBusThreadManager::Get()->GetBluetoothProfileManagerClient());
   FakeBluetoothProfileServiceProvider* profile_service_provider =
       fake_bluetooth_profile_manager_client->GetProfileServiceProvider(uuid);
   if (profile_service_provider == NULL) {
     error_callback.Run(kNoResponseError, "Missing profile");
     return;
   }
 
+  if (object_path == dbus::ObjectPath(kPairedUnconnectableDevicePath)) {
+    error_callback.Run(kNoResponseError, "unconnectable");

[armansito, 2015/02/07 00:29:55]

I think we use kNoResponseError for cases that are related to a D-Bus response
timeout. So maybe use a different error here.

[Marie Janssen, 2015/02/09 18:58:41]

Done. Using kErrorFailed instead.

+    return;
+  }
+
   // Make a socket pair of a compatible type with the type used by Bluetooth;
   // spin up a thread to simulate the server side and wrap the client side in
   // a D-Bus file descriptor object.
   int socket_type = SOCK_STREAM;
   if (uuid == FakeBluetoothProfileManagerClient::kL2capUuid)
     socket_type = SOCK_SEQPACKET;
 
   int fds[2];
   if (socketpair(AF_UNIX, socket_type, 0, fds) < 0) {
     error_callback.Run(kNoResponseError, "socketpair call failed");
@@ skipping 820 matching lines @@
     // TODO(keybuk): tear down this side of the connection
     callback.Run();
   } else if (status == BluetoothProfileServiceProvider::Delegate::CANCELLED) {
     error_callback.Run(bluetooth_device::kErrorFailed, "Canceled");
   } else if (status == BluetoothProfileServiceProvider::Delegate::REJECTED) {
     error_callback.Run(bluetooth_device::kErrorFailed, "Rejected");
   }
 }
 
 }  // namespace chromeos