device/bluetooth: Add I/O watcher for audio data retrieval triggered by state change.

device/bluetooth/bluetooth_audio_sink_chromeos_unittest.cc

 // Copyright 2015 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 <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 16 matching lines @@
 using device::BluetoothAdapterFactory;
 using device::BluetoothAudioSink;
 
 namespace chromeos {
 
 class TestAudioSinkObserver : public BluetoothAudioSink::Observer {
  public:
   explicit TestAudioSinkObserver(scoped_refptr<BluetoothAudioSink> audio_sink)
       : state_changed_count_(0),
         volume_changed_count_(0),
+        total_read_(0),
         state_(audio_sink->GetState()),
         audio_sink_(audio_sink) {
     audio_sink_->AddObserver(this);
   }
 
   ~TestAudioSinkObserver() override { audio_sink_->RemoveObserver(this); }
 
   void BluetoothAudioSinkStateChanged(
       BluetoothAudioSink* audio_sink,
       BluetoothAudioSink::State state) override {
+    if (state == BluetoothAudioSink::STATE_IDLE)
+      total_read_ = 0;
+
     ++state_changed_count_;
   }
 
   void BluetoothAudioSinkVolumeChanged(BluetoothAudioSink* audio_sink,
                                        uint16_t volume) override {
     ++volume_changed_count_;
   }
 
+  void BluetoothAudioSinkDataAvailable(BluetoothAudioSink* audio_sink,
+                                       char* data,
+                                       size_t size) override {
+    total_read_ += size;
+  }
+
   int state_changed_count_;
   int volume_changed_count_;
+  int data_available_count_;
+  size_t total_read_;
   BluetoothAudioSink::State state_;
 
  private:
   scoped_refptr<BluetoothAudioSink> audio_sink_;
 };
 
 class BluetoothAudioSinkChromeOSTest : public testing::Test {
  public:
   void SetUp() override {
     DBusThreadManager::Initialize();
 
     callback_count_ = 0;
     error_callback_count_ = 0;
 
+    fake_media_ = static_cast<FakeBluetoothMediaClient*>(
+        DBusThreadManager::Get()->GetBluetoothMediaClient());
+    fake_transport_ = static_cast<FakeBluetoothMediaTransportClient*>(
+        DBusThreadManager::Get()->GetBluetoothMediaTransportClient());
+
     // Initiates Delegate::TransportProperties with default values.
     properties_.device =
         ObjectPath(FakeBluetoothMediaTransportClient::kTransportDevicePath);
     properties_.uuid = BluetoothMediaClient::kBluetoothAudioSinkUUID;
     properties_.codec = FakeBluetoothMediaTransportClient::kTransportCodec;
     properties_.configuration =
         FakeBluetoothMediaTransportClient::kTransportConfiguration;
     properties_.state = BluetoothMediaTransportClient::kStateIdle;
     properties_.delay.reset(
         new uint16_t(FakeBluetoothMediaTransportClient::kTransportDelay));
     properties_.volume.reset(
         new uint16_t(FakeBluetoothMediaTransportClient::kTransportVolume));
 
-    media_ = static_cast<FakeBluetoothMediaClient*>(
-        DBusThreadManager::Get()->GetBluetoothMediaClient());
-    transport_ = static_cast<FakeBluetoothMediaTransportClient*>(
-        DBusThreadManager::Get()->GetBluetoothMediaTransportClient());
-
     GetAdapter();
   }
 
   void TearDown() override {
     callback_count_ = 0;
     error_callback_count_ = 0;
     observer_.reset();
 
-    media_->SetVisible(true);
+    fake_media_->SetVisible(true);
 
     // The adapter should outlive audio sink.
     audio_sink_ = nullptr;
     adapter_ = nullptr;
     DBusThreadManager::Shutdown();
   }
 
   // Gets the existing Bluetooth adapter.
   void GetAdapter() {
     BluetoothAdapterFactory::GetAdapter(
@@ skipping 57 matching lines @@
   }
 
   // Called whenever RegisterAudioSink is completed successfully.
   void RegisterCallback(
       scoped_refptr<BluetoothAudioSink> audio_sink) {
     ++callback_count_;
     audio_sink_ = audio_sink;
 
     GetFakeMediaEndpoint();
     ASSERT_NE(media_endpoint_, nullptr);
-    media_->SetEndpointRegistered(media_endpoint_, true);
+    fake_media_->SetEndpointRegistered(media_endpoint_, true);
 
     ASSERT_NE(audio_sink_.get(), nullptr);
     ASSERT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
   }
 
   // Called whenever RegisterAudioSink failed.
   void RegisterErrorCallback(BluetoothAudioSink::ErrorCode error_code) {
     ++error_callback_count_;
     EXPECT_EQ(error_code, BluetoothAudioSink::ERROR_NOT_REGISTERED);
   }
@@ skipping 18 matching lines @@
   }
 
   void ErrorCallback() {
     ++error_callback_count_;
   }
 
  protected:
   int callback_count_;
   int error_callback_count_;
 
-  base::MessageLoop message_loop_;
+  base::MessageLoopForIO message_loop_;
 
-  FakeBluetoothMediaClient* media_;
-  FakeBluetoothMediaTransportClient* transport_;
+  FakeBluetoothMediaClient* fake_media_;
+  FakeBluetoothMediaTransportClient* fake_transport_;
   FakeBluetoothMediaEndpointServiceProvider* media_endpoint_;
   scoped_ptr<TestAudioSinkObserver> observer_;
   scoped_refptr<BluetoothAdapter> adapter_;
   scoped_refptr<BluetoothAudioSink> audio_sink_;
 
   // The default property set used while calling SetConfiguration on a media
   // endpoint object.
   BluetoothMediaEndpointServiceProvider::Delegate::TransportProperties
       properties_;
 };
@@ skipping 60 matching lines @@
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
   EXPECT_EQ(callback_count_, 2);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 0);
   EXPECT_EQ(observer_->volume_changed_count_, 0);
 
   // Simulates calling SetConfiguration on the media endpoint object owned by
   // |audio_sink_| with a fake transport path and a
   // Delegate::TransportProperties structure.
   media_endpoint_->SetConfiguration(
-      transport_->GetTransportPath(media_endpoint_->object_path()),
+      fake_transport_->GetTransportPath(media_endpoint_->object_path()),
       properties_);
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
   EXPECT_EQ(callback_count_, 2);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 1);
   EXPECT_EQ(observer_->volume_changed_count_, 1);
 }
 
 TEST_F(BluetoothAudioSinkChromeOSTest, SetConfigurationWithUnexpectedState) {
   GetAudioSink();
 
   media_endpoint_->SelectConfiguration(
       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
   EXPECT_EQ(callback_count_, 2);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 0);
   EXPECT_EQ(observer_->volume_changed_count_, 0);
 
   // Set state of Delegate::TransportProperties with an unexpected value.
   properties_.state = "pending";
 
   media_endpoint_->SetConfiguration(
-      transport_->GetTransportPath(media_endpoint_->object_path()),
+      fake_transport_->GetTransportPath(media_endpoint_->object_path()),
       properties_);
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
   EXPECT_EQ(callback_count_, 2);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 0);
   EXPECT_EQ(observer_->volume_changed_count_, 0);
 }
 
-// TODO(mcchou): Adds test on media-removed events for STATE_PENDING and
-// STATE_ACTIVE.
 // Checks if the observer is notified on media-removed event when the state of
 // |audio_sink_| is STATE_DISCONNECTED. Once the media object is removed, the
 // audio sink is no longer valid.
 TEST_F(BluetoothAudioSinkChromeOSTest, MediaRemovedDuringDisconnectedState) {
   GetAudioSink();
 
   // Gets the media object and makes it invisible to see if the state of the
   // audio sink changes accordingly.
-  media_->SetVisible(false);
+  fake_media_->SetVisible(false);
 
   GetFakeMediaEndpoint();
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_INVALID);
   EXPECT_EQ(media_endpoint_, nullptr);
   EXPECT_EQ(observer_->state_changed_count_, 1);
   EXPECT_EQ(observer_->volume_changed_count_, 0);
 }
 
 // Checks if the observer is  notified on media-removed event when the state of
 // |audio_sink_| is STATE_IDLE. Once the media object is removed, the audio sink
 // is no longer valid.
 TEST_F(BluetoothAudioSinkChromeOSTest, MediaRemovedDuringIdleState) {
   GetAudioSink();
 
   media_endpoint_->SelectConfiguration(
       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
   EXPECT_EQ(callback_count_, 2);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 0);
   EXPECT_EQ(observer_->volume_changed_count_, 0);
 
   media_endpoint_->SetConfiguration(
-      transport_->GetTransportPath(media_endpoint_->object_path()),
+      fake_transport_->GetTransportPath(media_endpoint_->object_path()),
       properties_);
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
   EXPECT_EQ(callback_count_, 2);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 1);
   EXPECT_EQ(observer_->volume_changed_count_, 1);
 
   // Gets the media object and makes it invisible to see if the state of the
   // audio sink changes accordingly.
-  media_->SetVisible(false);
+  fake_media_->SetVisible(false);
 
   GetFakeMediaEndpoint();
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_INVALID);
   EXPECT_EQ(media_endpoint_, nullptr);
 
   // The state becomes disconnted and then invalid, since the removal of
   // transport object should happend before media becomes invisible.
   // State: STATE_IDLE -> STATE_DISCONNECTED -> STATE_INVALID
   EXPECT_EQ(observer_->state_changed_count_, 3);
   EXPECT_EQ(observer_->volume_changed_count_, 2);
 }
 
-// TODO(mcchou): Add tests on transport-removed event for STATE_PENDING and
-// STATE_ACTIVE.
+TEST_F(BluetoothAudioSinkChromeOSTest, MediaRemovedDuringActiveState) {
+  GetAudioSink();
+
+  media_endpoint_->SelectConfiguration(
+      std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
+      base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
+                 base::Unretained(this)));
+
+  EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
+  EXPECT_EQ(callback_count_, 2);
+  EXPECT_EQ(error_callback_count_, 0);
+  EXPECT_EQ(observer_->state_changed_count_, 0);
+  EXPECT_EQ(observer_->volume_changed_count_, 0);
+
+  media_endpoint_->SetConfiguration(
+      fake_transport_->GetTransportPath(media_endpoint_->object_path()),
+      properties_);
+
+  EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
+  EXPECT_EQ(callback_count_, 2);
+  EXPECT_EQ(error_callback_count_, 0);
+  EXPECT_EQ(observer_->state_changed_count_, 1);
+  EXPECT_EQ(observer_->volume_changed_count_, 1);
+
+  fake_transport_->SetState(media_endpoint_->object_path(), "pending");
+
+  message_loop_.RunUntilIdle();
+
+  // Acquire is called when the state of |audio_sink_| becomes STATE_PENDING,
+  // and Acquire will trigger state change. Therefore, the state will be
+  // STATE_ACTIVE right after STATE_PENDING.
+  // State: STATE_IDLE -> STATE_PENDING -> STATE_ACTIVE
+  EXPECT_EQ(observer_->state_changed_count_, 3);
+
+  // Gets the media object and makes it invisible to see if the state of the
+  // audio sink changes accordingly.
+  fake_media_->SetVisible(false);
+
+  GetFakeMediaEndpoint();
+
+  EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_INVALID);
+  EXPECT_EQ(media_endpoint_, nullptr);
+
+  // The state becomes disconnted and then invalid, since the removal of
+  // transport object should happend before media becomes invisible.
+  // State: STATE_ACTIVE -> STATE_DISCONNECTED -> STATE_INVALID
+  EXPECT_EQ(observer_->state_changed_count_, 5);
+  EXPECT_EQ(observer_->volume_changed_count_, 2);
+}
+
 // Checks if the observer is notified on transport-removed event when the state
 // of |audio_sink_| is STATE_IDEL. Once the media transport object is removed,
 // the audio sink is disconnected.
 TEST_F(BluetoothAudioSinkChromeOSTest, TransportRemovedDuringIdleState) {
   GetAudioSink();
 
   media_endpoint_->SelectConfiguration(
       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
   EXPECT_EQ(callback_count_, 2);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 0);
   EXPECT_EQ(observer_->volume_changed_count_, 0);
 
   media_endpoint_->SetConfiguration(
-      transport_->GetTransportPath(media_endpoint_->object_path()),
+      fake_transport_->GetTransportPath(media_endpoint_->object_path()),
       properties_);
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
   EXPECT_EQ(callback_count_, 2);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 1);
   EXPECT_EQ(observer_->volume_changed_count_, 1);
 
   // Makes the transport object invalid to see if the state of the audio sink
   // changes accordingly.
-  transport_->SetValid(media_endpoint_, false);
+  fake_transport_->SetValid(media_endpoint_, false);
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
   EXPECT_NE(media_endpoint_, nullptr);
   EXPECT_EQ(observer_->state_changed_count_, 2);
   EXPECT_EQ(observer_->volume_changed_count_, 2);
 }
 
+TEST_F(BluetoothAudioSinkChromeOSTest, TransportRemovedDuringActiveState) {
+  GetAudioSink();
+
+  media_endpoint_->SelectConfiguration(
+      std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
+      base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
+                 base::Unretained(this)));
+
+  EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
+  EXPECT_EQ(callback_count_, 2);
+  EXPECT_EQ(error_callback_count_, 0);
+  EXPECT_EQ(observer_->state_changed_count_, 0);
+  EXPECT_EQ(observer_->volume_changed_count_, 0);
+
+  media_endpoint_->SetConfiguration(
+      fake_transport_->GetTransportPath(media_endpoint_->object_path()),
+      properties_);
+
+  EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
+  EXPECT_EQ(callback_count_, 2);
+  EXPECT_EQ(error_callback_count_, 0);
+  EXPECT_EQ(observer_->state_changed_count_, 1);
+  EXPECT_EQ(observer_->volume_changed_count_, 1);
+
+  fake_transport_->SetState(media_endpoint_->object_path(), "pending");
+
+  message_loop_.RunUntilIdle();
+
+  // Acquire is called when the state of |audio_sink_| becomes STATE_PENDING,
+  // and Acquire will trigger state change. Therefore, the state will be
+  // STATE_ACTIVE right after STATE_PENDING.
+  // State: STATE_IDLE -> STATE_PENDING -> STATE_ACTIVE
+  EXPECT_EQ(observer_->state_changed_count_, 3);
+
+  // Makes the transport object invalid to see if the state of the audio sink
+  // changes accordingly.
+  fake_transport_->SetValid(media_endpoint_, false);
+
+  EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
+  EXPECT_NE(media_endpoint_, nullptr);
+  EXPECT_EQ(observer_->state_changed_count_, 4);
+  EXPECT_EQ(observer_->volume_changed_count_, 2);
+}
+
 TEST_F(BluetoothAudioSinkChromeOSTest,
        AdapterPoweredChangedDuringDisconnectedState) {
   GetAudioSink();
 
   adapter_->SetPowered(
       false,
       base::Bind(&BluetoothAudioSinkChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothAudioSinkChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
@@ skipping 30 matching lines @@
       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
   EXPECT_EQ(callback_count_, 2);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 0);
   EXPECT_EQ(observer_->volume_changed_count_, 0);
 
   media_endpoint_->SetConfiguration(
-      transport_->GetTransportPath(media_endpoint_->object_path()),
+      fake_transport_->GetTransportPath(media_endpoint_->object_path()),
       properties_);
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
   EXPECT_EQ(callback_count_, 2);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 1);
   EXPECT_EQ(observer_->volume_changed_count_, 1);
 
   adapter_->SetPowered(
       false,
       base::Bind(&BluetoothAudioSinkChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothAudioSinkChromeOSTest::ErrorCallback,
                  base::Unretained(this)));
   GetFakeMediaEndpoint();
 
   EXPECT_TRUE(adapter_->IsPresent());
   EXPECT_FALSE(adapter_->IsPowered());
   EXPECT_NE(media_endpoint_, nullptr);
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
   EXPECT_EQ(callback_count_, 3);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 2);
   EXPECT_EQ(observer_->volume_changed_count_, 2);
 }
 
-// TODO(mcchou): Add tests on UnregisterAudioSink for STATE_PENDING and
-// STATE_ACTIVE.
-
 TEST_F(BluetoothAudioSinkChromeOSTest,
        UnregisterAudioSinkDuringDisconnectedState) {
   GetAudioSink();
 
   audio_sink_->Unregister(
       base::Bind(&BluetoothAudioSinkChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothAudioSinkChromeOSTest::UnregisterErrorCallback,
                  base::Unretained(this)));
 
@@ skipping 12 matching lines @@
       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
   EXPECT_EQ(callback_count_, 2);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 0);
   EXPECT_EQ(observer_->volume_changed_count_, 0);
 
   media_endpoint_->SetConfiguration(
-      transport_->GetTransportPath(media_endpoint_->object_path()),
+      fake_transport_->GetTransportPath(media_endpoint_->object_path()),
       properties_);
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
   EXPECT_EQ(callback_count_, 2);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 1);
   EXPECT_EQ(observer_->volume_changed_count_, 1);
 
   audio_sink_->Unregister(
       base::Bind(&BluetoothAudioSinkChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothAudioSinkChromeOSTest::UnregisterErrorCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_INVALID);
   EXPECT_EQ(callback_count_, 3);
   EXPECT_EQ(error_callback_count_, 0);
 
   // The state becomes disconnted and then invalid, since the removal of
   // transport object should happend before the unregistration of endpoint.
   // State: STATE_IDLE -> STATE_DISCONNECTED -> STATE_INVALID
   EXPECT_EQ(observer_->state_changed_count_, 3);
   EXPECT_EQ(observer_->volume_changed_count_, 2);
 }
 
+TEST_F(BluetoothAudioSinkChromeOSTest, UnregisterAudioSinkDuringActiveState) {
+  GetAudioSink();
+
+  media_endpoint_->SelectConfiguration(
+      std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
+      base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
+                 base::Unretained(this)));
+
+  EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
+  EXPECT_EQ(callback_count_, 2);
+  EXPECT_EQ(error_callback_count_, 0);
+  EXPECT_EQ(observer_->state_changed_count_, 0);
+  EXPECT_EQ(observer_->volume_changed_count_, 0);
+
+  media_endpoint_->SetConfiguration(
+      fake_transport_->GetTransportPath(media_endpoint_->object_path()),
+      properties_);
+
+  EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
+  EXPECT_EQ(callback_count_, 2);
+  EXPECT_EQ(error_callback_count_, 0);
+  EXPECT_EQ(observer_->state_changed_count_, 1);
+  EXPECT_EQ(observer_->volume_changed_count_, 1);
+
+  fake_transport_->SetState(media_endpoint_->object_path(), "pending");
+
+  message_loop_.RunUntilIdle();
+
+  // Acquire is called when the state of |audio_sink_| becomes STATE_PENDING,
+  // and Acquire will trigger state change. Therefore, the state will be
+  // STATE_ACTIVE right after STATE_PENDING.
+  // State: STATE_IDLE -> STATE_PENDING -> STATE_ACTIVE
+  EXPECT_EQ(observer_->state_changed_count_, 3);
+
+  audio_sink_->Unregister(
+      base::Bind(&BluetoothAudioSinkChromeOSTest::Callback,
+                 base::Unretained(this)),
+      base::Bind(&BluetoothAudioSinkChromeOSTest::UnregisterErrorCallback,
+                 base::Unretained(this)));
+
+  EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_INVALID);
+  EXPECT_EQ(callback_count_, 3);
+  EXPECT_EQ(error_callback_count_, 0);
+  EXPECT_EQ(observer_->state_changed_count_, 5);
+  EXPECT_EQ(observer_->volume_changed_count_, 2);
+}
+
 TEST_F(BluetoothAudioSinkChromeOSTest, StateChanged) {
   GetAudioSink();
 
   media_endpoint_->SelectConfiguration(
       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
   EXPECT_EQ(callback_count_, 2);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 0);
   EXPECT_EQ(observer_->volume_changed_count_, 0);
 
   media_endpoint_->SetConfiguration(
-      transport_->GetTransportPath(media_endpoint_->object_path()),
+      fake_transport_->GetTransportPath(media_endpoint_->object_path()),
       properties_);
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
   EXPECT_EQ(callback_count_, 2);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 1);
   EXPECT_EQ(observer_->volume_changed_count_, 1);
 
   // Changes the current state of transport to pending.
-  transport_->SetState(media_endpoint_->object_path(), "pending");
+  fake_transport_->SetState(media_endpoint_->object_path(), "pending");
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_PENDING);
-  EXPECT_EQ(observer_->state_changed_count_, 2);
+  EXPECT_EQ(observer_->state_changed_count_, 3);
   EXPECT_EQ(observer_->volume_changed_count_, 1);
 }
 
 TEST_F(BluetoothAudioSinkChromeOSTest, VolumeChanged) {
   GetAudioSink();
 
   media_endpoint_->SelectConfiguration(
       std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
       base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
                  base::Unretained(this)));
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
   EXPECT_EQ(callback_count_, 2);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 0);
   EXPECT_EQ(observer_->volume_changed_count_, 0);
 
   media_endpoint_->SetConfiguration(
-      transport_->GetTransportPath(media_endpoint_->object_path()),
+      fake_transport_->GetTransportPath(media_endpoint_->object_path()),
       properties_);
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
   EXPECT_EQ(callback_count_, 2);
   EXPECT_EQ(error_callback_count_, 0);
   EXPECT_EQ(observer_->state_changed_count_, 1);
   EXPECT_EQ(observer_->volume_changed_count_, 1);
 
   // |kTransportVolume| is the initial volume of the transport, and this
   // value is propagated to the audio sink via SetConfiguration.
   EXPECT_EQ(audio_sink_->GetVolume(),
             FakeBluetoothMediaTransportClient::kTransportVolume);
 
   // Changes volume to a valid level.
-  transport_->SetVolume(media_endpoint_->object_path(), 100);
+  fake_transport_->SetVolume(media_endpoint_->object_path(), 100);
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
   EXPECT_EQ(observer_->state_changed_count_, 1);
   EXPECT_EQ(observer_->volume_changed_count_, 2);
   EXPECT_EQ(audio_sink_->GetVolume(), 100);
 
   // Changes volume to an invalid level.
-  transport_->SetVolume(media_endpoint_->object_path(), 200);
+  fake_transport_->SetVolume(media_endpoint_->object_path(), 200);
 
   EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
   EXPECT_EQ(observer_->state_changed_count_, 1);
   EXPECT_EQ(observer_->volume_changed_count_, 3);
   EXPECT_EQ(audio_sink_->GetVolume(), BluetoothAudioSink::kInvalidVolume);
 }
 
+TEST_F(BluetoothAudioSinkChromeOSTest, AcquireFD) {
+  GetAudioSink();
+
+  media_endpoint_->SelectConfiguration(
+      std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
+      base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
+                 base::Unretained(this)));
+
+  EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
+  EXPECT_EQ(callback_count_, 2);
+  EXPECT_EQ(error_callback_count_, 0);
+  EXPECT_EQ(observer_->state_changed_count_, 0);
+  EXPECT_EQ(observer_->volume_changed_count_, 0);
+
+  media_endpoint_->SetConfiguration(
+      fake_transport_->GetTransportPath(media_endpoint_->object_path()),
+      properties_);
+
+  EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
+  EXPECT_EQ(callback_count_, 2);
+  EXPECT_EQ(error_callback_count_, 0);
+  EXPECT_EQ(observer_->state_changed_count_, 1);
+  EXPECT_EQ(observer_->volume_changed_count_, 1);
+
+  fake_transport_->SetState(media_endpoint_->object_path(), "pending");
+
+  std::vector<char> data_one({0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+                              0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f});
+  fake_transport_->WriteData(media_endpoint_->object_path(), data_one);
+
+  message_loop_.RunUntilIdle();
+
+  // Acquire is called when the state of |audio_sink_| becomes STATE_PENDING,
+  // and Acquire will trigger state change. Therefore, the state will be
+  // STATE_ACTIVE right after STATE_PENDING.
+  // State: STATE_IDLE -> STATE_PENDING -> STATE_ACTIVE
+  EXPECT_EQ(observer_->state_changed_count_, 3);
+  EXPECT_EQ(observer_->total_read_, data_one.size());

[armansito, 2015/03/12 03:42:55]

It would be cool if you could also check that the data you read matches the data
that you sent over the wire. You can simply copy the data in the observer method
to a local variable in the test harness, just like you do with |total_read_|.

[Miao, 2015/03/12 22:33:32]

Added!

+}
+
+// Tests the case where the remote device pauses and resume audio streaming.
+TEST_F(BluetoothAudioSinkChromeOSTest, PauseAndResume) {
+  GetAudioSink();
+
+  media_endpoint_->SelectConfiguration(
+      std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
+      base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
+                 base::Unretained(this)));
+
+  EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
+  EXPECT_EQ(callback_count_, 2);
+  EXPECT_EQ(error_callback_count_, 0);
+  EXPECT_EQ(observer_->state_changed_count_, 0);
+  EXPECT_EQ(observer_->volume_changed_count_, 0);
+
+  media_endpoint_->SetConfiguration(
+      fake_transport_->GetTransportPath(media_endpoint_->object_path()),
+      properties_);
+
+  EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
+  EXPECT_EQ(callback_count_, 2);
+  EXPECT_EQ(error_callback_count_, 0);
+  EXPECT_EQ(observer_->state_changed_count_, 1);
+  EXPECT_EQ(observer_->volume_changed_count_, 1);
+
+  fake_transport_->SetState(media_endpoint_->object_path(), "pending");
+
+  std::vector<char> data_one(16, 0x12);
+  fake_transport_->WriteData(media_endpoint_->object_path(), data_one);
+
+  message_loop_.RunUntilIdle();
+
+  EXPECT_EQ(observer_->state_changed_count_, 3);
+  EXPECT_EQ(observer_->total_read_, data_one.size());
+
+  // Simulates the situation where the remote device pauses and resume audio
+  // streaming.
+  fake_transport_->SetState(media_endpoint_->object_path(), "idle");
+
+  EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
+  EXPECT_EQ(observer_->state_changed_count_, 4);
+
+  fake_transport_->SetState(media_endpoint_->object_path(), "pending");
+
+  std::vector<char> data_two(8, 0x10);
+  fake_transport_->WriteData(media_endpoint_->object_path(), data_two);
+
+  message_loop_.RunUntilIdle();
+
+  EXPECT_EQ(observer_->state_changed_count_, 6);
+  EXPECT_EQ(observer_->total_read_, data_two.size());
+}
+
+TEST_F(BluetoothAudioSinkChromeOSTest, ContinuouslyStreaming) {
+  GetAudioSink();
+
+  media_endpoint_->SelectConfiguration(
+      std::vector<uint8_t>({0x21, 0x15, 0x33, 0x2C}),
+      base::Bind(&BluetoothAudioSinkChromeOSTest::SelectConfigurationCallback,
+                 base::Unretained(this)));
+
+  EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_DISCONNECTED);
+  EXPECT_EQ(callback_count_, 2);
+  EXPECT_EQ(error_callback_count_, 0);
+  EXPECT_EQ(observer_->state_changed_count_, 0);
+  EXPECT_EQ(observer_->volume_changed_count_, 0);
+
+  media_endpoint_->SetConfiguration(
+      fake_transport_->GetTransportPath(media_endpoint_->object_path()),
+      properties_);
+
+  EXPECT_EQ(audio_sink_->GetState(), BluetoothAudioSink::STATE_IDLE);
+  EXPECT_EQ(callback_count_, 2);
+  EXPECT_EQ(error_callback_count_, 0);
+  EXPECT_EQ(observer_->state_changed_count_, 1);
+  EXPECT_EQ(observer_->volume_changed_count_, 1);
+
+  fake_transport_->SetState(media_endpoint_->object_path(), "pending");
+
+  std::vector<char> data_one(16, 0x12);
+  fake_transport_->WriteData(media_endpoint_->object_path(), data_one);
+
+  message_loop_.RunUntilIdle();
+
+  EXPECT_EQ(observer_->state_changed_count_, 3);
+  EXPECT_EQ(observer_->total_read_, data_one.size());
+
+  std::vector<char> data_two(8, 0x10);
+  fake_transport_->WriteData(media_endpoint_->object_path(), data_two);
+
+  message_loop_.RunUntilIdle();
+
+  EXPECT_EQ(observer_->state_changed_count_, 3);
+  EXPECT_EQ(observer_->total_read_, data_one.size() + data_two.size());
+}
+
 }  // namespace chromeos