device/bluetooth:Implement BluetoothMediaEndpointServiceProvider delegate and media-related overrid…

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 <string>
-
 #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/bus.h"
 #include "dbus/exported_object.h"
 #include "dbus/message.h"
 
 namespace {
 
 // TODO(mcchou): Move these constants to dbus/service_constants.h.
 // Bluetooth Media Endpoint service identifier.
 const char kBluetoothMediaEndpointInterface[] = "org.bluez.MediaEndpoint1";
 
-// Bluetooth Media Endpoint methods.
+// 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 {
 
 // The BluetoothMediaEndopintServiceProvider implementation used in production.
 class CHROMEOS_EXPORT BluetoothMediaEndpointServiceProviderImpl
     : public BluetoothMediaEndpointServiceProvider {
  public:
   BluetoothMediaEndpointServiceProviderImpl(dbus::Bus* bus,
                                             const dbus::ObjectPath& object_path,
@@ skipping 69 matching lines @@
   }
 
   // Called by dbus:: when the remote device connects to the Media Endpoint.
   void SetConfiguration(dbus::MethodCall* method_call,
                         dbus::ExportedObject::ResponseSender response_sender) {
     DCHECK(OnOriginThread());
     DCHECK(delegate_);
 
     dbus::MessageReader reader(method_call);
     dbus::ObjectPath transport_path;
-    dbus::MessageReader properties(method_call);
+    dbus::MessageReader property_reader(method_call);
     if (!reader.PopObjectPath(&transport_path) ||
-        !reader.PopArray(&properties)) {
+        !reader.PopArray(&property_reader)) {
       LOG(WARNING) << "SetConfiguration called with incorrect parameters: "
                    << method_call->ToString();
       return;
     }
 
-    delegate_->SetConfiguration(transport_path, properties);
+    // 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();
+      } 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 = std::vector<uint8_t>(bytes, bytes + length);

[Ben Chan, 2015/02/11 20:36:23]

perhaps simply:

  properties.configuration.assign(bytes, bytes + length);

[Miao, 2015/02/11 23:17:17]

Done.

+      } 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.compare(kInvalidState) != 0) {

[Ben Chan, 2015/02/11 20:36:23]

perhaps simply (string implements operator != (const char* ) correctly) :

  properties.state != kInvalidState

[Miao, 2015/02/11 23:17:17]

Done.

+      delegate_->SetConfiguration(transport_path, properties);
+    }
 
     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) {
     DCHECK(OnOriginThread());
@@ skipping 41 matching lines @@
     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) {
     DCHECK(OnOriginThread());
     DCHECK(delegate_);
 
-    delegate_->Release();
+    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) {
     DCHECK(OnOriginThread());
@@ skipping 32 matching lines @@
   // Weak pointer factory for generating 'this' printers that might live longer
   // than we do.
   // 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),
+      delay(nullptr),

[Ben Chan, 2015/02/11 20:36:23]

scoped_ptr is default constructed to nullptr, so these two lines are not
necessary.

[Miao, 2015/02/11 23:17:17]

Removed, and also removed those in bluetooth_audio_sink_chromeos.cc and
bluetooth_audio_sink_chromeos_unittest.cc.

+      volume(nullptr) {
+}
+
+BluetoothMediaEndpointServiceProvider::Delegate::TransportProperties::
+    ~TransportProperties() {
+}
+
 BluetoothMediaEndpointServiceProvider::BluetoothMediaEndpointServiceProvider() {
 }
 
-BluetoothMediaEndpointServiceProvider::~BluetoothMediaEndpointServiceProvider()
-{}
+BluetoothMediaEndpointServiceProvider::
+    ~BluetoothMediaEndpointServiceProvider() {
+}
 
 BluetoothMediaEndpointServiceProvider*
     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);
   }
   // Returns a fake implementation.
   return new FakeBluetoothMediaEndpointServiceProvider(object_path, delegate);
 }
 
 }  // namespace chromeos