Refactor DBusThreadManager to split away BT clients.

device/bluetooth/dbus/fake_bluetooth_media_transport_client.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/fake_bluetooth_media_transport_client.h"
+#include "device/bluetooth/dbus/fake_bluetooth_media_transport_client.h"
 
 #include <unistd.h>
 #include <sys/socket.h>
 
 #include <sstream>
 
 #include "base/bind.h"
 #include "base/stl_util.h"
-#include "chromeos/dbus/bluetooth_media_client.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/fake_bluetooth_adapter_client.h"
-#include "chromeos/dbus/fake_bluetooth_media_client.h"
-#include "chromeos/dbus/fake_bluetooth_media_endpoint_service_provider.h"
 #include "dbus/file_descriptor.h"
+#include "device/bluetooth/dbus/bluetooth_media_client.h"
+#include "device/bluetooth/dbus/bluez_dbus_manager.h"
+#include "device/bluetooth/dbus/fake_bluetooth_adapter_client.h"
+#include "device/bluetooth/dbus/fake_bluetooth_media_client.h"
+#include "device/bluetooth/dbus/fake_bluetooth_media_endpoint_service_provider.h"
 
 using dbus::ObjectPath;
 
 namespace {
 
 // TODO(mcchou): Remove this constants once it is in cros_system_api.
 const char kBluetoothMediaTransportInterface[] = "org.bluez.MediaTransport1";
 const char kNotImplemented[] = "org.bluez.NotImplemented";
 const char kNotAuthorized[] = "org.bluez.NotAuthorized";
 const char kFailed[] = "org.bluez.Failed";
 const char kNotAvailable[] = "org.bluez.NotAvailable";
 
 const int kInvalidFd = -1;
 
 ObjectPath GenerateTransportPath() {
   static unsigned int sequence_number = 0;
   ++sequence_number;
   std::stringstream path;
-  path << chromeos::FakeBluetoothAdapterClient::kAdapterPath
-       << chromeos::FakeBluetoothMediaTransportClient::kTransportDevicePath
+  path << bluez::FakeBluetoothAdapterClient::kAdapterPath
+       << bluez::FakeBluetoothMediaTransportClient::kTransportDevicePath
        << "/fd" << sequence_number;
   return ObjectPath(path.str());
 }
 
 }  // namespace
 
-namespace chromeos {
+namespace bluez {
 
 // static
 const char FakeBluetoothMediaTransportClient::kTransportDevicePath[] =
     "/fake_audio_source";
 const uint8_t FakeBluetoothMediaTransportClient::kTransportCodec = 0x00;
 const std::vector<uint8_t>
-    FakeBluetoothMediaTransportClient::kTransportConfiguration = {
-        0x21, 0x15, 0x33, 0x2C};
+    FakeBluetoothMediaTransportClient::kTransportConfiguration = {0x21, 0x15,
+                                                                  0x33, 0x2C};
 const uint16_t FakeBluetoothMediaTransportClient::kTransportDelay = 5;
 const uint16_t FakeBluetoothMediaTransportClient::kTransportVolume = 50;
 const uint16_t FakeBluetoothMediaTransportClient::kDefaultReadMtu = 20;
 const uint16_t FakeBluetoothMediaTransportClient::kDefaultWriteMtu = 25;
 
 FakeBluetoothMediaTransportClient::Properties::Properties(
     const PropertyChangedCallback& callback)
     : BluetoothMediaTransportClient::Properties(
-        nullptr,
-        kBluetoothMediaTransportInterface,
-        callback) {
-}
+          nullptr,
+          kBluetoothMediaTransportInterface,
+          callback) {}
 
-FakeBluetoothMediaTransportClient::Properties::~Properties() {
-}
+FakeBluetoothMediaTransportClient::Properties::~Properties() {}
 
 void FakeBluetoothMediaTransportClient::Properties::Get(
     dbus::PropertyBase* property,
     dbus::PropertySet::GetCallback callback) {
   VLOG(1) << "Get " << property->name();
   callback.Run(false);
 }
 
 void FakeBluetoothMediaTransportClient::Properties::GetAll() {
   VLOG(1) << "GetAll called.";
 }
 
 void FakeBluetoothMediaTransportClient::Properties::Set(
     dbus::PropertyBase* property,
     dbus::PropertySet::SetCallback callback) {
   VLOG(1) << "Set " << property->name();
   callback.Run(false);
 }
 
 FakeBluetoothMediaTransportClient::Transport::Transport(
     const ObjectPath& transport_path,
     Properties* transport_properties)
     : path(transport_path) {
   properties.reset(transport_properties);
 }
 
-FakeBluetoothMediaTransportClient::Transport::~Transport() {
-}
+FakeBluetoothMediaTransportClient::Transport::~Transport() {}
 
-FakeBluetoothMediaTransportClient::FakeBluetoothMediaTransportClient() {
-}
+FakeBluetoothMediaTransportClient::FakeBluetoothMediaTransportClient() {}
 
 FakeBluetoothMediaTransportClient::~FakeBluetoothMediaTransportClient() {
   STLDeleteValues(&endpoint_to_transport_map_);
 }
 
 // DBusClient override.
-void FakeBluetoothMediaTransportClient::Init(dbus::Bus* bus) {
-}
+void FakeBluetoothMediaTransportClient::Init(dbus::Bus* bus) {}
 
 void FakeBluetoothMediaTransportClient::AddObserver(
     BluetoothMediaTransportClient::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void FakeBluetoothMediaTransportClient::RemoveObserver(
     BluetoothMediaTransportClient::Observer* observer) {
   observers_.RemoveObserver(observer);
 }
@@ skipping 28 matching lines @@
     const ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   error_callback.Run(kNotImplemented, "");
 }
 
 void FakeBluetoothMediaTransportClient::SetValid(
     FakeBluetoothMediaEndpointServiceProvider* endpoint,
     bool valid) {
   FakeBluetoothMediaClient* media = static_cast<FakeBluetoothMediaClient*>(
-      DBusThreadManager::Get()->GetBluetoothMediaClient());
+      bluez::BluezDBusManager::Get()->GetBluetoothMediaClient());
   DCHECK(media);
 
   ObjectPath endpoint_path(endpoint->object_path());
   if (!media->IsRegistered(endpoint_path))
     return;
 
   if (valid) {
     ObjectPath transport_path = GenerateTransportPath();
     VLOG(1) << "New transport, " << transport_path.value()
             << " is created for endpoint " << endpoint_path.value();
@@ skipping 35 matching lines @@
 void FakeBluetoothMediaTransportClient::SetState(
     const ObjectPath& endpoint_path,
     const std::string& state) {
   VLOG(1) << "SetState - state: " << state;
 
   Transport* transport = GetTransport(endpoint_path);
   if (!transport)
     return;
 
   transport->properties->state.ReplaceValue(state);
-  FOR_EACH_OBSERVER(BluetoothMediaTransportClient::Observer, observers_,
-                    MediaTransportPropertyChanged(
-                        transport->path,
-                        BluetoothMediaTransportClient::kStateProperty));
+  FOR_EACH_OBSERVER(
+      BluetoothMediaTransportClient::Observer, observers_,
+      MediaTransportPropertyChanged(
+          transport->path, BluetoothMediaTransportClient::kStateProperty));
 }
 
 void FakeBluetoothMediaTransportClient::SetVolume(
     const ObjectPath& endpoint_path,
     const uint16_t& volume) {
   Transport* transport = GetTransport(endpoint_path);
   if (!transport)
     return;
 
   transport->properties->volume.ReplaceValue(volume);
-  FOR_EACH_OBSERVER(BluetoothMediaTransportClient::Observer, observers_,
-                    MediaTransportPropertyChanged(
-                        transport->path,
-                        BluetoothMediaTransportClient::kVolumeProperty));
+  FOR_EACH_OBSERVER(
+      BluetoothMediaTransportClient::Observer, observers_,
+      MediaTransportPropertyChanged(
+          transport->path, BluetoothMediaTransportClient::kVolumeProperty));
 }
 
 void FakeBluetoothMediaTransportClient::WriteData(
-    const ObjectPath& endpoint_path, const std::vector<char>& bytes) {
+    const ObjectPath& endpoint_path,
+    const std::vector<char>& bytes) {
   VLOG(1) << "WriteData - write " << bytes.size() << " bytes";
 
   Transport* transport = GetTransport(endpoint_path);
 
   if (!transport || transport->properties->state.value() != "active") {
     VLOG(1) << "WriteData - write operation rejected, since the state isn't "
-               "active for endpoint: " << endpoint_path.value();
+               "active for endpoint: "
+            << endpoint_path.value();
     return;
   }
 
   if (!transport->input_fd.get()) {
     VLOG(1) << "WriteData - invalid input file descriptor";
     return;
   }
 
   ssize_t written_len =
       write(transport->input_fd->GetPlatformFile(), bytes.data(), bytes.size());
@@ skipping 64 matching lines @@
     return;
   }
   DCHECK((fds[0] > kInvalidFd) && (fds[1] > kInvalidFd));
   transport->input_fd.reset(new base::File(fds[0]));
 
   dbus::FileDescriptor out_fd(fds[1]);
   callback.Run(&out_fd, kDefaultReadMtu, kDefaultWriteMtu);
   SetState(endpoint_path, "active");
 }
 
-}  // namespace chromeos
+}  // namespace bluez