Bluetooth: use generic names for fake devices

device/bluetooth/bluetooth_chromeos_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chromeos/dbus/fake_bluetooth_adapter_client.h"
 #include "chromeos/dbus/fake_bluetooth_agent_manager_client.h"
 #include "chromeos/dbus/fake_bluetooth_device_client.h"
 #include "chromeos/dbus/fake_bluetooth_input_client.h"
@@ skipping 756 matching lines @@
       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   message_loop_.Run();
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_TRUE(adapter_->IsDiscovering());
 
-  // First device to appear should be an Apple Mouse.
+  // First device to appear.
   message_loop_.Run();
 
   EXPECT_EQ(1, observer.device_added_count_);
-  EXPECT_EQ(FakeBluetoothDeviceClient::kAppleMouseAddress,
+  EXPECT_EQ(FakeBluetoothDeviceClient::kLegacyAutopairAddress,
             observer.last_device_address_);
 
   // Next we should get another two devices...
   message_loop_.Run();
   EXPECT_EQ(3, observer.device_added_count_);
 
   // Okay, let's run forward until a device is actually removed...
   while (!observer.device_removed_count_)
     message_loop_.Run();
 
@@ skipping 757 matching lines @@
   // GetDevices shouldn't return the device either.
   devices = adapter_->GetDevices();
   ASSERT_EQ(0U, devices.size());
 }
 
 TEST_F(BluetoothChromeOSTest, ForgetUnpairedDevice) {
   GetAdapter();
   DiscoverDevices();
 
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kMicrosoftMouseAddress);
+      FakeBluetoothDeviceClient::kConnectUnpairableAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   // Connect the device so it becomes trusted and remembered.
   device->Connect(
       NULL,
       base::Bind(&BluetoothChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                  base::Unretained(this)));
 
   ASSERT_EQ(1, callback_count_);
   ASSERT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(device->IsConnected());
   ASSERT_FALSE(device->IsConnecting());
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
-          dbus::ObjectPath(FakeBluetoothDeviceClient::kMicrosoftMousePath));
+          dbus::ObjectPath(FakeBluetoothDeviceClient::kConnectUnpairablePath));
   ASSERT_TRUE(properties->trusted.value());
 
   // Install an observer; expect the DeviceRemoved method to be called
   // with the device we remove.
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   device->Forget(
       base::Bind(&BluetoothChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.device_removed_count_);
-  EXPECT_EQ(FakeBluetoothDeviceClient::kMicrosoftMouseAddress,
+  EXPECT_EQ(FakeBluetoothDeviceClient::kConnectUnpairableAddress,
             observer.last_device_address_);
 
   // GetDevices shouldn't return the device either.
   device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kMicrosoftMouseAddress);
+      FakeBluetoothDeviceClient::kConnectUnpairableAddress);
   EXPECT_FALSE(device != NULL);
 }
 
 TEST_F(BluetoothChromeOSTest, ConnectPairedDevice) {
   GetAdapter();
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kPairedDeviceAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_TRUE(device->IsPaired());
@@ skipping 20 matching lines @@
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 }
 
 TEST_F(BluetoothChromeOSTest, ConnectUnpairableDevice) {
   GetAdapter();
   DiscoverDevices();
 
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kMicrosoftMouseAddress);
+      FakeBluetoothDeviceClient::kConnectUnpairableAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   // Connect without a pairing delegate; since the device does not require
   // pairing, this should succeed and the device should become connected.
   device->Connect(
       NULL,
       base::Bind(&BluetoothChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // Two changes for connecting, one for connected, one for for trusted after
   // connection, and one for the reconnect mode (IsConnectable).
   EXPECT_EQ(5, observer.device_changed_count_);
   EXPECT_EQ(device, observer.last_device_);
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
-          dbus::ObjectPath(FakeBluetoothDeviceClient::kMicrosoftMousePath));
+          dbus::ObjectPath(FakeBluetoothDeviceClient::kConnectUnpairablePath));
   EXPECT_TRUE(properties->trusted.value());
 
   // Verify is a HID device and is not connectable.
   BluetoothDevice::ServiceList uuids = device->GetServices();
   ASSERT_EQ(1U, uuids.size());
   EXPECT_EQ(uuids[0], "00001124-0000-1000-8000-00805f9b34fb");
   EXPECT_FALSE(device->IsConnectable());
 }
 
 TEST_F(BluetoothChromeOSTest, ConnectConnectedDevice) {
@@ skipping 38 matching lines @@
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 }
 
 TEST_F(BluetoothChromeOSTest, ConnectDeviceFails) {
   GetAdapter();
   DiscoverDevices();
 
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kAppleMouseAddress);
+      FakeBluetoothDeviceClient::kLegacyAutopairAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   // Connect without a pairing delegate; since the device requires pairing,
   // this should fail with an error.
   device->Connect(
       NULL,
@@ skipping 75 matching lines @@
                  base::Unretained(this)));
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
 
   EXPECT_EQ(0, observer.device_changed_count_);
 
   EXPECT_FALSE(device->IsConnected());
 }
 
-TEST_F(BluetoothChromeOSTest, PairAppleMouse) {
+TEST_F(BluetoothChromeOSTest, PairLegacyAutopair) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
-  // The Apple Mouse requires no PIN or Passkey to pair; this is equivalent
-  // to Simple Secure Pairing or a device with a fixed 0000 PIN.
+  // The Legacy Autopair device requires no PIN or Passkey to pair because
+  // the daemon provides 0000 to the device for us.
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kAppleMouseAddress);
+      FakeBluetoothDeviceClient::kLegacyAutopairAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(
       &pairing_delegate,
       base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 22 matching lines @@
 
   // Verify is a HID device and is connectable.
   BluetoothDevice::ServiceList uuids = device->GetServices();
   ASSERT_EQ(1U, uuids.size());
   EXPECT_EQ(uuids[0], "00001124-0000-1000-8000-00805f9b34fb");
   EXPECT_TRUE(device->IsConnectable());
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
-          dbus::ObjectPath(FakeBluetoothDeviceClient::kAppleMousePath));
+          dbus::ObjectPath(FakeBluetoothDeviceClient::kLegacyAutopairPath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
-TEST_F(BluetoothChromeOSTest, PairAppleKeyboard) {
+TEST_F(BluetoothChromeOSTest, PairDisplayPinCode) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
-  // The Apple Keyboard requires that we display a randomly generated
-  // PIN on the screen.
+  // Requires that we display a randomly generated PIN on the screen.
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kAppleKeyboardAddress);
+      FakeBluetoothDeviceClient::kDisplayPinCodeAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(
       &pairing_delegate,
       base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 24 matching lines @@
 
   // Verify is a HID device and is connectable.
   BluetoothDevice::ServiceList uuids = device->GetServices();
   ASSERT_EQ(1U, uuids.size());
   EXPECT_EQ(uuids[0], "00001124-0000-1000-8000-00805f9b34fb");
   EXPECT_TRUE(device->IsConnectable());
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
-          dbus::ObjectPath(FakeBluetoothDeviceClient::kAppleKeyboardPath));
+          dbus::ObjectPath(FakeBluetoothDeviceClient::kDisplayPinCodePath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
-TEST_F(BluetoothChromeOSTest, PairMotorolaKeyboard) {
+TEST_F(BluetoothChromeOSTest, PairDisplayPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
-  // The Motorola Keyboard requires that we display a randomly generated
-  // Passkey on the screen, and notifies us as it's typed in.
+  // Requires that we display a randomly generated Passkey on the screen,
+  // and notifies us as it's typed in.
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kMotorolaKeyboardAddress);
+      FakeBluetoothDeviceClient::kDisplayPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(
       &pairing_delegate,
       base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 39 matching lines @@
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 
   EXPECT_TRUE(device->IsPaired());
 
   // Verify is a HID device.
   BluetoothDevice::ServiceList uuids = device->GetServices();
   ASSERT_EQ(1U, uuids.size());
   EXPECT_EQ(uuids[0], "00001124-0000-1000-8000-00805f9b34fb");
 
-  // Fake MotorolaKeyboard is not connectable.
+  // And usually not connectable.
   EXPECT_FALSE(device->IsConnectable());
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
-          dbus::ObjectPath(FakeBluetoothDeviceClient::kMotorolaKeyboardPath));
+          dbus::ObjectPath(FakeBluetoothDeviceClient::kDisplayPasskeyPath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
-TEST_F(BluetoothChromeOSTest, PairSonyHeadphones) {
+TEST_F(BluetoothChromeOSTest, PairRequestPinCode) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
-  // The Sony Headphones fake requires that the user enters a PIN for them.
+  // Requires that the user enters a PIN for them.
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kSonyHeadphonesAddress);
+      FakeBluetoothDeviceClient::kRequestPinCodeAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(
       &pairing_delegate,
       base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 25 matching lines @@
   // Verify is not a HID device.
   BluetoothDevice::ServiceList uuids = device->GetServices();
   ASSERT_EQ(0U, uuids.size());
 
   // Non HID devices are always connectable.
   EXPECT_TRUE(device->IsConnectable());
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
-          dbus::ObjectPath(FakeBluetoothDeviceClient::kSonyHeadphonesPath));
+          dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
-TEST_F(BluetoothChromeOSTest, PairPhone) {
+TEST_F(BluetoothChromeOSTest, PairConfirmPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
-  // The fake phone requests that we confirm a displayed passkey.
+  // Requests that we confirm a displayed passkey.
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kPhoneAddress);
+      FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(
       &pairing_delegate,
       base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 22 matching lines @@
   EXPECT_FALSE(device->IsConnecting());
 
   EXPECT_TRUE(device->IsPaired());
 
   // Non HID devices are always connectable.
   EXPECT_TRUE(device->IsConnectable());
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
-          dbus::ObjectPath(FakeBluetoothDeviceClient::kPhonePath));
+          dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
-TEST_F(BluetoothChromeOSTest, PairWeirdDevice) {
+TEST_F(BluetoothChromeOSTest, PairRequestPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
-  // Use the "weird device" fake that requires that the user enters a Passkey,
-  // this would be some kind of device that has a display, but doesn't use
-  // "just works" - maybe a car?
+  // Requires that the user enters a Passkey, this would be some kind of
+  // device that has a display, but doesn't use "just works" - maybe a car?
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kWeirdDeviceAddress);
+      FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(
       &pairing_delegate,
       base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 21 matching lines @@
   EXPECT_FALSE(device->IsConnecting());
 
   EXPECT_TRUE(device->IsPaired());
 
   // Non HID devices are always connectable.
   EXPECT_TRUE(device->IsConnectable());
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
-          dbus::ObjectPath(FakeBluetoothDeviceClient::kWeirdDevicePath));
+          dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
-TEST_F(BluetoothChromeOSTest, PairBoseSpeakers) {
+TEST_F(BluetoothChromeOSTest, PairJustWorks) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
-  // Use the "bose speakers" fake that uses just-works pairing, since this is
-  // an outgoing pairing, no delegate interaction is required.
+  // Uses just-works pairing, since this is an outgoing pairing, no delegate
+  // interaction is required.
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kBoseSpeakersAddress);
+      FakeBluetoothDeviceClient::kJustWorksAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(
       &pairing_delegate,
       base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 17 matching lines @@
   EXPECT_FALSE(device->IsConnecting());
 
   EXPECT_TRUE(device->IsPaired());
 
   // Non HID devices are always connectable.
   EXPECT_TRUE(device->IsConnectable());
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
-          dbus::ObjectPath(FakeBluetoothDeviceClient::kBoseSpeakersPath));
+          dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
 TEST_F(BluetoothChromeOSTest, PairUnpairableDeviceFails) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevice(FakeBluetoothDeviceClient::kUnconnectableDeviceAddress);
 
   BluetoothDevice* device = adapter_->GetDevice(
@@ skipping 120 matching lines @@
 }
 
 TEST_F(BluetoothChromeOSTest, PairingRejectedAtPinCode) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Reject the pairing after we receive a request for the PIN code.
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kSonyHeadphonesAddress);
+      FakeBluetoothDeviceClient::kRequestPinCodeAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(
       &pairing_delegate,
       base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 21 matching lines @@
 }
 
 TEST_F(BluetoothChromeOSTest, PairingCancelledAtPinCode) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Cancel the pairing after we receive a request for the PIN code.
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kSonyHeadphonesAddress);
+      FakeBluetoothDeviceClient::kRequestPinCodeAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(
       &pairing_delegate,
       base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 21 matching lines @@
 }
 
 TEST_F(BluetoothChromeOSTest, PairingRejectedAtPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Reject the pairing after we receive a request for the passkey.
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kWeirdDeviceAddress);
+      FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(
       &pairing_delegate,
       base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 21 matching lines @@
 }
 
 TEST_F(BluetoothChromeOSTest, PairingCancelledAtPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Cancel the pairing after we receive a request for the passkey.
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kWeirdDeviceAddress);
+      FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(
       &pairing_delegate,
       base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 21 matching lines @@
 }
 
 TEST_F(BluetoothChromeOSTest, PairingRejectedAtConfirmation) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Reject the pairing after we receive a request for passkey confirmation.
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kPhoneAddress);
+      FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(
       &pairing_delegate,
       base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 21 matching lines @@
 }
 
 TEST_F(BluetoothChromeOSTest, PairingCancelledAtConfirmation) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Cancel the pairing after we receive a request for the passkey.
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kPhoneAddress);
+      FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(
       &pairing_delegate,
       base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 21 matching lines @@
 }
 
 TEST_F(BluetoothChromeOSTest, PairingCancelledInFlight) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Cancel the pairing while we're waiting for the remote host.
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kAppleMouseAddress);
+      FakeBluetoothDeviceClient::kLegacyAutopairAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(
       &pairing_delegate,
       base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 12 matching lines @@
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothDevice::ERROR_AUTH_CANCELED, last_connect_error_);
 
   // Should be no changes except connecting going true and false.
   EXPECT_EQ(2, observer.device_changed_count_);
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 }
 
-TEST_F(BluetoothChromeOSTest, IncomingPairSonyHeadphones) {
+TEST_F(BluetoothChromeOSTest, IncomingPairRequestPinCode) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
       &pairing_delegate,
       BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
-  // The sony headphones requests that we provide a PIN code.
+  // Requires that we provide a PIN code.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kSonyHeadphonesPath));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath));
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kSonyHeadphonesAddress);
+      FakeBluetoothDeviceClient::kRequestPinCodeAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kSonyHeadphonesPath),
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath),
       true,
       base::Bind(&BluetoothChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_pincode_count_);
 
   // Set the PIN.
   device->SetPinCode("1234");
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // One for paired.
   EXPECT_EQ(1, observer.device_changed_count_);
   EXPECT_EQ(device, observer.last_device_);
 
   EXPECT_TRUE(device->IsPaired());
 
   // No pairing context should remain on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
   EXPECT_TRUE(device_chromeos->GetPairing() == NULL);
 }
 
-TEST_F(BluetoothChromeOSTest, IncomingPairPhone) {
+TEST_F(BluetoothChromeOSTest, IncomingPairConfirmPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
       &pairing_delegate,
       BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
-  // The fake phone requests that we confirm a displayed passkey.
+  // Requests that we confirm a displayed passkey.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kPhonePath));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kPhoneAddress);
+      FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kPhonePath),
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath),
       true,
       base::Bind(&BluetoothChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.confirm_passkey_count_);
   EXPECT_EQ(123456U, pairing_delegate.last_passkey_);
 
   // Confirm the passkey.
   device->ConfirmPairing();
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // One for paired.
   EXPECT_EQ(1, observer.device_changed_count_);
   EXPECT_EQ(device, observer.last_device_);
 
   EXPECT_TRUE(device->IsPaired());
 
   // No pairing context should remain on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
   EXPECT_TRUE(device_chromeos->GetPairing() == NULL);
 }
 
-TEST_F(BluetoothChromeOSTest, IncomingPairWeirdDevice) {
+TEST_F(BluetoothChromeOSTest, IncomingPairRequestPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
       &pairing_delegate,
       BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
-  // The weird device requests that we provide a Passkey.
+  // Requests that we provide a Passkey.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kWeirdDevicePath));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kWeirdDeviceAddress);
+      FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kWeirdDevicePath),
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath),
       true,
       base::Bind(&BluetoothChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_passkey_count_);
 
   // Set the Passkey.
   device->SetPasskey(1234);
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // One for paired.
   EXPECT_EQ(1, observer.device_changed_count_);
   EXPECT_EQ(device, observer.last_device_);
 
   EXPECT_TRUE(device->IsPaired());
 
   // No pairing context should remain on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
   EXPECT_TRUE(device_chromeos->GetPairing() == NULL);
 }
 
-TEST_F(BluetoothChromeOSTest, IncomingPairBoseSpeakers) {
+TEST_F(BluetoothChromeOSTest, IncomingPairJustWorks) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
       &pairing_delegate,
       BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
-  // The Bose Speakers use just-works pairing so require authorization when
-  // the request is incoming.
+  // Uses just-works pairing so, sinec this an incoming pairing, require
+  // authorization from the user.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kBoseSpeakersPath));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath));
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kBoseSpeakersAddress);
+      FakeBluetoothDeviceClient::kJustWorksAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kBoseSpeakersPath),
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath),
       true,
       base::Bind(&BluetoothChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.authorize_pairing_count_);
 
   // Confirm the pairing.
   device->ConfirmPairing();
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // One for paired.
   EXPECT_EQ(1, observer.device_changed_count_);
   EXPECT_EQ(device, observer.last_device_);
 
   EXPECT_TRUE(device->IsPaired());
 
   // No pairing context should remain on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
   EXPECT_TRUE(device_chromeos->GetPairing() == NULL);
 }
 
-TEST_F(BluetoothChromeOSTest, IncomingPairSonyHeadphonesWithoutDelegate) {
+TEST_F(BluetoothChromeOSTest, IncomingPairRequestPinCodeWithoutDelegate) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
-  // The Sony Headphones requests that we provide a PIN Code, without a
-  // pairing delegate, that will be rejected.
+  // Requires that we provide a PIN Code, without a pairing delegate,
+  // that will be rejected.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kSonyHeadphonesPath));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath));
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kSonyHeadphonesAddress);
+      FakeBluetoothDeviceClient::kRequestPinCodeAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kSonyHeadphonesPath),
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath),
       true,
       base::Bind(&BluetoothChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                  base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_);
 
   // No changes should be observer.
   EXPECT_EQ(0, observer.device_changed_count_);
 
   EXPECT_FALSE(device->IsPaired());
 
   // No pairing context should remain on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
   EXPECT_TRUE(device_chromeos->GetPairing() == NULL);
 }
 
-TEST_F(BluetoothChromeOSTest, IncomingPairPhoneWithoutDelegate) {
+TEST_F(BluetoothChromeOSTest, IncomingPairConfirmPasskeyWithoutDelegate) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
-  // The fake phone requests that we confirm a displayed passkey, without a
-  // pairing delegate, that will be rejected.
+  // Requests that we confirm a displayed passkey, without a pairing delegate,
+  // that will be rejected.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kPhonePath));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kPhoneAddress);
+      FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kPhonePath),
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath),
       true,
       base::Bind(&BluetoothChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                  base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_);
 
   // No changes should be observer.
   EXPECT_EQ(0, observer.device_changed_count_);
 
   EXPECT_FALSE(device->IsPaired());
 
   // No pairing context should remain on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
   EXPECT_TRUE(device_chromeos->GetPairing() == NULL);
 }
 
-TEST_F(BluetoothChromeOSTest, IncomingPairWeirdDeviceWithoutDelegate) {
+TEST_F(BluetoothChromeOSTest, IncomingPairRequestPasskeyWithoutDelegate) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
-  // The weird device requests that we provide a displayed passkey, without a
-  // pairing delegate, that will be rejected.
+  // Requests that we provide a displayed passkey, without a pairing delegate,
+  // that will be rejected.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kWeirdDevicePath));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kWeirdDeviceAddress);
+      FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kWeirdDevicePath),
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath),
       true,
       base::Bind(&BluetoothChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                  base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_);
 
   // No changes should be observer.
   EXPECT_EQ(0, observer.device_changed_count_);
 
   EXPECT_FALSE(device->IsPaired());
 
   // No pairing context should remain on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
   EXPECT_TRUE(device_chromeos->GetPairing() == NULL);
 }
 
-TEST_F(BluetoothChromeOSTest, IncomingPairBoseSpeakersWithoutDelegate) {
+TEST_F(BluetoothChromeOSTest, IncomingPairJustWorksWithoutDelegate) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
-  // The Bose Speakers uses just-works pairing and thus requires authorization,
-  // without a pairing delegate, that will be rejected.
+  // Uses just-works pairing and thus requires authorization for incoming
+  // pairings, without a pairing delegate, that will be rejected.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kBoseSpeakersPath));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath));
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kBoseSpeakersAddress);
+      FakeBluetoothDeviceClient::kJustWorksAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kBoseSpeakersPath),
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath),
       true,
       base::Bind(&BluetoothChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                  base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
@@ skipping 13 matching lines @@
 TEST_F(BluetoothChromeOSTest, RemovePairingDelegateDuringPairing) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
       &pairing_delegate,
       BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
-  // The weird device requests that we provide a Passkey.
+  // Requests that we provide a Passkey.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kWeirdDevicePath));
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
-      FakeBluetoothDeviceClient::kWeirdDeviceAddress);
+      FakeBluetoothDeviceClient::kRequestPasskeyAddress);
   ASSERT_TRUE(device != NULL);
   ASSERT_FALSE(device->IsPaired());
 
   TestObserver observer(adapter_);
   adapter_->AddObserver(&observer);
 
   fake_bluetooth_device_client_->SimulatePairing(
-      dbus::ObjectPath(FakeBluetoothDeviceClient::kWeirdDevicePath),
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath),
       true,
       base::Bind(&BluetoothChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_passkey_count_);
 
   // A pairing context should now be set on the device.
@@ skipping 61 matching lines @@
 
   // Unknown vendor specification identifier.
   properties->modalias.ReplaceValue("chrome:v00E0p2400d0400");
 
   EXPECT_EQ(0, device->GetVendorID());
   EXPECT_EQ(0, device->GetProductID());
   EXPECT_EQ(0, device->GetDeviceID());
 }
 
 }  // namespace chromeos