chromeos/dbus: Add verbose log to media-related clients and service provider.

device/bluetooth/bluetooth_audio_sink_chromeos.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 "device/bluetooth/bluetooth_audio_sink_chromeos.h"
 
 #include <algorithm>
 #include <sstream>
+#include <string>
 #include <vector>
 
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "dbus/message.h"
 #include "device/bluetooth/bluetooth_adapter_chromeos.h"
 
 using dbus::ObjectPath;
 using device::BluetoothAudioSink;
 
 namespace {
 
 // TODO(mcchou): Add the constant to dbus/service_constants.h.
 const char kBluetoothAudioSinkServicePath[] = "/org/chromium/AudioSink";
 
+// Used in VLOG. Translates a BluetoothAudioSink::State to verbose description.
+const std::vector<std::string> kState = {
+  "invalid", "disconnected", "idle", "pending", "active"};
+const std::vector<std::string> kErrorCode = {"unsupported platform",
+                                             "invalid adapter",
+                                             "not registered",
+                                             "not unregistered"};

[armansito, 2015/02/28 00:50:28]

Define helper functions that do the string conversion instead.

[Ben Chan, 2015/02/28 01:09:22]

Don't define global constants of non-POD types
(http://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Static_and_Gl...).
Use helper functions as Arman suggested. That way, you can handle bogus enum
value that may fail out of the range of the array (or otherwise, it may result
in a crash)

[Miao, 2015/02/28 02:19:32]

Done.

+
 ObjectPath GenerateEndpointPath() {
   static unsigned int sequence_number = 0;
   ++sequence_number;
   std::stringstream path;
   path << kBluetoothAudioSinkServicePath << "/endpoint" << sequence_number;
   return ObjectPath(path.str());
 }
 
 // A dummy error callback for calling Unregister() in destructor.
 void UnregisterErrorCallback(
     device::BluetoothAudioSink::ErrorCode error_code) {
-  VLOG(1) << "Bluetooth audio sink: Error code: " << error_code;
+  VLOG(1) << "Bluetooth audio sink: Error code: " << kErrorCode[error_code]

[armansito, 2015/02/28 00:50:28]

Should this be "UnregisterErrorCallback - Error code: "?

[Miao, 2015/02/28 02:19:32]

Done.

+          << "(" << error_code << ")";
 }
 
 }  // namespace
 
 namespace chromeos {
 
 BluetoothAudioSinkChromeOS::BluetoothAudioSinkChromeOS(
     scoped_refptr<device::BluetoothAdapter> adapter)
     : state_(BluetoothAudioSink::STATE_INVALID),
       volume_(BluetoothAudioSink::kInvalidVolume),
       read_mtu_(nullptr),
       write_mtu_(nullptr),
       adapter_(adapter),
       weak_ptr_factory_(this) {
+  VLOG(1) << "Bluetooth audio sink created";
+
   DCHECK(adapter_.get());
   DCHECK(adapter_->IsPresent());
 
   adapter_->AddObserver(this);
 
   chromeos::BluetoothMediaClient* media =
       DBusThreadManager::Get()->GetBluetoothMediaClient();
   DCHECK(media);
   media->AddObserver(this);
 
   chromeos::BluetoothMediaTransportClient *transport =
       chromeos::DBusThreadManager::Get()->GetBluetoothMediaTransportClient();
   DCHECK(transport);
   transport->AddObserver(this);
 
   StateChanged(device::BluetoothAudioSink::STATE_DISCONNECTED);
 }
 
 BluetoothAudioSinkChromeOS::~BluetoothAudioSinkChromeOS() {
+  VLOG(1) << "Bluetooth audio sink destroyed";
+
   DCHECK(adapter_.get());
 
   if (state_ != BluetoothAudioSink::STATE_INVALID && media_endpoint_.get()) {
     Unregister(base::Bind(&base::DoNothing),
                base::Bind(&UnregisterErrorCallback));
   }
 
   adapter_->RemoveObserver(this);
 
   chromeos::BluetoothMediaClient* media =
       DBusThreadManager::Get()->GetBluetoothMediaClient();
   DCHECK(media);
   media->RemoveObserver(this);
 
   chromeos::BluetoothMediaTransportClient *transport =
       chromeos::DBusThreadManager::Get()->GetBluetoothMediaTransportClient();
   DCHECK(transport);
   transport->RemoveObserver(this);
 }
 
 void BluetoothAudioSinkChromeOS::Unregister(
     const base::Closure& callback,
     const device::BluetoothAudioSink::ErrorCallback& error_callback) {
+  VLOG(1) << "Bluetooth audio sink: Unregister called";
+
   if (!DBusThreadManager::IsInitialized())
     error_callback.Run(BluetoothAudioSink::ERROR_NOT_UNREGISTERED);
 
   chromeos::BluetoothMediaClient* media =
       DBusThreadManager::Get()->GetBluetoothMediaClient();
   DCHECK(media);
 
   media->UnregisterEndpoint(
       media_path_,
       endpoint_path_,
@@ skipping 44 matching lines @@
   // Regardless of the new powered state, |state_| goes to STATE_DISCONNECTED.
   // If false, the transport is closed, but the endpoint is still valid for use.
   // If true, the previous transport has been torn down, so the |state_| has to
   // be disconnected before SetConfigruation is called.
   if (state_ != BluetoothAudioSink::STATE_INVALID)
     StateChanged(BluetoothAudioSink::STATE_DISCONNECTED);
 }
 
 void BluetoothAudioSinkChromeOS::MediaRemoved(const ObjectPath& object_path) {
   if (object_path == media_path_) {
+    VLOG(1) << "Bluetooth audio sink: media removed: "
+            << object_path.value();
     StateChanged(BluetoothAudioSink::STATE_INVALID);
   }
 }
 
 void BluetoothAudioSinkChromeOS::MediaTransportRemoved(
     const ObjectPath& object_path) {
   // Whenever powered of |adapter_| turns false while present stays true, media
   // transport object should be removed accordingly, and the state should be
   // changed to STATE_DISCONNECTED.
   if (object_path == transport_path_) {
+    VLOG(1) << "Bluetooth audio sink: media transport removed: "

[armansito, 2015/02/28 00:50:28]

"Bluetooth audio sink - media transport removed: "

[Miao, 2015/02/28 02:19:33]

Done.

+            << object_path.value();
     StateChanged(BluetoothAudioSink::STATE_DISCONNECTED);
   }
 }
 
 void BluetoothAudioSinkChromeOS::MediaTransportPropertyChanged(
     const ObjectPath& object_path,
     const std::string& property_name) {
   if (object_path != transport_path_)
     return;
 
@@ skipping 24 matching lines @@
 }
 
 void BluetoothAudioSinkChromeOS::SetConfiguration(
     const ObjectPath& transport_path,
     const TransportProperties& properties) {
   VLOG(1) << "Bluetooth audio sink: SetConfiguration called";
   transport_path_ = transport_path;
 
   // The initial state for a connection should be "idle".
   if (properties.state != BluetoothMediaTransportClient::kStateIdle) {
-    VLOG(1) << "Bluetooth Audio Sink: unexpected state " << properties.state;
+    VLOG(1) << "Bluetooth audio sink: unexpected state " << properties.state;
     return;
   }
 
   // Updates |volume_| if the volume level is provided in |properties|.
   if (properties.volume.get()) {
     VolumeChanged(*properties.volume);
   }
 
   StateChanged(BluetoothAudioSink::STATE_IDLE);
 }
@@ skipping 15 matching lines @@
 
 void BluetoothAudioSinkChromeOS::Released() {
   VLOG(1) << "Bluetooth audio sink: Released called";
   StateChanged(BluetoothAudioSink::STATE_INVALID);
 }
 
 void BluetoothAudioSinkChromeOS::Register(
     const BluetoothAudioSink::Options& options,
     const base::Closure& callback,
     const BluetoothAudioSink::ErrorCallback& error_callback) {
+  VLOG(1) << "Bluetooth audio sink: Register called";
+
   DCHECK(adapter_.get());
   DCHECK_EQ(state_, BluetoothAudioSink::STATE_DISCONNECTED);
 
   // Gets system bus.
   dbus::Bus* system_bus = DBusThreadManager::Get()->GetSystemBus();
 
   // Creates a Media Endpoint with newly-generated path.
   endpoint_path_ = GenerateEndpointPath();
   media_endpoint_.reset(
       BluetoothMediaEndpointServiceProvider::Create(
@@ skipping 27 matching lines @@
 BluetoothMediaEndpointServiceProvider*
     BluetoothAudioSinkChromeOS::GetEndpointServiceProvider() {
   return media_endpoint_.get();
 }
 
 void BluetoothAudioSinkChromeOS::StateChanged(
     BluetoothAudioSink::State state) {
   if (state == state_)
     return;
 
-  VLOG(1) << "Bluetooth audio sink state changed: " << state;
+  VLOG(1) << "Bluetooth audio sink state changed: " << kState[state];
+
   switch (state) {
     case BluetoothAudioSink::STATE_INVALID:
       ResetMedia();
       ResetEndpoint();
     case BluetoothAudioSink::STATE_DISCONNECTED:
       ResetTransport();
       break;
     case BluetoothAudioSink::STATE_IDLE:
       // TODO(mcchou): BUG=441581
       // Triggered by MediaTransportPropertyChanged and SetConfiguration.
@@ skipping 15 matching lines @@
   state_ = state;
   FOR_EACH_OBSERVER(BluetoothAudioSink::Observer, observers_,
                     BluetoothAudioSinkStateChanged(this, state_));
 }
 
 void BluetoothAudioSinkChromeOS::VolumeChanged(uint16_t volume) {
   if (volume == volume_)
     return;
 
   VLOG(1) << "Bluetooth audio sink volume changed: " << volume;
+
   volume_ = std::min(volume, BluetoothAudioSink::kInvalidVolume);
-
   FOR_EACH_OBSERVER(BluetoothAudioSink::Observer, observers_,
                     BluetoothAudioSinkVolumeChanged(this, volume_));
 }
 
 void BluetoothAudioSinkChromeOS::OnRegisterSucceeded(
     const base::Closure& callback) {
   DCHECK(media_endpoint_.get());
   VLOG(1) << "Bluetooth audio sink registerd";
 
   StateChanged(BluetoothAudioSink::STATE_DISCONNECTED);
   callback.Run();
 }
 
 void BluetoothAudioSinkChromeOS::OnRegisterFailed(
     const BluetoothAudioSink::ErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
-  VLOG(1) << "Bluetooth audio sink: " << error_name << ": " <<  error_message;
+  VLOG(1) << "Bluetooth audio sink: error " << error_name << ": "
+          << error_message;
 
   ResetEndpoint();
   error_callback.Run(BluetoothAudioSink::ERROR_NOT_REGISTERED);
 }
 
 void BluetoothAudioSinkChromeOS::OnUnregisterSucceeded(
     const base::Closure& callback) {
   VLOG(1) << "Bluetooth audio sink unregisterd";
 
   // Once the state becomes STATE_INVALID, media, media transport and media
   // endpoint will be reset.
   StateChanged(BluetoothAudioSink::STATE_INVALID);
   callback.Run();
 }
 
 void BluetoothAudioSinkChromeOS::OnUnregisterFailed(
     const device::BluetoothAudioSink::ErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
-  VLOG(1) << "Bluetooth audio sink: " << error_name << ": " <<  error_message;
+  VLOG(1) << "Bluetooth audio sink: error " << error_name << ": "

[armansito, 2015/02/28 00:50:28]

"UnregisterError - error_name: " << error_name << ", message: " << error_message

[Miao, 2015/02/28 02:19:33]

Done.

+          << error_message;
+
   error_callback.Run(BluetoothAudioSink::ERROR_NOT_UNREGISTERED);
 }
 
 void BluetoothAudioSinkChromeOS::ReadFromFD() {
   DCHECK_GE(fd_.value(), 0);
 
   // TODO(mcchou): BUG=441581
   // Read from file descriptor using watcher and create a buffer to contain the
   // data. Notify |Observers_| while there is audio data available.
 }
 
 void BluetoothAudioSinkChromeOS::ResetMedia() {
+  VLOG(1) << "Bluetooth audio sink: ResetMedia";
+
   media_path_ = dbus::ObjectPath("");
 }
 
 void BluetoothAudioSinkChromeOS::ResetTransport() {
+  VLOG(1) << "Bluetooth audio sink: ResetTransport";
+
   if (transport_path_.value() == "")
     return;
   transport_path_ = dbus::ObjectPath("");
   VolumeChanged(BluetoothAudioSink::kInvalidVolume);
   read_mtu_ = 0;
   write_mtu_ = 0;
   fd_.PutValue(-1);
 }
 
 void BluetoothAudioSinkChromeOS::ResetEndpoint() {
+  VLOG(1) << "Bluetooth audio sink: ResetEndpoint";
+
   endpoint_path_ = ObjectPath("");
   media_endpoint_ = nullptr;
 }
 
 }  // namespace chromeos