Refactor DBusThreadManager to split away BT clients.

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"
-#include "chromeos/dbus/bluetooth_media_client.h"
-#include "chromeos/dbus/bluetooth_media_endpoint_service_provider.h"
-#include "chromeos/dbus/bluetooth_media_transport_client.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/fake_bluetooth_media_client.h"
-#include "chromeos/dbus/fake_bluetooth_media_endpoint_service_provider.h"
-#include "chromeos/dbus/fake_bluetooth_media_transport_client.h"
 #include "dbus/object_path.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_audio_sink.h"
 #include "device/bluetooth/bluetooth_audio_sink_chromeos.h"
+#include "device/bluetooth/dbus/bluetooth_media_client.h"
+#include "device/bluetooth/dbus/bluetooth_media_endpoint_service_provider.h"
+#include "device/bluetooth/dbus/bluetooth_media_transport_client.h"
+#include "device/bluetooth/dbus/bluez_dbus_manager.h"
+#include "device/bluetooth/dbus/fake_bluetooth_media_client.h"
+#include "device/bluetooth/dbus/fake_bluetooth_media_endpoint_service_provider.h"
+#include "device/bluetooth/dbus/fake_bluetooth_media_transport_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using dbus::ObjectPath;
 using device::BluetoothAdapter;
 using device::BluetoothAdapterFactory;
 using device::BluetoothAudioSink;
 
 namespace chromeos {
 
 class TestAudioSinkObserver : public BluetoothAudioSink::Observer {
@@ skipping 41 matching lines @@
   uint16_t read_mtu_;
   BluetoothAudioSink::State state_;
 
  private:
   scoped_refptr<BluetoothAudioSink> audio_sink_;
 };
 
 class BluetoothAudioSinkChromeOSTest : public testing::Test {
  public:
   void SetUp() override {
-    DBusThreadManager::Initialize();
+    bluez::BluezDBusManager::Initialize(NULL, true);
 
     callback_count_ = 0;
     error_callback_count_ = 0;
 
-    fake_media_ = static_cast<FakeBluetoothMediaClient*>(
-        DBusThreadManager::Get()->GetBluetoothMediaClient());
-    fake_transport_ = static_cast<FakeBluetoothMediaTransportClient*>(
-        DBusThreadManager::Get()->GetBluetoothMediaTransportClient());
+    fake_media_ = static_cast<bluez::FakeBluetoothMediaClient*>(
+        bluez::BluezDBusManager::Get()->GetBluetoothMediaClient());
+    fake_transport_ = static_cast<bluez::FakeBluetoothMediaTransportClient*>(
+        bluez::BluezDBusManager::Get()->GetBluetoothMediaTransportClient());
 
     // Initiates Delegate::TransportProperties with default values.
-    properties_.device =
-        ObjectPath(FakeBluetoothMediaTransportClient::kTransportDevicePath);
-    properties_.uuid = BluetoothMediaClient::kBluetoothAudioSinkUUID;
-    properties_.codec = FakeBluetoothMediaTransportClient::kTransportCodec;
+    properties_.device = ObjectPath(
+        bluez::FakeBluetoothMediaTransportClient::kTransportDevicePath);
+    properties_.uuid = bluez::BluetoothMediaClient::kBluetoothAudioSinkUUID;
+    properties_.codec =
+        bluez::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));
+        bluez::FakeBluetoothMediaTransportClient::kTransportConfiguration;
+    properties_.state = bluez::BluetoothMediaTransportClient::kStateIdle;
+    properties_.delay.reset(new uint16_t(
+        bluez::FakeBluetoothMediaTransportClient::kTransportDelay));
+    properties_.volume.reset(new uint16_t(
+        bluez::FakeBluetoothMediaTransportClient::kTransportVolume));
 
     GetAdapter();
   }
 
   void TearDown() override {
     callback_count_ = 0;
     error_callback_count_ = 0;
     observer_.reset();
 
     fake_media_->SetVisible(true);
 
     // The adapter should outlive audio sink.
     audio_sink_ = nullptr;
     adapter_ = nullptr;
-    DBusThreadManager::Shutdown();
+    bluez::BluezDBusManager::Shutdown();
   }
 
   // Gets the existing Bluetooth adapter.
   void GetAdapter() {
     BluetoothAdapterFactory::GetAdapter(
         base::Bind(&BluetoothAudioSinkChromeOSTest::GetAdapterCallback,
                    base::Unretained(this)));
   }
 
   // Called whenever BluetoothAdapter is retrieved successfully.
@@ skipping 40 matching lines @@
     EXPECT_EQ(error_callback_count_, 0);
     EXPECT_EQ(observer_->state_changed_count_, 0);
     EXPECT_EQ(observer_->volume_changed_count_, 0);
   }
 
   void GetFakeMediaEndpoint() {
     BluetoothAudioSinkChromeOS* audio_sink_chromeos =
         static_cast<BluetoothAudioSinkChromeOS*>(audio_sink_.get());
     ASSERT_NE(audio_sink_chromeos, nullptr);
 
-    media_endpoint_ = static_cast<FakeBluetoothMediaEndpointServiceProvider*>(
-        audio_sink_chromeos->GetEndpointServiceProvider());
+    media_endpoint_ =
+        static_cast<bluez::FakeBluetoothMediaEndpointServiceProvider*>(
+            audio_sink_chromeos->GetEndpointServiceProvider());
   }
 
   // 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);
@@ skipping 31 matching lines @@
   void ErrorCallback() {
     ++error_callback_count_;
   }
 
  protected:
   int callback_count_;
   int error_callback_count_;
 
   base::MessageLoopForIO message_loop_;
 
-  FakeBluetoothMediaClient* fake_media_;
-  FakeBluetoothMediaTransportClient* fake_transport_;
-  FakeBluetoothMediaEndpointServiceProvider* media_endpoint_;
+  bluez::FakeBluetoothMediaClient* fake_media_;
+  bluez::FakeBluetoothMediaTransportClient* fake_transport_;
+  bluez::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
+  bluez::BluetoothMediaEndpointServiceProvider::Delegate::TransportProperties
       properties_;
 };
 
 TEST_F(BluetoothAudioSinkChromeOSTest, RegisterSucceeded) {
   GetAudioSink();
 }
 
 TEST_F(BluetoothAudioSinkChromeOSTest, RegisterFailedWithInvalidOptions) {
   // Sets options with an invalid codec and valid capabilities.
   BluetoothAudioSink::Options options;
@@ skipping 523 matching lines @@
 
   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);
+            bluez::FakeBluetoothMediaTransportClient::kTransportVolume);
 
   // Changes volume to a valid level.
   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.
@@ skipping 37 matching lines @@
   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());
   EXPECT_EQ(observer_->data_, data_one);
   EXPECT_EQ(observer_->read_mtu_,
-            FakeBluetoothMediaTransportClient::kDefaultReadMtu);
+            bluez::FakeBluetoothMediaTransportClient::kDefaultReadMtu);
 }
 
 // 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)));
@@ skipping 16 matching lines @@
 
   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_->data_, data_one);
   EXPECT_EQ(observer_->read_mtu_,
-            FakeBluetoothMediaTransportClient::kDefaultReadMtu);
+            bluez::FakeBluetoothMediaTransportClient::kDefaultReadMtu);
   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_->data_, data_two);
   EXPECT_EQ(observer_->read_mtu_,
-            FakeBluetoothMediaTransportClient::kDefaultReadMtu);
+            bluez::FakeBluetoothMediaTransportClient::kDefaultReadMtu);
   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,
@@ skipping 17 matching lines @@
 
   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_->data_, data_one);
   EXPECT_EQ(observer_->read_mtu_,
-            FakeBluetoothMediaTransportClient::kDefaultReadMtu);
+            bluez::FakeBluetoothMediaTransportClient::kDefaultReadMtu);
   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_->data_, data_two);
   EXPECT_EQ(observer_->read_mtu_,
-            FakeBluetoothMediaTransportClient::kDefaultReadMtu);
+            bluez::FakeBluetoothMediaTransportClient::kDefaultReadMtu);
   EXPECT_EQ(observer_->state_changed_count_, 3);
   EXPECT_EQ(observer_->total_read_, data_one.size() + data_two.size());
 }
 
 }  // namespace chromeos