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 "base/memory/scoped_vector.h" 6 #include "base/message_loop/message_loop.h" 7 #include "base/strings/utf_string_conversions.h" 8 #include "chromeos/dbus/fake_bluetooth_adapter_client.h" 9 #include "chromeos/dbus/fake_bluetooth_agent_manager_client.h" 10 #include "chromeos/dbus/fake_bluetooth_device_client.h" 11 #include "chromeos/dbus/fake_bluetooth_gatt_service_client.h" 12 #include "chromeos/dbus/fake_bluetooth_input_client.h" 13 #include "chromeos/dbus/fake_dbus_thread_manager.h" 14 #include "dbus/object_path.h" 15 #include "device/bluetooth/bluetooth_adapter.h" 16 #include "device/bluetooth/bluetooth_adapter_chromeos.h" 17 #include "device/bluetooth/bluetooth_adapter_factory.h" 18 #include "device/bluetooth/bluetooth_device.h" 19 #include "device/bluetooth/bluetooth_device_chromeos.h" 20 #include "device/bluetooth/bluetooth_discovery_session.h" 21 #include "device/bluetooth/bluetooth_pairing_chromeos.h" 22 #include "testing/gtest/include/gtest/gtest.h" 23 #include "third_party/cros_system_api/dbus/service_constants.h" 24 25 using device::BluetoothAdapter; 26 using device::BluetoothAdapterFactory; 27 using device::BluetoothDevice; 28 using device::BluetoothDiscoverySession; 29 using device::BluetoothUUID; 30 31 namespace chromeos { 32 33 namespace { 34 35 class TestObserver : public BluetoothAdapter::Observer { 36 public: 37 TestObserver(scoped_refptr<BluetoothAdapter> adapter) 38 : present_changed_count_(0), 39 powered_changed_count_(0), 40 discoverable_changed_count_(0), 41 discovering_changed_count_(0), 42 last_present_(false), 43 last_powered_(false), 44 last_discovering_(false), 45 device_added_count_(0), 46 device_changed_count_(0), 47 device_removed_count_(0), 48 last_device_(NULL), 49 adapter_(adapter) { 50 adapter_->AddObserver(this); 51 } 52 53 virtual ~TestObserver() { 54 adapter_->RemoveObserver(this); 55 } 56 57 virtual void AdapterPresentChanged(BluetoothAdapter* adapter, 58 bool present) OVERRIDE { 59 EXPECT_EQ(adapter_, adapter); 60 61 ++present_changed_count_; 62 last_present_ = present; 63 } 64 65 virtual void AdapterPoweredChanged(BluetoothAdapter* adapter, 66 bool powered) OVERRIDE { 67 EXPECT_EQ(adapter_, adapter); 68 69 ++powered_changed_count_; 70 last_powered_ = powered; 71 } 72 73 virtual void AdapterDiscoverableChanged(BluetoothAdapter* adapter, 74 bool discoverable) OVERRIDE { 75 EXPECT_EQ(adapter_, adapter); 76 77 ++discoverable_changed_count_; 78 } 79 80 virtual void AdapterDiscoveringChanged(BluetoothAdapter* adapter, 81 bool discovering) OVERRIDE { 82 EXPECT_EQ(adapter_, adapter); 83 84 ++discovering_changed_count_; 85 last_discovering_ = discovering; 86 } 87 88 virtual void DeviceAdded(BluetoothAdapter* adapter, 89 BluetoothDevice* device) OVERRIDE { 90 EXPECT_EQ(adapter_, adapter); 91 92 ++device_added_count_; 93 last_device_ = device; 94 last_device_address_ = device->GetAddress(); 95 96 QuitMessageLoop(); 97 } 98 99 virtual void DeviceChanged(BluetoothAdapter* adapter, 100 BluetoothDevice* device) OVERRIDE { 101 EXPECT_EQ(adapter_, adapter); 102 103 ++device_changed_count_; 104 last_device_ = device; 105 last_device_address_ = device->GetAddress(); 106 107 QuitMessageLoop(); 108 } 109 110 virtual void DeviceRemoved(BluetoothAdapter* adapter, 111 BluetoothDevice* device) OVERRIDE { 112 EXPECT_EQ(adapter_, adapter); 113 114 ++device_removed_count_; 115 // Can't save device, it may be freed 116 last_device_address_ = device->GetAddress(); 117 118 QuitMessageLoop(); 119 } 120 121 int present_changed_count_; 122 int powered_changed_count_; 123 int discoverable_changed_count_; 124 int discovering_changed_count_; 125 bool last_present_; 126 bool last_powered_; 127 bool last_discovering_; 128 int device_added_count_; 129 int device_changed_count_; 130 int device_removed_count_; 131 BluetoothDevice* last_device_; 132 std::string last_device_address_; 133 134 private: 135 // Some tests use a message loop since background processing is simulated; 136 // break out of those loops. 137 void QuitMessageLoop() { 138 if (base::MessageLoop::current() && 139 base::MessageLoop::current()->is_running()) 140 base::MessageLoop::current()->Quit(); 141 } 142 143 scoped_refptr<BluetoothAdapter> adapter_; 144 }; 145 146 } // namespace 147 148 class TestPairingDelegate : public BluetoothDevice::PairingDelegate { 149 public: 150 TestPairingDelegate() 151 : call_count_(0), 152 request_pincode_count_(0), 153 request_passkey_count_(0), 154 display_pincode_count_(0), 155 display_passkey_count_(0), 156 keys_entered_count_(0), 157 confirm_passkey_count_(0), 158 authorize_pairing_count_(0), 159 last_passkey_(9999999U), 160 last_entered_(999U) {} 161 virtual ~TestPairingDelegate() {} 162 163 virtual void RequestPinCode(BluetoothDevice* device) OVERRIDE { 164 ++call_count_; 165 ++request_pincode_count_; 166 QuitMessageLoop(); 167 } 168 169 virtual void RequestPasskey(BluetoothDevice* device) OVERRIDE { 170 ++call_count_; 171 ++request_passkey_count_; 172 QuitMessageLoop(); 173 } 174 175 virtual void DisplayPinCode(BluetoothDevice* device, 176 const std::string& pincode) OVERRIDE { 177 ++call_count_; 178 ++display_pincode_count_; 179 last_pincode_ = pincode; 180 QuitMessageLoop(); 181 } 182 183 virtual void DisplayPasskey(BluetoothDevice* device, 184 uint32 passkey) OVERRIDE { 185 ++call_count_; 186 ++display_passkey_count_; 187 last_passkey_ = passkey; 188 QuitMessageLoop(); 189 } 190 191 virtual void KeysEntered(BluetoothDevice* device, uint32 entered) OVERRIDE { 192 ++call_count_; 193 ++keys_entered_count_; 194 last_entered_ = entered; 195 QuitMessageLoop(); 196 } 197 198 virtual void ConfirmPasskey(BluetoothDevice* device, 199 uint32 passkey) OVERRIDE { 200 ++call_count_; 201 ++confirm_passkey_count_; 202 last_passkey_ = passkey; 203 QuitMessageLoop(); 204 } 205 206 virtual void AuthorizePairing(BluetoothDevice* device) OVERRIDE { 207 ++call_count_; 208 ++authorize_pairing_count_; 209 QuitMessageLoop(); 210 } 211 212 int call_count_; 213 int request_pincode_count_; 214 int request_passkey_count_; 215 int display_pincode_count_; 216 int display_passkey_count_; 217 int keys_entered_count_; 218 int confirm_passkey_count_; 219 int authorize_pairing_count_; 220 uint32 last_passkey_; 221 uint32 last_entered_; 222 std::string last_pincode_; 223 224 private: 225 // Some tests use a message loop since background processing is simulated; 226 // break out of those loops. 227 void QuitMessageLoop() { 228 if (base::MessageLoop::current() && 229 base::MessageLoop::current()->is_running()) 230 base::MessageLoop::current()->Quit(); 231 } 232 }; 233 234 class BluetoothChromeOSTest : public testing::Test { 235 public: 236 virtual void SetUp() { 237 FakeDBusThreadManager* fake_dbus_thread_manager = new FakeDBusThreadManager; 238 fake_bluetooth_adapter_client_ = new FakeBluetoothAdapterClient; 239 fake_dbus_thread_manager->SetBluetoothAdapterClient( 240 scoped_ptr<BluetoothAdapterClient>(fake_bluetooth_adapter_client_)); 241 fake_bluetooth_device_client_ = new FakeBluetoothDeviceClient; 242 fake_dbus_thread_manager->SetBluetoothDeviceClient( 243 scoped_ptr<BluetoothDeviceClient>(fake_bluetooth_device_client_)); 244 fake_dbus_thread_manager->SetBluetoothInputClient( 245 scoped_ptr<BluetoothInputClient>(new FakeBluetoothInputClient)); 246 fake_dbus_thread_manager->SetBluetoothAgentManagerClient( 247 scoped_ptr<BluetoothAgentManagerClient>( 248 new FakeBluetoothAgentManagerClient)); 249 fake_dbus_thread_manager->SetBluetoothGattServiceClient( 250 scoped_ptr<BluetoothGattServiceClient>( 251 new FakeBluetoothGattServiceClient)); 252 DBusThreadManager::InitializeForTesting(fake_dbus_thread_manager); 253 254 fake_bluetooth_adapter_client_->SetSimulationIntervalMs(10); 255 256 callback_count_ = 0; 257 error_callback_count_ = 0; 258 last_connect_error_ = BluetoothDevice::ERROR_UNKNOWN; 259 last_client_error_ = ""; 260 } 261 262 virtual void TearDown() { 263 for (ScopedVector<BluetoothDiscoverySession>::iterator iter = 264 discovery_sessions_.begin(); 265 iter != discovery_sessions_.end(); 266 ++iter) { 267 BluetoothDiscoverySession* session = *iter; 268 if (!session->IsActive()) 269 continue; 270 callback_count_ = 0; 271 session->Stop( 272 base::Bind(&BluetoothChromeOSTest::Callback, 273 base::Unretained(this)), 274 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 275 base::Unretained(this))); 276 message_loop_.Run(); 277 ASSERT_EQ(1, callback_count_); 278 } 279 discovery_sessions_.clear(); 280 adapter_ = NULL; 281 DBusThreadManager::Shutdown(); 282 } 283 284 // Generic callbacks 285 void Callback() { 286 ++callback_count_; 287 QuitMessageLoop(); 288 } 289 290 void DiscoverySessionCallback( 291 scoped_ptr<BluetoothDiscoverySession> discovery_session) { 292 ++callback_count_; 293 discovery_sessions_.push_back(discovery_session.release()); 294 QuitMessageLoop(); 295 } 296 297 void ErrorCallback() { 298 ++error_callback_count_; 299 QuitMessageLoop(); 300 } 301 302 void DBusErrorCallback(const std::string& error_name, 303 const std::string& error_message) { 304 ++error_callback_count_; 305 last_client_error_ = error_name; 306 QuitMessageLoop(); 307 } 308 309 void ConnectErrorCallback(BluetoothDevice::ConnectErrorCode error) { 310 ++error_callback_count_; 311 last_connect_error_ = error; 312 } 313 314 // Call to fill the adapter_ member with a BluetoothAdapter instance. 315 void GetAdapter() { 316 adapter_ = new BluetoothAdapterChromeOS(); 317 ASSERT_TRUE(adapter_.get() != NULL); 318 ASSERT_TRUE(adapter_->IsInitialized()); 319 } 320 321 // Run a discovery phase until the named device is detected, or if the named 322 // device is not created, the discovery process ends without finding it. 323 // 324 // The correct behavior of discovery is tested by the "Discovery" test case 325 // without using this function. 326 void DiscoverDevice(const std::string& address) { 327 ASSERT_TRUE(adapter_.get() != NULL); 328 ASSERT_TRUE(base::MessageLoop::current() != NULL); 329 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 330 331 TestObserver observer(adapter_); 332 333 adapter_->SetPowered( 334 true, 335 base::Bind(&BluetoothChromeOSTest::Callback, 336 base::Unretained(this)), 337 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 338 base::Unretained(this))); 339 adapter_->StartDiscoverySession( 340 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 341 base::Unretained(this)), 342 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 343 base::Unretained(this))); 344 base::MessageLoop::current()->Run(); 345 ASSERT_EQ(2, callback_count_); 346 ASSERT_EQ(0, error_callback_count_); 347 ASSERT_EQ((size_t)1, discovery_sessions_.size()); 348 ASSERT_TRUE(discovery_sessions_[0]->IsActive()); 349 callback_count_ = 0; 350 351 ASSERT_TRUE(adapter_->IsPowered()); 352 ASSERT_TRUE(adapter_->IsDiscovering()); 353 354 while (!observer.device_removed_count_ && 355 observer.last_device_address_ != address) 356 base::MessageLoop::current()->Run(); 357 358 discovery_sessions_[0]->Stop( 359 base::Bind(&BluetoothChromeOSTest::Callback, 360 base::Unretained(this)), 361 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 362 base::Unretained(this))); 363 base::MessageLoop::current()->Run(); 364 ASSERT_EQ(1, callback_count_); 365 ASSERT_EQ(0, error_callback_count_); 366 callback_count_ = 0; 367 368 ASSERT_FALSE(adapter_->IsDiscovering()); 369 } 370 371 // Run a discovery phase so we have devices that can be paired with. 372 void DiscoverDevices() { 373 // Pass an invalid address for the device so that the discovery process 374 // completes with all devices. 375 DiscoverDevice("does not exist"); 376 } 377 378 protected: 379 base::MessageLoop message_loop_; 380 FakeBluetoothAdapterClient* fake_bluetooth_adapter_client_; 381 FakeBluetoothDeviceClient* fake_bluetooth_device_client_; 382 scoped_refptr<BluetoothAdapter> adapter_; 383 384 int callback_count_; 385 int error_callback_count_; 386 enum BluetoothDevice::ConnectErrorCode last_connect_error_; 387 std::string last_client_error_; 388 ScopedVector<BluetoothDiscoverySession> discovery_sessions_; 389 390 private: 391 // Some tests use a message loop since background processing is simulated; 392 // break out of those loops. 393 void QuitMessageLoop() { 394 if (base::MessageLoop::current() && 395 base::MessageLoop::current()->is_running()) 396 base::MessageLoop::current()->Quit(); 397 } 398 }; 399 400 TEST_F(BluetoothChromeOSTest, AlreadyPresent) { 401 GetAdapter(); 402 403 // This verifies that the class gets the list of adapters when created; 404 // and initializes with an existing adapter if there is one. 405 EXPECT_TRUE(adapter_->IsPresent()); 406 EXPECT_FALSE(adapter_->IsPowered()); 407 EXPECT_EQ(FakeBluetoothAdapterClient::kAdapterAddress, 408 adapter_->GetAddress()); 409 EXPECT_FALSE(adapter_->IsDiscovering()); 410 411 // There should be a device 412 BluetoothAdapter::DeviceList devices = adapter_->GetDevices(); 413 EXPECT_EQ(1U, devices.size()); 414 EXPECT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress, 415 devices[0]->GetAddress()); 416 } 417 418 TEST_F(BluetoothChromeOSTest, BecomePresent) { 419 fake_bluetooth_adapter_client_->SetVisible(false); 420 GetAdapter(); 421 ASSERT_FALSE(adapter_->IsPresent()); 422 423 // Install an observer; expect the AdapterPresentChanged to be called 424 // with true, and IsPresent() to return true. 425 TestObserver observer(adapter_); 426 427 fake_bluetooth_adapter_client_->SetVisible(true); 428 429 EXPECT_EQ(1, observer.present_changed_count_); 430 EXPECT_TRUE(observer.last_present_); 431 432 EXPECT_TRUE(adapter_->IsPresent()); 433 434 // We should have had a device announced. 435 EXPECT_EQ(1, observer.device_added_count_); 436 EXPECT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress, 437 observer.last_device_address_); 438 439 // Other callbacks shouldn't be called if the values are false. 440 EXPECT_EQ(0, observer.powered_changed_count_); 441 EXPECT_EQ(0, observer.discovering_changed_count_); 442 EXPECT_FALSE(adapter_->IsPowered()); 443 EXPECT_FALSE(adapter_->IsDiscovering()); 444 } 445 446 TEST_F(BluetoothChromeOSTest, BecomeNotPresent) { 447 GetAdapter(); 448 ASSERT_TRUE(adapter_->IsPresent()); 449 450 // Install an observer; expect the AdapterPresentChanged to be called 451 // with false, and IsPresent() to return false. 452 TestObserver observer(adapter_); 453 454 fake_bluetooth_adapter_client_->SetVisible(false); 455 456 EXPECT_EQ(1, observer.present_changed_count_); 457 EXPECT_FALSE(observer.last_present_); 458 459 EXPECT_FALSE(adapter_->IsPresent()); 460 461 // We should have had a device removed. 462 EXPECT_EQ(1, observer.device_removed_count_); 463 EXPECT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress, 464 observer.last_device_address_); 465 466 // Other callbacks shouldn't be called since the values are false. 467 EXPECT_EQ(0, observer.powered_changed_count_); 468 EXPECT_EQ(0, observer.discovering_changed_count_); 469 EXPECT_FALSE(adapter_->IsPowered()); 470 EXPECT_FALSE(adapter_->IsDiscovering()); 471 } 472 473 TEST_F(BluetoothChromeOSTest, SecondAdapter) { 474 GetAdapter(); 475 ASSERT_TRUE(adapter_->IsPresent()); 476 477 // Install an observer, then add a second adapter. Nothing should change, 478 // we ignore the second adapter. 479 TestObserver observer(adapter_); 480 481 fake_bluetooth_adapter_client_->SetSecondVisible(true); 482 483 EXPECT_EQ(0, observer.present_changed_count_); 484 485 EXPECT_TRUE(adapter_->IsPresent()); 486 EXPECT_EQ(FakeBluetoothAdapterClient::kAdapterAddress, 487 adapter_->GetAddress()); 488 489 // Try removing the first adapter, we should now act as if the adapter 490 // is no longer present rather than fall back to the second. 491 fake_bluetooth_adapter_client_->SetVisible(false); 492 493 EXPECT_EQ(1, observer.present_changed_count_); 494 EXPECT_FALSE(observer.last_present_); 495 496 EXPECT_FALSE(adapter_->IsPresent()); 497 498 // We should have had a device removed. 499 EXPECT_EQ(1, observer.device_removed_count_); 500 EXPECT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress, 501 observer.last_device_address_); 502 503 // Other callbacks shouldn't be called since the values are false. 504 EXPECT_EQ(0, observer.powered_changed_count_); 505 EXPECT_EQ(0, observer.discovering_changed_count_); 506 EXPECT_FALSE(adapter_->IsPowered()); 507 EXPECT_FALSE(adapter_->IsDiscovering()); 508 509 observer.device_removed_count_ = 0; 510 511 // Removing the second adapter shouldn't set anything either. 512 fake_bluetooth_adapter_client_->SetSecondVisible(false); 513 514 EXPECT_EQ(0, observer.device_removed_count_); 515 EXPECT_EQ(0, observer.powered_changed_count_); 516 EXPECT_EQ(0, observer.discovering_changed_count_); 517 } 518 519 TEST_F(BluetoothChromeOSTest, BecomePowered) { 520 GetAdapter(); 521 ASSERT_FALSE(adapter_->IsPowered()); 522 523 // Install an observer; expect the AdapterPoweredChanged to be called 524 // with true, and IsPowered() to return true. 525 TestObserver observer(adapter_); 526 527 adapter_->SetPowered( 528 true, 529 base::Bind(&BluetoothChromeOSTest::Callback, 530 base::Unretained(this)), 531 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 532 base::Unretained(this))); 533 EXPECT_EQ(1, callback_count_); 534 EXPECT_EQ(0, error_callback_count_); 535 536 EXPECT_EQ(1, observer.powered_changed_count_); 537 EXPECT_TRUE(observer.last_powered_); 538 539 EXPECT_TRUE(adapter_->IsPowered()); 540 } 541 542 TEST_F(BluetoothChromeOSTest, BecomeNotPowered) { 543 GetAdapter(); 544 adapter_->SetPowered( 545 true, 546 base::Bind(&BluetoothChromeOSTest::Callback, 547 base::Unretained(this)), 548 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 549 base::Unretained(this))); 550 EXPECT_EQ(1, callback_count_); 551 EXPECT_EQ(0, error_callback_count_); 552 callback_count_ = 0; 553 554 ASSERT_TRUE(adapter_->IsPowered()); 555 556 // Install an observer; expect the AdapterPoweredChanged to be called 557 // with false, and IsPowered() to return false. 558 TestObserver observer(adapter_); 559 560 adapter_->SetPowered( 561 false, 562 base::Bind(&BluetoothChromeOSTest::Callback, 563 base::Unretained(this)), 564 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 565 base::Unretained(this))); 566 EXPECT_EQ(1, callback_count_); 567 EXPECT_EQ(0, error_callback_count_); 568 569 EXPECT_EQ(1, observer.powered_changed_count_); 570 EXPECT_FALSE(observer.last_powered_); 571 572 EXPECT_FALSE(adapter_->IsPowered()); 573 } 574 575 TEST_F(BluetoothChromeOSTest, ChangeAdapterName) { 576 GetAdapter(); 577 578 static const std::string new_name(".__."); 579 580 adapter_->SetName( 581 new_name, 582 base::Bind(&BluetoothChromeOSTest::Callback, 583 base::Unretained(this)), 584 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 585 base::Unretained(this))); 586 EXPECT_EQ(1, callback_count_); 587 EXPECT_EQ(0, error_callback_count_); 588 589 EXPECT_EQ(new_name, adapter_->GetName()); 590 } 591 592 TEST_F(BluetoothChromeOSTest, BecomeDiscoverable) { 593 GetAdapter(); 594 ASSERT_FALSE(adapter_->IsDiscoverable()); 595 596 // Install an observer; expect the AdapterDiscoverableChanged to be called 597 // with true, and IsDiscoverable() to return true. 598 TestObserver observer(adapter_); 599 600 adapter_->SetDiscoverable( 601 true, 602 base::Bind(&BluetoothChromeOSTest::Callback, 603 base::Unretained(this)), 604 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 605 base::Unretained(this))); 606 EXPECT_EQ(1, callback_count_); 607 EXPECT_EQ(0, error_callback_count_); 608 609 EXPECT_EQ(1, observer.discoverable_changed_count_); 610 611 EXPECT_TRUE(adapter_->IsDiscoverable()); 612 } 613 614 TEST_F(BluetoothChromeOSTest, BecomeNotDiscoverable) { 615 GetAdapter(); 616 adapter_->SetDiscoverable( 617 true, 618 base::Bind(&BluetoothChromeOSTest::Callback, 619 base::Unretained(this)), 620 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 621 base::Unretained(this))); 622 EXPECT_EQ(1, callback_count_); 623 EXPECT_EQ(0, error_callback_count_); 624 callback_count_ = 0; 625 626 ASSERT_TRUE(adapter_->IsDiscoverable()); 627 628 // Install an observer; expect the AdapterDiscoverableChanged to be called 629 // with false, and IsDiscoverable() to return false. 630 TestObserver observer(adapter_); 631 632 adapter_->SetDiscoverable( 633 false, 634 base::Bind(&BluetoothChromeOSTest::Callback, 635 base::Unretained(this)), 636 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 637 base::Unretained(this))); 638 EXPECT_EQ(1, callback_count_); 639 EXPECT_EQ(0, error_callback_count_); 640 641 EXPECT_EQ(1, observer.discoverable_changed_count_); 642 643 EXPECT_FALSE(adapter_->IsDiscoverable()); 644 } 645 646 TEST_F(BluetoothChromeOSTest, StopDiscovery) { 647 GetAdapter(); 648 649 adapter_->SetPowered( 650 true, 651 base::Bind(&BluetoothChromeOSTest::Callback, 652 base::Unretained(this)), 653 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 654 base::Unretained(this))); 655 adapter_->StartDiscoverySession( 656 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 657 base::Unretained(this)), 658 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 659 base::Unretained(this))); 660 message_loop_.Run(); 661 EXPECT_EQ(2, callback_count_); 662 EXPECT_EQ(0, error_callback_count_); 663 callback_count_ = 0; 664 665 ASSERT_TRUE(adapter_->IsPowered()); 666 ASSERT_TRUE(adapter_->IsDiscovering()); 667 ASSERT_EQ((size_t)1, discovery_sessions_.size()); 668 ASSERT_TRUE(discovery_sessions_[0]->IsActive()); 669 670 // Install an observer; aside from the callback, expect the 671 // AdapterDiscoveringChanged method to be called and no longer to be 672 // discovering, 673 TestObserver observer(adapter_); 674 675 discovery_sessions_[0]->Stop( 676 base::Bind(&BluetoothChromeOSTest::Callback, 677 base::Unretained(this)), 678 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 679 base::Unretained(this))); 680 message_loop_.Run(); 681 EXPECT_EQ(1, callback_count_); 682 EXPECT_EQ(0, error_callback_count_); 683 684 EXPECT_EQ(1, observer.discovering_changed_count_); 685 EXPECT_FALSE(observer.last_discovering_); 686 687 EXPECT_FALSE(adapter_->IsDiscovering()); 688 } 689 690 TEST_F(BluetoothChromeOSTest, Discovery) { 691 // Test a simulated discovery session. 692 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 693 GetAdapter(); 694 695 TestObserver observer(adapter_); 696 697 adapter_->SetPowered( 698 true, 699 base::Bind(&BluetoothChromeOSTest::Callback, 700 base::Unretained(this)), 701 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 702 base::Unretained(this))); 703 adapter_->StartDiscoverySession( 704 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 705 base::Unretained(this)), 706 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 707 base::Unretained(this))); 708 message_loop_.Run(); 709 EXPECT_EQ(2, callback_count_); 710 EXPECT_EQ(0, error_callback_count_); 711 callback_count_ = 0; 712 713 ASSERT_TRUE(adapter_->IsPowered()); 714 ASSERT_TRUE(adapter_->IsDiscovering()); 715 ASSERT_EQ((size_t)1, discovery_sessions_.size()); 716 ASSERT_TRUE(discovery_sessions_[0]->IsActive()); 717 718 // First two devices to appear. 719 message_loop_.Run(); 720 721 EXPECT_EQ(2, observer.device_added_count_); 722 EXPECT_EQ(FakeBluetoothDeviceClient::kLowEnergyAddress, 723 observer.last_device_address_); 724 725 // Next we should get another two devices... 726 message_loop_.Run(); 727 EXPECT_EQ(4, observer.device_added_count_); 728 729 // Okay, let's run forward until a device is actually removed... 730 while (!observer.device_removed_count_) 731 message_loop_.Run(); 732 733 EXPECT_EQ(1, observer.device_removed_count_); 734 EXPECT_EQ(FakeBluetoothDeviceClient::kVanishingDeviceAddress, 735 observer.last_device_address_); 736 } 737 738 TEST_F(BluetoothChromeOSTest, PoweredAndDiscovering) { 739 GetAdapter(); 740 adapter_->SetPowered( 741 true, 742 base::Bind(&BluetoothChromeOSTest::Callback, 743 base::Unretained(this)), 744 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 745 base::Unretained(this))); 746 adapter_->StartDiscoverySession( 747 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 748 base::Unretained(this)), 749 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 750 base::Unretained(this))); 751 message_loop_.Run(); 752 EXPECT_EQ(2, callback_count_); 753 EXPECT_EQ(0, error_callback_count_); 754 callback_count_ = 0; 755 ASSERT_EQ((size_t)1, discovery_sessions_.size()); 756 ASSERT_TRUE(discovery_sessions_[0]->IsActive()); 757 758 // Stop the timers that the simulation uses 759 fake_bluetooth_device_client_->EndDiscoverySimulation( 760 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath)); 761 762 ASSERT_TRUE(adapter_->IsPowered()); 763 ASSERT_TRUE(adapter_->IsDiscovering()); 764 765 fake_bluetooth_adapter_client_->SetVisible(false); 766 ASSERT_FALSE(adapter_->IsPresent()); 767 ASSERT_FALSE(discovery_sessions_[0]->IsActive()); 768 769 // Install an observer; expect the AdapterPresentChanged, 770 // AdapterPoweredChanged and AdapterDiscoveringChanged methods to be called 771 // with true, and IsPresent(), IsPowered() and IsDiscovering() to all 772 // return true. 773 TestObserver observer(adapter_); 774 775 fake_bluetooth_adapter_client_->SetVisible(true); 776 777 EXPECT_EQ(1, observer.present_changed_count_); 778 EXPECT_TRUE(observer.last_present_); 779 EXPECT_TRUE(adapter_->IsPresent()); 780 781 EXPECT_EQ(1, observer.powered_changed_count_); 782 EXPECT_TRUE(observer.last_powered_); 783 EXPECT_TRUE(adapter_->IsPowered()); 784 785 EXPECT_EQ(1, observer.discovering_changed_count_); 786 EXPECT_TRUE(observer.last_discovering_); 787 EXPECT_TRUE(adapter_->IsDiscovering()); 788 789 observer.present_changed_count_ = 0; 790 observer.powered_changed_count_ = 0; 791 observer.discovering_changed_count_ = 0; 792 793 // Now mark the adapter not present again. Expect the methods to be called 794 // again, to reset the properties back to false 795 fake_bluetooth_adapter_client_->SetVisible(false); 796 797 EXPECT_EQ(1, observer.present_changed_count_); 798 EXPECT_FALSE(observer.last_present_); 799 EXPECT_FALSE(adapter_->IsPresent()); 800 801 EXPECT_EQ(1, observer.powered_changed_count_); 802 EXPECT_FALSE(observer.last_powered_); 803 EXPECT_FALSE(adapter_->IsPowered()); 804 805 EXPECT_EQ(1, observer.discovering_changed_count_); 806 EXPECT_FALSE(observer.last_discovering_); 807 EXPECT_FALSE(adapter_->IsDiscovering()); 808 } 809 810 // This unit test asserts that the basic reference counting logic works 811 // correctly for discovery requests done via the BluetoothAdapter. 812 TEST_F(BluetoothChromeOSTest, MultipleDiscoverySessions) { 813 GetAdapter(); 814 adapter_->SetPowered( 815 true, 816 base::Bind(&BluetoothChromeOSTest::Callback, 817 base::Unretained(this)), 818 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 819 base::Unretained(this))); 820 EXPECT_EQ(1, callback_count_); 821 EXPECT_EQ(0, error_callback_count_); 822 EXPECT_TRUE(adapter_->IsPowered()); 823 callback_count_ = 0; 824 825 TestObserver observer(adapter_); 826 827 EXPECT_EQ(0, observer.discovering_changed_count_); 828 EXPECT_FALSE(observer.last_discovering_); 829 EXPECT_FALSE(adapter_->IsDiscovering()); 830 831 // Request device discovery 3 times. 832 for (int i = 0; i < 3; i++) { 833 adapter_->StartDiscoverySession( 834 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 835 base::Unretained(this)), 836 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 837 base::Unretained(this))); 838 } 839 // Run only once, as there should have been one D-Bus call. 840 message_loop_.Run(); 841 842 // The observer should have received the discovering changed event exactly 843 // once, the success callback should have been called 3 times and the adapter 844 // should be discovering. 845 EXPECT_EQ(1, observer.discovering_changed_count_); 846 EXPECT_EQ(3, callback_count_); 847 EXPECT_EQ(0, error_callback_count_); 848 EXPECT_TRUE(observer.last_discovering_); 849 EXPECT_TRUE(adapter_->IsDiscovering()); 850 ASSERT_EQ((size_t)3, discovery_sessions_.size()); 851 852 // Request to stop discovery twice. 853 for (int i = 0; i < 2; i++) { 854 discovery_sessions_[i]->Stop( 855 base::Bind(&BluetoothChromeOSTest::Callback, 856 base::Unretained(this)), 857 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 858 base::Unretained(this))); 859 } 860 861 // The observer should have received no additional discovering changed events, 862 // the success callback should have been called 2 times and the adapter should 863 // still be discovering. 864 EXPECT_EQ(1, observer.discovering_changed_count_); 865 EXPECT_EQ(5, callback_count_); 866 EXPECT_EQ(0, error_callback_count_); 867 EXPECT_TRUE(observer.last_discovering_); 868 EXPECT_TRUE(adapter_->IsDiscovering()); 869 EXPECT_TRUE(adapter_->IsDiscovering()); 870 EXPECT_FALSE(discovery_sessions_[0]->IsActive()); 871 EXPECT_FALSE(discovery_sessions_[1]->IsActive()); 872 EXPECT_TRUE(discovery_sessions_[2]->IsActive()); 873 874 // Request device discovery 3 times. 875 for (int i = 0; i < 3; i++) { 876 adapter_->StartDiscoverySession( 877 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 878 base::Unretained(this)), 879 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 880 base::Unretained(this))); 881 } 882 883 // The observer should have received no additional discovering changed events, 884 // the success callback should have been called 3 times and the adapter should 885 // still be discovering. 886 EXPECT_EQ(1, observer.discovering_changed_count_); 887 EXPECT_EQ(8, callback_count_); 888 EXPECT_EQ(0, error_callback_count_); 889 EXPECT_TRUE(observer.last_discovering_); 890 EXPECT_TRUE(adapter_->IsDiscovering()); 891 ASSERT_EQ((size_t)6, discovery_sessions_.size()); 892 893 // Request to stop discovery 4 times. 894 for (int i = 2; i < 6; i++) { 895 discovery_sessions_[i]->Stop( 896 base::Bind(&BluetoothChromeOSTest::Callback, 897 base::Unretained(this)), 898 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 899 base::Unretained(this))); 900 } 901 // Run only once, as there should have been one D-Bus call. 902 message_loop_.Run(); 903 904 // The observer should have received the discovering changed event exactly 905 // once, the success callback should have been called 4 times and the adapter 906 // should no longer be discovering. 907 EXPECT_EQ(2, observer.discovering_changed_count_); 908 EXPECT_EQ(12, callback_count_); 909 EXPECT_EQ(0, error_callback_count_); 910 EXPECT_FALSE(observer.last_discovering_); 911 EXPECT_FALSE(adapter_->IsDiscovering()); 912 913 // All discovery sessions should be inactive. 914 for (int i = 0; i < 6; i++) 915 EXPECT_FALSE(discovery_sessions_[i]->IsActive()); 916 917 // Request to stop discovery on of the inactive sessions. 918 discovery_sessions_[0]->Stop( 919 base::Bind(&BluetoothChromeOSTest::Callback, 920 base::Unretained(this)), 921 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 922 base::Unretained(this))); 923 924 // The call should have failed. 925 EXPECT_EQ(2, observer.discovering_changed_count_); 926 EXPECT_EQ(12, callback_count_); 927 EXPECT_EQ(1, error_callback_count_); 928 EXPECT_FALSE(observer.last_discovering_); 929 EXPECT_FALSE(adapter_->IsDiscovering()); 930 } 931 932 // This unit test asserts that the reference counting logic works correctly in 933 // the cases when the adapter gets reset and D-Bus calls are made outside of 934 // the BluetoothAdapter. 935 TEST_F(BluetoothChromeOSTest, 936 UnexpectedChangesDuringMultipleDiscoverySessions) { 937 GetAdapter(); 938 adapter_->SetPowered( 939 true, 940 base::Bind(&BluetoothChromeOSTest::Callback, 941 base::Unretained(this)), 942 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 943 base::Unretained(this))); 944 EXPECT_EQ(1, callback_count_); 945 EXPECT_EQ(0, error_callback_count_); 946 EXPECT_TRUE(adapter_->IsPowered()); 947 callback_count_ = 0; 948 949 TestObserver observer(adapter_); 950 951 EXPECT_EQ(0, observer.discovering_changed_count_); 952 EXPECT_FALSE(observer.last_discovering_); 953 EXPECT_FALSE(adapter_->IsDiscovering()); 954 955 // Request device discovery 3 times. 956 for (int i = 0; i < 3; i++) { 957 adapter_->StartDiscoverySession( 958 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 959 base::Unretained(this)), 960 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 961 base::Unretained(this))); 962 } 963 // Run only once, as there should have been one D-Bus call. 964 message_loop_.Run(); 965 966 // The observer should have received the discovering changed event exactly 967 // once, the success callback should have been called 3 times and the adapter 968 // should be discovering. 969 EXPECT_EQ(1, observer.discovering_changed_count_); 970 EXPECT_EQ(3, callback_count_); 971 EXPECT_EQ(0, error_callback_count_); 972 EXPECT_TRUE(observer.last_discovering_); 973 EXPECT_TRUE(adapter_->IsDiscovering()); 974 ASSERT_EQ((size_t)3, discovery_sessions_.size()); 975 976 for (int i = 0; i < 3; i++) 977 EXPECT_TRUE(discovery_sessions_[i]->IsActive()); 978 979 // Stop the timers that the simulation uses 980 fake_bluetooth_device_client_->EndDiscoverySimulation( 981 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath)); 982 983 ASSERT_TRUE(adapter_->IsPowered()); 984 ASSERT_TRUE(adapter_->IsDiscovering()); 985 986 // Stop device discovery behind the adapter. The adapter and the observer 987 // should be notified of the change and the reference count should be reset. 988 // Even though FakeBluetoothAdapterClient does its own reference counting and 989 // we called 3 BluetoothAdapter::StartDiscoverySession 3 times, the 990 // FakeBluetoothAdapterClient's count should be only 1 and a single call to 991 // FakeBluetoothAdapterClient::StopDiscovery should work. 992 fake_bluetooth_adapter_client_->StopDiscovery( 993 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), 994 base::Bind(&BluetoothChromeOSTest::Callback, 995 base::Unretained(this)), 996 base::Bind(&BluetoothChromeOSTest::DBusErrorCallback, 997 base::Unretained(this))); 998 message_loop_.Run(); 999 EXPECT_EQ(2, observer.discovering_changed_count_); 1000 EXPECT_EQ(4, callback_count_); 1001 EXPECT_EQ(0, error_callback_count_); 1002 EXPECT_FALSE(observer.last_discovering_); 1003 EXPECT_FALSE(adapter_->IsDiscovering()); 1004 1005 // All discovery session instances should have been updated. 1006 for (int i = 0; i < 3; i++) 1007 EXPECT_FALSE(discovery_sessions_[i]->IsActive()); 1008 discovery_sessions_.clear(); 1009 1010 // It should be possible to successfully start discovery. 1011 for (int i = 0; i < 2; i++) { 1012 adapter_->StartDiscoverySession( 1013 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 1014 base::Unretained(this)), 1015 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1016 base::Unretained(this))); 1017 } 1018 // Run only once, as there should have been one D-Bus call. 1019 message_loop_.Run(); 1020 EXPECT_EQ(3, observer.discovering_changed_count_); 1021 EXPECT_EQ(6, callback_count_); 1022 EXPECT_EQ(0, error_callback_count_); 1023 EXPECT_TRUE(observer.last_discovering_); 1024 EXPECT_TRUE(adapter_->IsDiscovering()); 1025 ASSERT_EQ((size_t)2, discovery_sessions_.size()); 1026 1027 for (int i = 0; i < 2; i++) 1028 EXPECT_TRUE(discovery_sessions_[i]->IsActive()); 1029 1030 fake_bluetooth_device_client_->EndDiscoverySimulation( 1031 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath)); 1032 1033 // Make the adapter disappear and appear. This will make it come back as 1034 // discovering. When this happens, the reference count should become and 1035 // remain 0 as no new request was made through the BluetoothAdapter. 1036 fake_bluetooth_adapter_client_->SetVisible(false); 1037 ASSERT_FALSE(adapter_->IsPresent()); 1038 EXPECT_EQ(4, observer.discovering_changed_count_); 1039 EXPECT_EQ(6, callback_count_); 1040 EXPECT_EQ(0, error_callback_count_); 1041 EXPECT_FALSE(observer.last_discovering_); 1042 EXPECT_FALSE(adapter_->IsDiscovering()); 1043 1044 for (int i = 0; i < 2; i++) 1045 EXPECT_FALSE(discovery_sessions_[i]->IsActive()); 1046 discovery_sessions_.clear(); 1047 1048 fake_bluetooth_adapter_client_->SetVisible(true); 1049 ASSERT_TRUE(adapter_->IsPresent()); 1050 EXPECT_EQ(5, observer.discovering_changed_count_); 1051 EXPECT_EQ(6, callback_count_); 1052 EXPECT_EQ(0, error_callback_count_); 1053 EXPECT_TRUE(observer.last_discovering_); 1054 EXPECT_TRUE(adapter_->IsDiscovering()); 1055 1056 // Start and stop discovery. At this point, FakeBluetoothAdapterClient has 1057 // a reference count that is equal to 1. Pretend that this was done by an 1058 // application other than us. Starting and stopping discovery will succeed 1059 // but it won't cause the discovery state to change. 1060 adapter_->StartDiscoverySession( 1061 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 1062 base::Unretained(this)), 1063 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1064 base::Unretained(this))); 1065 message_loop_.Run(); // Run the loop, as there should have been a D-Bus call. 1066 EXPECT_EQ(5, observer.discovering_changed_count_); 1067 EXPECT_EQ(7, callback_count_); 1068 EXPECT_EQ(0, error_callback_count_); 1069 EXPECT_TRUE(observer.last_discovering_); 1070 EXPECT_TRUE(adapter_->IsDiscovering()); 1071 ASSERT_EQ((size_t)1, discovery_sessions_.size()); 1072 EXPECT_TRUE(discovery_sessions_[0]->IsActive()); 1073 1074 discovery_sessions_[0]->Stop( 1075 base::Bind(&BluetoothChromeOSTest::Callback, 1076 base::Unretained(this)), 1077 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1078 base::Unretained(this))); 1079 message_loop_.Run(); // Run the loop, as there should have been a D-Bus call. 1080 EXPECT_EQ(5, observer.discovering_changed_count_); 1081 EXPECT_EQ(8, callback_count_); 1082 EXPECT_EQ(0, error_callback_count_); 1083 EXPECT_TRUE(observer.last_discovering_); 1084 EXPECT_TRUE(adapter_->IsDiscovering()); 1085 EXPECT_FALSE(discovery_sessions_[0]->IsActive()); 1086 discovery_sessions_.clear(); 1087 1088 // Start discovery again. 1089 adapter_->StartDiscoverySession( 1090 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 1091 base::Unretained(this)), 1092 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1093 base::Unretained(this))); 1094 message_loop_.Run(); // Run the loop, as there should have been a D-Bus call. 1095 EXPECT_EQ(5, observer.discovering_changed_count_); 1096 EXPECT_EQ(9, callback_count_); 1097 EXPECT_EQ(0, error_callback_count_); 1098 EXPECT_TRUE(observer.last_discovering_); 1099 EXPECT_TRUE(adapter_->IsDiscovering()); 1100 ASSERT_EQ((size_t)1, discovery_sessions_.size()); 1101 EXPECT_TRUE(discovery_sessions_[0]->IsActive()); 1102 1103 // Stop discovery via D-Bus. The fake client's reference count will drop but 1104 // the discovery state won't change since our BluetoothAdapter also just 1105 // requested it via D-Bus. 1106 fake_bluetooth_adapter_client_->StopDiscovery( 1107 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), 1108 base::Bind(&BluetoothChromeOSTest::Callback, 1109 base::Unretained(this)), 1110 base::Bind(&BluetoothChromeOSTest::DBusErrorCallback, 1111 base::Unretained(this))); 1112 message_loop_.Run(); 1113 EXPECT_EQ(5, observer.discovering_changed_count_); 1114 EXPECT_EQ(10, callback_count_); 1115 EXPECT_EQ(0, error_callback_count_); 1116 EXPECT_TRUE(observer.last_discovering_); 1117 EXPECT_TRUE(adapter_->IsDiscovering()); 1118 1119 // Now end the discovery session. This should change the adapter's discovery 1120 // state. 1121 discovery_sessions_[0]->Stop( 1122 base::Bind(&BluetoothChromeOSTest::Callback, 1123 base::Unretained(this)), 1124 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1125 base::Unretained(this))); 1126 message_loop_.Run(); 1127 EXPECT_EQ(6, observer.discovering_changed_count_); 1128 EXPECT_EQ(11, callback_count_); 1129 EXPECT_EQ(0, error_callback_count_); 1130 EXPECT_FALSE(observer.last_discovering_); 1131 EXPECT_FALSE(adapter_->IsDiscovering()); 1132 EXPECT_FALSE(discovery_sessions_[0]->IsActive()); 1133 } 1134 1135 TEST_F(BluetoothChromeOSTest, InvalidatedDiscoverySessions) { 1136 GetAdapter(); 1137 adapter_->SetPowered( 1138 true, 1139 base::Bind(&BluetoothChromeOSTest::Callback, 1140 base::Unretained(this)), 1141 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1142 base::Unretained(this))); 1143 EXPECT_EQ(1, callback_count_); 1144 EXPECT_EQ(0, error_callback_count_); 1145 EXPECT_TRUE(adapter_->IsPowered()); 1146 callback_count_ = 0; 1147 1148 TestObserver observer(adapter_); 1149 1150 EXPECT_EQ(0, observer.discovering_changed_count_); 1151 EXPECT_FALSE(observer.last_discovering_); 1152 EXPECT_FALSE(adapter_->IsDiscovering()); 1153 1154 // Request device discovery 3 times. 1155 for (int i = 0; i < 3; i++) { 1156 adapter_->StartDiscoverySession( 1157 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 1158 base::Unretained(this)), 1159 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1160 base::Unretained(this))); 1161 } 1162 // Run only once, as there should have been one D-Bus call. 1163 message_loop_.Run(); 1164 1165 // The observer should have received the discovering changed event exactly 1166 // once, the success callback should have been called 3 times and the adapter 1167 // should be discovering. 1168 EXPECT_EQ(1, observer.discovering_changed_count_); 1169 EXPECT_EQ(3, callback_count_); 1170 EXPECT_EQ(0, error_callback_count_); 1171 EXPECT_TRUE(observer.last_discovering_); 1172 EXPECT_TRUE(adapter_->IsDiscovering()); 1173 ASSERT_EQ((size_t)3, discovery_sessions_.size()); 1174 1175 for (int i = 0; i < 3; i++) 1176 EXPECT_TRUE(discovery_sessions_[i]->IsActive()); 1177 1178 // Stop the timers that the simulation uses 1179 fake_bluetooth_device_client_->EndDiscoverySimulation( 1180 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath)); 1181 1182 ASSERT_TRUE(adapter_->IsPowered()); 1183 ASSERT_TRUE(adapter_->IsDiscovering()); 1184 1185 // Delete all but one discovery session. 1186 discovery_sessions_.pop_back(); 1187 discovery_sessions_.pop_back(); 1188 ASSERT_EQ((size_t)1, discovery_sessions_.size()); 1189 EXPECT_TRUE(discovery_sessions_[0]->IsActive()); 1190 EXPECT_TRUE(adapter_->IsDiscovering()); 1191 1192 // Stop device discovery behind the adapter. The one active discovery session 1193 // should become inactive, but more importantly, we shouldn't run into any 1194 // memory errors as the sessions that we explicitly deleted should get 1195 // cleaned up. 1196 fake_bluetooth_adapter_client_->StopDiscovery( 1197 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), 1198 base::Bind(&BluetoothChromeOSTest::Callback, 1199 base::Unretained(this)), 1200 base::Bind(&BluetoothChromeOSTest::DBusErrorCallback, 1201 base::Unretained(this))); 1202 message_loop_.Run(); 1203 EXPECT_EQ(2, observer.discovering_changed_count_); 1204 EXPECT_EQ(4, callback_count_); 1205 EXPECT_EQ(0, error_callback_count_); 1206 EXPECT_FALSE(observer.last_discovering_); 1207 EXPECT_FALSE(adapter_->IsDiscovering()); 1208 EXPECT_FALSE(discovery_sessions_[0]->IsActive()); 1209 } 1210 1211 TEST_F(BluetoothChromeOSTest, QueuedDiscoveryRequests) { 1212 GetAdapter(); 1213 1214 adapter_->SetPowered( 1215 true, 1216 base::Bind(&BluetoothChromeOSTest::Callback, 1217 base::Unretained(this)), 1218 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1219 base::Unretained(this))); 1220 EXPECT_EQ(1, callback_count_); 1221 EXPECT_EQ(0, error_callback_count_); 1222 EXPECT_TRUE(adapter_->IsPowered()); 1223 callback_count_ = 0; 1224 1225 TestObserver observer(adapter_); 1226 1227 EXPECT_EQ(0, observer.discovering_changed_count_); 1228 EXPECT_FALSE(observer.last_discovering_); 1229 EXPECT_FALSE(adapter_->IsDiscovering()); 1230 1231 // Request to start discovery. The call should be pending. 1232 adapter_->StartDiscoverySession( 1233 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 1234 base::Unretained(this)), 1235 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1236 base::Unretained(this))); 1237 EXPECT_EQ(0, callback_count_); 1238 1239 fake_bluetooth_device_client_->EndDiscoverySimulation( 1240 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath)); 1241 1242 // The underlying adapter has started discovery, but our call hasn't returned 1243 // yet. 1244 EXPECT_EQ(1, observer.discovering_changed_count_); 1245 EXPECT_TRUE(observer.last_discovering_); 1246 EXPECT_TRUE(adapter_->IsDiscovering()); 1247 EXPECT_TRUE(discovery_sessions_.empty()); 1248 1249 // Request to start discovery twice. These should get queued and there should 1250 // be no change in state. 1251 for (int i = 0; i < 2; i++) { 1252 adapter_->StartDiscoverySession( 1253 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 1254 base::Unretained(this)), 1255 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1256 base::Unretained(this))); 1257 } 1258 EXPECT_EQ(0, callback_count_); 1259 EXPECT_EQ(0, error_callback_count_); 1260 EXPECT_EQ(1, observer.discovering_changed_count_); 1261 EXPECT_TRUE(observer.last_discovering_); 1262 EXPECT_TRUE(adapter_->IsDiscovering()); 1263 EXPECT_TRUE(discovery_sessions_.empty()); 1264 1265 // Process the pending call. The queued calls should execute and the discovery 1266 // session reference count should increase. 1267 message_loop_.Run(); 1268 EXPECT_EQ(3, callback_count_); 1269 EXPECT_EQ(0, error_callback_count_); 1270 EXPECT_EQ(1, observer.discovering_changed_count_); 1271 EXPECT_TRUE(observer.last_discovering_); 1272 EXPECT_TRUE(adapter_->IsDiscovering()); 1273 ASSERT_EQ((size_t)3, discovery_sessions_.size()); 1274 1275 // Verify the reference count by removing sessions 3 times. The last request 1276 // should remain pending. 1277 for (int i = 0; i < 3; i++) { 1278 discovery_sessions_[i]->Stop( 1279 base::Bind(&BluetoothChromeOSTest::Callback, 1280 base::Unretained(this)), 1281 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1282 base::Unretained(this))); 1283 } 1284 EXPECT_EQ(5, callback_count_); 1285 EXPECT_EQ(0, error_callback_count_); 1286 EXPECT_EQ(2, observer.discovering_changed_count_); 1287 EXPECT_FALSE(observer.last_discovering_); 1288 EXPECT_FALSE(adapter_->IsDiscovering()); 1289 EXPECT_FALSE(discovery_sessions_[0]->IsActive()); 1290 EXPECT_FALSE(discovery_sessions_[1]->IsActive()); 1291 EXPECT_TRUE(discovery_sessions_[2]->IsActive()); 1292 1293 // Request to stop the session whose call is pending should fail. 1294 discovery_sessions_[2]->Stop( 1295 base::Bind(&BluetoothChromeOSTest::Callback, 1296 base::Unretained(this)), 1297 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1298 base::Unretained(this))); 1299 EXPECT_EQ(5, callback_count_); 1300 EXPECT_EQ(1, error_callback_count_); 1301 EXPECT_EQ(2, observer.discovering_changed_count_); 1302 EXPECT_FALSE(observer.last_discovering_); 1303 EXPECT_FALSE(adapter_->IsDiscovering()); 1304 EXPECT_TRUE(discovery_sessions_[2]->IsActive()); 1305 1306 // Request to start should get queued. 1307 adapter_->StartDiscoverySession( 1308 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 1309 base::Unretained(this)), 1310 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1311 base::Unretained(this))); 1312 EXPECT_EQ(5, callback_count_); 1313 EXPECT_EQ(1, error_callback_count_); 1314 EXPECT_EQ(2, observer.discovering_changed_count_); 1315 EXPECT_FALSE(observer.last_discovering_); 1316 EXPECT_FALSE(adapter_->IsDiscovering()); 1317 ASSERT_EQ((size_t)3, discovery_sessions_.size()); 1318 1319 // Run the pending request. 1320 message_loop_.Run(); 1321 EXPECT_EQ(6, callback_count_); 1322 EXPECT_EQ(1, error_callback_count_); 1323 EXPECT_EQ(3, observer.discovering_changed_count_); 1324 EXPECT_TRUE(observer.last_discovering_); 1325 EXPECT_TRUE(adapter_->IsDiscovering()); 1326 ASSERT_EQ((size_t)3, discovery_sessions_.size()); 1327 EXPECT_FALSE(discovery_sessions_[2]->IsActive()); 1328 1329 // The queued request to start discovery should have been issued but is still 1330 // pending. Run the loop and verify. 1331 message_loop_.Run(); 1332 EXPECT_EQ(7, callback_count_); 1333 EXPECT_EQ(1, error_callback_count_); 1334 EXPECT_EQ(3, observer.discovering_changed_count_); 1335 EXPECT_TRUE(observer.last_discovering_); 1336 EXPECT_TRUE(adapter_->IsDiscovering()); 1337 ASSERT_EQ((size_t)4, discovery_sessions_.size()); 1338 EXPECT_TRUE(discovery_sessions_[3]->IsActive()); 1339 } 1340 1341 TEST_F(BluetoothChromeOSTest, StartDiscoverySession) { 1342 GetAdapter(); 1343 1344 adapter_->SetPowered( 1345 true, 1346 base::Bind(&BluetoothChromeOSTest::Callback, 1347 base::Unretained(this)), 1348 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1349 base::Unretained(this))); 1350 EXPECT_EQ(1, callback_count_); 1351 EXPECT_EQ(0, error_callback_count_); 1352 EXPECT_TRUE(adapter_->IsPowered()); 1353 callback_count_ = 0; 1354 1355 TestObserver observer(adapter_); 1356 1357 EXPECT_EQ(0, observer.discovering_changed_count_); 1358 EXPECT_FALSE(observer.last_discovering_); 1359 EXPECT_FALSE(adapter_->IsDiscovering()); 1360 EXPECT_TRUE(discovery_sessions_.empty()); 1361 1362 // Request a new discovery session. 1363 adapter_->StartDiscoverySession( 1364 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 1365 base::Unretained(this)), 1366 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1367 base::Unretained(this))); 1368 message_loop_.Run(); 1369 EXPECT_EQ(1, observer.discovering_changed_count_); 1370 EXPECT_EQ(1, callback_count_); 1371 EXPECT_EQ(0, error_callback_count_); 1372 EXPECT_TRUE(observer.last_discovering_); 1373 EXPECT_TRUE(adapter_->IsDiscovering()); 1374 ASSERT_EQ((size_t)1, discovery_sessions_.size()); 1375 EXPECT_TRUE(discovery_sessions_[0]->IsActive()); 1376 1377 // Start another session. A new one should be returned in the callback, which 1378 // in turn will destroy the previous session. Adapter should still be 1379 // discovering and the reference count should be 1. 1380 adapter_->StartDiscoverySession( 1381 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 1382 base::Unretained(this)), 1383 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1384 base::Unretained(this))); 1385 message_loop_.Run(); 1386 EXPECT_EQ(1, observer.discovering_changed_count_); 1387 EXPECT_EQ(2, callback_count_); 1388 EXPECT_EQ(0, error_callback_count_); 1389 EXPECT_TRUE(observer.last_discovering_); 1390 EXPECT_TRUE(adapter_->IsDiscovering()); 1391 ASSERT_EQ((size_t)2, discovery_sessions_.size()); 1392 EXPECT_TRUE(discovery_sessions_[0]->IsActive()); 1393 1394 // Request a new session. 1395 adapter_->StartDiscoverySession( 1396 base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback, 1397 base::Unretained(this)), 1398 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1399 base::Unretained(this))); 1400 message_loop_.Run(); 1401 EXPECT_EQ(1, observer.discovering_changed_count_); 1402 EXPECT_EQ(3, callback_count_); 1403 EXPECT_EQ(0, error_callback_count_); 1404 EXPECT_TRUE(observer.last_discovering_); 1405 EXPECT_TRUE(adapter_->IsDiscovering()); 1406 ASSERT_EQ((size_t)3, discovery_sessions_.size()); 1407 EXPECT_TRUE(discovery_sessions_[1]->IsActive()); 1408 EXPECT_NE(discovery_sessions_[0], discovery_sessions_[1]); 1409 1410 // Stop the previous discovery session. The session should end but discovery 1411 // should continue. 1412 discovery_sessions_[0]->Stop( 1413 base::Bind(&BluetoothChromeOSTest::Callback, 1414 base::Unretained(this)), 1415 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1416 base::Unretained(this))); 1417 message_loop_.Run(); 1418 EXPECT_EQ(1, observer.discovering_changed_count_); 1419 EXPECT_EQ(4, callback_count_); 1420 EXPECT_EQ(0, error_callback_count_); 1421 EXPECT_TRUE(observer.last_discovering_); 1422 EXPECT_TRUE(adapter_->IsDiscovering()); 1423 ASSERT_EQ((size_t)3, discovery_sessions_.size()); 1424 EXPECT_FALSE(discovery_sessions_[0]->IsActive()); 1425 EXPECT_TRUE(discovery_sessions_[1]->IsActive()); 1426 1427 // Delete the current active session. Discovery should eventually stop. 1428 discovery_sessions_.clear(); 1429 while (observer.last_discovering_) 1430 message_loop_.RunUntilIdle(); 1431 1432 EXPECT_EQ(2, observer.discovering_changed_count_); 1433 EXPECT_EQ(4, callback_count_); 1434 EXPECT_EQ(0, error_callback_count_); 1435 EXPECT_FALSE(observer.last_discovering_); 1436 EXPECT_FALSE(adapter_->IsDiscovering()); 1437 } 1438 1439 TEST_F(BluetoothChromeOSTest, DeviceProperties) { 1440 GetAdapter(); 1441 1442 BluetoothAdapter::DeviceList devices = adapter_->GetDevices(); 1443 ASSERT_EQ(1U, devices.size()); 1444 ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress, 1445 devices[0]->GetAddress()); 1446 1447 // Verify the other device properties. 1448 EXPECT_EQ(base::UTF8ToUTF16(FakeBluetoothDeviceClient::kPairedDeviceName), 1449 devices[0]->GetName()); 1450 EXPECT_EQ(BluetoothDevice::DEVICE_COMPUTER, devices[0]->GetDeviceType()); 1451 EXPECT_TRUE(devices[0]->IsPaired()); 1452 EXPECT_FALSE(devices[0]->IsConnected()); 1453 EXPECT_FALSE(devices[0]->IsConnecting()); 1454 1455 // Non HID devices are always connectable. 1456 EXPECT_TRUE(devices[0]->IsConnectable()); 1457 1458 BluetoothDevice::UUIDList uuids = devices[0]->GetUUIDs(); 1459 ASSERT_EQ(2U, uuids.size()); 1460 EXPECT_EQ(uuids[0], BluetoothUUID("1800")); 1461 EXPECT_EQ(uuids[1], BluetoothUUID("1801")); 1462 1463 EXPECT_EQ(BluetoothDevice::VENDOR_ID_USB, devices[0]->GetVendorIDSource()); 1464 EXPECT_EQ(0x05ac, devices[0]->GetVendorID()); 1465 EXPECT_EQ(0x030d, devices[0]->GetProductID()); 1466 EXPECT_EQ(0x0306, devices[0]->GetDeviceID()); 1467 } 1468 1469 TEST_F(BluetoothChromeOSTest, DeviceClassChanged) { 1470 // Simulate a change of class of a device, as sometimes occurs 1471 // during discovery. 1472 GetAdapter(); 1473 1474 BluetoothAdapter::DeviceList devices = adapter_->GetDevices(); 1475 ASSERT_EQ(1U, devices.size()); 1476 ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress, 1477 devices[0]->GetAddress()); 1478 ASSERT_EQ(BluetoothDevice::DEVICE_COMPUTER, devices[0]->GetDeviceType()); 1479 1480 // Install an observer; expect the DeviceChanged method to be called when 1481 // we change the class of the device. 1482 TestObserver observer(adapter_); 1483 1484 FakeBluetoothDeviceClient::Properties* properties = 1485 fake_bluetooth_device_client_->GetProperties( 1486 dbus::ObjectPath(FakeBluetoothDeviceClient::kPairedDevicePath)); 1487 1488 properties->bluetooth_class.ReplaceValue(0x002580); 1489 1490 EXPECT_EQ(1, observer.device_changed_count_); 1491 EXPECT_EQ(devices[0], observer.last_device_); 1492 1493 EXPECT_EQ(BluetoothDevice::DEVICE_MOUSE, devices[0]->GetDeviceType()); 1494 } 1495 1496 TEST_F(BluetoothChromeOSTest, DeviceNameChanged) { 1497 // Simulate a change of name of a device. 1498 GetAdapter(); 1499 1500 BluetoothAdapter::DeviceList devices = adapter_->GetDevices(); 1501 ASSERT_EQ(1U, devices.size()); 1502 ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress, 1503 devices[0]->GetAddress()); 1504 ASSERT_EQ(base::UTF8ToUTF16(FakeBluetoothDeviceClient::kPairedDeviceName), 1505 devices[0]->GetName()); 1506 1507 // Install an observer; expect the DeviceChanged method to be called when 1508 // we change the alias of the device. 1509 TestObserver observer(adapter_); 1510 1511 FakeBluetoothDeviceClient::Properties* properties = 1512 fake_bluetooth_device_client_->GetProperties( 1513 dbus::ObjectPath(FakeBluetoothDeviceClient::kPairedDevicePath)); 1514 1515 static const std::string new_name("New Device Name"); 1516 properties->alias.ReplaceValue(new_name); 1517 1518 EXPECT_EQ(1, observer.device_changed_count_); 1519 EXPECT_EQ(devices[0], observer.last_device_); 1520 1521 EXPECT_EQ(base::UTF8ToUTF16(new_name), devices[0]->GetName()); 1522 } 1523 1524 TEST_F(BluetoothChromeOSTest, DeviceUuidsChanged) { 1525 // Simulate a change of advertised services of a device. 1526 GetAdapter(); 1527 1528 BluetoothAdapter::DeviceList devices = adapter_->GetDevices(); 1529 ASSERT_EQ(1U, devices.size()); 1530 ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress, 1531 devices[0]->GetAddress()); 1532 1533 BluetoothDevice::UUIDList uuids = devices[0]->GetUUIDs(); 1534 ASSERT_EQ(2U, uuids.size()); 1535 ASSERT_EQ(uuids[0], BluetoothUUID("1800")); 1536 ASSERT_EQ(uuids[1], BluetoothUUID("1801")); 1537 1538 // Install an observer; expect the DeviceChanged method to be called when 1539 // we change the class of the device. 1540 TestObserver observer(adapter_); 1541 1542 FakeBluetoothDeviceClient::Properties* properties = 1543 fake_bluetooth_device_client_->GetProperties( 1544 dbus::ObjectPath(FakeBluetoothDeviceClient::kPairedDevicePath)); 1545 1546 std::vector<std::string> new_uuids; 1547 new_uuids.push_back(uuids[0].canonical_value()); 1548 new_uuids.push_back(uuids[1].canonical_value()); 1549 new_uuids.push_back("0000110c-0000-1000-8000-00805f9b34fb"); 1550 new_uuids.push_back("0000110e-0000-1000-8000-00805f9b34fb"); 1551 new_uuids.push_back("0000110a-0000-1000-8000-00805f9b34fb"); 1552 1553 properties->uuids.ReplaceValue(new_uuids); 1554 1555 EXPECT_EQ(1, observer.device_changed_count_); 1556 EXPECT_EQ(devices[0], observer.last_device_); 1557 1558 // Fetching the value should give the new one. 1559 uuids = devices[0]->GetUUIDs(); 1560 ASSERT_EQ(5U, uuids.size()); 1561 EXPECT_EQ(uuids[0], BluetoothUUID("1800")); 1562 EXPECT_EQ(uuids[1], BluetoothUUID("1801")); 1563 EXPECT_EQ(uuids[2], BluetoothUUID("110c")); 1564 EXPECT_EQ(uuids[3], BluetoothUUID("110e")); 1565 EXPECT_EQ(uuids[4], BluetoothUUID("110a")); 1566 } 1567 1568 TEST_F(BluetoothChromeOSTest, ForgetDevice) { 1569 GetAdapter(); 1570 1571 BluetoothAdapter::DeviceList devices = adapter_->GetDevices(); 1572 ASSERT_EQ(1U, devices.size()); 1573 ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress, 1574 devices[0]->GetAddress()); 1575 1576 std::string address = devices[0]->GetAddress(); 1577 1578 // Install an observer; expect the DeviceRemoved method to be called 1579 // with the device we remove. 1580 TestObserver observer(adapter_); 1581 1582 devices[0]->Forget( 1583 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1584 base::Unretained(this))); 1585 EXPECT_EQ(0, error_callback_count_); 1586 1587 EXPECT_EQ(1, observer.device_removed_count_); 1588 EXPECT_EQ(address, observer.last_device_address_); 1589 1590 // GetDevices shouldn't return the device either. 1591 devices = adapter_->GetDevices(); 1592 ASSERT_EQ(0U, devices.size()); 1593 } 1594 1595 TEST_F(BluetoothChromeOSTest, ForgetUnpairedDevice) { 1596 GetAdapter(); 1597 DiscoverDevices(); 1598 1599 BluetoothDevice* device = adapter_->GetDevice( 1600 FakeBluetoothDeviceClient::kConnectUnpairableAddress); 1601 ASSERT_TRUE(device != NULL); 1602 ASSERT_FALSE(device->IsPaired()); 1603 1604 // Connect the device so it becomes trusted and remembered. 1605 device->Connect( 1606 NULL, 1607 base::Bind(&BluetoothChromeOSTest::Callback, 1608 base::Unretained(this)), 1609 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 1610 base::Unretained(this))); 1611 1612 ASSERT_EQ(1, callback_count_); 1613 ASSERT_EQ(0, error_callback_count_); 1614 callback_count_ = 0; 1615 1616 ASSERT_TRUE(device->IsConnected()); 1617 ASSERT_FALSE(device->IsConnecting()); 1618 1619 // Make sure the trusted property has been set to true. 1620 FakeBluetoothDeviceClient::Properties* properties = 1621 fake_bluetooth_device_client_->GetProperties( 1622 dbus::ObjectPath(FakeBluetoothDeviceClient::kConnectUnpairablePath)); 1623 ASSERT_TRUE(properties->trusted.value()); 1624 1625 // Install an observer; expect the DeviceRemoved method to be called 1626 // with the device we remove. 1627 TestObserver observer(adapter_); 1628 1629 device->Forget( 1630 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1631 base::Unretained(this))); 1632 EXPECT_EQ(0, error_callback_count_); 1633 1634 EXPECT_EQ(1, observer.device_removed_count_); 1635 EXPECT_EQ(FakeBluetoothDeviceClient::kConnectUnpairableAddress, 1636 observer.last_device_address_); 1637 1638 // GetDevices shouldn't return the device either. 1639 device = adapter_->GetDevice( 1640 FakeBluetoothDeviceClient::kConnectUnpairableAddress); 1641 EXPECT_FALSE(device != NULL); 1642 } 1643 1644 TEST_F(BluetoothChromeOSTest, ConnectPairedDevice) { 1645 GetAdapter(); 1646 1647 BluetoothDevice* device = adapter_->GetDevice( 1648 FakeBluetoothDeviceClient::kPairedDeviceAddress); 1649 ASSERT_TRUE(device != NULL); 1650 ASSERT_TRUE(device->IsPaired()); 1651 1652 TestObserver observer(adapter_); 1653 1654 // Connect without a pairing delegate; since the device is already Paired 1655 // this should succeed and the device should become connected. 1656 device->Connect( 1657 NULL, 1658 base::Bind(&BluetoothChromeOSTest::Callback, 1659 base::Unretained(this)), 1660 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 1661 base::Unretained(this))); 1662 1663 EXPECT_EQ(1, callback_count_); 1664 EXPECT_EQ(0, error_callback_count_); 1665 1666 // Two changes for connecting, one for connected and one for for trusted 1667 // after connecting. 1668 EXPECT_EQ(4, observer.device_changed_count_); 1669 EXPECT_EQ(device, observer.last_device_); 1670 1671 EXPECT_TRUE(device->IsConnected()); 1672 EXPECT_FALSE(device->IsConnecting()); 1673 } 1674 1675 TEST_F(BluetoothChromeOSTest, ConnectUnpairableDevice) { 1676 GetAdapter(); 1677 DiscoverDevices(); 1678 1679 BluetoothDevice* device = adapter_->GetDevice( 1680 FakeBluetoothDeviceClient::kConnectUnpairableAddress); 1681 ASSERT_TRUE(device != NULL); 1682 ASSERT_FALSE(device->IsPaired()); 1683 1684 TestObserver observer(adapter_); 1685 1686 // Connect without a pairing delegate; since the device does not require 1687 // pairing, this should succeed and the device should become connected. 1688 device->Connect( 1689 NULL, 1690 base::Bind(&BluetoothChromeOSTest::Callback, 1691 base::Unretained(this)), 1692 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 1693 base::Unretained(this))); 1694 1695 EXPECT_EQ(1, callback_count_); 1696 EXPECT_EQ(0, error_callback_count_); 1697 1698 // Two changes for connecting, one for connected, one for for trusted after 1699 // connection, and one for the reconnect mode (IsConnectable). 1700 EXPECT_EQ(5, observer.device_changed_count_); 1701 EXPECT_EQ(device, observer.last_device_); 1702 1703 EXPECT_TRUE(device->IsConnected()); 1704 EXPECT_FALSE(device->IsConnecting()); 1705 1706 // Make sure the trusted property has been set to true. 1707 FakeBluetoothDeviceClient::Properties* properties = 1708 fake_bluetooth_device_client_->GetProperties( 1709 dbus::ObjectPath(FakeBluetoothDeviceClient::kConnectUnpairablePath)); 1710 EXPECT_TRUE(properties->trusted.value()); 1711 1712 // Verify is a HID device and is not connectable. 1713 BluetoothDevice::UUIDList uuids = device->GetUUIDs(); 1714 ASSERT_EQ(1U, uuids.size()); 1715 EXPECT_EQ(uuids[0], BluetoothUUID("1124")); 1716 EXPECT_FALSE(device->IsConnectable()); 1717 } 1718 1719 TEST_F(BluetoothChromeOSTest, ConnectConnectedDevice) { 1720 GetAdapter(); 1721 1722 BluetoothDevice* device = adapter_->GetDevice( 1723 FakeBluetoothDeviceClient::kPairedDeviceAddress); 1724 ASSERT_TRUE(device != NULL); 1725 ASSERT_TRUE(device->IsPaired()); 1726 1727 device->Connect( 1728 NULL, 1729 base::Bind(&BluetoothChromeOSTest::Callback, 1730 base::Unretained(this)), 1731 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 1732 base::Unretained(this))); 1733 1734 ASSERT_EQ(1, callback_count_); 1735 ASSERT_EQ(0, error_callback_count_); 1736 callback_count_ = 0; 1737 1738 ASSERT_TRUE(device->IsConnected()); 1739 1740 // Connect again; since the device is already Connected, this shouldn't do 1741 // anything to initiate the connection. 1742 TestObserver observer(adapter_); 1743 1744 device->Connect( 1745 NULL, 1746 base::Bind(&BluetoothChromeOSTest::Callback, 1747 base::Unretained(this)), 1748 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 1749 base::Unretained(this))); 1750 1751 EXPECT_EQ(1, callback_count_); 1752 EXPECT_EQ(0, error_callback_count_); 1753 1754 // The observer will be called because Connecting will toggle true and false, 1755 // and the trusted property will be updated to true. 1756 EXPECT_EQ(3, observer.device_changed_count_); 1757 1758 EXPECT_TRUE(device->IsConnected()); 1759 EXPECT_FALSE(device->IsConnecting()); 1760 } 1761 1762 TEST_F(BluetoothChromeOSTest, ConnectDeviceFails) { 1763 GetAdapter(); 1764 DiscoverDevices(); 1765 1766 BluetoothDevice* device = adapter_->GetDevice( 1767 FakeBluetoothDeviceClient::kLegacyAutopairAddress); 1768 ASSERT_TRUE(device != NULL); 1769 ASSERT_FALSE(device->IsPaired()); 1770 1771 TestObserver observer(adapter_); 1772 1773 // Connect without a pairing delegate; since the device requires pairing, 1774 // this should fail with an error. 1775 device->Connect( 1776 NULL, 1777 base::Bind(&BluetoothChromeOSTest::Callback, 1778 base::Unretained(this)), 1779 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 1780 base::Unretained(this))); 1781 1782 EXPECT_EQ(0, callback_count_); 1783 EXPECT_EQ(1, error_callback_count_); 1784 EXPECT_EQ(BluetoothDevice::ERROR_FAILED, last_connect_error_); 1785 1786 EXPECT_EQ(2, observer.device_changed_count_); 1787 1788 EXPECT_FALSE(device->IsConnected()); 1789 EXPECT_FALSE(device->IsConnecting()); 1790 } 1791 1792 TEST_F(BluetoothChromeOSTest, DisconnectDevice) { 1793 GetAdapter(); 1794 1795 BluetoothDevice* device = adapter_->GetDevice( 1796 FakeBluetoothDeviceClient::kPairedDeviceAddress); 1797 ASSERT_TRUE(device != NULL); 1798 ASSERT_TRUE(device->IsPaired()); 1799 1800 device->Connect( 1801 NULL, 1802 base::Bind(&BluetoothChromeOSTest::Callback, 1803 base::Unretained(this)), 1804 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 1805 base::Unretained(this))); 1806 1807 ASSERT_EQ(1, callback_count_); 1808 ASSERT_EQ(0, error_callback_count_); 1809 callback_count_ = 0; 1810 1811 ASSERT_TRUE(device->IsConnected()); 1812 ASSERT_FALSE(device->IsConnecting()); 1813 1814 // Disconnect the device, we should see the observer method fire and the 1815 // device get dropped. 1816 TestObserver observer(adapter_); 1817 1818 device->Disconnect( 1819 base::Bind(&BluetoothChromeOSTest::Callback, 1820 base::Unretained(this)), 1821 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1822 base::Unretained(this))); 1823 1824 EXPECT_EQ(1, callback_count_); 1825 EXPECT_EQ(0, error_callback_count_); 1826 1827 EXPECT_EQ(1, observer.device_changed_count_); 1828 EXPECT_EQ(device, observer.last_device_); 1829 1830 EXPECT_FALSE(device->IsConnected()); 1831 } 1832 1833 TEST_F(BluetoothChromeOSTest, DisconnectUnconnectedDevice) { 1834 GetAdapter(); 1835 1836 BluetoothDevice* device = adapter_->GetDevice( 1837 FakeBluetoothDeviceClient::kPairedDeviceAddress); 1838 ASSERT_TRUE(device != NULL); 1839 ASSERT_TRUE(device->IsPaired()); 1840 ASSERT_FALSE(device->IsConnected()); 1841 1842 // Disconnect the device, we should see the observer method fire and the 1843 // device get dropped. 1844 TestObserver observer(adapter_); 1845 1846 device->Disconnect( 1847 base::Bind(&BluetoothChromeOSTest::Callback, 1848 base::Unretained(this)), 1849 base::Bind(&BluetoothChromeOSTest::ErrorCallback, 1850 base::Unretained(this))); 1851 1852 EXPECT_EQ(0, callback_count_); 1853 EXPECT_EQ(1, error_callback_count_); 1854 1855 EXPECT_EQ(0, observer.device_changed_count_); 1856 1857 EXPECT_FALSE(device->IsConnected()); 1858 } 1859 1860 TEST_F(BluetoothChromeOSTest, PairLegacyAutopair) { 1861 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 1862 1863 GetAdapter(); 1864 DiscoverDevices(); 1865 1866 // The Legacy Autopair device requires no PIN or Passkey to pair because 1867 // the daemon provides 0000 to the device for us. 1868 BluetoothDevice* device = adapter_->GetDevice( 1869 FakeBluetoothDeviceClient::kLegacyAutopairAddress); 1870 ASSERT_TRUE(device != NULL); 1871 ASSERT_FALSE(device->IsPaired()); 1872 1873 TestObserver observer(adapter_); 1874 1875 TestPairingDelegate pairing_delegate; 1876 device->Connect( 1877 &pairing_delegate, 1878 base::Bind(&BluetoothChromeOSTest::Callback, 1879 base::Unretained(this)), 1880 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 1881 base::Unretained(this))); 1882 1883 EXPECT_EQ(0, pairing_delegate.call_count_); 1884 EXPECT_TRUE(device->IsConnecting()); 1885 1886 message_loop_.Run(); 1887 1888 EXPECT_EQ(1, callback_count_); 1889 EXPECT_EQ(0, error_callback_count_); 1890 1891 // Two changes for connecting, one change for connected, one for paired, 1892 // two for trusted (after pairing and connection), and one for the reconnect 1893 // mode (IsConnectable). 1894 EXPECT_EQ(7, observer.device_changed_count_); 1895 EXPECT_EQ(device, observer.last_device_); 1896 1897 EXPECT_TRUE(device->IsConnected()); 1898 EXPECT_FALSE(device->IsConnecting()); 1899 1900 EXPECT_TRUE(device->IsPaired()); 1901 1902 // Verify is a HID device and is connectable. 1903 BluetoothDevice::UUIDList uuids = device->GetUUIDs(); 1904 ASSERT_EQ(1U, uuids.size()); 1905 EXPECT_EQ(uuids[0], BluetoothUUID("1124")); 1906 EXPECT_TRUE(device->IsConnectable()); 1907 1908 // Make sure the trusted property has been set to true. 1909 FakeBluetoothDeviceClient::Properties* properties = 1910 fake_bluetooth_device_client_->GetProperties( 1911 dbus::ObjectPath(FakeBluetoothDeviceClient::kLegacyAutopairPath)); 1912 EXPECT_TRUE(properties->trusted.value()); 1913 } 1914 1915 TEST_F(BluetoothChromeOSTest, PairDisplayPinCode) { 1916 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 1917 1918 GetAdapter(); 1919 DiscoverDevices(); 1920 1921 // Requires that we display a randomly generated PIN on the screen. 1922 BluetoothDevice* device = adapter_->GetDevice( 1923 FakeBluetoothDeviceClient::kDisplayPinCodeAddress); 1924 ASSERT_TRUE(device != NULL); 1925 ASSERT_FALSE(device->IsPaired()); 1926 1927 TestObserver observer(adapter_); 1928 1929 TestPairingDelegate pairing_delegate; 1930 device->Connect( 1931 &pairing_delegate, 1932 base::Bind(&BluetoothChromeOSTest::Callback, 1933 base::Unretained(this)), 1934 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 1935 base::Unretained(this))); 1936 1937 EXPECT_EQ(1, pairing_delegate.call_count_); 1938 EXPECT_EQ(1, pairing_delegate.display_pincode_count_); 1939 EXPECT_EQ("123456", pairing_delegate.last_pincode_); 1940 EXPECT_TRUE(device->IsConnecting()); 1941 1942 message_loop_.Run(); 1943 1944 EXPECT_EQ(1, callback_count_); 1945 EXPECT_EQ(0, error_callback_count_); 1946 1947 // Two changes for connecting, one change for connected, one for paired, 1948 // two for trusted (after pairing and connection), and one for the reconnect 1949 // mode (IsConnectable). 1950 EXPECT_EQ(7, observer.device_changed_count_); 1951 EXPECT_EQ(device, observer.last_device_); 1952 1953 EXPECT_TRUE(device->IsConnected()); 1954 EXPECT_FALSE(device->IsConnecting()); 1955 1956 EXPECT_TRUE(device->IsPaired()); 1957 1958 // Verify is a HID device and is connectable. 1959 BluetoothDevice::UUIDList uuids = device->GetUUIDs(); 1960 ASSERT_EQ(1U, uuids.size()); 1961 EXPECT_EQ(uuids[0], BluetoothUUID("1124")); 1962 EXPECT_TRUE(device->IsConnectable()); 1963 1964 // Make sure the trusted property has been set to true. 1965 FakeBluetoothDeviceClient::Properties* properties = 1966 fake_bluetooth_device_client_->GetProperties( 1967 dbus::ObjectPath(FakeBluetoothDeviceClient::kDisplayPinCodePath)); 1968 EXPECT_TRUE(properties->trusted.value()); 1969 } 1970 1971 TEST_F(BluetoothChromeOSTest, PairDisplayPasskey) { 1972 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 1973 1974 GetAdapter(); 1975 DiscoverDevices(); 1976 1977 // Requires that we display a randomly generated Passkey on the screen, 1978 // and notifies us as it's typed in. 1979 BluetoothDevice* device = adapter_->GetDevice( 1980 FakeBluetoothDeviceClient::kDisplayPasskeyAddress); 1981 ASSERT_TRUE(device != NULL); 1982 ASSERT_FALSE(device->IsPaired()); 1983 1984 TestObserver observer(adapter_); 1985 1986 TestPairingDelegate pairing_delegate; 1987 device->Connect( 1988 &pairing_delegate, 1989 base::Bind(&BluetoothChromeOSTest::Callback, 1990 base::Unretained(this)), 1991 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 1992 base::Unretained(this))); 1993 1994 // One call for DisplayPasskey() and one for KeysEntered(). 1995 EXPECT_EQ(2, pairing_delegate.call_count_); 1996 EXPECT_EQ(1, pairing_delegate.display_passkey_count_); 1997 EXPECT_EQ(123456U, pairing_delegate.last_passkey_); 1998 EXPECT_EQ(1, pairing_delegate.keys_entered_count_); 1999 EXPECT_EQ(0U, pairing_delegate.last_entered_); 2000 2001 EXPECT_TRUE(device->IsConnecting()); 2002 2003 // One call to KeysEntered() for each key, including [enter]. 2004 for(int i = 1; i <= 7; ++i) { 2005 message_loop_.Run(); 2006 2007 EXPECT_EQ(2 + i, pairing_delegate.call_count_); 2008 EXPECT_EQ(1 + i, pairing_delegate.keys_entered_count_); 2009 EXPECT_EQ(static_cast<uint32_t>(i), pairing_delegate.last_entered_); 2010 } 2011 2012 message_loop_.Run(); 2013 2014 // 8 KeysEntered notifications (0 to 7, inclusive) and one aditional call for 2015 // DisplayPasskey(). 2016 EXPECT_EQ(9, pairing_delegate.call_count_); 2017 EXPECT_EQ(8, pairing_delegate.keys_entered_count_); 2018 EXPECT_EQ(7U, pairing_delegate.last_entered_); 2019 2020 EXPECT_EQ(1, callback_count_); 2021 EXPECT_EQ(0, error_callback_count_); 2022 2023 // Two changes for connecting, one change for connected, one for paired, 2024 // two for trusted (after pairing and connection), and one for the reconnect 2025 // mode (IsConnectable). 2026 EXPECT_EQ(7, observer.device_changed_count_); 2027 EXPECT_EQ(device, observer.last_device_); 2028 2029 EXPECT_TRUE(device->IsConnected()); 2030 EXPECT_FALSE(device->IsConnecting()); 2031 2032 EXPECT_TRUE(device->IsPaired()); 2033 2034 // Verify is a HID device. 2035 BluetoothDevice::UUIDList uuids = device->GetUUIDs(); 2036 ASSERT_EQ(1U, uuids.size()); 2037 EXPECT_EQ(uuids[0], BluetoothUUID("1124")); 2038 2039 // And usually not connectable. 2040 EXPECT_FALSE(device->IsConnectable()); 2041 2042 // Make sure the trusted property has been set to true. 2043 FakeBluetoothDeviceClient::Properties* properties = 2044 fake_bluetooth_device_client_->GetProperties( 2045 dbus::ObjectPath(FakeBluetoothDeviceClient::kDisplayPasskeyPath)); 2046 EXPECT_TRUE(properties->trusted.value()); 2047 } 2048 2049 TEST_F(BluetoothChromeOSTest, PairRequestPinCode) { 2050 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2051 2052 GetAdapter(); 2053 DiscoverDevices(); 2054 2055 // Requires that the user enters a PIN for them. 2056 BluetoothDevice* device = adapter_->GetDevice( 2057 FakeBluetoothDeviceClient::kRequestPinCodeAddress); 2058 ASSERT_TRUE(device != NULL); 2059 ASSERT_FALSE(device->IsPaired()); 2060 2061 TestObserver observer(adapter_); 2062 2063 TestPairingDelegate pairing_delegate; 2064 device->Connect( 2065 &pairing_delegate, 2066 base::Bind(&BluetoothChromeOSTest::Callback, 2067 base::Unretained(this)), 2068 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 2069 base::Unretained(this))); 2070 2071 EXPECT_EQ(1, pairing_delegate.call_count_); 2072 EXPECT_EQ(1, pairing_delegate.request_pincode_count_); 2073 EXPECT_TRUE(device->IsConnecting()); 2074 2075 // Set the PIN. 2076 device->SetPinCode("1234"); 2077 message_loop_.Run(); 2078 2079 EXPECT_EQ(1, callback_count_); 2080 EXPECT_EQ(0, error_callback_count_); 2081 2082 // Two changes for connecting, one change for connected, one for paired and 2083 // two for trusted (after pairing and connection). 2084 EXPECT_EQ(6, observer.device_changed_count_); 2085 EXPECT_EQ(device, observer.last_device_); 2086 2087 EXPECT_TRUE(device->IsConnected()); 2088 EXPECT_FALSE(device->IsConnecting()); 2089 2090 EXPECT_TRUE(device->IsPaired()); 2091 2092 // Verify is not a HID device. 2093 BluetoothDevice::UUIDList uuids = device->GetUUIDs(); 2094 ASSERT_EQ(0U, uuids.size()); 2095 2096 // Non HID devices are always connectable. 2097 EXPECT_TRUE(device->IsConnectable()); 2098 2099 // Make sure the trusted property has been set to true. 2100 FakeBluetoothDeviceClient::Properties* properties = 2101 fake_bluetooth_device_client_->GetProperties( 2102 dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath)); 2103 EXPECT_TRUE(properties->trusted.value()); 2104 } 2105 2106 TEST_F(BluetoothChromeOSTest, PairConfirmPasskey) { 2107 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2108 2109 GetAdapter(); 2110 DiscoverDevices(); 2111 2112 // Requests that we confirm a displayed passkey. 2113 BluetoothDevice* device = adapter_->GetDevice( 2114 FakeBluetoothDeviceClient::kConfirmPasskeyAddress); 2115 ASSERT_TRUE(device != NULL); 2116 ASSERT_FALSE(device->IsPaired()); 2117 2118 TestObserver observer(adapter_); 2119 2120 TestPairingDelegate pairing_delegate; 2121 device->Connect( 2122 &pairing_delegate, 2123 base::Bind(&BluetoothChromeOSTest::Callback, 2124 base::Unretained(this)), 2125 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 2126 base::Unretained(this))); 2127 2128 EXPECT_EQ(1, pairing_delegate.call_count_); 2129 EXPECT_EQ(1, pairing_delegate.confirm_passkey_count_); 2130 EXPECT_EQ(123456U, pairing_delegate.last_passkey_); 2131 EXPECT_TRUE(device->IsConnecting()); 2132 2133 // Confirm the passkey. 2134 device->ConfirmPairing(); 2135 message_loop_.Run(); 2136 2137 EXPECT_EQ(1, callback_count_); 2138 EXPECT_EQ(0, error_callback_count_); 2139 2140 // Two changes for connecting, one change for connected, one for paired and 2141 // two for trusted (after pairing and connection). 2142 EXPECT_EQ(6, observer.device_changed_count_); 2143 EXPECT_EQ(device, observer.last_device_); 2144 2145 EXPECT_TRUE(device->IsConnected()); 2146 EXPECT_FALSE(device->IsConnecting()); 2147 2148 EXPECT_TRUE(device->IsPaired()); 2149 2150 // Non HID devices are always connectable. 2151 EXPECT_TRUE(device->IsConnectable()); 2152 2153 // Make sure the trusted property has been set to true. 2154 FakeBluetoothDeviceClient::Properties* properties = 2155 fake_bluetooth_device_client_->GetProperties( 2156 dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath)); 2157 EXPECT_TRUE(properties->trusted.value()); 2158 } 2159 2160 TEST_F(BluetoothChromeOSTest, PairRequestPasskey) { 2161 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2162 2163 GetAdapter(); 2164 DiscoverDevices(); 2165 2166 // Requires that the user enters a Passkey, this would be some kind of 2167 // device that has a display, but doesn't use "just works" - maybe a car? 2168 BluetoothDevice* device = adapter_->GetDevice( 2169 FakeBluetoothDeviceClient::kRequestPasskeyAddress); 2170 ASSERT_TRUE(device != NULL); 2171 ASSERT_FALSE(device->IsPaired()); 2172 2173 TestObserver observer(adapter_); 2174 2175 TestPairingDelegate pairing_delegate; 2176 device->Connect( 2177 &pairing_delegate, 2178 base::Bind(&BluetoothChromeOSTest::Callback, 2179 base::Unretained(this)), 2180 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 2181 base::Unretained(this))); 2182 2183 EXPECT_EQ(1, pairing_delegate.call_count_); 2184 EXPECT_EQ(1, pairing_delegate.request_passkey_count_); 2185 EXPECT_TRUE(device->IsConnecting()); 2186 2187 // Set the Passkey. 2188 device->SetPasskey(1234); 2189 message_loop_.Run(); 2190 2191 EXPECT_EQ(1, callback_count_); 2192 EXPECT_EQ(0, error_callback_count_); 2193 2194 // Two changes for connecting, one change for connected, one for paired and 2195 // two for trusted (after pairing and connection). 2196 EXPECT_EQ(6, observer.device_changed_count_); 2197 EXPECT_EQ(device, observer.last_device_); 2198 2199 EXPECT_TRUE(device->IsConnected()); 2200 EXPECT_FALSE(device->IsConnecting()); 2201 2202 EXPECT_TRUE(device->IsPaired()); 2203 2204 // Non HID devices are always connectable. 2205 EXPECT_TRUE(device->IsConnectable()); 2206 2207 // Make sure the trusted property has been set to true. 2208 FakeBluetoothDeviceClient::Properties* properties = 2209 fake_bluetooth_device_client_->GetProperties( 2210 dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath)); 2211 EXPECT_TRUE(properties->trusted.value()); 2212 } 2213 2214 TEST_F(BluetoothChromeOSTest, PairJustWorks) { 2215 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2216 2217 GetAdapter(); 2218 DiscoverDevices(); 2219 2220 // Uses just-works pairing, since this is an outgoing pairing, no delegate 2221 // interaction is required. 2222 BluetoothDevice* device = adapter_->GetDevice( 2223 FakeBluetoothDeviceClient::kJustWorksAddress); 2224 ASSERT_TRUE(device != NULL); 2225 ASSERT_FALSE(device->IsPaired()); 2226 2227 TestObserver observer(adapter_); 2228 2229 TestPairingDelegate pairing_delegate; 2230 device->Connect( 2231 &pairing_delegate, 2232 base::Bind(&BluetoothChromeOSTest::Callback, 2233 base::Unretained(this)), 2234 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 2235 base::Unretained(this))); 2236 2237 EXPECT_EQ(0, pairing_delegate.call_count_); 2238 2239 message_loop_.Run(); 2240 2241 EXPECT_EQ(1, callback_count_); 2242 EXPECT_EQ(0, error_callback_count_); 2243 2244 // Two changes for connecting, one change for connected, one for paired and 2245 // two for trusted (after pairing and connection). 2246 EXPECT_EQ(6, observer.device_changed_count_); 2247 EXPECT_EQ(device, observer.last_device_); 2248 2249 EXPECT_TRUE(device->IsConnected()); 2250 EXPECT_FALSE(device->IsConnecting()); 2251 2252 EXPECT_TRUE(device->IsPaired()); 2253 2254 // Non HID devices are always connectable. 2255 EXPECT_TRUE(device->IsConnectable()); 2256 2257 // Make sure the trusted property has been set to true. 2258 FakeBluetoothDeviceClient::Properties* properties = 2259 fake_bluetooth_device_client_->GetProperties( 2260 dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath)); 2261 EXPECT_TRUE(properties->trusted.value()); 2262 } 2263 2264 TEST_F(BluetoothChromeOSTest, PairUnpairableDeviceFails) { 2265 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2266 2267 GetAdapter(); 2268 DiscoverDevice(FakeBluetoothDeviceClient::kUnconnectableDeviceAddress); 2269 2270 BluetoothDevice* device = adapter_->GetDevice( 2271 FakeBluetoothDeviceClient::kUnpairableDeviceAddress); 2272 ASSERT_TRUE(device != NULL); 2273 ASSERT_FALSE(device->IsPaired()); 2274 2275 TestObserver observer(adapter_); 2276 2277 TestPairingDelegate pairing_delegate; 2278 device->Connect( 2279 &pairing_delegate, 2280 base::Bind(&BluetoothChromeOSTest::Callback, 2281 base::Unretained(this)), 2282 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 2283 base::Unretained(this))); 2284 2285 EXPECT_EQ(0, pairing_delegate.call_count_); 2286 EXPECT_TRUE(device->IsConnecting()); 2287 2288 // Run the loop to get the error.. 2289 message_loop_.Run(); 2290 2291 EXPECT_EQ(0, callback_count_); 2292 EXPECT_EQ(1, error_callback_count_); 2293 2294 EXPECT_EQ(BluetoothDevice::ERROR_FAILED, last_connect_error_); 2295 2296 EXPECT_FALSE(device->IsConnected()); 2297 EXPECT_FALSE(device->IsConnecting()); 2298 EXPECT_FALSE(device->IsPaired()); 2299 } 2300 2301 TEST_F(BluetoothChromeOSTest, PairingFails) { 2302 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2303 2304 GetAdapter(); 2305 DiscoverDevice(FakeBluetoothDeviceClient::kVanishingDeviceAddress); 2306 2307 // The vanishing device times out during pairing 2308 BluetoothDevice* device = adapter_->GetDevice( 2309 FakeBluetoothDeviceClient::kVanishingDeviceAddress); 2310 ASSERT_TRUE(device != NULL); 2311 ASSERT_FALSE(device->IsPaired()); 2312 2313 TestObserver observer(adapter_); 2314 2315 TestPairingDelegate pairing_delegate; 2316 device->Connect( 2317 &pairing_delegate, 2318 base::Bind(&BluetoothChromeOSTest::Callback, 2319 base::Unretained(this)), 2320 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 2321 base::Unretained(this))); 2322 2323 EXPECT_EQ(0, pairing_delegate.call_count_); 2324 EXPECT_TRUE(device->IsConnecting()); 2325 2326 // Run the loop to get the error.. 2327 message_loop_.Run(); 2328 2329 EXPECT_EQ(0, callback_count_); 2330 EXPECT_EQ(1, error_callback_count_); 2331 2332 EXPECT_EQ(BluetoothDevice::ERROR_AUTH_TIMEOUT, last_connect_error_); 2333 2334 EXPECT_FALSE(device->IsConnected()); 2335 EXPECT_FALSE(device->IsConnecting()); 2336 EXPECT_FALSE(device->IsPaired()); 2337 } 2338 2339 TEST_F(BluetoothChromeOSTest, PairingFailsAtConnection) { 2340 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2341 2342 GetAdapter(); 2343 DiscoverDevices(); 2344 2345 // Everything seems to go according to plan with the unconnectable device; 2346 // it pairs, but then you can't make connections to it after. 2347 BluetoothDevice* device = adapter_->GetDevice( 2348 FakeBluetoothDeviceClient::kUnconnectableDeviceAddress); 2349 ASSERT_TRUE(device != NULL); 2350 ASSERT_FALSE(device->IsPaired()); 2351 2352 TestObserver observer(adapter_); 2353 2354 TestPairingDelegate pairing_delegate; 2355 device->Connect( 2356 &pairing_delegate, 2357 base::Bind(&BluetoothChromeOSTest::Callback, 2358 base::Unretained(this)), 2359 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 2360 base::Unretained(this))); 2361 2362 EXPECT_EQ(0, pairing_delegate.call_count_); 2363 EXPECT_TRUE(device->IsConnecting()); 2364 2365 message_loop_.Run(); 2366 2367 EXPECT_EQ(0, callback_count_); 2368 EXPECT_EQ(1, error_callback_count_); 2369 EXPECT_EQ(BluetoothDevice::ERROR_FAILED, last_connect_error_); 2370 2371 // Two changes for connecting, one for paired and one for trusted after 2372 // pairing. The device should not be connected. 2373 EXPECT_EQ(4, observer.device_changed_count_); 2374 EXPECT_EQ(device, observer.last_device_); 2375 2376 EXPECT_FALSE(device->IsConnected()); 2377 EXPECT_FALSE(device->IsConnecting()); 2378 2379 EXPECT_TRUE(device->IsPaired()); 2380 2381 // Make sure the trusted property has been set to true still (since pairing 2382 // worked). 2383 FakeBluetoothDeviceClient::Properties* properties = 2384 fake_bluetooth_device_client_->GetProperties( 2385 dbus::ObjectPath( 2386 FakeBluetoothDeviceClient::kUnconnectableDevicePath)); 2387 EXPECT_TRUE(properties->trusted.value()); 2388 } 2389 2390 TEST_F(BluetoothChromeOSTest, PairingRejectedAtPinCode) { 2391 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2392 2393 GetAdapter(); 2394 DiscoverDevices(); 2395 2396 // Reject the pairing after we receive a request for the PIN code. 2397 BluetoothDevice* device = adapter_->GetDevice( 2398 FakeBluetoothDeviceClient::kRequestPinCodeAddress); 2399 ASSERT_TRUE(device != NULL); 2400 ASSERT_FALSE(device->IsPaired()); 2401 2402 TestObserver observer(adapter_); 2403 2404 TestPairingDelegate pairing_delegate; 2405 device->Connect( 2406 &pairing_delegate, 2407 base::Bind(&BluetoothChromeOSTest::Callback, 2408 base::Unretained(this)), 2409 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 2410 base::Unretained(this))); 2411 2412 EXPECT_EQ(1, pairing_delegate.call_count_); 2413 EXPECT_EQ(1, pairing_delegate.request_pincode_count_); 2414 EXPECT_TRUE(device->IsConnecting()); 2415 2416 // Reject the pairing. 2417 device->RejectPairing(); 2418 message_loop_.Run(); 2419 2420 EXPECT_EQ(0, callback_count_); 2421 EXPECT_EQ(1, error_callback_count_); 2422 EXPECT_EQ(BluetoothDevice::ERROR_AUTH_REJECTED, last_connect_error_); 2423 2424 // Should be no changes except connecting going true and false. 2425 EXPECT_EQ(2, observer.device_changed_count_); 2426 EXPECT_FALSE(device->IsConnected()); 2427 EXPECT_FALSE(device->IsConnecting()); 2428 EXPECT_FALSE(device->IsPaired()); 2429 } 2430 2431 TEST_F(BluetoothChromeOSTest, PairingCancelledAtPinCode) { 2432 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2433 2434 GetAdapter(); 2435 DiscoverDevices(); 2436 2437 // Cancel the pairing after we receive a request for the PIN code. 2438 BluetoothDevice* device = adapter_->GetDevice( 2439 FakeBluetoothDeviceClient::kRequestPinCodeAddress); 2440 ASSERT_TRUE(device != NULL); 2441 ASSERT_FALSE(device->IsPaired()); 2442 2443 TestObserver observer(adapter_); 2444 2445 TestPairingDelegate pairing_delegate; 2446 device->Connect( 2447 &pairing_delegate, 2448 base::Bind(&BluetoothChromeOSTest::Callback, 2449 base::Unretained(this)), 2450 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 2451 base::Unretained(this))); 2452 2453 EXPECT_EQ(1, pairing_delegate.call_count_); 2454 EXPECT_EQ(1, pairing_delegate.request_pincode_count_); 2455 EXPECT_TRUE(device->IsConnecting()); 2456 2457 // Cancel the pairing. 2458 device->CancelPairing(); 2459 message_loop_.Run(); 2460 2461 EXPECT_EQ(0, callback_count_); 2462 EXPECT_EQ(1, error_callback_count_); 2463 EXPECT_EQ(BluetoothDevice::ERROR_AUTH_CANCELED, last_connect_error_); 2464 2465 // Should be no changes except connecting going true and false. 2466 EXPECT_EQ(2, observer.device_changed_count_); 2467 EXPECT_FALSE(device->IsConnected()); 2468 EXPECT_FALSE(device->IsConnecting()); 2469 EXPECT_FALSE(device->IsPaired()); 2470 } 2471 2472 TEST_F(BluetoothChromeOSTest, PairingRejectedAtPasskey) { 2473 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2474 2475 GetAdapter(); 2476 DiscoverDevices(); 2477 2478 // Reject the pairing after we receive a request for the passkey. 2479 BluetoothDevice* device = adapter_->GetDevice( 2480 FakeBluetoothDeviceClient::kRequestPasskeyAddress); 2481 ASSERT_TRUE(device != NULL); 2482 ASSERT_FALSE(device->IsPaired()); 2483 2484 TestObserver observer(adapter_); 2485 2486 TestPairingDelegate pairing_delegate; 2487 device->Connect( 2488 &pairing_delegate, 2489 base::Bind(&BluetoothChromeOSTest::Callback, 2490 base::Unretained(this)), 2491 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 2492 base::Unretained(this))); 2493 2494 EXPECT_EQ(1, pairing_delegate.call_count_); 2495 EXPECT_EQ(1, pairing_delegate.request_passkey_count_); 2496 EXPECT_TRUE(device->IsConnecting()); 2497 2498 // Reject the pairing. 2499 device->RejectPairing(); 2500 message_loop_.Run(); 2501 2502 EXPECT_EQ(0, callback_count_); 2503 EXPECT_EQ(1, error_callback_count_); 2504 EXPECT_EQ(BluetoothDevice::ERROR_AUTH_REJECTED, last_connect_error_); 2505 2506 // Should be no changes except connecting going true and false. 2507 EXPECT_EQ(2, observer.device_changed_count_); 2508 EXPECT_FALSE(device->IsConnected()); 2509 EXPECT_FALSE(device->IsConnecting()); 2510 EXPECT_FALSE(device->IsPaired()); 2511 } 2512 2513 TEST_F(BluetoothChromeOSTest, PairingCancelledAtPasskey) { 2514 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2515 2516 GetAdapter(); 2517 DiscoverDevices(); 2518 2519 // Cancel the pairing after we receive a request for the passkey. 2520 BluetoothDevice* device = adapter_->GetDevice( 2521 FakeBluetoothDeviceClient::kRequestPasskeyAddress); 2522 ASSERT_TRUE(device != NULL); 2523 ASSERT_FALSE(device->IsPaired()); 2524 2525 TestObserver observer(adapter_); 2526 2527 TestPairingDelegate pairing_delegate; 2528 device->Connect( 2529 &pairing_delegate, 2530 base::Bind(&BluetoothChromeOSTest::Callback, 2531 base::Unretained(this)), 2532 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 2533 base::Unretained(this))); 2534 2535 EXPECT_EQ(1, pairing_delegate.call_count_); 2536 EXPECT_EQ(1, pairing_delegate.request_passkey_count_); 2537 EXPECT_TRUE(device->IsConnecting()); 2538 2539 // Cancel the pairing. 2540 device->CancelPairing(); 2541 message_loop_.Run(); 2542 2543 EXPECT_EQ(0, callback_count_); 2544 EXPECT_EQ(1, error_callback_count_); 2545 EXPECT_EQ(BluetoothDevice::ERROR_AUTH_CANCELED, last_connect_error_); 2546 2547 // Should be no changes except connecting going true and false. 2548 EXPECT_EQ(2, observer.device_changed_count_); 2549 EXPECT_FALSE(device->IsConnected()); 2550 EXPECT_FALSE(device->IsConnecting()); 2551 EXPECT_FALSE(device->IsPaired()); 2552 } 2553 2554 TEST_F(BluetoothChromeOSTest, PairingRejectedAtConfirmation) { 2555 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2556 2557 GetAdapter(); 2558 DiscoverDevices(); 2559 2560 // Reject the pairing after we receive a request for passkey confirmation. 2561 BluetoothDevice* device = adapter_->GetDevice( 2562 FakeBluetoothDeviceClient::kConfirmPasskeyAddress); 2563 ASSERT_TRUE(device != NULL); 2564 ASSERT_FALSE(device->IsPaired()); 2565 2566 TestObserver observer(adapter_); 2567 2568 TestPairingDelegate pairing_delegate; 2569 device->Connect( 2570 &pairing_delegate, 2571 base::Bind(&BluetoothChromeOSTest::Callback, 2572 base::Unretained(this)), 2573 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 2574 base::Unretained(this))); 2575 2576 EXPECT_EQ(1, pairing_delegate.call_count_); 2577 EXPECT_EQ(1, pairing_delegate.confirm_passkey_count_); 2578 EXPECT_TRUE(device->IsConnecting()); 2579 2580 // Reject the pairing. 2581 device->RejectPairing(); 2582 message_loop_.Run(); 2583 2584 EXPECT_EQ(0, callback_count_); 2585 EXPECT_EQ(1, error_callback_count_); 2586 EXPECT_EQ(BluetoothDevice::ERROR_AUTH_REJECTED, last_connect_error_); 2587 2588 // Should be no changes except connecting going true and false. 2589 EXPECT_EQ(2, observer.device_changed_count_); 2590 EXPECT_FALSE(device->IsConnected()); 2591 EXPECT_FALSE(device->IsConnecting()); 2592 EXPECT_FALSE(device->IsPaired()); 2593 } 2594 2595 TEST_F(BluetoothChromeOSTest, PairingCancelledAtConfirmation) { 2596 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2597 2598 GetAdapter(); 2599 DiscoverDevices(); 2600 2601 // Cancel the pairing after we receive a request for the passkey. 2602 BluetoothDevice* device = adapter_->GetDevice( 2603 FakeBluetoothDeviceClient::kConfirmPasskeyAddress); 2604 ASSERT_TRUE(device != NULL); 2605 ASSERT_FALSE(device->IsPaired()); 2606 2607 TestObserver observer(adapter_); 2608 2609 TestPairingDelegate pairing_delegate; 2610 device->Connect( 2611 &pairing_delegate, 2612 base::Bind(&BluetoothChromeOSTest::Callback, 2613 base::Unretained(this)), 2614 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 2615 base::Unretained(this))); 2616 2617 EXPECT_EQ(1, pairing_delegate.call_count_); 2618 EXPECT_EQ(1, pairing_delegate.confirm_passkey_count_); 2619 EXPECT_TRUE(device->IsConnecting()); 2620 2621 // Cancel the pairing. 2622 device->CancelPairing(); 2623 message_loop_.Run(); 2624 2625 EXPECT_EQ(0, callback_count_); 2626 EXPECT_EQ(1, error_callback_count_); 2627 EXPECT_EQ(BluetoothDevice::ERROR_AUTH_CANCELED, last_connect_error_); 2628 2629 // Should be no changes except connecting going true and false. 2630 EXPECT_EQ(2, observer.device_changed_count_); 2631 EXPECT_FALSE(device->IsConnected()); 2632 EXPECT_FALSE(device->IsConnecting()); 2633 EXPECT_FALSE(device->IsPaired()); 2634 } 2635 2636 TEST_F(BluetoothChromeOSTest, PairingCancelledInFlight) { 2637 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2638 2639 GetAdapter(); 2640 DiscoverDevices(); 2641 2642 // Cancel the pairing while we're waiting for the remote host. 2643 BluetoothDevice* device = adapter_->GetDevice( 2644 FakeBluetoothDeviceClient::kLegacyAutopairAddress); 2645 ASSERT_TRUE(device != NULL); 2646 ASSERT_FALSE(device->IsPaired()); 2647 2648 TestObserver observer(adapter_); 2649 2650 TestPairingDelegate pairing_delegate; 2651 device->Connect( 2652 &pairing_delegate, 2653 base::Bind(&BluetoothChromeOSTest::Callback, 2654 base::Unretained(this)), 2655 base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback, 2656 base::Unretained(this))); 2657 2658 EXPECT_EQ(0, pairing_delegate.call_count_); 2659 EXPECT_TRUE(device->IsConnecting()); 2660 2661 // Cancel the pairing. 2662 device->CancelPairing(); 2663 message_loop_.Run(); 2664 2665 EXPECT_EQ(0, callback_count_); 2666 EXPECT_EQ(1, error_callback_count_); 2667 EXPECT_EQ(BluetoothDevice::ERROR_AUTH_CANCELED, last_connect_error_); 2668 2669 // Should be no changes except connecting going true and false. 2670 EXPECT_EQ(2, observer.device_changed_count_); 2671 EXPECT_FALSE(device->IsConnected()); 2672 EXPECT_FALSE(device->IsConnecting()); 2673 EXPECT_FALSE(device->IsPaired()); 2674 } 2675 2676 TEST_F(BluetoothChromeOSTest, IncomingPairRequestPinCode) { 2677 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2678 2679 GetAdapter(); 2680 2681 TestPairingDelegate pairing_delegate; 2682 adapter_->AddPairingDelegate( 2683 &pairing_delegate, 2684 BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH); 2685 2686 // Requires that we provide a PIN code. 2687 fake_bluetooth_device_client_->CreateDevice( 2688 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), 2689 dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath)); 2690 BluetoothDevice* device = adapter_->GetDevice( 2691 FakeBluetoothDeviceClient::kRequestPinCodeAddress); 2692 ASSERT_TRUE(device != NULL); 2693 ASSERT_FALSE(device->IsPaired()); 2694 2695 TestObserver observer(adapter_); 2696 2697 fake_bluetooth_device_client_->SimulatePairing( 2698 dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath), 2699 true, 2700 base::Bind(&BluetoothChromeOSTest::Callback, 2701 base::Unretained(this)), 2702 base::Bind(&BluetoothChromeOSTest::DBusErrorCallback, 2703 base::Unretained(this))); 2704 2705 EXPECT_EQ(1, pairing_delegate.call_count_); 2706 EXPECT_EQ(1, pairing_delegate.request_pincode_count_); 2707 2708 // Set the PIN. 2709 device->SetPinCode("1234"); 2710 message_loop_.Run(); 2711 2712 EXPECT_EQ(1, callback_count_); 2713 EXPECT_EQ(0, error_callback_count_); 2714 2715 // One change for paired, and one for trusted. 2716 EXPECT_EQ(2, observer.device_changed_count_); 2717 EXPECT_EQ(device, observer.last_device_); 2718 2719 EXPECT_TRUE(device->IsPaired()); 2720 2721 // Make sure the trusted property has been set to true. 2722 FakeBluetoothDeviceClient::Properties* properties = 2723 fake_bluetooth_device_client_->GetProperties( 2724 dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath)); 2725 ASSERT_TRUE(properties->trusted.value()); 2726 2727 // No pairing context should remain on the device. 2728 BluetoothDeviceChromeOS* device_chromeos = 2729 static_cast<BluetoothDeviceChromeOS*>(device); 2730 EXPECT_TRUE(device_chromeos->GetPairing() == NULL); 2731 } 2732 2733 TEST_F(BluetoothChromeOSTest, IncomingPairConfirmPasskey) { 2734 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2735 2736 GetAdapter(); 2737 2738 TestPairingDelegate pairing_delegate; 2739 adapter_->AddPairingDelegate( 2740 &pairing_delegate, 2741 BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH); 2742 2743 // Requests that we confirm a displayed passkey. 2744 fake_bluetooth_device_client_->CreateDevice( 2745 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), 2746 dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath)); 2747 BluetoothDevice* device = adapter_->GetDevice( 2748 FakeBluetoothDeviceClient::kConfirmPasskeyAddress); 2749 ASSERT_TRUE(device != NULL); 2750 ASSERT_FALSE(device->IsPaired()); 2751 2752 TestObserver observer(adapter_); 2753 2754 fake_bluetooth_device_client_->SimulatePairing( 2755 dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath), 2756 true, 2757 base::Bind(&BluetoothChromeOSTest::Callback, 2758 base::Unretained(this)), 2759 base::Bind(&BluetoothChromeOSTest::DBusErrorCallback, 2760 base::Unretained(this))); 2761 2762 EXPECT_EQ(1, pairing_delegate.call_count_); 2763 EXPECT_EQ(1, pairing_delegate.confirm_passkey_count_); 2764 EXPECT_EQ(123456U, pairing_delegate.last_passkey_); 2765 2766 // Confirm the passkey. 2767 device->ConfirmPairing(); 2768 message_loop_.Run(); 2769 2770 EXPECT_EQ(1, callback_count_); 2771 EXPECT_EQ(0, error_callback_count_); 2772 2773 // One change for paired, and one for trusted. 2774 EXPECT_EQ(2, observer.device_changed_count_); 2775 EXPECT_EQ(device, observer.last_device_); 2776 2777 EXPECT_TRUE(device->IsPaired()); 2778 2779 // Make sure the trusted property has been set to true. 2780 FakeBluetoothDeviceClient::Properties* properties = 2781 fake_bluetooth_device_client_->GetProperties( 2782 dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath)); 2783 ASSERT_TRUE(properties->trusted.value()); 2784 2785 // No pairing context should remain on the device. 2786 BluetoothDeviceChromeOS* device_chromeos = 2787 static_cast<BluetoothDeviceChromeOS*>(device); 2788 EXPECT_TRUE(device_chromeos->GetPairing() == NULL); 2789 } 2790 2791 TEST_F(BluetoothChromeOSTest, IncomingPairRequestPasskey) { 2792 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2793 2794 GetAdapter(); 2795 2796 TestPairingDelegate pairing_delegate; 2797 adapter_->AddPairingDelegate( 2798 &pairing_delegate, 2799 BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH); 2800 2801 // Requests that we provide a Passkey. 2802 fake_bluetooth_device_client_->CreateDevice( 2803 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), 2804 dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath)); 2805 BluetoothDevice* device = adapter_->GetDevice( 2806 FakeBluetoothDeviceClient::kRequestPasskeyAddress); 2807 ASSERT_TRUE(device != NULL); 2808 ASSERT_FALSE(device->IsPaired()); 2809 2810 TestObserver observer(adapter_); 2811 2812 fake_bluetooth_device_client_->SimulatePairing( 2813 dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath), 2814 true, 2815 base::Bind(&BluetoothChromeOSTest::Callback, 2816 base::Unretained(this)), 2817 base::Bind(&BluetoothChromeOSTest::DBusErrorCallback, 2818 base::Unretained(this))); 2819 2820 EXPECT_EQ(1, pairing_delegate.call_count_); 2821 EXPECT_EQ(1, pairing_delegate.request_passkey_count_); 2822 2823 // Set the Passkey. 2824 device->SetPasskey(1234); 2825 message_loop_.Run(); 2826 2827 EXPECT_EQ(1, callback_count_); 2828 EXPECT_EQ(0, error_callback_count_); 2829 2830 // One change for paired, and one for trusted. 2831 EXPECT_EQ(2, observer.device_changed_count_); 2832 EXPECT_EQ(device, observer.last_device_); 2833 2834 EXPECT_TRUE(device->IsPaired()); 2835 2836 // Make sure the trusted property has been set to true. 2837 FakeBluetoothDeviceClient::Properties* properties = 2838 fake_bluetooth_device_client_->GetProperties( 2839 dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath)); 2840 ASSERT_TRUE(properties->trusted.value()); 2841 2842 // No pairing context should remain on the device. 2843 BluetoothDeviceChromeOS* device_chromeos = 2844 static_cast<BluetoothDeviceChromeOS*>(device); 2845 EXPECT_TRUE(device_chromeos->GetPairing() == NULL); 2846 } 2847 2848 TEST_F(BluetoothChromeOSTest, IncomingPairJustWorks) { 2849 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2850 2851 GetAdapter(); 2852 2853 TestPairingDelegate pairing_delegate; 2854 adapter_->AddPairingDelegate( 2855 &pairing_delegate, 2856 BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH); 2857 2858 // Uses just-works pairing so, sinec this an incoming pairing, require 2859 // authorization from the user. 2860 fake_bluetooth_device_client_->CreateDevice( 2861 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), 2862 dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath)); 2863 BluetoothDevice* device = adapter_->GetDevice( 2864 FakeBluetoothDeviceClient::kJustWorksAddress); 2865 ASSERT_TRUE(device != NULL); 2866 ASSERT_FALSE(device->IsPaired()); 2867 2868 TestObserver observer(adapter_); 2869 2870 fake_bluetooth_device_client_->SimulatePairing( 2871 dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath), 2872 true, 2873 base::Bind(&BluetoothChromeOSTest::Callback, 2874 base::Unretained(this)), 2875 base::Bind(&BluetoothChromeOSTest::DBusErrorCallback, 2876 base::Unretained(this))); 2877 2878 EXPECT_EQ(1, pairing_delegate.call_count_); 2879 EXPECT_EQ(1, pairing_delegate.authorize_pairing_count_); 2880 2881 // Confirm the pairing. 2882 device->ConfirmPairing(); 2883 message_loop_.Run(); 2884 2885 EXPECT_EQ(1, callback_count_); 2886 EXPECT_EQ(0, error_callback_count_); 2887 2888 // One change for paired, and one for trusted. 2889 EXPECT_EQ(2, observer.device_changed_count_); 2890 EXPECT_EQ(device, observer.last_device_); 2891 2892 EXPECT_TRUE(device->IsPaired()); 2893 2894 // Make sure the trusted property has been set to true. 2895 FakeBluetoothDeviceClient::Properties* properties = 2896 fake_bluetooth_device_client_->GetProperties( 2897 dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath)); 2898 ASSERT_TRUE(properties->trusted.value()); 2899 2900 // No pairing context should remain on the device. 2901 BluetoothDeviceChromeOS* device_chromeos = 2902 static_cast<BluetoothDeviceChromeOS*>(device); 2903 EXPECT_TRUE(device_chromeos->GetPairing() == NULL); 2904 } 2905 2906 TEST_F(BluetoothChromeOSTest, IncomingPairRequestPinCodeWithoutDelegate) { 2907 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2908 2909 GetAdapter(); 2910 2911 // Requires that we provide a PIN Code, without a pairing delegate, 2912 // that will be rejected. 2913 fake_bluetooth_device_client_->CreateDevice( 2914 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), 2915 dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath)); 2916 BluetoothDevice* device = adapter_->GetDevice( 2917 FakeBluetoothDeviceClient::kRequestPinCodeAddress); 2918 ASSERT_TRUE(device != NULL); 2919 ASSERT_FALSE(device->IsPaired()); 2920 2921 TestObserver observer(adapter_); 2922 2923 fake_bluetooth_device_client_->SimulatePairing( 2924 dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath), 2925 true, 2926 base::Bind(&BluetoothChromeOSTest::Callback, 2927 base::Unretained(this)), 2928 base::Bind(&BluetoothChromeOSTest::DBusErrorCallback, 2929 base::Unretained(this))); 2930 2931 message_loop_.Run(); 2932 2933 EXPECT_EQ(0, callback_count_); 2934 EXPECT_EQ(1, error_callback_count_); 2935 EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_); 2936 2937 // No changes should be observer. 2938 EXPECT_EQ(0, observer.device_changed_count_); 2939 2940 EXPECT_FALSE(device->IsPaired()); 2941 2942 // No pairing context should remain on the device. 2943 BluetoothDeviceChromeOS* device_chromeos = 2944 static_cast<BluetoothDeviceChromeOS*>(device); 2945 EXPECT_TRUE(device_chromeos->GetPairing() == NULL); 2946 } 2947 2948 TEST_F(BluetoothChromeOSTest, IncomingPairConfirmPasskeyWithoutDelegate) { 2949 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2950 2951 GetAdapter(); 2952 2953 // Requests that we confirm a displayed passkey, without a pairing delegate, 2954 // that will be rejected. 2955 fake_bluetooth_device_client_->CreateDevice( 2956 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), 2957 dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath)); 2958 BluetoothDevice* device = adapter_->GetDevice( 2959 FakeBluetoothDeviceClient::kConfirmPasskeyAddress); 2960 ASSERT_TRUE(device != NULL); 2961 ASSERT_FALSE(device->IsPaired()); 2962 2963 TestObserver observer(adapter_); 2964 2965 fake_bluetooth_device_client_->SimulatePairing( 2966 dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath), 2967 true, 2968 base::Bind(&BluetoothChromeOSTest::Callback, 2969 base::Unretained(this)), 2970 base::Bind(&BluetoothChromeOSTest::DBusErrorCallback, 2971 base::Unretained(this))); 2972 2973 message_loop_.Run(); 2974 2975 EXPECT_EQ(0, callback_count_); 2976 EXPECT_EQ(1, error_callback_count_); 2977 EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_); 2978 2979 // No changes should be observer. 2980 EXPECT_EQ(0, observer.device_changed_count_); 2981 2982 EXPECT_FALSE(device->IsPaired()); 2983 2984 // No pairing context should remain on the device. 2985 BluetoothDeviceChromeOS* device_chromeos = 2986 static_cast<BluetoothDeviceChromeOS*>(device); 2987 EXPECT_TRUE(device_chromeos->GetPairing() == NULL); 2988 } 2989 2990 TEST_F(BluetoothChromeOSTest, IncomingPairRequestPasskeyWithoutDelegate) { 2991 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 2992 2993 GetAdapter(); 2994 2995 // Requests that we provide a displayed passkey, without a pairing delegate, 2996 // that will be rejected. 2997 fake_bluetooth_device_client_->CreateDevice( 2998 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), 2999 dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath)); 3000 BluetoothDevice* device = adapter_->GetDevice( 3001 FakeBluetoothDeviceClient::kRequestPasskeyAddress); 3002 ASSERT_TRUE(device != NULL); 3003 ASSERT_FALSE(device->IsPaired()); 3004 3005 TestObserver observer(adapter_); 3006 3007 fake_bluetooth_device_client_->SimulatePairing( 3008 dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath), 3009 true, 3010 base::Bind(&BluetoothChromeOSTest::Callback, 3011 base::Unretained(this)), 3012 base::Bind(&BluetoothChromeOSTest::DBusErrorCallback, 3013 base::Unretained(this))); 3014 3015 message_loop_.Run(); 3016 3017 EXPECT_EQ(0, callback_count_); 3018 EXPECT_EQ(1, error_callback_count_); 3019 EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_); 3020 3021 // No changes should be observer. 3022 EXPECT_EQ(0, observer.device_changed_count_); 3023 3024 EXPECT_FALSE(device->IsPaired()); 3025 3026 // No pairing context should remain on the device. 3027 BluetoothDeviceChromeOS* device_chromeos = 3028 static_cast<BluetoothDeviceChromeOS*>(device); 3029 EXPECT_TRUE(device_chromeos->GetPairing() == NULL); 3030 } 3031 3032 TEST_F(BluetoothChromeOSTest, IncomingPairJustWorksWithoutDelegate) { 3033 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 3034 3035 GetAdapter(); 3036 3037 // Uses just-works pairing and thus requires authorization for incoming 3038 // pairings, without a pairing delegate, that will be rejected. 3039 fake_bluetooth_device_client_->CreateDevice( 3040 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), 3041 dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath)); 3042 BluetoothDevice* device = adapter_->GetDevice( 3043 FakeBluetoothDeviceClient::kJustWorksAddress); 3044 ASSERT_TRUE(device != NULL); 3045 ASSERT_FALSE(device->IsPaired()); 3046 3047 TestObserver observer(adapter_); 3048 3049 fake_bluetooth_device_client_->SimulatePairing( 3050 dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath), 3051 true, 3052 base::Bind(&BluetoothChromeOSTest::Callback, 3053 base::Unretained(this)), 3054 base::Bind(&BluetoothChromeOSTest::DBusErrorCallback, 3055 base::Unretained(this))); 3056 3057 message_loop_.Run(); 3058 3059 EXPECT_EQ(0, callback_count_); 3060 EXPECT_EQ(1, error_callback_count_); 3061 EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_); 3062 3063 // No changes should be observer. 3064 EXPECT_EQ(0, observer.device_changed_count_); 3065 3066 EXPECT_FALSE(device->IsPaired()); 3067 3068 // No pairing context should remain on the device. 3069 BluetoothDeviceChromeOS* device_chromeos = 3070 static_cast<BluetoothDeviceChromeOS*>(device); 3071 EXPECT_TRUE(device_chromeos->GetPairing() == NULL); 3072 } 3073 3074 TEST_F(BluetoothChromeOSTest, RemovePairingDelegateDuringPairing) { 3075 fake_bluetooth_device_client_->SetSimulationIntervalMs(10); 3076 3077 GetAdapter(); 3078 3079 TestPairingDelegate pairing_delegate; 3080 adapter_->AddPairingDelegate( 3081 &pairing_delegate, 3082 BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH); 3083 3084 // Requests that we provide a Passkey. 3085 fake_bluetooth_device_client_->CreateDevice( 3086 dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath), 3087 dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath)); 3088 BluetoothDevice* device = adapter_->GetDevice( 3089 FakeBluetoothDeviceClient::kRequestPasskeyAddress); 3090 ASSERT_TRUE(device != NULL); 3091 ASSERT_FALSE(device->IsPaired()); 3092 3093 TestObserver observer(adapter_); 3094 3095 fake_bluetooth_device_client_->SimulatePairing( 3096 dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath), 3097 true, 3098 base::Bind(&BluetoothChromeOSTest::Callback, 3099 base::Unretained(this)), 3100 base::Bind(&BluetoothChromeOSTest::DBusErrorCallback, 3101 base::Unretained(this))); 3102 3103 EXPECT_EQ(1, pairing_delegate.call_count_); 3104 EXPECT_EQ(1, pairing_delegate.request_passkey_count_); 3105 3106 // A pairing context should now be set on the device. 3107 BluetoothDeviceChromeOS* device_chromeos = 3108 static_cast<BluetoothDeviceChromeOS*>(device); 3109 ASSERT_TRUE(device_chromeos->GetPairing() != NULL); 3110 3111 // Removing the pairing delegate should remove that pairing context. 3112 adapter_->RemovePairingDelegate(&pairing_delegate); 3113 3114 EXPECT_TRUE(device_chromeos->GetPairing() == NULL); 3115 3116 // Set the Passkey, this should now have no effect since the pairing has 3117 // been, in-effect, cancelled 3118 device->SetPasskey(1234); 3119 3120 EXPECT_EQ(0, callback_count_); 3121 EXPECT_EQ(0, error_callback_count_); 3122 EXPECT_EQ(0, observer.device_changed_count_); 3123 3124 EXPECT_FALSE(device->IsPaired()); 3125 } 3126 3127 TEST_F(BluetoothChromeOSTest, DeviceId) { 3128 GetAdapter(); 3129 3130 // Use the built-in paired device for this test, grab its Properties 3131 // structure so we can adjust the underlying modalias property. 3132 BluetoothDevice* device = adapter_->GetDevice( 3133 FakeBluetoothDeviceClient::kPairedDeviceAddress); 3134 FakeBluetoothDeviceClient::Properties* properties = 3135 fake_bluetooth_device_client_->GetProperties( 3136 dbus::ObjectPath(FakeBluetoothDeviceClient::kPairedDevicePath)); 3137 3138 ASSERT_TRUE(device != NULL); 3139 ASSERT_TRUE(properties != NULL); 3140 3141 // Valid USB IF-assigned identifier. 3142 ASSERT_EQ("usb:v05ACp030Dd0306", properties->modalias.value()); 3143 3144 EXPECT_EQ(BluetoothDevice::VENDOR_ID_USB, device->GetVendorIDSource()); 3145 EXPECT_EQ(0x05ac, device->GetVendorID()); 3146 EXPECT_EQ(0x030d, device->GetProductID()); 3147 EXPECT_EQ(0x0306, device->GetDeviceID()); 3148 3149 // Valid Bluetooth SIG-assigned identifier. 3150 properties->modalias.ReplaceValue("bluetooth:v00E0p2400d0400"); 3151 3152 EXPECT_EQ(BluetoothDevice::VENDOR_ID_BLUETOOTH, device->GetVendorIDSource()); 3153 EXPECT_EQ(0x00e0, device->GetVendorID()); 3154 EXPECT_EQ(0x2400, device->GetProductID()); 3155 EXPECT_EQ(0x0400, device->GetDeviceID()); 3156 3157 // Invalid USB IF-assigned identifier. 3158 properties->modalias.ReplaceValue("usb:x00E0p2400d0400"); 3159 3160 EXPECT_EQ(BluetoothDevice::VENDOR_ID_UNKNOWN, device->GetVendorIDSource()); 3161 EXPECT_EQ(0, device->GetVendorID()); 3162 EXPECT_EQ(0, device->GetProductID()); 3163 EXPECT_EQ(0, device->GetDeviceID()); 3164 3165 // Invalid Bluetooth SIG-assigned identifier. 3166 properties->modalias.ReplaceValue("bluetooth:x00E0p2400d0400"); 3167 3168 EXPECT_EQ(BluetoothDevice::VENDOR_ID_UNKNOWN, device->GetVendorIDSource()); 3169 EXPECT_EQ(0, device->GetVendorID()); 3170 EXPECT_EQ(0, device->GetProductID()); 3171 EXPECT_EQ(0, device->GetDeviceID()); 3172 3173 // Unknown vendor specification identifier. 3174 properties->modalias.ReplaceValue("chrome:v00E0p2400d0400"); 3175 3176 EXPECT_EQ(BluetoothDevice::VENDOR_ID_UNKNOWN, device->GetVendorIDSource()); 3177 EXPECT_EQ(0, device->GetVendorID()); 3178 EXPECT_EQ(0, device->GetProductID()); 3179 EXPECT_EQ(0, device->GetDeviceID()); 3180 } 3181 3182 } // namespace chromeos 3183