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

chromeos/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 "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 88 matching lines @@
   // Returns true if the current thread is on the origin thread, false
   // otherwise.
   bool OnOriginThread() const {
     return base::PlatformThread::CurrentId() == origin_thread_id_;
   }
 
   // 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(ERROR, !success) << "Failed to export " << interface_name << "."
+                            << method_name;
   }
 
   // Called by dbus:: when the remote device connects to the Media Endpoint.
   void SetConfiguration(dbus::MethodCall* method_call,
                         dbus::ExportedObject::ResponseSender response_sender) {
+    VLOG(1) << "SetConfiuration";
+
     DCHECK(OnOriginThread());
     DCHECK(delegate_);
 
     dbus::MessageReader reader(method_call);
     dbus::ObjectPath transport_path;
     dbus::MessageReader property_reader(method_call);
     if (!reader.PopObjectPath(&transport_path) ||
         !reader.PopArray(&property_reader)) {
-      LOG(WARNING) << "SetConfiguration called with incorrect parameters: "
-                   << method_call->ToString();
+      LOG(ERROR) << "SetConfiguration called with incorrect parameters: "
+                 << method_call->ToString();
       return;
     }
 
     // Parses |properties| and passes the property set as a
     // Delegate::TransportProperties structure to |delegate_|.
     Delegate::TransportProperties properties;
     while (property_reader.HasMoreData()) {
       dbus::MessageReader dict_entry_reader(nullptr);
       std::string key;
       if (!property_reader.PopDictEntry(&dict_entry_reader) ||
           !dict_entry_reader.PopString(&key)) {
-        LOG(WARNING) << "SetConfiguration called with incorrect parameters: "
-                     << method_call->ToString();
+        LOG(ERROR) << "SetConfiguration called with incorrect parameters: "
+                   << method_call->ToString();
       } else if (key == BluetoothMediaTransportClient::kDeviceProperty) {
         dict_entry_reader.PopVariantOfObjectPath(&properties.device);
       } else if (key == BluetoothMediaTransportClient::kUUIDProperty) {
         dict_entry_reader.PopVariantOfString(&properties.uuid);
       } else if (key == BluetoothMediaTransportClient::kCodecProperty) {
         dict_entry_reader.PopVariantOfByte(&properties.codec);
       } else if (key == BluetoothMediaTransportClient::kConfigurationProperty) {
         dbus::MessageReader variant_reader(nullptr);
         const uint8_t* bytes = nullptr;
         size_t length = 0;
         dict_entry_reader.PopVariant(&variant_reader);
         variant_reader.PopArrayOfBytes(&bytes, &length);
         properties.configuration.assign(bytes, bytes + length);
       } else if (key == BluetoothMediaTransportClient::kStateProperty) {
         dict_entry_reader.PopVariantOfString(&properties.state);
       } else if (key == BluetoothMediaTransportClient::kDelayProperty) {
         properties.delay.reset(new uint16_t());
         dict_entry_reader.PopVariantOfUint16(properties.delay.get());
       } else if (key == BluetoothMediaTransportClient::kVolumeProperty) {
         properties.volume.reset(new uint16_t());
         dict_entry_reader.PopVariantOfUint16(properties.volume.get());
       }
     }
 
     if (properties.codec != kInvalidCodec &&
         properties.state != kInvalidState) {
       delegate_->SetConfiguration(transport_path, properties);
     } else {
-      LOG(WARNING) << "SetConfiguration called with incorrect parameters: "
-                   << method_call->ToString();
+      LOG(ERROR) << "SetConfiguration called with incorrect parameters: "
+                 << method_call->ToString();
     }
 
     response_sender.Run(dbus::Response::FromMethodCall(method_call));
   }
 
   // Called by dbus:: when the remote device receives the configuration for
   // media transport.
   void SelectConfiguration(
       dbus::MethodCall* method_call,
       dbus::ExportedObject::ResponseSender response_sender) {
+    VLOG(1) << "SelectConfiguration";
+
     DCHECK(OnOriginThread());
     DCHECK(delegate_);
 
     dbus::MessageReader reader(method_call);
     const uint8_t* capabilities = nullptr;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&capabilities, &length)) {
-      LOG(WARNING) << "SelectConfiguration called with incorrect parameters: "
-                   << method_call->ToString();
+      LOG(ERROR) << "SelectConfiguration called with incorrect parameters: "
+                 << 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);
 
     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";
+
     DCHECK(OnOriginThread());
     DCHECK(delegate_);
 
     dbus::MessageReader reader(method_call);
     dbus::ObjectPath transport_path;
     if (!reader.PopObjectPath(&transport_path)) {
-      LOG(WARNING) << "ClearConfiguration called with incorrect parameters: "
-                   << method_call->ToString();
+      LOG(ERROR) << "ClearConfiguration called with incorrect parameters: "
+                 << method_call->ToString();
       return;
     }
 
     delegate_->ClearConfiguration(transport_path);
 
     response_sender.Run(dbus::Response::FromMethodCall(method_call));
   }
 
   // Called by Bluetooth daemon to do the clean up after unregistering the Media
   // Endpoint.
   void Release(dbus::MethodCall* method_call,
                dbus::ExportedObject::ResponseSender response_sender) {
+    VLOG(1) << "Release";
+
     DCHECK(OnOriginThread());
     DCHECK(delegate_);
 
     delegate_->Released();
 
     response_sender.Run(dbus::Response::FromMethodCall(method_call));
   }
 
   // Called by Delegate to response to a method requiring transport
   // configuration.
   void OnConfiguration(dbus::MethodCall* method_call,
                        dbus::ExportedObject::ResponseSender response_sender,
                        const std::vector<uint8_t>& configuration) {
+    VLOG(1) << "OnConfiguration";
+
     DCHECK(OnOriginThread());
 
     // Generates the response to the method call.
     scoped_ptr<dbus::Response> response(
         dbus::Response::FromMethodCall(method_call));
     dbus::MessageWriter writer(response.get());
     if (configuration.empty()) {
-      LOG(WARNING) << "OnConfiguration called with empty configuration.";
+      LOG(ERROR) << "OnConfiguration called with empty configuration.";
       writer.AppendArrayOfBytes(nullptr, 0);
     } else {
       writer.AppendArrayOfBytes(&configuration[0], configuration.size());
     }
     response_sender.Run(response.Pass());
   }
 
   // Origin thread (i.e. the UI thread in production).
   base::PlatformThreadId origin_thread_id_;
 
@@ skipping 47 matching lines @@
   // Returns a real implementation.
   if (!DBusThreadManager::Get()->IsUsingStub(DBusClientBundle::BLUETOOTH)) {
     return new BluetoothMediaEndpointServiceProviderImpl(
         bus, object_path, delegate);
   }
   // Returns a fake implementation.
   return new FakeBluetoothMediaEndpointServiceProvider(object_path, delegate);
 }
 
 }  // namespace chromeos