device/bluetooth/bluetooth_audio_sink_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 <vector>
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/memory/ref_counted.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "chromeos/dbus/bluetooth_media_client.h"
  12 #include "chromeos/dbus/bluetooth_media_endpoint_service_provider.h"
  13 #include "chromeos/dbus/bluetooth_media_transport_client.h"
  14 #include "chromeos/dbus/dbus_thread_manager.h"
  15 #include "chromeos/dbus/fake_bluetooth_media_client.h"
  16 #include "chromeos/dbus/fake_bluetooth_media_endpoint_service_provider.h"
  17 #include "chromeos/dbus/fake_bluetooth_media_transport_client.h"
  18 #include "dbus/object_path.h"
  19 #include "device/bluetooth/bluetooth_adapter.h"
  20 #include "device/bluetooth/bluetooth_adapter_factory.h"
  21 #include "device/bluetooth/bluetooth_audio_sink.h"
  22 #include "device/bluetooth/bluetooth_audio_sink_chromeos.h"
  23 #include "testing/gtest/include/gtest/gtest.h"
  24
  25 using dbus::ObjectPath;
  26 using device::BluetoothAdapter;
  27 using device::BluetoothAdapterFactory;
  28 using device::BluetoothAudioSink;
  29
  30 namespace chromeos {
  31
  32 class TestAudioSinkObserver : public BluetoothAudioSink::Observer {
  33  public:
  34   explicit TestAudioSinkObserver(scoped_refptr<BluetoothAudioSink> audio_sink)
  35       : state_changed_count_(0),
  36         volume_changed_count_(0),
  37         total_read_(0),
  38         state_(audio_sink->GetState()),
  39         audio_sink_(audio_sink) {
  40     audio_sink_->AddObserver(this);
  41   }
  42
  43   ~TestAudioSinkObserver() override { audio_sink_->RemoveObserver(this); }
  44
  45   void BluetoothAudioSinkStateChanged(
  46       BluetoothAudioSink* audio_sink,
  47       BluetoothAudioSink::State state) override {
  48     if (state == BluetoothAudioSink::STATE_IDLE)
  49       total_read_ = 0;
  50
  51     ++state_changed_count_;
  52   }
  53
  54   void BluetoothAudioSinkVolumeChanged(BluetoothAudioSink* audio_sink,
  55                                        uint16_t volume) override {
  56     ++volume_changed_count_;
  57   }
  58
  59   void BluetoothAudioSinkDataAvailable(BluetoothAudioSink* audio_sink,
  60                                        char* data,
  61                                        size_t size) override {
  62     total_read_ += size;
  63     data_.clear();
  64     data_.insert(data_.begin(), data, data + size);
  65   }
  66
  67   int state_changed_count_;
  68   int volume_changed_count_;
  69   int data_available_count_;
  70   size_t total_read_;
  71   std::vector<char> data_;
  72   BluetoothAudioSink::State state_;
  73
  74  private:
  75   scoped_refptr<BluetoothAudioSink> audio_sink_;
  76 };
  77
  78 class BluetoothAudioSinkChromeOSTest : public testing::Test {
  79  public:
  80   void SetUp() override {
  81     DBusThreadManager::Initialize();
  82
  83     callback_count_ = 0;
  84     error_callback_count_ = 0;
  85
  86     fake_media_ = static_cast<FakeBluetoothMediaClient*>(
  87         DBusThreadManager::Get()->GetBluetoothMediaClient());
  88     fake_transport_ = static_cast<FakeBluetoothMediaTransportClient*>(
  89         DBusThreadManager::Get()->GetBluetoothMediaTransportClient());
  90
  91     // Initiates Delegate::TransportProperties with default values.
  92     properties_.device =
  93         ObjectPath(FakeBluetoothMediaTransportClient::kTransportDevicePath);
  94     properties_.uuid = BluetoothMediaClient::kBluetoothAudioSinkUUID;
  95     properties_.codec = FakeBluetoothMediaTransportClient::kTransportCodec;
  96     properties_.configuration =
  97         FakeBluetoothMediaTransportClient::kTransportConfiguration;
  98     properties_.state = BluetoothMediaTransportClient::kStateIdle;
  99     properties_.delay.reset(
 100         new uint16_t(FakeBluetoothMediaTransportClient::kTransportDelay));
 101     properties_.volume.reset(
 102         new uint16_t(FakeBluetoothMediaTransportClient::kTransportVolume));
 103
 104     GetAdapter();
 105   }
 106
 107   void TearDown() override {
 108     callback_count_ = 0;
 109     error_callback_count_ = 0;
 110     observer_.reset();
 111
 112     fake_media_->SetVisible(true);
 113
 114     // The adapter should outlive audio sink.
 115     audio_sink_ = nullptr;
 116     adapter_ = nullptr;
 117     DBusThreadManager::Shutdown();
 118   }
 119
 120   // Gets the existing Bluetooth adapter.
 121   void GetAdapter() {
 122     BluetoothAdapterFactory::GetAdapter(
 123         base::Bind(&BluetoothAudioSinkChromeOSTest::GetAdapterCallback,
 124                    base::Unretained(this)));
 125   }
 126
 127   // Called whenever BluetoothAdapter is retrieved successfully.
 128   void GetAdapterCallback(scoped_refptr<BluetoothAdapter> adapter) {
 129     adapter_ = adapter;
 130
 131     ASSERT_NE(adapter_.get(), nullptr);
 132     ASSERT_TRUE(adapter_->IsInitialized());
 133     adapter_->SetPowered(
 134         true,
 135         base::Bind(&BluetoothAudioSinkChromeOSTest::Callback,
 136                    base::Unretained(this)),
 137         base::Bind(&BluetoothAudioSinkChromeOSTest::ErrorCallback,
 138                    base::Unretained(this)));
 139     ASSERT_TRUE(adapter_->IsPresent());
 140     ASSERT_TRUE(adapter_->IsPowered());
 141     EXPECT_EQ(callback_count_, 1);
 142     EXPECT_EQ(error_callback_count_, 0);
 143
 144     // Resets callback_count_.
 145     --callback_count_;
 146   }
 147
 148   // Registers BluetoothAudioSinkChromeOS with default codec and capabilities.
 149   // If the audio sink is retrieved successfully, the state changes to
 150   // STATE_DISCONNECTED.
 151   void GetAudioSink() {
 152     // Sets up valid codec and capabilities.
 153     BluetoothAudioSink::Options options;
 154     ASSERT_EQ(options.codec, 0x00);
 155     ASSERT_EQ(options.capabilities,
 156               std::vector<uint8_t>({0x3f, 0xff, 0x12, 0x35}));
 157
 158     // Registers |audio_sink_| with valid codec and capabilities
 159     adapter_->RegisterAudioSink(
 160         options,
 161         base::Bind(&BluetoothAudioSinkChromeOSTest::RegisterCallback,
 162                    base::Unretained(this)),
 163         base::Bind(&BluetoothAudioSinkChromeOSTest::RegisterErrorCallback,
 164                    base::Unretained(this)));
 165
 166     observer_.reset(new TestAudioSinkObserver(audio_sink_));
 167     EXPECT_EQ(callback_count_, 1);
 168     EXPECT_EQ(error_callback_count_, 0);
 169     EXPECT_EQ(observer_->state_changed_count_, 0);
 170     EXPECT_EQ(observer_->volume_changed_count_, 0);
 171   }
 172
 173   void GetFakeMediaEndpoint() {
 174     BluetoothAudioSinkChromeOS* audio_sink_chromeos =
 175         static_cast<BluetoothAudioSinkChromeOS*>(audio_sink_.get());
 176     ASSERT_NE(audio_sink_chromeos, nullptr);
 177
 178     media_endpoint_ = static_cast<FakeBluetoothMediaEndpointServiceProvider*>(
 179         audio_sink_chromeos->GetEndpointServiceProvider());
 180   }
 181
 182   // Called whenever RegisterAudioSink is completed successfully.
 183   void RegisterCallback(
 184       scoped_refptr<BluetoothAudioSink> audio_sink) {
 185     ++callback_count_;
 186     audio_sink_ = audio_sink;
 187
 188     GetFakeMediaEndpoint();
 189     ASSERT_NE(media_endpoint_, nullptr);
 190     fake_media_->SetEndpointRegistered(media_endpoint_, true);
 191
 192     ASSERT_NE(audio_sink_.get(), nullptr);
 193     ASSERT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 194   }
 195
 196   // Called whenever RegisterAudioSink failed.
 197   void RegisterErrorCallback(BluetoothAudioSink::ErrorCode error_code) {
 198     ++error_callback_count_;
 199     EXPECT_EQ(error_code, BluetoothAudioSink::ERROR_NOT_REGISTERED);
 200   }
 201
 202   // Called whenever there capabilities are returned from SelectConfiguration.
 203   void SelectConfigurationCallback(const std::vector<uint8_t>& capabilities) {
 204     ++callback_count_;
 205
 206     // |capabilities| should be the same as the capabilities for registering an
 207     // audio sink in GetAudioSink().
 208     EXPECT_EQ(capabilities, std::vector<uint8_t>({0x3f, 0xff, 0x12, 0x35}));
 209   }
 210
 211   void UnregisterErrorCallback(BluetoothAudioSink::ErrorCode error_code) {
 212     ++error_callback_count_;
 213     EXPECT_EQ(error_code, BluetoothAudioSink::ERROR_NOT_UNREGISTERED);
 214   }
 215
 216   // Generic callbacks.
 217   void Callback() {
 218     ++callback_count_;
 219   }
 220
 221   void ErrorCallback() {
 222     ++error_callback_count_;
 223   }
 224
 225  protected:
 226   int callback_count_;
 227   int error_callback_count_;
 228
 229   base::MessageLoopForIO message_loop_;
 230
 231   FakeBluetoothMediaClient* fake_media_;
 232   FakeBluetoothMediaTransportClient* fake_transport_;
 233   FakeBluetoothMediaEndpointServiceProvider* media_endpoint_;
 234   scoped_ptr<TestAudioSinkObserver> observer_;
 235   scoped_refptr<BluetoothAdapter> adapter_;
 236   scoped_refptr<BluetoothAudioSink> audio_sink_;
 237
 238   // The default property set used while calling SetConfiguration on a media
 239   // endpoint object.
 240   BluetoothMediaEndpointServiceProvider::Delegate::TransportProperties
 241       properties_;
 242 };
 243
 244 TEST_F(BluetoothAudioSinkChromeOSTest, RegisterSucceeded) {
 245   GetAudioSink();
 246 }
 247
 248 TEST_F(BluetoothAudioSinkChromeOSTest, RegisterFailedWithInvalidOptions) {
 249   // Sets options with an invalid codec and valid capabilities.
 250   BluetoothAudioSink::Options options;
 251   options.codec = 0xff;
 252   options.capabilities = std::vector<uint8_t>({0x3f, 0xff, 0x12, 0x35});
 253
 254   adapter_->RegisterAudioSink(
 255       options,
 256       base::Bind(&BluetoothAudioSinkChromeOSTest::RegisterCallback,
 257                  base::Unretained(this)),
 258       base::Bind(&BluetoothAudioSinkChromeOSTest::RegisterErrorCallback,
 259                  base::Unretained(this)));
 260
 261   EXPECT_EQ(callback_count_, 0);
 262   EXPECT_EQ(error_callback_count_, 1);
 263
 264   // Sets options with a valid codec and invalid capabilities.
 265   options.codec = 0x00;
 266   options.capabilities.clear();
 267   adapter_->RegisterAudioSink(
 268       options,
 269       base::Bind(&BluetoothAudioSinkChromeOSTest::RegisterCallback,
 270                  base::Unretained(this)),
 271       base::Bind(&BluetoothAudioSinkChromeOSTest::RegisterErrorCallback,
 272                  base::Unretained(this)));
 273
 274   EXPECT_EQ(callback_count_, 0);
 275   EXPECT_EQ(error_callback_count_, 2);
 276 }
 277
 278 TEST_F(BluetoothAudioSinkChromeOSTest, SelectConfiguration) {
 279   GetAudioSink();
 280
 281   // Simulates calling SelectConfiguration on the media endpoint object owned by
 282   // |audio_sink_| with some fake capabilities.
 283   media_endpoint_->SelectConfiguration(
 284       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
 285       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
 286                  base::Unretained(this)));
 287
 288   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 289   EXPECT_EQ(callback_count_, 2);
 290   EXPECT_EQ(error_callback_count_, 0);
 291   EXPECT_EQ(observer_->state_changed_count_, 0);
 292   EXPECT_EQ(observer_->volume_changed_count_, 0);
 293 }
 294
 295 TEST_F(BluetoothAudioSinkChromeOSTest, SetConfiguration) {
 296   GetAudioSink();
 297
 298   media_endpoint_->SelectConfiguration(
 299       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
 300       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
 301                  base::Unretained(this)));
 302
 303   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 304   EXPECT_EQ(callback_count_, 2);
 305   EXPECT_EQ(error_callback_count_, 0);
 306   EXPECT_EQ(observer_->state_changed_count_, 0);
 307   EXPECT_EQ(observer_->volume_changed_count_, 0);
 308
 309   // Simulates calling SetConfiguration on the media endpoint object owned by
 310   // |audio_sink_| with a fake transport path and a
 311   // Delegate::TransportProperties structure.
 312   media_endpoint_->SetConfiguration(
 313       fake_transport_->GetTransportPath(media_endpoint_->object_path()),
 314       properties_);
 315
 316   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
 317   EXPECT_EQ(callback_count_, 2);
 318   EXPECT_EQ(error_callback_count_, 0);
 319   EXPECT_EQ(observer_->state_changed_count_, 1);
 320   EXPECT_EQ(observer_->volume_changed_count_, 1);
 321 }
 322
 323 TEST_F(BluetoothAudioSinkChromeOSTest, SetConfigurationWithUnexpectedState) {
 324   GetAudioSink();
 325
 326   media_endpoint_->SelectConfiguration(
 327       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
 328       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
 329                  base::Unretained(this)));
 330
 331   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 332   EXPECT_EQ(callback_count_, 2);
 333   EXPECT_EQ(error_callback_count_, 0);
 334   EXPECT_EQ(observer_->state_changed_count_, 0);
 335   EXPECT_EQ(observer_->volume_changed_count_, 0);
 336
 337   // Set state of Delegate::TransportProperties with an unexpected value.
 338   properties_.state = "pending";
 339
 340   media_endpoint_->SetConfiguration(
 341       fake_transport_->GetTransportPath(media_endpoint_->object_path()),
 342       properties_);
 343
 344   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 345   EXPECT_EQ(callback_count_, 2);
 346   EXPECT_EQ(error_callback_count_, 0);
 347   EXPECT_EQ(observer_->state_changed_count_, 0);
 348   EXPECT_EQ(observer_->volume_changed_count_, 0);
 349 }
 350
 351 // Checks if the observer is notified on media-removed event when the state of
 352 // |audio_sink_| is STATE_DISCONNECTED. Once the media object is removed, the
 353 // audio sink is no longer valid.
 354 TEST_F(BluetoothAudioSinkChromeOSTest, MediaRemovedDuringDisconnectedState) {
 355   GetAudioSink();
 356
 357   // Gets the media object and makes it invisible to see if the state of the
 358   // audio sink changes accordingly.
 359   fake_media_->SetVisible(false);
 360
 361   GetFakeMediaEndpoint();
 362
 363   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_INVALID);
 364   EXPECT_EQ(media_endpoint_, nullptr);
 365   EXPECT_EQ(observer_->state_changed_count_, 1);
 366   EXPECT_EQ(observer_->volume_changed_count_, 0);
 367 }
 368
 369 // Checks if the observer is  notified on media-removed event when the state of
 370 // |audio_sink_| is STATE_IDLE. Once the media object is removed, the audio sink
 371 // is no longer valid.
 372 TEST_F(BluetoothAudioSinkChromeOSTest, MediaRemovedDuringIdleState) {
 373   GetAudioSink();
 374
 375   media_endpoint_->SelectConfiguration(
 376       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
 377       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
 378                  base::Unretained(this)));
 379
 380   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 381   EXPECT_EQ(callback_count_, 2);
 382   EXPECT_EQ(error_callback_count_, 0);
 383   EXPECT_EQ(observer_->state_changed_count_, 0);
 384   EXPECT_EQ(observer_->volume_changed_count_, 0);
 385
 386   media_endpoint_->SetConfiguration(
 387       fake_transport_->GetTransportPath(media_endpoint_->object_path()),
 388       properties_);
 389
 390   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
 391   EXPECT_EQ(callback_count_, 2);
 392   EXPECT_EQ(error_callback_count_, 0);
 393   EXPECT_EQ(observer_->state_changed_count_, 1);
 394   EXPECT_EQ(observer_->volume_changed_count_, 1);
 395
 396   // Gets the media object and makes it invisible to see if the state of the
 397   // audio sink changes accordingly.
 398   fake_media_->SetVisible(false);
 399
 400   GetFakeMediaEndpoint();
 401
 402   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_INVALID);
 403   EXPECT_EQ(media_endpoint_, nullptr);
 404
 405   // The state becomes disconnted and then invalid, since the removal of
 406   // transport object should happend before media becomes invisible.
 407   // State: STATE_IDLE -> STATE_DISCONNECTED -> STATE_INVALID
 408   EXPECT_EQ(observer_->state_changed_count_, 3);
 409   EXPECT_EQ(observer_->volume_changed_count_, 2);
 410 }
 411
 412 TEST_F(BluetoothAudioSinkChromeOSTest, MediaRemovedDuringActiveState) {
 413   GetAudioSink();
 414
 415   media_endpoint_->SelectConfiguration(
 416       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
 417       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
 418                  base::Unretained(this)));
 419
 420   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 421   EXPECT_EQ(callback_count_, 2);
 422   EXPECT_EQ(error_callback_count_, 0);
 423   EXPECT_EQ(observer_->state_changed_count_, 0);
 424   EXPECT_EQ(observer_->volume_changed_count_, 0);
 425
 426   media_endpoint_->SetConfiguration(
 427       fake_transport_->GetTransportPath(media_endpoint_->object_path()),
 428       properties_);
 429
 430   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
 431   EXPECT_EQ(callback_count_, 2);
 432   EXPECT_EQ(error_callback_count_, 0);
 433   EXPECT_EQ(observer_->state_changed_count_, 1);
 434   EXPECT_EQ(observer_->volume_changed_count_, 1);
 435
 436   fake_transport_->SetState(media_endpoint_->object_path(), "pending");
 437
 438   message_loop_.RunUntilIdle();
 439
 440   // Acquire is called when the state of |audio_sink_| becomes STATE_PENDING,
 441   // and Acquire will trigger state change. Therefore, the state will be
 442   // STATE_ACTIVE right after STATE_PENDING.
 443   // State: STATE_IDLE -> STATE_PENDING -> STATE_ACTIVE
 444   EXPECT_EQ(observer_->state_changed_count_, 3);
 445
 446   // Gets the media object and makes it invisible to see if the state of the
 447   // audio sink changes accordingly.
 448   fake_media_->SetVisible(false);
 449
 450   GetFakeMediaEndpoint();
 451
 452   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_INVALID);
 453   EXPECT_EQ(media_endpoint_, nullptr);
 454
 455   // The state becomes disconnted and then invalid, since the removal of
 456   // transport object should happend before media becomes invisible.
 457   // State: STATE_ACTIVE -> STATE_DISCONNECTED -> STATE_INVALID
 458   EXPECT_EQ(observer_->state_changed_count_, 5);
 459   EXPECT_EQ(observer_->volume_changed_count_, 2);
 460 }
 461
 462 // Checks if the observer is notified on transport-removed event when the state
 463 // of |audio_sink_| is STATE_IDEL. Once the media transport object is removed,
 464 // the audio sink is disconnected.
 465 TEST_F(BluetoothAudioSinkChromeOSTest, TransportRemovedDuringIdleState) {
 466   GetAudioSink();
 467
 468   media_endpoint_->SelectConfiguration(
 469       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
 470       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
 471                  base::Unretained(this)));
 472
 473   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 474   EXPECT_EQ(callback_count_, 2);
 475   EXPECT_EQ(error_callback_count_, 0);
 476   EXPECT_EQ(observer_->state_changed_count_, 0);
 477   EXPECT_EQ(observer_->volume_changed_count_, 0);
 478
 479   media_endpoint_->SetConfiguration(
 480       fake_transport_->GetTransportPath(media_endpoint_->object_path()),
 481       properties_);
 482
 483   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
 484   EXPECT_EQ(callback_count_, 2);
 485   EXPECT_EQ(error_callback_count_, 0);
 486   EXPECT_EQ(observer_->state_changed_count_, 1);
 487   EXPECT_EQ(observer_->volume_changed_count_, 1);
 488
 489   // Makes the transport object invalid to see if the state of the audio sink
 490   // changes accordingly.
 491   fake_transport_->SetValid(media_endpoint_, false);
 492
 493   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 494   EXPECT_NE(media_endpoint_, nullptr);
 495   EXPECT_EQ(observer_->state_changed_count_, 2);
 496   EXPECT_EQ(observer_->volume_changed_count_, 2);
 497 }
 498
 499 TEST_F(BluetoothAudioSinkChromeOSTest, TransportRemovedDuringActiveState) {
 500   GetAudioSink();
 501
 502   media_endpoint_->SelectConfiguration(
 503       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
 504       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
 505                  base::Unretained(this)));
 506
 507   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 508   EXPECT_EQ(callback_count_, 2);
 509   EXPECT_EQ(error_callback_count_, 0);
 510   EXPECT_EQ(observer_->state_changed_count_, 0);
 511   EXPECT_EQ(observer_->volume_changed_count_, 0);
 512
 513   media_endpoint_->SetConfiguration(
 514       fake_transport_->GetTransportPath(media_endpoint_->object_path()),
 515       properties_);
 516
 517   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
 518   EXPECT_EQ(callback_count_, 2);
 519   EXPECT_EQ(error_callback_count_, 0);
 520   EXPECT_EQ(observer_->state_changed_count_, 1);
 521   EXPECT_EQ(observer_->volume_changed_count_, 1);
 522
 523   fake_transport_->SetState(media_endpoint_->object_path(), "pending");
 524
 525   message_loop_.RunUntilIdle();
 526
 527   // Acquire is called when the state of |audio_sink_| becomes STATE_PENDING,
 528   // and Acquire will trigger state change. Therefore, the state will be
 529   // STATE_ACTIVE right after STATE_PENDING.
 530   // State: STATE_IDLE -> STATE_PENDING -> STATE_ACTIVE
 531   EXPECT_EQ(observer_->state_changed_count_, 3);
 532
 533   // Makes the transport object invalid to see if the state of the audio sink
 534   // changes accordingly.
 535   fake_transport_->SetValid(media_endpoint_, false);
 536
 537   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 538   EXPECT_NE(media_endpoint_, nullptr);
 539   EXPECT_EQ(observer_->state_changed_count_, 4);
 540   EXPECT_EQ(observer_->volume_changed_count_, 2);
 541 }
 542
 543 TEST_F(BluetoothAudioSinkChromeOSTest,
 544        AdapterPoweredChangedDuringDisconnectedState) {
 545   GetAudioSink();
 546
 547   adapter_->SetPowered(
 548       false,
 549       base::Bind(&BluetoothAudioSinkChromeOSTest::Callback,
 550                  base::Unretained(this)),
 551       base::Bind(&BluetoothAudioSinkChromeOSTest::ErrorCallback,
 552                  base::Unretained(this)));
 553
 554   EXPECT_TRUE(adapter_->IsPresent());
 555   EXPECT_FALSE(adapter_->IsPowered());
 556   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 557   EXPECT_EQ(callback_count_, 2);
 558   EXPECT_EQ(error_callback_count_, 0);
 559   EXPECT_EQ(observer_->state_changed_count_, 0);
 560   EXPECT_EQ(observer_->volume_changed_count_, 0);
 561
 562   adapter_->SetPowered(
 563       true,
 564       base::Bind(&BluetoothAudioSinkChromeOSTest::Callback,
 565                  base::Unretained(this)),
 566       base::Bind(&BluetoothAudioSinkChromeOSTest::ErrorCallback,
 567                  base::Unretained(this)));
 568
 569   EXPECT_TRUE(adapter_->IsPresent());
 570   EXPECT_TRUE(adapter_->IsPowered());
 571   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 572   EXPECT_EQ(callback_count_, 3);
 573   EXPECT_EQ(error_callback_count_, 0);
 574   EXPECT_EQ(observer_->state_changed_count_, 0);
 575   EXPECT_EQ(observer_->volume_changed_count_, 0);
 576 }
 577
 578 TEST_F(BluetoothAudioSinkChromeOSTest, AdapterPoweredChangedDuringIdleState) {
 579   GetAudioSink();
 580
 581   media_endpoint_->SelectConfiguration(
 582       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
 583       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
 584                  base::Unretained(this)));
 585
 586   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 587   EXPECT_EQ(callback_count_, 2);
 588   EXPECT_EQ(error_callback_count_, 0);
 589   EXPECT_EQ(observer_->state_changed_count_, 0);
 590   EXPECT_EQ(observer_->volume_changed_count_, 0);
 591
 592   media_endpoint_->SetConfiguration(
 593       fake_transport_->GetTransportPath(media_endpoint_->object_path()),
 594       properties_);
 595
 596   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
 597   EXPECT_EQ(callback_count_, 2);
 598   EXPECT_EQ(error_callback_count_, 0);
 599   EXPECT_EQ(observer_->state_changed_count_, 1);
 600   EXPECT_EQ(observer_->volume_changed_count_, 1);
 601
 602   adapter_->SetPowered(
 603       false,
 604       base::Bind(&BluetoothAudioSinkChromeOSTest::Callback,
 605                  base::Unretained(this)),
 606       base::Bind(&BluetoothAudioSinkChromeOSTest::ErrorCallback,
 607                  base::Unretained(this)));
 608   GetFakeMediaEndpoint();
 609
 610   EXPECT_TRUE(adapter_->IsPresent());
 611   EXPECT_FALSE(adapter_->IsPowered());
 612   EXPECT_NE(media_endpoint_, nullptr);
 613   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 614   EXPECT_EQ(callback_count_, 3);
 615   EXPECT_EQ(error_callback_count_, 0);
 616   EXPECT_EQ(observer_->state_changed_count_, 2);
 617   EXPECT_EQ(observer_->volume_changed_count_, 2);
 618 }
 619
 620 TEST_F(BluetoothAudioSinkChromeOSTest,
 621        UnregisterAudioSinkDuringDisconnectedState) {
 622   GetAudioSink();
 623
 624   audio_sink_->Unregister(
 625       base::Bind(&BluetoothAudioSinkChromeOSTest::Callback,
 626                  base::Unretained(this)),
 627       base::Bind(&BluetoothAudioSinkChromeOSTest::UnregisterErrorCallback,
 628                  base::Unretained(this)));
 629
 630   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_INVALID);
 631   EXPECT_EQ(callback_count_, 2);
 632   EXPECT_EQ(error_callback_count_, 0);
 633   EXPECT_EQ(observer_->state_changed_count_, 1);
 634   EXPECT_EQ(observer_->volume_changed_count_, 0);
 635 }
 636
 637 TEST_F(BluetoothAudioSinkChromeOSTest, UnregisterAudioSinkDuringIdleState) {
 638   GetAudioSink();
 639
 640   media_endpoint_->SelectConfiguration(
 641       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
 642       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
 643                  base::Unretained(this)));
 644
 645   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 646   EXPECT_EQ(callback_count_, 2);
 647   EXPECT_EQ(error_callback_count_, 0);
 648   EXPECT_EQ(observer_->state_changed_count_, 0);
 649   EXPECT_EQ(observer_->volume_changed_count_, 0);
 650
 651   media_endpoint_->SetConfiguration(
 652       fake_transport_->GetTransportPath(media_endpoint_->object_path()),
 653       properties_);
 654
 655   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
 656   EXPECT_EQ(callback_count_, 2);
 657   EXPECT_EQ(error_callback_count_, 0);
 658   EXPECT_EQ(observer_->state_changed_count_, 1);
 659   EXPECT_EQ(observer_->volume_changed_count_, 1);
 660
 661   audio_sink_->Unregister(
 662       base::Bind(&BluetoothAudioSinkChromeOSTest::Callback,
 663                  base::Unretained(this)),
 664       base::Bind(&BluetoothAudioSinkChromeOSTest::UnregisterErrorCallback,
 665                  base::Unretained(this)));
 666
 667   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_INVALID);
 668   EXPECT_EQ(callback_count_, 3);
 669   EXPECT_EQ(error_callback_count_, 0);
 670
 671   // The state becomes disconnted and then invalid, since the removal of
 672   // transport object should happend before the unregistration of endpoint.
 673   // State: STATE_IDLE -> STATE_DISCONNECTED -> STATE_INVALID
 674   EXPECT_EQ(observer_->state_changed_count_, 3);
 675   EXPECT_EQ(observer_->volume_changed_count_, 2);
 676 }
 677
 678 TEST_F(BluetoothAudioSinkChromeOSTest, UnregisterAudioSinkDuringActiveState) {
 679   GetAudioSink();
 680
 681   media_endpoint_->SelectConfiguration(
 682       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
 683       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
 684                  base::Unretained(this)));
 685
 686   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 687   EXPECT_EQ(callback_count_, 2);
 688   EXPECT_EQ(error_callback_count_, 0);
 689   EXPECT_EQ(observer_->state_changed_count_, 0);
 690   EXPECT_EQ(observer_->volume_changed_count_, 0);
 691
 692   media_endpoint_->SetConfiguration(
 693       fake_transport_->GetTransportPath(media_endpoint_->object_path()),
 694       properties_);
 695
 696   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
 697   EXPECT_EQ(callback_count_, 2);
 698   EXPECT_EQ(error_callback_count_, 0);
 699   EXPECT_EQ(observer_->state_changed_count_, 1);
 700   EXPECT_EQ(observer_->volume_changed_count_, 1);
 701
 702   fake_transport_->SetState(media_endpoint_->object_path(), "pending");
 703
 704   message_loop_.RunUntilIdle();
 705
 706   // Acquire is called when the state of |audio_sink_| becomes STATE_PENDING,
 707   // and Acquire will trigger state change. Therefore, the state will be
 708   // STATE_ACTIVE right after STATE_PENDING.
 709   // State: STATE_IDLE -> STATE_PENDING -> STATE_ACTIVE
 710   EXPECT_EQ(observer_->state_changed_count_, 3);
 711
 712   audio_sink_->Unregister(
 713       base::Bind(&BluetoothAudioSinkChromeOSTest::Callback,
 714                  base::Unretained(this)),
 715       base::Bind(&BluetoothAudioSinkChromeOSTest::UnregisterErrorCallback,
 716                  base::Unretained(this)));
 717
 718   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_INVALID);
 719   EXPECT_EQ(callback_count_, 3);
 720   EXPECT_EQ(error_callback_count_, 0);
 721   EXPECT_EQ(observer_->state_changed_count_, 5);
 722   EXPECT_EQ(observer_->volume_changed_count_, 2);
 723 }
 724
 725 TEST_F(BluetoothAudioSinkChromeOSTest, StateChanged) {
 726   GetAudioSink();
 727
 728   media_endpoint_->SelectConfiguration(
 729       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
 730       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
 731                  base::Unretained(this)));
 732
 733   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 734   EXPECT_EQ(callback_count_, 2);
 735   EXPECT_EQ(error_callback_count_, 0);
 736   EXPECT_EQ(observer_->state_changed_count_, 0);
 737   EXPECT_EQ(observer_->volume_changed_count_, 0);
 738
 739   media_endpoint_->SetConfiguration(
 740       fake_transport_->GetTransportPath(media_endpoint_->object_path()),
 741       properties_);
 742
 743   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
 744   EXPECT_EQ(callback_count_, 2);
 745   EXPECT_EQ(error_callback_count_, 0);
 746   EXPECT_EQ(observer_->state_changed_count_, 1);
 747   EXPECT_EQ(observer_->volume_changed_count_, 1);
 748
 749   // Changes the current state of transport to pending.
 750   fake_transport_->SetState(media_endpoint_->object_path(), "pending");
 751
 752   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_PENDING);
 753   EXPECT_EQ(observer_->state_changed_count_, 3);
 754   EXPECT_EQ(observer_->volume_changed_count_, 1);
 755 }
 756
 757 TEST_F(BluetoothAudioSinkChromeOSTest, VolumeChanged) {
 758   GetAudioSink();
 759
 760   media_endpoint_->SelectConfiguration(
 761       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
 762       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
 763                  base::Unretained(this)));
 764
 765   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 766   EXPECT_EQ(callback_count_, 2);
 767   EXPECT_EQ(error_callback_count_, 0);
 768   EXPECT_EQ(observer_->state_changed_count_, 0);
 769   EXPECT_EQ(observer_->volume_changed_count_, 0);
 770
 771   media_endpoint_->SetConfiguration(
 772       fake_transport_->GetTransportPath(media_endpoint_->object_path()),
 773       properties_);
 774
 775   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
 776   EXPECT_EQ(callback_count_, 2);
 777   EXPECT_EQ(error_callback_count_, 0);
 778   EXPECT_EQ(observer_->state_changed_count_, 1);
 779   EXPECT_EQ(observer_->volume_changed_count_, 1);
 780
 781   // |kTransportVolume| is the initial volume of the transport, and this
 782   // value is propagated to the audio sink via SetConfiguration.
 783   EXPECT_EQ(audio_sink_->GetVolume(),
 784             FakeBluetoothMediaTransportClient::kTransportVolume);
 785
 786   // Changes volume to a valid level.
 787   fake_transport_->SetVolume(media_endpoint_->object_path(), 100);
 788
 789   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
 790   EXPECT_EQ(observer_->state_changed_count_, 1);
 791   EXPECT_EQ(observer_->volume_changed_count_, 2);
 792   EXPECT_EQ(audio_sink_->GetVolume(), 100);
 793
 794   // Changes volume to an invalid level.
 795   fake_transport_->SetVolume(media_endpoint_->object_path(), 200);
 796
 797   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
 798   EXPECT_EQ(observer_->state_changed_count_, 1);
 799   EXPECT_EQ(observer_->volume_changed_count_, 3);
 800   EXPECT_EQ(audio_sink_->GetVolume(), BluetoothAudioSink::kInvalidVolume);
 801 }
 802
 803 TEST_F(BluetoothAudioSinkChromeOSTest, AcquireFD) {
 804   GetAudioSink();
 805
 806   media_endpoint_->SelectConfiguration(
 807       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
 808       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
 809                  base::Unretained(this)));
 810
 811   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 812   EXPECT_EQ(callback_count_, 2);
 813   EXPECT_EQ(error_callback_count_, 0);
 814   EXPECT_EQ(observer_->state_changed_count_, 0);
 815   EXPECT_EQ(observer_->volume_changed_count_, 0);
 816
 817   media_endpoint_->SetConfiguration(
 818       fake_transport_->GetTransportPath(media_endpoint_->object_path()),
 819       properties_);
 820
 821   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
 822   EXPECT_EQ(callback_count_, 2);
 823   EXPECT_EQ(error_callback_count_, 0);
 824   EXPECT_EQ(observer_->state_changed_count_, 1);
 825   EXPECT_EQ(observer_->volume_changed_count_, 1);
 826
 827   fake_transport_->SetState(media_endpoint_->object_path(), "pending");
 828
 829   std::vector<char> data_one(16, 0x12);
 830   fake_transport_->WriteData(media_endpoint_->object_path(), data_one);
 831
 832   message_loop_.RunUntilIdle();
 833
 834   // Acquire is called when the state of |audio_sink_| becomes STATE_PENDING,
 835   // and Acquire will trigger state change. Therefore, the state will be
 836   // STATE_ACTIVE right after STATE_PENDING.
 837   // State: STATE_IDLE -> STATE_PENDING -> STATE_ACTIVE
 838   EXPECT_EQ(observer_->state_changed_count_, 3);
 839   EXPECT_EQ(observer_->total_read_, data_one.size());
 840   EXPECT_EQ(observer_->data_, data_one);
 841 }
 842
 843 // Tests the case where the remote device pauses and resume audio streaming.
 844 TEST_F(BluetoothAudioSinkChromeOSTest, PauseAndResume) {
 845   GetAudioSink();
 846
 847   media_endpoint_->SelectConfiguration(
 848       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
 849       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
 850                  base::Unretained(this)));
 851
 852   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 853   EXPECT_EQ(callback_count_, 2);
 854   EXPECT_EQ(error_callback_count_, 0);
 855   EXPECT_EQ(observer_->state_changed_count_, 0);
 856   EXPECT_EQ(observer_->volume_changed_count_, 0);
 857
 858   media_endpoint_->SetConfiguration(
 859       fake_transport_->GetTransportPath(media_endpoint_->object_path()),
 860       properties_);
 861
 862   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
 863   EXPECT_EQ(callback_count_, 2);
 864   EXPECT_EQ(error_callback_count_, 0);
 865   EXPECT_EQ(observer_->state_changed_count_, 1);
 866   EXPECT_EQ(observer_->volume_changed_count_, 1);
 867
 868   fake_transport_->SetState(media_endpoint_->object_path(), "pending");
 869
 870   std::vector<char> data_one(16, 0x12);
 871   fake_transport_->WriteData(media_endpoint_->object_path(), data_one);
 872
 873   message_loop_.RunUntilIdle();
 874
 875   EXPECT_EQ(observer_->data_, data_one);
 876   EXPECT_EQ(observer_->state_changed_count_, 3);
 877   EXPECT_EQ(observer_->total_read_, data_one.size());
 878
 879   // Simulates the situation where the remote device pauses and resume audio
 880   // streaming.
 881   fake_transport_->SetState(media_endpoint_->object_path(), "idle");
 882
 883   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
 884   EXPECT_EQ(observer_->state_changed_count_, 4);
 885
 886   fake_transport_->SetState(media_endpoint_->object_path(), "pending");
 887
 888   std::vector<char> data_two(8, 0x10);
 889   fake_transport_->WriteData(media_endpoint_->object_path(), data_two);
 890
 891   message_loop_.RunUntilIdle();
 892
 893   EXPECT_EQ(observer_->data_, data_two);
 894   EXPECT_EQ(observer_->state_changed_count_, 6);
 895   EXPECT_EQ(observer_->total_read_, data_two.size());
 896 }
 897
 898 TEST_F(BluetoothAudioSinkChromeOSTest, ContinuouslyStreaming) {
 899   GetAudioSink();
 900
 901   media_endpoint_->SelectConfiguration(
 902       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
 903       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
 904                  base::Unretained(this)));
 905
 906   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
 907   EXPECT_EQ(callback_count_, 2);
 908   EXPECT_EQ(error_callback_count_, 0);
 909   EXPECT_EQ(observer_->state_changed_count_, 0);
 910   EXPECT_EQ(observer_->volume_changed_count_, 0);
 911
 912   media_endpoint_->SetConfiguration(
 913       fake_transport_->GetTransportPath(media_endpoint_->object_path()),
 914       properties_);
 915
 916   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
 917   EXPECT_EQ(callback_count_, 2);
 918   EXPECT_EQ(error_callback_count_, 0);
 919   EXPECT_EQ(observer_->state_changed_count_, 1);
 920   EXPECT_EQ(observer_->volume_changed_count_, 1);
 921
 922   fake_transport_->SetState(media_endpoint_->object_path(), "pending");
 923
 924   std::vector<char> data_one(16, 0x12);
 925   fake_transport_->WriteData(media_endpoint_->object_path(), data_one);
 926
 927   message_loop_.RunUntilIdle();
 928
 929   EXPECT_EQ(observer_->data_, data_one);
 930   EXPECT_EQ(observer_->state_changed_count_, 3);
 931   EXPECT_EQ(observer_->total_read_, data_one.size());
 932
 933   std::vector<char> data_two(8, 0x10);
 934   fake_transport_->WriteData(media_endpoint_->object_path(), data_two);
 935
 936   message_loop_.RunUntilIdle();
 937
 938   EXPECT_EQ(observer_->data_, data_two);
 939   EXPECT_EQ(observer_->state_changed_count_, 3);
 940   EXPECT_EQ(observer_->total_read_, data_one.size() + data_two.size());
 941 }
 942
 943 }  // namespace chromeos