Refactor DBusThreadManager to split away BT clients.

device/bluetooth/dbus/bluetooth_profile_service_provider.cc

 // Copyright 2013 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_profile_service_provider.h"
-
+#include "device/bluetooth/dbus/bluetooth_profile_service_provider.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/threading/platform_thread.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/fake_bluetooth_profile_service_provider.h"
 #include "dbus/exported_object.h"
 #include "dbus/message.h"
+#include "device/bluetooth/dbus/bluez_dbus_manager.h"
+#include "device/bluetooth/dbus/fake_bluetooth_profile_service_provider.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
-namespace chromeos {
+namespace bluez {
 
 // The BluetoothProfileServiceProvider implementation used in production.
 class BluetoothProfileServiceProviderImpl
     : public BluetoothProfileServiceProvider {
  public:
   BluetoothProfileServiceProviderImpl(dbus::Bus* bus,
                                       const dbus::ObjectPath& object_path,
                                       Delegate* delegate)
       : origin_thread_id_(base::PlatformThread::CurrentId()),
         bus_(bus),
@@ skipping 92 matching lines @@
       } else {
         if (key == bluetooth_profile::kVersionProperty)
           dict_entry_reader.PopVariantOfUint16(&options.version);
         else if (key == bluetooth_profile::kFeaturesProperty)
           dict_entry_reader.PopVariantOfUint16(&options.features);
       }
     }
 
     Delegate::ConfirmationCallback callback = base::Bind(
         &BluetoothProfileServiceProviderImpl::OnConfirmation,
-        weak_ptr_factory_.GetWeakPtr(),
-        method_call,
-        response_sender);
+        weak_ptr_factory_.GetWeakPtr(), method_call, response_sender);
 
     delegate_->NewConnection(device_path, fd.Pass(), options, callback);
   }
 
   // Called by dbus:: when the Bluetooth daemon is about to disconnect the
   // profile.
   void RequestDisconnection(
       dbus::MethodCall* method_call,
       dbus::ExportedObject::ResponseSender response_sender) {
     DCHECK(OnOriginThread());
     DCHECK(delegate_);
 
     dbus::MessageReader reader(method_call);
     dbus::ObjectPath device_path;
     if (!reader.PopObjectPath(&device_path)) {
       LOG(WARNING) << "RequestDisconnection called with incorrect paramters: "
                    << method_call->ToString();
       return;
     }
 
     Delegate::ConfirmationCallback callback = base::Bind(
         &BluetoothProfileServiceProviderImpl::OnConfirmation,
-        weak_ptr_factory_.GetWeakPtr(),
-        method_call,
-        response_sender);
+        weak_ptr_factory_.GetWeakPtr(), method_call, response_sender);
 
     delegate_->RequestDisconnection(device_path, callback);
   }
 
   // Called by dbus:: when the request failed before a reply was returned
   // from the device.
   void Cancel(dbus::MethodCall* method_call,
               dbus::ExportedObject::ResponseSender response_sender) {
     DCHECK(OnOriginThread());
     DCHECK(delegate_);
 
     delegate_->Cancel();
 
     response_sender.Run(dbus::Response::FromMethodCall(method_call));
   }
 
   // Called by dbus:: when a method is exported.
   void OnExported(const std::string& interface_name,
                   const std::string& method_name,
                   bool success) {
-    LOG_IF(WARNING, !success) << "Failed to export "
-                              << interface_name << "." << method_name;
+    LOG_IF(WARNING, !success) << "Failed to export " << interface_name << "."
+                              << method_name;
   }
 
   // Called by the Delegate in response to a method requiring confirmation.
   void OnConfirmation(dbus::MethodCall* method_call,
                       dbus::ExportedObject::ResponseSender response_sender,
                       Delegate::Status status) {
     DCHECK(OnOriginThread());
 
     switch (status) {
       case Delegate::SUCCESS: {
@@ skipping 36 matching lines @@
 
   // Weak pointer factory for generating 'this' pointers that might live longer
   // than we do.
   // 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<BluetoothProfileServiceProviderImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothProfileServiceProviderImpl);
 };
 
-BluetoothProfileServiceProvider::BluetoothProfileServiceProvider() {
-}
+BluetoothProfileServiceProvider::BluetoothProfileServiceProvider() {}
 
-BluetoothProfileServiceProvider::~BluetoothProfileServiceProvider() {
-}
+BluetoothProfileServiceProvider::~BluetoothProfileServiceProvider() {}
 
 // static
 BluetoothProfileServiceProvider* BluetoothProfileServiceProvider::Create(
     dbus::Bus* bus,
     const dbus::ObjectPath& object_path,
     Delegate* delegate) {
-  if (!DBusThreadManager::Get()->IsUsingStub(DBusClientBundle::BLUETOOTH)) {
+  if (!bluez::BluezDBusManager::Get()->IsUsingStub()) {
     return new BluetoothProfileServiceProviderImpl(bus, object_path, delegate);
   } else {
     return new FakeBluetoothProfileServiceProvider(object_path, delegate);
   }
 }
 
-}  // namespace chromeos
+}  // namespace bluez