Refactor DBusThreadManager to split away BT clients.

device/bluetooth/dbus/bluetooth_media_endpoint_service_provider.cc

 // Copyright 2014 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 "chromeos/dbus/bluetooth_media_endpoint_service_provider.h"
+#include "device/bluetooth/dbus/bluetooth_media_endpoint_service_provider.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/platform_thread.h"
-#include "chromeos/dbus/bluetooth_media_transport_client.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/fake_bluetooth_media_endpoint_service_provider.h"
 #include "dbus/exported_object.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_endpoint_service_provider.h"
 
 namespace {
 
 // TODO(mcchou): Move these constants to dbus/service_constants.h.
 // Bluetooth Media Endpoint service identifier.
 const char kBluetoothMediaEndpointInterface[] = "org.bluez.MediaEndpoint1";
 
 // Method names in Bluetooth Media Endpoint interface.
 const char kSetConfiguration[] = "SetConfiguration";
 const char kSelectConfiguration[] = "SelectConfiguration";
 const char kClearConfiguration[] = "ClearConfiguration";
 const char kRelease[] = "Release";
 
 const uint8_t kInvalidCodec = 0xff;
 const char kInvalidState[] = "unknown";
 
 }  // namespace
 
-namespace chromeos {
+namespace bluez {
 
 // The BluetoothMediaEndopintServiceProvider implementation used in production.
-class CHROMEOS_EXPORT BluetoothMediaEndpointServiceProviderImpl
+class DEVICE_BLUETOOTH_EXPORT BluetoothMediaEndpointServiceProviderImpl
     : public BluetoothMediaEndpointServiceProvider {
  public:
   BluetoothMediaEndpointServiceProviderImpl(dbus::Bus* bus,
                                             const dbus::ObjectPath& object_path,
                                             Delegate* delegate)
       : origin_thread_id_(base::PlatformThread::CurrentId()),
         bus_(bus),
         delegate_(delegate),
         object_path_(object_path),
         weak_ptr_factory_(this) {
     VLOG(1) << "Creating Bluetooth Media Endpoint: " << object_path_.value();
     DCHECK(bus_);
     DCHECK(delegate_);
     DCHECK(object_path_.IsValid());
 
     exported_object_ = bus_->GetExportedObject(object_path_);
 
     exported_object_->ExportMethod(
-        kBluetoothMediaEndpointInterface,
-        kSetConfiguration,
-        base::Bind(
-            &BluetoothMediaEndpointServiceProviderImpl::SetConfiguration,
-            weak_ptr_factory_.GetWeakPtr()),
+        kBluetoothMediaEndpointInterface, kSetConfiguration,
+        base::Bind(&BluetoothMediaEndpointServiceProviderImpl::SetConfiguration,
+                   weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&BluetoothMediaEndpointServiceProviderImpl::OnExported,
                    weak_ptr_factory_.GetWeakPtr()));
 
     exported_object_->ExportMethod(
-        kBluetoothMediaEndpointInterface,
-        kSelectConfiguration,
+        kBluetoothMediaEndpointInterface, kSelectConfiguration,
         base::Bind(
             &BluetoothMediaEndpointServiceProviderImpl::SelectConfiguration,
             weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&BluetoothMediaEndpointServiceProviderImpl::OnExported,
                    weak_ptr_factory_.GetWeakPtr()));
 
     exported_object_->ExportMethod(
-        kBluetoothMediaEndpointInterface,
-        kClearConfiguration,
+        kBluetoothMediaEndpointInterface, kClearConfiguration,
         base::Bind(
             &BluetoothMediaEndpointServiceProviderImpl::ClearConfiguration,
             weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&BluetoothMediaEndpointServiceProviderImpl::OnExported,
                    weak_ptr_factory_.GetWeakPtr()));
 
     exported_object_->ExportMethod(
-        kBluetoothMediaEndpointInterface,
-        kRelease,
+        kBluetoothMediaEndpointInterface, kRelease,
         base::Bind(&BluetoothMediaEndpointServiceProviderImpl::Release,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&BluetoothMediaEndpointServiceProviderImpl::OnExported,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   ~BluetoothMediaEndpointServiceProviderImpl() override {
-    VLOG(1) << "Cleaning up Bluetooth Media Endpoint: "
-            << object_path_.value();
+    VLOG(1) << "Cleaning up Bluetooth Media Endpoint: " << object_path_.value();
 
     bus_->UnregisterExportedObject(object_path_);
   }
 
  private:
   // Returns true if the current thread is on the origin thread, false
   // otherwise.
   bool OnOriginThread() const {
     return base::PlatformThread::CurrentId() == origin_thread_id_;
   }
@@ skipping 87 matching lines @@
                  << method_call->ToString();
       return;
     }
 
     std::vector<uint8_t> configuration(capabilities, capabilities + length);
 
     // |delegate_| generates the response to |SelectConfiguration| and sends it
     // back via |callback|.
     Delegate::SelectConfigurationCallback callback = base::Bind(
         &BluetoothMediaEndpointServiceProviderImpl::OnConfiguration,
-        weak_ptr_factory_.GetWeakPtr(),
-        method_call,
-        response_sender);
+        weak_ptr_factory_.GetWeakPtr(), method_call, response_sender);
 
     delegate_->SelectConfiguration(configuration, callback);
   }
 
   // Called by dbus:: when the remote device is about to close the connection.
   void ClearConfiguration(
       dbus::MethodCall* method_call,
       dbus::ExportedObject::ResponseSender response_sender) {
     VLOG(1) << "ClearConfiguration";
 
@@ skipping 72 matching lines @@
   // Note This should remain the last member so it'll be destroyed and
   // invalidate it's weak pointers before any other members are destroyed.
   base::WeakPtrFactory<BluetoothMediaEndpointServiceProviderImpl>
       weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothMediaEndpointServiceProviderImpl);
 };
 
 BluetoothMediaEndpointServiceProvider::Delegate::TransportProperties::
     TransportProperties()
-    : codec(kInvalidCodec),
-      state(kInvalidState) {
-}
+    : codec(kInvalidCodec), state(kInvalidState) {}
 
 BluetoothMediaEndpointServiceProvider::Delegate::TransportProperties::
-    ~TransportProperties() {
-}
+    ~TransportProperties() {}
 
 BluetoothMediaEndpointServiceProvider::BluetoothMediaEndpointServiceProvider() {
 }
 
 BluetoothMediaEndpointServiceProvider::
-    ~BluetoothMediaEndpointServiceProvider() {
-}
+    ~BluetoothMediaEndpointServiceProvider() {}
 
 BluetoothMediaEndpointServiceProvider*
-    BluetoothMediaEndpointServiceProvider::Create(
+BluetoothMediaEndpointServiceProvider::Create(
     dbus::Bus* bus,
     const dbus::ObjectPath& object_path,
     Delegate* delegate) {
   // Returns a real implementation.
-  if (!DBusThreadManager::Get()->IsUsingStub(DBusClientBundle::BLUETOOTH)) {
-    return new BluetoothMediaEndpointServiceProviderImpl(
-        bus, object_path, delegate);
+  if (!bluez::BluezDBusManager::Get()->IsUsingStub()) {
+    return new BluetoothMediaEndpointServiceProviderImpl(bus, object_path,
+                                                         delegate);
   }
   // Returns a fake implementation.
   return new FakeBluetoothMediaEndpointServiceProvider(object_path, delegate);
 }
 
-}  // namespace chromeos
+}  // namespace bluez