device/bluetooth/bluetooth_adapter_profile_chromeos_unittest.cc

   1 // Copyright 2015 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/bind.h"
   6 #include "base/message_loop/message_loop.h"
   7 #include "chromeos/dbus/bluetooth_profile_service_provider.h"
   8 #include "chromeos/dbus/dbus_thread_manager.h"
   9 #include "chromeos/dbus/fake_bluetooth_adapter_client.h"
  10 #include "chromeos/dbus/fake_bluetooth_agent_manager_client.h"
  11 #include "chromeos/dbus/fake_bluetooth_device_client.h"
  12 #include "chromeos/dbus/fake_bluetooth_profile_manager_client.h"
  13 #include "device/bluetooth/bluetooth_adapter.h"
  14 #include "device/bluetooth/bluetooth_adapter_chromeos.h"
  15 #include "device/bluetooth/bluetooth_adapter_factory.h"
  16 #include "device/bluetooth/bluetooth_adapter_profile_chromeos.h"
  17 #include "device/bluetooth/bluetooth_uuid.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 using device::BluetoothAdapter;
  21 using device::BluetoothUUID;
  22
  23 namespace chromeos {
  24
  25 class BluetoothAdapterProfileChromeOSTest : public testing::Test {
  26  public:
  27   BluetoothAdapterProfileChromeOSTest()
  28       : fake_delegate_paired_(FakeBluetoothDeviceClient::kPairedDevicePath),
  29         fake_delegate_autopair_(FakeBluetoothDeviceClient::kLegacyAutopairPath),
  30         fake_delegate_listen_(""),
  31         profile_(nullptr),
  32         success_callback_count_(0),
  33         error_callback_count_(0) {}
  34
  35   void SetUp() override {
  36     scoped_ptr<DBusThreadManagerSetter> dbus_setter =
  37         DBusThreadManager::GetSetterForTesting();
  38
  39     dbus_setter->SetBluetoothAdapterClient(
  40         scoped_ptr<BluetoothAdapterClient>(new FakeBluetoothAdapterClient));
  41     dbus_setter->SetBluetoothAgentManagerClient(
  42         scoped_ptr<BluetoothAgentManagerClient>(
  43             new FakeBluetoothAgentManagerClient));
  44     dbus_setter->SetBluetoothDeviceClient(
  45         scoped_ptr<BluetoothDeviceClient>(new FakeBluetoothDeviceClient));
  46     dbus_setter->SetBluetoothProfileManagerClient(
  47         scoped_ptr<BluetoothProfileManagerClient>(
  48             new FakeBluetoothProfileManagerClient));
  49
  50     // Grab a pointer to the adapter.
  51     device::BluetoothAdapterFactory::GetAdapter(
  52         base::Bind(&BluetoothAdapterProfileChromeOSTest::AdapterCallback,
  53                    base::Unretained(this)));
  54     ASSERT_TRUE(adapter_.get() != nullptr);
  55     ASSERT_TRUE(adapter_->IsInitialized());
  56     ASSERT_TRUE(adapter_->IsPresent());
  57
  58     // Turn on the adapter.
  59     adapter_->SetPowered(true, base::Bind(&base::DoNothing),
  60                          base::Bind(&base::DoNothing));
  61     ASSERT_TRUE(adapter_->IsPowered());
  62   }
  63
  64   void TearDown() override {
  65     adapter_ = nullptr;
  66     DBusThreadManager::Shutdown();
  67   }
  68
  69   void AdapterCallback(scoped_refptr<BluetoothAdapter> adapter) {
  70     adapter_ = adapter;
  71   }
  72
  73   class FakeDelegate
  74       : public chromeos::BluetoothProfileServiceProvider::Delegate {
  75    public:
  76     FakeDelegate(std::string device_path) : connections_(0) {
  77       device_path_ = dbus::ObjectPath(device_path);
  78     }
  79
  80     // BluetoothProfileServiceProvider::Delegate:
  81     void Released() override {
  82       // noop
  83     }
  84
  85     void NewConnection(
  86         const dbus::ObjectPath& device_path,
  87         scoped_ptr<dbus::FileDescriptor> fd,
  88         const BluetoothProfileServiceProvider::Delegate::Options& options,
  89         const ConfirmationCallback& callback) override {
  90       VLOG(1) << "connection for " << device_path.value() << " on "
  91               << device_path_.value();
  92       ++connections_;
  93       fd->CheckValidity();
  94       close(fd->TakeValue());
  95       callback.Run(SUCCESS);
  96       if (device_path_.value() != "")
  97         ASSERT_EQ(device_path_, device_path);
  98     }
  99
 100     void RequestDisconnection(const dbus::ObjectPath& device_path,
 101                               const ConfirmationCallback& callback) override {
 102       VLOG(1) << "disconnect " << device_path.value();
 103       ++disconnections_;
 104     }
 105
 106     void Cancel() override {
 107       VLOG(1) << "cancel";
 108       // noop
 109     }
 110
 111     unsigned int connections_;
 112     unsigned int disconnections_;
 113     dbus::ObjectPath device_path_;
 114   };
 115
 116   FakeDelegate fake_delegate_paired_;
 117   FakeDelegate fake_delegate_autopair_;
 118   FakeDelegate fake_delegate_listen_;
 119
 120   BluetoothAdapterProfileChromeOS* profile_;
 121
 122   void ProfileSuccessCallback(BluetoothAdapterProfileChromeOS* profile) {
 123     profile_ = profile;
 124     ++success_callback_count_;
 125   }
 126
 127   void MatchedProfileCallback(BluetoothAdapterProfileChromeOS* profile) {
 128     VLOG(1) << "Matched Profile Callback";
 129     ASSERT_EQ(profile_, profile);
 130     ++success_callback_count_;
 131   }
 132
 133   void DBusConnectSuccessCallback() { ++success_callback_count_; }
 134
 135   void DBusErrorCallback(const std::string& error_name,
 136                          const std::string& error_message) {
 137     VLOG(1) << "DBus Connect Error: " << error_name << " - " << error_message;
 138     ++error_callback_count_;
 139   }
 140
 141   void BasicErrorCallback(const std::string& error_message) {
 142     VLOG(1) << "Error: " << error_message;
 143     ++error_callback_count_;
 144   }
 145
 146  protected:
 147   base::MessageLoop message_loop_;
 148
 149   scoped_refptr<BluetoothAdapter> adapter_;
 150
 151   unsigned int success_callback_count_;
 152   unsigned int error_callback_count_;
 153 };
 154
 155 TEST_F(BluetoothAdapterProfileChromeOSTest, DelegateCount) {
 156   BluetoothUUID uuid(FakeBluetoothProfileManagerClient::kRfcommUuid);
 157   BluetoothProfileManagerClient::Options options;
 158
 159   options.require_authentication.reset(new bool(false));
 160
 161   BluetoothAdapterProfileChromeOS::Register(
 162       uuid, options,
 163       base::Bind(&BluetoothAdapterProfileChromeOSTest::ProfileSuccessCallback,
 164                  base::Unretained(this)),
 165       base::Bind(&BluetoothAdapterProfileChromeOSTest::DBusErrorCallback,
 166                  base::Unretained(this)));
 167
 168   message_loop_.RunUntilIdle();
 169
 170   EXPECT_TRUE(profile_);
 171   EXPECT_EQ(1U, success_callback_count_);
 172   EXPECT_EQ(0U, error_callback_count_);
 173
 174   EXPECT_EQ(0U, profile_->DelegateCount());
 175
 176   profile_->SetDelegate(fake_delegate_paired_.device_path_,
 177                         &fake_delegate_paired_);
 178
 179   EXPECT_EQ(1U, profile_->DelegateCount());
 180
 181   profile_->RemoveDelegate(fake_delegate_autopair_.device_path_,
 182                            base::Bind(&base::DoNothing));
 183
 184   EXPECT_EQ(1U, profile_->DelegateCount());
 185
 186   profile_->RemoveDelegate(fake_delegate_paired_.device_path_,
 187                            base::Bind(&base::DoNothing));
 188
 189   EXPECT_EQ(0U, profile_->DelegateCount());
 190
 191   delete profile_;
 192 };
 193
 194 TEST_F(BluetoothAdapterProfileChromeOSTest, BlackHole) {
 195   BluetoothUUID uuid(FakeBluetoothProfileManagerClient::kRfcommUuid);
 196   BluetoothProfileManagerClient::Options options;
 197
 198   options.require_authentication.reset(new bool(false));
 199
 200   BluetoothAdapterProfileChromeOS::Register(
 201       uuid, options,
 202       base::Bind(&BluetoothAdapterProfileChromeOSTest::ProfileSuccessCallback,
 203                  base::Unretained(this)),
 204       base::Bind(&BluetoothAdapterProfileChromeOSTest::DBusErrorCallback,
 205                  base::Unretained(this)));
 206
 207   message_loop_.RunUntilIdle();
 208
 209   EXPECT_TRUE(profile_);
 210   EXPECT_EQ(1U, success_callback_count_);
 211   EXPECT_EQ(0U, error_callback_count_);
 212
 213   DBusThreadManager::Get()->GetBluetoothDeviceClient()->ConnectProfile(
 214       dbus::ObjectPath(FakeBluetoothDeviceClient::kPairedDevicePath),
 215       FakeBluetoothProfileManagerClient::kRfcommUuid,
 216       base::Bind(
 217           &BluetoothAdapterProfileChromeOSTest::DBusConnectSuccessCallback,
 218           base::Unretained(this)),
 219       base::Bind(&BluetoothAdapterProfileChromeOSTest::DBusErrorCallback,
 220                  base::Unretained(this)));
 221
 222   message_loop_.RunUntilIdle();
 223
 224   EXPECT_EQ(1U, success_callback_count_);
 225   EXPECT_EQ(1U, error_callback_count_);
 226
 227   EXPECT_EQ(0U, fake_delegate_paired_.connections_);
 228
 229   delete profile_;
 230 };
 231
 232 TEST_F(BluetoothAdapterProfileChromeOSTest, Routing) {
 233   BluetoothUUID uuid(FakeBluetoothProfileManagerClient::kRfcommUuid);
 234   BluetoothProfileManagerClient::Options options;
 235
 236   options.require_authentication.reset(new bool(false));
 237
 238   profile_ = BluetoothAdapterProfileChromeOS::Register(
 239       uuid, options,
 240       base::Bind(&BluetoothAdapterProfileChromeOSTest::ProfileSuccessCallback,
 241                  base::Unretained(this)),
 242       base::Bind(&BluetoothAdapterProfileChromeOSTest::DBusErrorCallback,
 243                  base::Unretained(this)));
 244
 245   message_loop_.RunUntilIdle();
 246
 247   ASSERT_TRUE(profile_);
 248   ASSERT_EQ(1U, success_callback_count_);
 249   ASSERT_EQ(0U, error_callback_count_);
 250
 251   profile_->SetDelegate(fake_delegate_paired_.device_path_,
 252                         &fake_delegate_paired_);
 253   profile_->SetDelegate(fake_delegate_autopair_.device_path_,
 254                         &fake_delegate_autopair_);
 255   profile_->SetDelegate(fake_delegate_listen_.device_path_,
 256                         &fake_delegate_listen_);
 257
 258   DBusThreadManager::Get()->GetBluetoothDeviceClient()->ConnectProfile(
 259       dbus::ObjectPath(FakeBluetoothDeviceClient::kPairedDevicePath),
 260       FakeBluetoothProfileManagerClient::kRfcommUuid,
 261       base::Bind(
 262           &BluetoothAdapterProfileChromeOSTest::DBusConnectSuccessCallback,
 263           base::Unretained(this)),
 264       base::Bind(&BluetoothAdapterProfileChromeOSTest::DBusErrorCallback,
 265                  base::Unretained(this)));
 266
 267   message_loop_.RunUntilIdle();
 268
 269   EXPECT_EQ(2U, success_callback_count_);
 270   EXPECT_EQ(0U, error_callback_count_);
 271
 272   EXPECT_EQ(1U, fake_delegate_paired_.connections_);
 273
 274   DBusThreadManager::Get()->GetBluetoothDeviceClient()->ConnectProfile(
 275       dbus::ObjectPath(FakeBluetoothDeviceClient::kLegacyAutopairPath),
 276       FakeBluetoothProfileManagerClient::kRfcommUuid,
 277       base::Bind(
 278           &BluetoothAdapterProfileChromeOSTest::DBusConnectSuccessCallback,
 279           base::Unretained(this)),
 280       base::Bind(&BluetoothAdapterProfileChromeOSTest::DBusErrorCallback,
 281                  base::Unretained(this)));
 282
 283   message_loop_.RunUntilIdle();
 284
 285   EXPECT_EQ(3U, success_callback_count_);
 286   EXPECT_EQ(0U, error_callback_count_);
 287
 288   EXPECT_EQ(1U, fake_delegate_autopair_.connections_);
 289
 290   // Incoming connections look the same from BlueZ.
 291   DBusThreadManager::Get()->GetBluetoothDeviceClient()->ConnectProfile(
 292       dbus::ObjectPath(FakeBluetoothDeviceClient::kDisplayPinCodePath),
 293       FakeBluetoothProfileManagerClient::kRfcommUuid,
 294       base::Bind(
 295           &BluetoothAdapterProfileChromeOSTest::DBusConnectSuccessCallback,
 296           base::Unretained(this)),
 297       base::Bind(&BluetoothAdapterProfileChromeOSTest::DBusErrorCallback,
 298                  base::Unretained(this)));
 299
 300   message_loop_.RunUntilIdle();
 301
 302   EXPECT_EQ(4U, success_callback_count_);
 303   EXPECT_EQ(0U, error_callback_count_);
 304
 305   EXPECT_EQ(1U, fake_delegate_listen_.connections_);
 306
 307   delete profile_;
 308 };
 309
 310 TEST_F(BluetoothAdapterProfileChromeOSTest, SimultaneousRegister) {
 311   BluetoothUUID uuid(FakeBluetoothProfileManagerClient::kRfcommUuid);
 312   BluetoothProfileManagerClient::Options options;
 313   BluetoothAdapterChromeOS* adapter =
 314       static_cast<BluetoothAdapterChromeOS*>(adapter_.get());
 315
 316   options.require_authentication.reset(new bool(false));
 317
 318   success_callback_count_ = 0;
 319   error_callback_count_ = 0;
 320
 321   adapter->UseProfile(
 322       uuid, fake_delegate_paired_.device_path_, options, &fake_delegate_paired_,
 323       base::Bind(&BluetoothAdapterProfileChromeOSTest::ProfileSuccessCallback,
 324                  base::Unretained(this)),
 325       base::Bind(&BluetoothAdapterProfileChromeOSTest::BasicErrorCallback,
 326                  base::Unretained(this)));
 327
 328   adapter->UseProfile(
 329       uuid, fake_delegate_autopair_.device_path_, options,
 330       &fake_delegate_autopair_,
 331       base::Bind(&BluetoothAdapterProfileChromeOSTest::MatchedProfileCallback,
 332                  base::Unretained(this)),
 333       base::Bind(&BluetoothAdapterProfileChromeOSTest::BasicErrorCallback,
 334                  base::Unretained(this)));
 335
 336   message_loop_.RunUntilIdle();
 337
 338   EXPECT_TRUE(profile_);
 339   EXPECT_EQ(2U, success_callback_count_);
 340   EXPECT_EQ(0U, error_callback_count_);
 341
 342   adapter->ReleaseProfile(fake_delegate_paired_.device_path_, profile_);
 343   adapter->ReleaseProfile(fake_delegate_autopair_.device_path_, profile_);
 344
 345   message_loop_.RunUntilIdle();
 346 };
 347
 348 TEST_F(BluetoothAdapterProfileChromeOSTest, SimultaneousRegisterFail) {
 349   BluetoothUUID uuid(FakeBluetoothProfileManagerClient::kUnregisterableUuid);
 350   BluetoothProfileManagerClient::Options options;
 351   BluetoothAdapterChromeOS* adapter =
 352       static_cast<BluetoothAdapterChromeOS*>(adapter_.get());
 353
 354   options.require_authentication.reset(new bool(false));
 355
 356   success_callback_count_ = 0;
 357   error_callback_count_ = 0;
 358
 359   adapter->UseProfile(
 360       uuid, fake_delegate_paired_.device_path_, options, &fake_delegate_paired_,
 361       base::Bind(&BluetoothAdapterProfileChromeOSTest::ProfileSuccessCallback,
 362                  base::Unretained(this)),
 363       base::Bind(&BluetoothAdapterProfileChromeOSTest::BasicErrorCallback,
 364                  base::Unretained(this)));
 365
 366   adapter->UseProfile(
 367       uuid, fake_delegate_autopair_.device_path_, options,
 368       &fake_delegate_autopair_,
 369       base::Bind(&BluetoothAdapterProfileChromeOSTest::MatchedProfileCallback,
 370                  base::Unretained(this)),
 371       base::Bind(&BluetoothAdapterProfileChromeOSTest::BasicErrorCallback,
 372                  base::Unretained(this)));
 373
 374   message_loop_.RunUntilIdle();
 375
 376   EXPECT_FALSE(profile_);
 377   EXPECT_EQ(0U, success_callback_count_);
 378   EXPECT_EQ(2U, error_callback_count_);
 379 };
 380
 381 }  // namespace chromeos