diff options
Diffstat (limited to 'device')
20 files changed, 238 insertions, 63 deletions
diff --git a/device/bluetooth/bluetooth_adapter_bluez.cc b/device/bluetooth/bluetooth_adapter_bluez.cc index 1d22ef7..4424b02 100644 --- a/device/bluetooth/bluetooth_adapter_bluez.cc +++ b/device/bluetooth/bluetooth_adapter_bluez.cc @@ -92,7 +92,7 @@ namespace device { // static base::WeakPtr<BluetoothAdapter> BluetoothAdapter::CreateAdapter( const InitCallback& init_callback) { - return bluez::BluetoothAdapterBlueZ::CreateAdapter(); + return bluez::BluetoothAdapterBlueZ::CreateAdapter(init_callback); } } // namespace device @@ -100,8 +100,9 @@ base::WeakPtr<BluetoothAdapter> BluetoothAdapter::CreateAdapter( namespace bluez { // static -base::WeakPtr<BluetoothAdapter> BluetoothAdapterBlueZ::CreateAdapter() { - BluetoothAdapterBlueZ* adapter = new BluetoothAdapterBlueZ(); +base::WeakPtr<BluetoothAdapter> BluetoothAdapterBlueZ::CreateAdapter( + const InitCallback& init_callback) { + BluetoothAdapterBlueZ* adapter = new BluetoothAdapterBlueZ(init_callback); return adapter->weak_ptr_factory_.GetWeakPtr(); } @@ -112,6 +113,13 @@ void BluetoothAdapterBlueZ::Shutdown() { << "Call BluetoothAdapterFactory::Shutdown() before " "BluezDBusManager::Shutdown()."; + // Since we don't initialize anything if Object Manager is not supported, + // no need to do any clean up. + if (!bluez::BluezDBusManager::Get()->IsObjectManagerSupported()) { + dbus_is_shutdown_ = true; + return; + } + if (IsPresent()) RemoveAdapter(); // Also deletes devices_. DCHECK(devices_.empty()); @@ -141,14 +149,36 @@ void BluetoothAdapterBlueZ::Shutdown() { dbus_is_shutdown_ = true; } -BluetoothAdapterBlueZ::BluetoothAdapterBlueZ() - : dbus_is_shutdown_(false), +BluetoothAdapterBlueZ::BluetoothAdapterBlueZ(const InitCallback& init_callback) + : init_callback_(init_callback), + initialized_(false), + dbus_is_shutdown_(false), num_discovery_sessions_(0), discovery_request_pending_(false), weak_ptr_factory_(this) { ui_task_runner_ = base::ThreadTaskRunnerHandle::Get(); socket_thread_ = device::BluetoothSocketThread::Get(); + // Can't initialize the adapter until DBus clients are ready. + if (bluez::BluezDBusManager::Get()->IsObjectManagerSupportKnown()) { + base::ThreadTaskRunnerHandle::Get()->PostTask( + FROM_HERE, base::Bind(&BluetoothAdapterBlueZ::Init, + weak_ptr_factory_.GetWeakPtr())); + return; + } + bluez::BluezDBusManager::Get()->CallWhenObjectManagerSupportIsKnown( + base::Bind(&BluetoothAdapterBlueZ::Init, weak_ptr_factory_.GetWeakPtr())); +} + +void BluetoothAdapterBlueZ::Init() { + // If the platform doesn't support Object Manager then Bluez 5 is probably + // not present. In this case we just return without initializing anything. + if (!bluez::BluezDBusManager::Get()->IsObjectManagerSupported()) { + initialized_ = true; + init_callback_.Run(); + return; + } + bluez::BluezDBusManager::Get()->GetBluetoothAdapterClient()->AddObserver( this); bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->AddObserver(this); @@ -168,6 +198,8 @@ BluetoothAdapterBlueZ::BluetoothAdapterBlueZ() VLOG(1) << object_paths.size() << " Bluetooth adapter(s) available."; SetAdapter(object_paths[0]); } + initialized_ = true; + init_callback_.Run(); } BluetoothAdapterBlueZ::~BluetoothAdapterBlueZ() { @@ -218,7 +250,7 @@ void BluetoothAdapterBlueZ::SetName(const std::string& name, } bool BluetoothAdapterBlueZ::IsInitialized() const { - return true; + return initialized_; } bool BluetoothAdapterBlueZ::IsPresent() const { diff --git a/device/bluetooth/bluetooth_adapter_bluez.h b/device/bluetooth/bluetooth_adapter_bluez.h index e2a07ff..4f847a5 100644 --- a/device/bluetooth/bluetooth_adapter_bluez.h +++ b/device/bluetooth/bluetooth_adapter_bluez.h @@ -73,7 +73,9 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothAdapterBlueZ typedef base::Callback<void(BluetoothAdapterProfileBlueZ* profile)> ProfileRegisteredCallback; - static base::WeakPtr<BluetoothAdapter> CreateAdapter(); + // Calls |init_callback| after a BluetoothAdapter is fully initialized. + static base::WeakPtr<BluetoothAdapter> CreateAdapter( + const InitCallback& init_callback); // BluetoothAdapter: void Shutdown() override; @@ -171,9 +173,13 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothAdapterBlueZ typedef std::pair<base::Closure, ErrorCompletionCallback> RegisterProfileCompletionPair; - BluetoothAdapterBlueZ(); + explicit BluetoothAdapterBlueZ(const InitCallback& init_callback); ~BluetoothAdapterBlueZ() override; + // Init will get asynchronouly called once we know if Object Manager is + // supported. + void Init(); + // bluez::BluetoothAdapterClient::Observer override. void AdapterAdded(const dbus::ObjectPath& object_path) override; void AdapterRemoved(const dbus::ObjectPath& object_path) override; @@ -333,6 +339,10 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothAdapterBlueZ // ended (with either success or failure). void ProcessQueuedDiscoveryRequests(); + InitCallback init_callback_; + + bool initialized_; + // Set in |Shutdown()|, makes IsPresent()| return false. bool dbus_is_shutdown_; diff --git a/device/bluetooth/bluetooth_adapter_factory.cc b/device/bluetooth/bluetooth_adapter_factory.cc index 2bcfbe90..dfea790 100644 --- a/device/bluetooth/bluetooth_adapter_factory.cc +++ b/device/bluetooth/bluetooth_adapter_factory.cc @@ -28,7 +28,7 @@ namespace { base::LazyInstance<base::WeakPtr<BluetoothAdapter> >::Leaky default_adapter = LAZY_INSTANCE_INITIALIZER; -#if defined(OS_WIN) +#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_CHROMEOS) typedef std::vector<BluetoothAdapterFactory::AdapterCallback> AdapterCallbackList; @@ -49,7 +49,7 @@ void RunAdapterCallbacks() { } adapter_callbacks.Get().clear(); } -#endif // defined(OS_WIN) +#endif // defined(OS_WIN) || defined(OS_LINUX) || defined(OS_CHROMEOS) } // namespace @@ -73,7 +73,7 @@ bool BluetoothAdapterFactory::IsBluetoothAdapterAvailable() { void BluetoothAdapterFactory::GetAdapter(const AdapterCallback& callback) { DCHECK(IsBluetoothAdapterAvailable()); -#if defined(OS_WIN) +#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_CHROMEOS) if (!default_adapter.Get()) { default_adapter.Get() = BluetoothAdapter::CreateAdapter(base::Bind(&RunAdapterCallbacks)); @@ -82,18 +82,17 @@ void BluetoothAdapterFactory::GetAdapter(const AdapterCallback& callback) { if (!default_adapter.Get()->IsInitialized()) adapter_callbacks.Get().push_back(callback); -#else // !defined(OS_WIN) +#else // !defined(OS_WIN) && !defined(OS_LINUX) && !defined(OS_CHROMEOS) if (!default_adapter.Get()) { default_adapter.Get() = BluetoothAdapter::CreateAdapter(BluetoothAdapter::InitCallback()); } DCHECK(default_adapter.Get()->IsInitialized()); -#endif // defined(OS_WIN) +#endif // defined(OS_WIN) || defined(OS_LINUX) || defined(OS_CHROMEOS) if (default_adapter.Get()->IsInitialized()) callback.Run(scoped_refptr<BluetoothAdapter>(default_adapter.Get().get())); - } #if defined(OS_CHROMEOS) || defined(OS_LINUX) diff --git a/device/bluetooth/bluetooth_adapter_profile_bluez_unittest.cc b/device/bluetooth/bluetooth_adapter_profile_bluez_unittest.cc index f64359d..8f06723 100644 --- a/device/bluetooth/bluetooth_adapter_profile_bluez_unittest.cc +++ b/device/bluetooth/bluetooth_adapter_profile_bluez_unittest.cc @@ -55,6 +55,7 @@ class BluetoothAdapterProfileBlueZTest : public testing::Test { device::BluetoothAdapterFactory::GetAdapter( base::Bind(&BluetoothAdapterProfileBlueZTest::AdapterCallback, base::Unretained(this))); + base::MessageLoop::current()->Run(); ASSERT_TRUE(adapter_.get() != nullptr); ASSERT_TRUE(adapter_->IsInitialized()); ASSERT_TRUE(adapter_->IsPresent()); @@ -73,6 +74,10 @@ class BluetoothAdapterProfileBlueZTest : public testing::Test { void AdapterCallback(scoped_refptr<BluetoothAdapter> adapter) { adapter_ = adapter; + if (base::MessageLoop::current() && + base::MessageLoop::current()->is_running()) { + base::MessageLoop::current()->QuitWhenIdle(); + } } class FakeDelegate : public bluez::BluetoothProfileServiceProvider::Delegate { diff --git a/device/bluetooth/bluetooth_advertisement_bluez_unittest.cc b/device/bluetooth/bluetooth_advertisement_bluez_unittest.cc index 27b2c8f..4e07002 100644 --- a/device/bluetooth/bluetooth_advertisement_bluez_unittest.cc +++ b/device/bluetooth/bluetooth_advertisement_bluez_unittest.cc @@ -80,6 +80,7 @@ class BluetoothAdvertisementBlueZTest : public testing::Test { BluetoothAdapterFactory::GetAdapter( base::Bind(&BluetoothAdvertisementBlueZTest::GetAdapterCallback, base::Unretained(this))); + base::MessageLoop::current()->Run(); } // Called whenever BluetoothAdapter is retrieved successfully. @@ -87,6 +88,10 @@ class BluetoothAdvertisementBlueZTest : public testing::Test { adapter_ = adapter; ASSERT_NE(adapter_.get(), nullptr); ASSERT_TRUE(adapter_->IsInitialized()); + if (base::MessageLoop::current() && + base::MessageLoop::current()->is_running()) { + base::MessageLoop::current()->QuitWhenIdle(); + } } scoped_ptr<BluetoothAdvertisement::Data> CreateAdvertisementData() { diff --git a/device/bluetooth/bluetooth_audio_sink_bluez_unittest.cc b/device/bluetooth/bluetooth_audio_sink_bluez_unittest.cc index 25b53d5..235ba2d 100644 --- a/device/bluetooth/bluetooth_audio_sink_bluez_unittest.cc +++ b/device/bluetooth/bluetooth_audio_sink_bluez_unittest.cc @@ -132,6 +132,7 @@ class BluetoothAudioSinkBlueZTest : public testing::Test { BluetoothAdapterFactory::GetAdapter( base::Bind(&BluetoothAudioSinkBlueZTest::GetAdapterCallback, base::Unretained(this))); + base::MessageLoop::current()->Run(); } // Called whenever BluetoothAdapter is retrieved successfully. @@ -152,6 +153,11 @@ class BluetoothAudioSinkBlueZTest : public testing::Test { // Resets callback_count_. --callback_count_; + + if (base::MessageLoop::current() && + base::MessageLoop::current()->is_running()) { + base::MessageLoop::current()->QuitWhenIdle(); + } } // Registers BluetoothAudioSinkBlueZ with default codec and capabilities. diff --git a/device/bluetooth/bluetooth_bluez_unittest.cc b/device/bluetooth/bluetooth_bluez_unittest.cc index f99caab..f2823dd 100644 --- a/device/bluetooth/bluetooth_bluez_unittest.cc +++ b/device/bluetooth/bluetooth_bluez_unittest.cc @@ -6,6 +6,7 @@ #include <stdint.h> #include <utility> +#include "base/bind_helpers.h" #include "base/memory/scoped_vector.h" #include "base/message_loop/message_loop.h" #include "base/run_loop.h" @@ -231,6 +232,8 @@ class BluetoothBlueZTest : public testing::Test { return base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)); } + void AdapterCallback() { QuitMessageLoop(); } + void DiscoverySessionCallback( scoped_ptr<BluetoothDiscoverySession> discovery_session) { ++callback_count_; @@ -293,7 +296,9 @@ class BluetoothBlueZTest : public testing::Test { // Call to fill the adapter_ member with a BluetoothAdapter instance. void GetAdapter() { - adapter_ = new BluetoothAdapterBlueZ(); + adapter_ = new BluetoothAdapterBlueZ(base::Bind( + &BluetoothBlueZTest::AdapterCallback, base::Unretained(this))); + base::MessageLoop::current()->Run(); ASSERT_TRUE(adapter_.get() != nullptr); ASSERT_TRUE(adapter_->IsInitialized()); } diff --git a/device/bluetooth/bluetooth_gatt_bluez_unittest.cc b/device/bluetooth/bluetooth_gatt_bluez_unittest.cc index 43daec0..6ae2d05 100644 --- a/device/bluetooth/bluetooth_gatt_bluez_unittest.cc +++ b/device/bluetooth/bluetooth_gatt_bluez_unittest.cc @@ -121,6 +121,7 @@ class BluetoothGattBlueZTest : public testing::Test { void GetAdapter() { device::BluetoothAdapterFactory::GetAdapter(base::Bind( &BluetoothGattBlueZTest::AdapterCallback, base::Unretained(this))); + base::MessageLoop::current()->Run(); ASSERT_TRUE(adapter_.get() != NULL); ASSERT_TRUE(adapter_->IsInitialized()); ASSERT_TRUE(adapter_->IsPresent()); @@ -128,6 +129,10 @@ class BluetoothGattBlueZTest : public testing::Test { void AdapterCallback(scoped_refptr<BluetoothAdapter> adapter) { adapter_ = adapter; + if (base::MessageLoop::current() && + base::MessageLoop::current()->is_running()) { + base::MessageLoop::current()->QuitWhenIdle(); + } } void SuccessCallback() { ++success_callback_count_; } diff --git a/device/bluetooth/bluetooth_socket_bluez_unittest.cc b/device/bluetooth/bluetooth_socket_bluez_unittest.cc index 171d77d..80585bc 100644 --- a/device/bluetooth/bluetooth_socket_bluez_unittest.cc +++ b/device/bluetooth/bluetooth_socket_bluez_unittest.cc @@ -78,6 +78,9 @@ class BluetoothSocketBlueZTest : public testing::Test { // Grab a pointer to the adapter. device::BluetoothAdapterFactory::GetAdapter(base::Bind( &BluetoothSocketBlueZTest::AdapterCallback, base::Unretained(this))); + + base::MessageLoop::current()->Run(); + ASSERT_TRUE(adapter_.get() != nullptr); ASSERT_TRUE(adapter_->IsInitialized()); ASSERT_TRUE(adapter_->IsPresent()); @@ -96,6 +99,10 @@ class BluetoothSocketBlueZTest : public testing::Test { void AdapterCallback(scoped_refptr<BluetoothAdapter> adapter) { adapter_ = adapter; + if (base::MessageLoop::current() && + base::MessageLoop::current()->is_running()) { + base::MessageLoop::current()->QuitWhenIdle(); + } } void SuccessCallback() { diff --git a/device/bluetooth/dbus/bluetooth_agent_service_provider.cc b/device/bluetooth/dbus/bluetooth_agent_service_provider.cc index 1bafcb0..ba51ba8 100644 --- a/device/bluetooth/dbus/bluetooth_agent_service_provider.cc +++ b/device/bluetooth/dbus/bluetooth_agent_service_provider.cc @@ -437,11 +437,10 @@ BluetoothAgentServiceProvider* BluetoothAgentServiceProvider::Create( dbus::Bus* bus, const dbus::ObjectPath& object_path, Delegate* delegate) { - if (!bluez::BluezDBusManager::Get()->IsUsingStub()) { + if (!bluez::BluezDBusManager::Get()->IsUsingFakes()) { return new BluetoothAgentServiceProviderImpl(bus, object_path, delegate); - } else { - return new FakeBluetoothAgentServiceProvider(object_path, delegate); } + return new FakeBluetoothAgentServiceProvider(object_path, delegate); } } // namespace bluez diff --git a/device/bluetooth/dbus/bluetooth_dbus_client_bundle.cc b/device/bluetooth/dbus/bluetooth_dbus_client_bundle.cc index 1d53d8a..5e2fffd 100644 --- a/device/bluetooth/dbus/bluetooth_dbus_client_bundle.cc +++ b/device/bluetooth/dbus/bluetooth_dbus_client_bundle.cc @@ -36,9 +36,9 @@ namespace bluez { -BluetoothDBusClientBundle::BluetoothDBusClientBundle(bool use_stubs) - : use_stubs_(use_stubs) { - if (!use_stubs) { +BluetoothDBusClientBundle::BluetoothDBusClientBundle(bool use_fakes) + : use_fakes_(use_fakes) { + if (!use_fakes_) { bluetooth_adapter_client_.reset(BluetoothAdapterClient::Create()); bluetooth_le_advertising_manager_client_.reset( BluetoothLEAdvertisingManagerClient::Create()); diff --git a/device/bluetooth/dbus/bluetooth_dbus_client_bundle.h b/device/bluetooth/dbus/bluetooth_dbus_client_bundle.h index 3beef61..2cd102e 100644 --- a/device/bluetooth/dbus/bluetooth_dbus_client_bundle.h +++ b/device/bluetooth/dbus/bluetooth_dbus_client_bundle.h @@ -31,11 +31,11 @@ class BluetoothProfileManagerClient; // system bus. See also the comment in the destructor of DBusThreadManager. class DEVICE_BLUETOOTH_EXPORT BluetoothDBusClientBundle { public: - explicit BluetoothDBusClientBundle(bool use_stubs); + explicit BluetoothDBusClientBundle(bool use_fakes); ~BluetoothDBusClientBundle(); // Returns true if |client| is stubbed. - bool IsUsingStub() { return use_stubs_; } + bool IsUsingFakes() { return use_fakes_; } BluetoothAdapterClient* bluetooth_adapter_client() { return bluetooth_adapter_client_.get(); @@ -89,7 +89,7 @@ class DEVICE_BLUETOOTH_EXPORT BluetoothDBusClientBundle { private: friend class BluezDBusManagerSetter; - bool use_stubs_; + bool use_fakes_; scoped_ptr<BluetoothAdapterClient> bluetooth_adapter_client_; scoped_ptr<BluetoothLEAdvertisingManagerClient> diff --git a/device/bluetooth/dbus/bluetooth_gatt_characteristic_service_provider.cc b/device/bluetooth/dbus/bluetooth_gatt_characteristic_service_provider.cc index bd578532..da27bd5 100644 --- a/device/bluetooth/dbus/bluetooth_gatt_characteristic_service_provider.cc +++ b/device/bluetooth/dbus/bluetooth_gatt_characteristic_service_provider.cc @@ -457,7 +457,7 @@ BluetoothGattCharacteristicServiceProvider::Create( const std::vector<std::string>& flags, const std::vector<std::string>& permissions, const dbus::ObjectPath& service_path) { - if (!bluez::BluezDBusManager::Get()->IsUsingStub()) { + if (!bluez::BluezDBusManager::Get()->IsUsingFakes()) { return new BluetoothGattCharacteristicServiceProviderImpl( bus, object_path, delegate, uuid, flags, permissions, service_path); } diff --git a/device/bluetooth/dbus/bluetooth_gatt_descriptor_service_provider.cc b/device/bluetooth/dbus/bluetooth_gatt_descriptor_service_provider.cc index 53cc7f1..25a4e4c 100644 --- a/device/bluetooth/dbus/bluetooth_gatt_descriptor_service_provider.cc +++ b/device/bluetooth/dbus/bluetooth_gatt_descriptor_service_provider.cc @@ -450,7 +450,7 @@ BluetoothGattDescriptorServiceProvider::Create( const std::string& uuid, const std::vector<std::string>& permissions, const dbus::ObjectPath& characteristic_path) { - if (!bluez::BluezDBusManager::Get()->IsUsingStub()) { + if (!bluez::BluezDBusManager::Get()->IsUsingFakes()) { return new BluetoothGattDescriptorServiceProviderImpl( bus, object_path, delegate, uuid, permissions, characteristic_path); } diff --git a/device/bluetooth/dbus/bluetooth_gatt_service_service_provider.cc b/device/bluetooth/dbus/bluetooth_gatt_service_service_provider.cc index c30587f..dc66fd0 100644 --- a/device/bluetooth/dbus/bluetooth_gatt_service_service_provider.cc +++ b/device/bluetooth/dbus/bluetooth_gatt_service_service_provider.cc @@ -264,7 +264,7 @@ BluetoothGattServiceServiceProvider::Create( const dbus::ObjectPath& object_path, const std::string& uuid, const std::vector<dbus::ObjectPath>& includes) { - if (!bluez::BluezDBusManager::Get()->IsUsingStub()) { + if (!bluez::BluezDBusManager::Get()->IsUsingFakes()) { return new BluetoothGattServiceServiceProviderImpl(bus, object_path, uuid, includes); } diff --git a/device/bluetooth/dbus/bluetooth_le_advertisement_service_provider.cc b/device/bluetooth/dbus/bluetooth_le_advertisement_service_provider.cc index b5e6f81..6081112 100644 --- a/device/bluetooth/dbus/bluetooth_le_advertisement_service_provider.cc +++ b/device/bluetooth/dbus/bluetooth_le_advertisement_service_provider.cc @@ -413,15 +413,14 @@ BluetoothLEAdvertisementServiceProvider::Create( scoped_ptr<ManufacturerData> manufacturer_data, scoped_ptr<UUIDList> solicit_uuids, scoped_ptr<ServiceData> service_data) { - if (!bluez::BluezDBusManager::Get()->IsUsingStub()) { + if (!bluez::BluezDBusManager::Get()->IsUsingFakes()) { return make_scoped_ptr(new BluetoothAdvertisementServiceProviderImpl( bus, object_path, delegate, type, std::move(service_uuids), std::move(manufacturer_data), std::move(solicit_uuids), std::move(service_data))); - } else { - return make_scoped_ptr( - new FakeBluetoothLEAdvertisementServiceProvider(object_path, delegate)); } + return make_scoped_ptr( + new FakeBluetoothLEAdvertisementServiceProvider(object_path, delegate)); } } // namespace bluez diff --git a/device/bluetooth/dbus/bluetooth_media_endpoint_service_provider.cc b/device/bluetooth/dbus/bluetooth_media_endpoint_service_provider.cc index 5a0d17f..7a9ce59 100644 --- a/device/bluetooth/dbus/bluetooth_media_endpoint_service_provider.cc +++ b/device/bluetooth/dbus/bluetooth_media_endpoint_service_provider.cc @@ -306,7 +306,7 @@ BluetoothMediaEndpointServiceProvider::Create( const dbus::ObjectPath& object_path, Delegate* delegate) { // Returns a real implementation. - if (!bluez::BluezDBusManager::Get()->IsUsingStub()) { + if (!bluez::BluezDBusManager::Get()->IsUsingFakes()) { return new BluetoothMediaEndpointServiceProviderImpl(bus, object_path, delegate); } diff --git a/device/bluetooth/dbus/bluetooth_profile_service_provider.cc b/device/bluetooth/dbus/bluetooth_profile_service_provider.cc index 4d2845d..ef6dc8d 100644 --- a/device/bluetooth/dbus/bluetooth_profile_service_provider.cc +++ b/device/bluetooth/dbus/bluetooth_profile_service_provider.cc @@ -241,11 +241,10 @@ BluetoothProfileServiceProvider* BluetoothProfileServiceProvider::Create( dbus::Bus* bus, const dbus::ObjectPath& object_path, Delegate* delegate) { - if (!bluez::BluezDBusManager::Get()->IsUsingStub()) { + if (!bluez::BluezDBusManager::Get()->IsUsingFakes()) { return new BluetoothProfileServiceProviderImpl(bus, object_path, delegate); - } else { - return new FakeBluetoothProfileServiceProvider(object_path, delegate); } + return new FakeBluetoothProfileServiceProvider(object_path, delegate); } } // namespace bluez diff --git a/device/bluetooth/dbus/bluez_dbus_manager.cc b/device/bluetooth/dbus/bluez_dbus_manager.cc index 9736f67..8c0690e 100644 --- a/device/bluetooth/dbus/bluez_dbus_manager.cc +++ b/device/bluetooth/dbus/bluez_dbus_manager.cc @@ -11,6 +11,9 @@ #include "base/threading/thread.h" #include "dbus/bus.h" #include "dbus/dbus_statistics.h" +#include "dbus/message.h" +#include "dbus/object_manager.h" +#include "dbus/object_proxy.h" #include "device/bluetooth/dbus/bluetooth_adapter_client.h" #include "device/bluetooth/dbus/bluetooth_agent_manager_client.h" #include "device/bluetooth/dbus/bluetooth_device_client.h" @@ -23,16 +26,48 @@ #include "device/bluetooth/dbus/bluetooth_media_client.h" #include "device/bluetooth/dbus/bluetooth_media_transport_client.h" #include "device/bluetooth/dbus/bluetooth_profile_manager_client.h" +#include "third_party/cros_system_api/dbus/service_constants.h" namespace bluez { static BluezDBusManager* g_bluez_dbus_manager = nullptr; static bool g_using_bluez_dbus_manager_for_testing = false; -BluezDBusManager::BluezDBusManager( - dbus::Bus* bus, - scoped_ptr<BluetoothDBusClientBundle> client_bundle) - : bus_(bus), client_bundle_(std::move(client_bundle)) {} +BluezDBusManager::BluezDBusManager(dbus::Bus* bus, bool use_dbus_fakes) + : bus_(bus), + object_manager_support_known_(false), + object_manager_supported_(false), + weak_ptr_factory_(this) { + // On Chrome OS, Bluez might not be ready by the time we initialize the + // BluezDBusManager so we initialize the clients anyway. + bool should_check_object_manager = true; +#if defined(OS_CHROMEOS) + should_check_object_manager = false; +#endif + + if (!should_check_object_manager || use_dbus_fakes) { + client_bundle_.reset(new BluetoothDBusClientBundle(use_dbus_fakes)); + InitializeClients(); + object_manager_supported_ = true; + object_manager_support_known_ = true; + return; + } + + CHECK(GetSystemBus()) << "Can't initialize real clients without DBus."; + dbus::MethodCall method_call(dbus::kObjectManagerInterface, + dbus::kObjectManagerGetManagedObjects); + GetSystemBus() + ->GetObjectProxy( + bluetooth_object_manager::kBluetoothObjectManagerServiceName, + dbus::ObjectPath( + bluetooth_object_manager::kBluetoothObjectManagerServicePath)) + ->CallMethodWithErrorCallback( + &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, + base::Bind(&BluezDBusManager::OnObjectManagerSupported, + weak_ptr_factory_.GetWeakPtr()), + base::Bind(&BluezDBusManager::OnObjectManagerNotSupported, + weak_ptr_factory_.GetWeakPtr())); +} BluezDBusManager::~BluezDBusManager() { // Delete all D-Bus clients before shutting down the system bus. @@ -43,75 +78,121 @@ dbus::Bus* bluez::BluezDBusManager::GetSystemBus() { return bus_; } +void BluezDBusManager::CallWhenObjectManagerSupportIsKnown( + base::Closure callback) { + object_manager_support_known_callback_ = callback; +} + BluetoothAdapterClient* bluez::BluezDBusManager::GetBluetoothAdapterClient() { + DCHECK(object_manager_support_known_); return client_bundle_->bluetooth_adapter_client(); } BluetoothLEAdvertisingManagerClient* bluez::BluezDBusManager::GetBluetoothLEAdvertisingManagerClient() { + DCHECK(object_manager_support_known_); return client_bundle_->bluetooth_le_advertising_manager_client(); } BluetoothAgentManagerClient* bluez::BluezDBusManager::GetBluetoothAgentManagerClient() { + DCHECK(object_manager_support_known_); return client_bundle_->bluetooth_agent_manager_client(); } BluetoothDeviceClient* bluez::BluezDBusManager::GetBluetoothDeviceClient() { + DCHECK(object_manager_support_known_); return client_bundle_->bluetooth_device_client(); } BluetoothGattCharacteristicClient* bluez::BluezDBusManager::GetBluetoothGattCharacteristicClient() { + DCHECK(object_manager_support_known_); return client_bundle_->bluetooth_gatt_characteristic_client(); } BluetoothGattDescriptorClient* bluez::BluezDBusManager::GetBluetoothGattDescriptorClient() { + DCHECK(object_manager_support_known_); return client_bundle_->bluetooth_gatt_descriptor_client(); } BluetoothGattManagerClient* bluez::BluezDBusManager::GetBluetoothGattManagerClient() { + DCHECK(object_manager_support_known_); return client_bundle_->bluetooth_gatt_manager_client(); } BluetoothGattServiceClient* bluez::BluezDBusManager::GetBluetoothGattServiceClient() { + DCHECK(object_manager_support_known_); return client_bundle_->bluetooth_gatt_service_client(); } BluetoothInputClient* bluez::BluezDBusManager::GetBluetoothInputClient() { + DCHECK(object_manager_support_known_); return client_bundle_->bluetooth_input_client(); } BluetoothMediaClient* bluez::BluezDBusManager::GetBluetoothMediaClient() { + DCHECK(object_manager_support_known_); return client_bundle_->bluetooth_media_client(); } BluetoothMediaTransportClient* bluez::BluezDBusManager::GetBluetoothMediaTransportClient() { + DCHECK(object_manager_support_known_); return client_bundle_->bluetooth_media_transport_client(); } BluetoothProfileManagerClient* bluez::BluezDBusManager::GetBluetoothProfileManagerClient() { + DCHECK(object_manager_support_known_); return client_bundle_->bluetooth_profile_manager_client(); } +void BluezDBusManager::OnObjectManagerSupported(dbus::Response* response) { + VLOG(1) << "Bluetooth supported. Initializing clients."; + object_manager_supported_ = true; + + client_bundle_.reset(new BluetoothDBusClientBundle(false /* use_fakes */)); + InitializeClients(); + + object_manager_support_known_ = true; + if (!object_manager_support_known_callback_.is_null()) { + object_manager_support_known_callback_.Run(); + object_manager_support_known_callback_.Reset(); + } +} + +void BluezDBusManager::OnObjectManagerNotSupported( + dbus::ErrorResponse* response) { + VLOG(1) << "Bluetooth not supported."; + object_manager_supported_ = false; + + // We don't initialize clients since the clients need ObjectManager. + + object_manager_support_known_ = true; + if (!object_manager_support_known_callback_.is_null()) { + object_manager_support_known_callback_.Run(); + object_manager_support_known_callback_.Reset(); + } +} + void BluezDBusManager::InitializeClients() { - GetBluetoothAdapterClient()->Init(GetSystemBus()); - GetBluetoothAgentManagerClient()->Init(GetSystemBus()); - GetBluetoothDeviceClient()->Init(GetSystemBus()); - GetBluetoothGattCharacteristicClient()->Init(GetSystemBus()); - GetBluetoothGattDescriptorClient()->Init(GetSystemBus()); - GetBluetoothGattManagerClient()->Init(GetSystemBus()); - GetBluetoothGattServiceClient()->Init(GetSystemBus()); - GetBluetoothInputClient()->Init(GetSystemBus()); - GetBluetoothLEAdvertisingManagerClient()->Init(GetSystemBus()); - GetBluetoothMediaClient()->Init(GetSystemBus()); - GetBluetoothMediaTransportClient()->Init(GetSystemBus()); - GetBluetoothProfileManagerClient()->Init(GetSystemBus()); + client_bundle_->bluetooth_adapter_client()->Init(GetSystemBus()); + client_bundle_->bluetooth_agent_manager_client()->Init(GetSystemBus()); + client_bundle_->bluetooth_device_client()->Init(GetSystemBus()); + client_bundle_->bluetooth_gatt_characteristic_client()->Init(GetSystemBus()); + client_bundle_->bluetooth_gatt_descriptor_client()->Init(GetSystemBus()); + client_bundle_->bluetooth_gatt_manager_client()->Init(GetSystemBus()); + client_bundle_->bluetooth_gatt_service_client()->Init(GetSystemBus()); + client_bundle_->bluetooth_input_client()->Init(GetSystemBus()); + client_bundle_->bluetooth_le_advertising_manager_client()->Init( + GetSystemBus()); + client_bundle_->bluetooth_media_client()->Init(GetSystemBus()); + client_bundle_->bluetooth_media_transport_client()->Init(GetSystemBus()); + client_bundle_->bluetooth_profile_manager_client()->Init(GetSystemBus()); // This must be called after the list of clients so they've each had a // chance to register with their object g_dbus_thread_managers. @@ -144,9 +225,7 @@ bluez::BluezDBusManager::GetSetterForTesting() { // static void BluezDBusManager::CreateGlobalInstance(dbus::Bus* bus, bool use_stubs) { CHECK(!g_bluez_dbus_manager); - g_bluez_dbus_manager = new BluezDBusManager( - bus, make_scoped_ptr(new BluetoothDBusClientBundle(use_stubs))); - g_bluez_dbus_manager->InitializeClients(); + g_bluez_dbus_manager = new BluezDBusManager(bus, use_stubs); } // static diff --git a/device/bluetooth/dbus/bluez_dbus_manager.h b/device/bluetooth/dbus/bluez_dbus_manager.h index fe879c4..9ebe6b3 100644 --- a/device/bluetooth/dbus/bluez_dbus_manager.h +++ b/device/bluetooth/dbus/bluez_dbus_manager.h @@ -11,12 +11,15 @@ #include "base/macros.h" #include "base/memory/ref_counted.h" #include "base/memory/scoped_ptr.h" +#include "base/memory/weak_ptr.h" #include "device/bluetooth/bluetooth_export.h" #include "device/bluetooth/dbus/bluetooth_dbus_client_bundle.h" namespace dbus { class Bus; class ObjectPath; +class Response; +class ErrorResponse; } // namespace dbus namespace bluez { @@ -56,9 +59,10 @@ class DEVICE_BLUETOOTH_EXPORT BluezDBusManager { // Sets the global instance. Must be called before any calls to Get(). // We explicitly initialize and shut down the global object, rather than // making it a Singleton, to ensure clean startup and shutdown. - // This will initialize real or stub DBusClients depending on command-line - // arguments and whether this process runs in a real or test environment. - static void Initialize(dbus::Bus* bus, bool use_dbus_stub); + // This will initialize real, stub, or fake DBusClients depending on + // command-line arguments, whether Object Manager is supported and + // whether this process runs in a real or test environment. + static void Initialize(dbus::Bus* bus, bool use_dbus_fakes); // Returns a BluezDBusManagerSetter instance that allows tests to // replace individual D-Bus clients with their own implementations. @@ -75,12 +79,23 @@ class DEVICE_BLUETOOTH_EXPORT BluezDBusManager { // Gets the global instance. Initialize() must be called first. static BluezDBusManager* Get(); - // Returns true if |client| is stubbed. - bool IsUsingStub() { return client_bundle_->IsUsingStub(); } - // Returns various D-Bus bus instances, owned by BluezDBusManager. dbus::Bus* GetSystemBus(); + // Returns true once we know whether Object Manager is supported or not. + // Until this method returns true, no classes should try to use the + // DBus Clients. + bool IsObjectManagerSupportKnown() { return object_manager_support_known_; } + + // Calls |callback| once we know whether Object Manager is supported or not. + void CallWhenObjectManagerSupportIsKnown(base::Closure callback); + + // Returns true if Object Manager is supported. + bool IsObjectManagerSupported() { return object_manager_supported_; } + + // Returns true if |client| is fake. + bool IsUsingFakes() { return client_bundle_->IsUsingFakes(); } + // All returned objects are owned by BluezDBusManager. Do not use these // pointers after BluezDBusManager has been shut down. BluetoothAdapterClient* GetBluetoothAdapterClient(); @@ -101,15 +116,16 @@ class DEVICE_BLUETOOTH_EXPORT BluezDBusManager { // Creates a new BluezDBusManager using the DBusClients set in // |client_bundle|. - explicit BluezDBusManager( - dbus::Bus* bus, - scoped_ptr<BluetoothDBusClientBundle> client_bundle); + explicit BluezDBusManager(dbus::Bus* bus, bool use_stubs); ~BluezDBusManager(); // Creates a global instance of BluezDBusManager. Cannot be called more than // once. static void CreateGlobalInstance(dbus::Bus* bus, bool use_stubs); + void OnObjectManagerSupported(dbus::Response* response); + void OnObjectManagerNotSupported(dbus::ErrorResponse* response); + // Initializes all currently stored DBusClients with the system bus and // performs additional setup. void InitializeClients(); @@ -117,6 +133,15 @@ class DEVICE_BLUETOOTH_EXPORT BluezDBusManager { dbus::Bus* bus_; scoped_ptr<BluetoothDBusClientBundle> client_bundle_; + base::Closure object_manager_support_known_callback_; + + bool object_manager_support_known_; + bool object_manager_supported_; + + // Note: This should remain the last member so it'll be destroyed and + // invalidate its weak pointers before any other members are destroyed. + base::WeakPtrFactory<BluezDBusManager> weak_ptr_factory_; + DISALLOW_COPY_AND_ASSIGN(BluezDBusManager); }; |