Bluetooth: D-Bus client interface for org.bluez.Input1

device/bluetooth/bluetooth_experimental_chromeos_unittest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/fake_bluetooth_adapter_client.h"
 #include "chromeos/dbus/fake_bluetooth_device_client.h"
+#include "chromeos/dbus/fake_bluetooth_input_client.h"
 #include "chromeos/dbus/mock_dbus_thread_manager_without_gmock.h"
 #include "dbus/object_path.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_experimental_chromeos.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_device_experimental_chromeos.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using device::BluetoothAdapter;
@@ skipping 181 matching lines @@
           chromeos::switches::kEnableExperimentalBluetooth);
 
     mock_dbus_thread_manager_ =
         new MockDBusThreadManagerWithoutGMock();
     DBusThreadManager::InitializeForTesting(mock_dbus_thread_manager_);
 
     fake_bluetooth_adapter_client_ =
       mock_dbus_thread_manager_->fake_bluetooth_adapter_client();
     fake_bluetooth_device_client_ =
       mock_dbus_thread_manager_->fake_bluetooth_device_client();
+    fake_bluetooth_input_client_ =
+      mock_dbus_thread_manager_->fake_bluetooth_input_client();
 
     callback_count_ = 0;
     error_callback_count_ = 0;
     last_connect_error_ = BluetoothDevice::ERROR_UNKNOWN;
   }
 
   virtual void TearDown() {
     adapter_ = NULL;
     DBusThreadManager::Shutdown();
   }
@@ skipping 77 matching lines @@
   // Run a discovery phase so we have devices that can be paired with.
   void DiscoverDevices() {
     // Pass an invalid address for the device so that the discovery process
     // completes with all devices.
     DiscoverDevice("does not exist");
   }
 
  protected:
   FakeBluetoothAdapterClient* fake_bluetooth_adapter_client_;
   FakeBluetoothDeviceClient* fake_bluetooth_device_client_;
+  FakeBluetoothInputClient* fake_bluetooth_input_client_;
   MockDBusThreadManagerWithoutGMock* mock_dbus_thread_manager_;
   scoped_refptr<BluetoothAdapter> adapter_;
 
   int callback_count_;
   int error_callback_count_;
   enum BluetoothDevice::ConnectErrorCode last_connect_error_;
 };
 
 TEST_F(BluetoothExperimentalChromeOSTest, AlreadyPresent) {
   GetAdapter();
@@ skipping 416 matching lines @@
   ASSERT_EQ(1U, devices.size());
   ASSERT_EQ(FakeBluetoothDeviceClient::kPairedDeviceAddress,
             devices[0]->GetAddress());
 
   // Verify the other device properties.
   EXPECT_EQ(UTF8ToUTF16(FakeBluetoothDeviceClient::kPairedDeviceName),
             devices[0]->GetName());
   EXPECT_EQ(BluetoothDevice::DEVICE_COMPUTER, devices[0]->GetDeviceType());
   EXPECT_TRUE(devices[0]->IsPaired());
   EXPECT_FALSE(devices[0]->IsConnected());
-  EXPECT_FALSE(devices[0]->IsConnectable());
   EXPECT_FALSE(devices[0]->IsConnecting());
 
+  // Non HID devices are always connectable.
+  EXPECT_TRUE(devices[0]->IsConnectable());
+
   BluetoothDevice::ServiceList uuids = devices[0]->GetServices();
   ASSERT_EQ(2U, uuids.size());
   EXPECT_EQ(uuids[0], "00001800-0000-1000-8000-00805f9b34fb");
   EXPECT_EQ(uuids[1], "00001801-0000-1000-8000-00805f9b34fb");
 }
 
 TEST_F(BluetoothExperimentalChromeOSTest, DeviceClassChanged) {
   // Simulate a change of class of a device, as sometimes occurs
   // during discovery.
   GetAdapter();
@@ skipping 349 matching lines @@
       &pairing_delegate,
       base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothExperimentalChromeOSTest::ConnectErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
   EXPECT_TRUE(device->IsConnecting());
 
   message_loop.Run();
+  fake_bluetooth_input_client_->AddInputDevice(
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kAppleMousePath));

[keybuk, 2013/04/18 20:50:25]

This should be handled by the FakeBluetoothDeviceClient, not by the test case;
e.g. in FakeBluetoothDeviceClient::DiscoverySimulationTimer

Otherwise this property won't be correct on the Linux Desktop

[deymo, 2013/04/18 22:19:55]

Done. This is emulated by FakeBluetoothDeviceClient based on the device class.
The Input interface is emulated to appear once the device is paired, to mimic
the real bluez5 behavior. 

 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // One change for connected, and one for paired.
   EXPECT_EQ(2, observer.device_changed_count_);
   EXPECT_EQ(device, observer.last_device_);
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 
   EXPECT_TRUE(device->IsPaired());
+  EXPECT_TRUE(device->IsConnectable());
 
   // Pairing dialog should be dismissed
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kAppleMousePath));
   EXPECT_TRUE(properties->trusted.value());
@@ skipping 23 matching lines @@
                  base::Unretained(this)),
       base::Bind(&BluetoothExperimentalChromeOSTest::ConnectErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.display_pincode_count_);
   EXPECT_EQ("123456", pairing_delegate.last_pincode_);
   EXPECT_TRUE(device->IsConnecting());
 
   message_loop.Run();
+  fake_bluetooth_input_client_->AddInputDevice(
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kAppleKeyboardPath));

[keybuk, 2013/04/18 20:50:25]

ditto

 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // One change for connected, and one for paired.
   EXPECT_EQ(2, observer.device_changed_count_);
   EXPECT_EQ(device, observer.last_device_);
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 
   EXPECT_TRUE(device->IsPaired());
+  EXPECT_TRUE(device->IsConnectable());
 
   // Pairing dialog should be dismissed
   EXPECT_EQ(2, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kAppleKeyboardPath));
   EXPECT_TRUE(properties->trusted.value());
@@ skipping 25 matching lines @@
                  base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.display_passkey_count_);
   EXPECT_EQ(123456U, pairing_delegate.last_passkey_);
   EXPECT_TRUE(device->IsConnecting());
 
   // TODO(keybuk): verify we get typing notifications
 
   message_loop.Run();
+  fake_bluetooth_input_client_->AddInputDevice(
+      dbus::ObjectPath(FakeBluetoothDeviceClient::kMotorolaKeyboardPath));
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // One change for connected, and one for paired.
   EXPECT_EQ(2, observer.device_changed_count_);
   EXPECT_EQ(device, observer.last_device_);
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 
   EXPECT_TRUE(device->IsPaired());
 
+  // Fake MotorolaKeyboard is not connectable.
+  EXPECT_FALSE(device->IsConnectable());
+
   // Pairing dialog should be dismissed
   EXPECT_EQ(2, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kMotorolaKeyboardPath));
   EXPECT_TRUE(properties->trusted.value());
 }
@@ skipping 35 matching lines @@
 
   // One change for connected, and one for paired.
   EXPECT_EQ(2, observer.device_changed_count_);
   EXPECT_EQ(device, observer.last_device_);
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 
   EXPECT_TRUE(device->IsPaired());
 
+  // Non HID devices are always connectable.
+  EXPECT_TRUE(device->IsConnectable());
+
   // Pairing dialog should be dismissed
   EXPECT_EQ(2, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kSonyHeadphonesPath));
   EXPECT_TRUE(properties->trusted.value());
 }
@@ skipping 36 matching lines @@
 
   // One change for connected, and one for paired.
   EXPECT_EQ(2, observer.device_changed_count_);
   EXPECT_EQ(device, observer.last_device_);
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 
   EXPECT_TRUE(device->IsPaired());
 
+  // Non HID devices are always connectable.
+  EXPECT_TRUE(device->IsConnectable());
+
   // Pairing dialog should be dismissed
   EXPECT_EQ(2, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kPhonePath));
   EXPECT_TRUE(properties->trusted.value());
 }
@@ skipping 37 matching lines @@
 
   // One change for connected, and one for paired.
   EXPECT_EQ(2, observer.device_changed_count_);
   EXPECT_EQ(device, observer.last_device_);
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 
   EXPECT_TRUE(device->IsPaired());
 
+  // Non HID devices are always connectable.
+  EXPECT_TRUE(device->IsConnectable());
+
   // Pairing dialog should be dismissed
   EXPECT_EQ(2, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kWeirdDevicePath));
   EXPECT_TRUE(properties->trusted.value());
 }
@@ skipping 419 matching lines @@
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 
   // Pairing dialog should be dismissed
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 }
 
 }  // namespace chromeos