Fix crash on second failed connect to a paired device

device/bluetooth/bluetooth_chromeos_unittest.cc

 // Copyright 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 "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_bluetooth_adapter_client.h"
 #include "chromeos/dbus/fake_bluetooth_agent_manager_client.h"
@@ skipping 396 matching lines @@
   // This verifies that the class gets the list of adapters when created;
   // and initializes with an existing adapter if there is one.
   EXPECT_TRUE(adapter_->IsPresent());
   EXPECT_FALSE(adapter_->IsPowered());
   EXPECT_EQ(FakeBluetoothAdapterClient::kAdapterAddress,
             adapter_->GetAddress());
   EXPECT_FALSE(adapter_->IsDiscovering());
 
   // There should be a device
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
-  EXPECT_EQ(1U, devices.size());
+  EXPECT_EQ(2U, devices.size());
   EXPECT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
             devices[0]->GetAddress());
+  EXPECT_EQ(FakeBluetoothDeviceClient::kPairedUnconnectableDeviceAddress,
+            devices[1]->GetAddress());
 }
 
 TEST_F(BluetoothChromeOSTest, BecomePresent) {
   fake_bluetooth_adapter_client_->SetVisible(false);
   GetAdapter();
   ASSERT_FALSE(adapter_->IsPresent());
 
   // Install an observer; expect the AdapterPresentChanged to be called
   // with true, and IsPresent() to return true.
   TestObserver observer(adapter_);
 
   fake_bluetooth_adapter_client_->SetVisible(true);
 
   EXPECT_EQ(1, observer.present_changed_count_);
   EXPECT_TRUE(observer.last_present_);
 
   EXPECT_TRUE(adapter_->IsPresent());
 
   // We should have had a device announced.
-  EXPECT_EQ(1, observer.device_added_count_);
-  EXPECT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
+  EXPECT_EQ(2, observer.device_added_count_);
+  EXPECT_EQ(FakeBluetoothDeviceClient::kPairedUnconnectableDeviceAddress,
             observer.last_device_address_);
 
   // Other callbacks shouldn't be called if the values are false.
   EXPECT_EQ(0, observer.powered_changed_count_);
   EXPECT_EQ(0, observer.discovering_changed_count_);
   EXPECT_FALSE(adapter_->IsPowered());
   EXPECT_FALSE(adapter_->IsDiscovering());
 }
 
 TEST_F(BluetoothChromeOSTest, BecomeNotPresent) {
   GetAdapter();
   ASSERT_TRUE(adapter_->IsPresent());
 
   // Install an observer; expect the AdapterPresentChanged to be called
   // with false, and IsPresent() to return false.
   TestObserver observer(adapter_);
 
   fake_bluetooth_adapter_client_->SetVisible(false);
 
   EXPECT_EQ(1, observer.present_changed_count_);
   EXPECT_FALSE(observer.last_present_);
 
   EXPECT_FALSE(adapter_->IsPresent());
 
   // We should have had a device removed.
-  EXPECT_EQ(1, observer.device_removed_count_);
-  EXPECT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
+  EXPECT_EQ(2, observer.device_removed_count_);
+  EXPECT_EQ(FakeBluetoothDeviceClient::kPairedUnconnectableDeviceAddress,
             observer.last_device_address_);
 
   // Other callbacks shouldn't be called since the values are false.
   EXPECT_EQ(0, observer.powered_changed_count_);
   EXPECT_EQ(0, observer.discovering_changed_count_);
   EXPECT_FALSE(adapter_->IsPowered());
   EXPECT_FALSE(adapter_->IsDiscovering());
 }
 
 TEST_F(BluetoothChromeOSTest, SecondAdapter) {
@@ skipping 15 matching lines @@
   // Try removing the first adapter, we should now act as if the adapter
   // is no longer present rather than fall back to the second.
   fake_bluetooth_adapter_client_->SetVisible(false);
 
   EXPECT_EQ(1, observer.present_changed_count_);
   EXPECT_FALSE(observer.last_present_);
 
   EXPECT_FALSE(adapter_->IsPresent());
 
   // We should have had a device removed.
-  EXPECT_EQ(1, observer.device_removed_count_);
-  EXPECT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
+  EXPECT_EQ(2, observer.device_removed_count_);
+  EXPECT_EQ(FakeBluetoothDeviceClient::kPairedUnconnectableDeviceAddress,
             observer.last_device_address_);
 
   // Other callbacks shouldn't be called since the values are false.
   EXPECT_EQ(0, observer.powered_changed_count_);
   EXPECT_EQ(0, observer.discovering_changed_count_);
   EXPECT_FALSE(adapter_->IsPowered());
   EXPECT_FALSE(adapter_->IsDiscovering());
 
   observer.device_removed_count_ = 0;
 
@@ skipping 1012 matching lines @@
   EXPECT_EQ(4, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(observer.last_discovering_);
   EXPECT_FALSE(adapter_->IsDiscovering());
 }
 
 TEST_F(BluetoothChromeOSTest, DeviceProperties) {
   GetAdapter();
 
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
-  ASSERT_EQ(1U, devices.size());
+  ASSERT_EQ(2U, devices.size());
   ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
             devices[0]->GetAddress());
 
   // Verify the other device properties.
   EXPECT_EQ(base::UTF8ToUTF16(FakeBluetoothDeviceClient::kPairedDeviceName),
             devices[0]->GetName());
   EXPECT_EQ(BluetoothDevice::DEVICE_COMPUTER, devices[0]->GetDeviceType());
   EXPECT_TRUE(devices[0]->IsPaired());
   EXPECT_FALSE(devices[0]->IsConnected());
   EXPECT_FALSE(devices[0]->IsConnecting());
@@ skipping 11 matching lines @@
   EXPECT_EQ(0x030d, devices[0]->GetProductID());
   EXPECT_EQ(0x0306, devices[0]->GetDeviceID());
 }
 
 TEST_F(BluetoothChromeOSTest, DeviceClassChanged) {
   // Simulate a change of class of a device, as sometimes occurs
   // during discovery.
   GetAdapter();
 
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
-  ASSERT_EQ(1U, devices.size());
+  ASSERT_EQ(2U, devices.size());
   ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
             devices[0]->GetAddress());
   ASSERT_EQ(BluetoothDevice::DEVICE_COMPUTER, devices[0]->GetDeviceType());
 
   // Install an observer; expect the DeviceChanged method to be called when
   // we change the class of the device.
   TestObserver observer(adapter_);
 
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kPairedDevicePath));
 
   properties->bluetooth_class.ReplaceValue(0x002580);
 
   EXPECT_EQ(1, observer.device_changed_count_);
   EXPECT_EQ(devices[0], observer.last_device_);
 
   EXPECT_EQ(BluetoothDevice::DEVICE_MOUSE, devices[0]->GetDeviceType());
 }
 
 TEST_F(BluetoothChromeOSTest, DeviceNameChanged) {
   // Simulate a change of name of a device.
   GetAdapter();
 
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
-  ASSERT_EQ(1U, devices.size());
+  ASSERT_EQ(2U, devices.size());
   ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
             devices[0]->GetAddress());
   ASSERT_EQ(base::UTF8ToUTF16(FakeBluetoothDeviceClient::kPairedDeviceName),
             devices[0]->GetName());
 
   // Install an observer; expect the DeviceChanged method to be called when
   // we change the alias of the device.
   TestObserver observer(adapter_);
 
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kPairedDevicePath));
 
   static const std::string new_name("New Device Name");
   properties->alias.ReplaceValue(new_name);
 
   EXPECT_EQ(1, observer.device_changed_count_);
   EXPECT_EQ(devices[0], observer.last_device_);
 
   EXPECT_EQ(base::UTF8ToUTF16(new_name), devices[0]->GetName());
 }
 
 TEST_F(BluetoothChromeOSTest, DeviceUuidsChanged) {
   // Simulate a change of advertised services of a device.
   GetAdapter();
 
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
-  ASSERT_EQ(1U, devices.size());
+  ASSERT_EQ(2U, devices.size());
   ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
             devices[0]->GetAddress());
 
   BluetoothDevice::UUIDList uuids = devices[0]->GetUUIDs();
   ASSERT_EQ(2U, uuids.size());
   ASSERT_EQ(uuids[0], BluetoothUUID("1800"));
   ASSERT_EQ(uuids[1], BluetoothUUID("1801"));
 
   // Install an observer; expect the DeviceChanged method to be called when
   // we change the class of the device.
@@ skipping 22 matching lines @@
   EXPECT_EQ(uuids[1], BluetoothUUID("1801"));
   EXPECT_EQ(uuids[2], BluetoothUUID("110c"));
   EXPECT_EQ(uuids[3], BluetoothUUID("110e"));
   EXPECT_EQ(uuids[4], BluetoothUUID("110a"));
 }
 
 TEST_F(BluetoothChromeOSTest, ForgetDevice) {
   GetAdapter();
 
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
-  ASSERT_EQ(1U, devices.size());
+  ASSERT_EQ(2U, devices.size());
   ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
             devices[0]->GetAddress());
 
   std::string address = devices[0]->GetAddress();
 
   // Install an observer; expect the DeviceRemoved method to be called
   // with the device we remove.
   TestObserver observer(adapter_);
 
   devices[0]->Forget(
       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.device_removed_count_);
   EXPECT_EQ(address, observer.last_device_address_);
 
   // GetDevices shouldn't return the device either.
   devices = adapter_->GetDevices();
-  ASSERT_EQ(0U, devices.size());
+  ASSERT_EQ(1U, devices.size());
 }
 
 TEST_F(BluetoothChromeOSTest, ForgetUnpairedDevice) {
   GetAdapter();
   DiscoverDevices();
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConnectUnpairableAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
@@ skipping 1638 matching lines @@
   callback_count_ = 0;
 
   // Validate running adapter state.
   EXPECT_NE("", adapter_->GetAddress());
   EXPECT_NE("", adapter_->GetName());
   EXPECT_TRUE(adapter_->IsInitialized());
   EXPECT_TRUE(adapter_->IsPresent());
   EXPECT_TRUE(adapter_->IsPowered());
   EXPECT_TRUE(adapter_->IsDiscoverable());
   EXPECT_TRUE(adapter_->IsDiscovering());
-  EXPECT_EQ(1U, adapter_->GetDevices().size());
+  EXPECT_EQ(2U, adapter_->GetDevices().size());
   EXPECT_NE(nullptr, adapter_->GetDevice(
                          FakeBluetoothDeviceClient::kPairedDeviceAddress));
   EXPECT_NE(dbus::ObjectPath(""), static_cast<BluetoothAdapterChromeOS*>(
                                       adapter_.get())->object_path());
 
   // Shutdown
   static_cast<BluetoothAdapterChromeOS*>(adapter_.get())->Shutdown();
 
   // Validate post shutdown state.
   EXPECT_EQ("", adapter_->GetAddress());
@@ skipping 20 matching lines @@
   adapter_->StartDiscoverySession(
       base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   ASSERT_EQ(0, callback_count_);
   ASSERT_EQ(3, error_callback_count_);
 }
 
 }  // namespace chromeos