device/bluetooth: Add I/O watcher for audio data retrieval triggered by state change.

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 <unistd.h>
+
 #include <algorithm>
 #include <sstream>
 #include <string>
 #include <vector>
 
 #include "base/debug/stack_trace.h"
+#include "base/files/file_util.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";
 
+const int kInvalidFd = -1;
+const uint16_t kInvalidReadMtu = 0;
+const uint16_t kInvalidWriteMtu = 0;
+
 ObjectPath GenerateEndpointPath() {
   static unsigned int sequence_number = 0;
   ++sequence_number;
   std::stringstream path;
   path << kBluetoothAudioSinkServicePath << "/endpoint" << sequence_number;
   return ObjectPath(path.str());
 }
 
 std::string StateToString(const BluetoothAudioSink::State& state) {
   switch (state) {
@@ skipping 35 matching lines @@
 }
 
 }  // namespace
 
 namespace chromeos {
 
 BluetoothAudioSinkChromeOS::BluetoothAudioSinkChromeOS(
     scoped_refptr<device::BluetoothAdapter> adapter)
     : state_(BluetoothAudioSink::STATE_INVALID),
       volume_(BluetoothAudioSink::kInvalidVolume),
-      read_mtu_(nullptr),
-      write_mtu_(nullptr),
+      read_mtu_(kInvalidReadMtu),
+      write_mtu_(kInvalidWriteMtu),
+      read_has_failed_(false),
       adapter_(adapter),
       weak_ptr_factory_(this) {
   VLOG(1) << "BluetoothAudioSinkChromeOS created";
 
-  DCHECK(adapter_.get());
-  DCHECK(adapter_->IsPresent());
+  CHECK(adapter_.get());
+  CHECK(adapter_->IsPresent());
+  CHECK(DBusThreadManager::IsInitialized());
 
   adapter_->AddObserver(this);
 
-  chromeos::BluetoothMediaClient* media =
+  BluetoothMediaClient* media =
       DBusThreadManager::Get()->GetBluetoothMediaClient();
-  DCHECK(media);
+  CHECK(media);
   media->AddObserver(this);
 
-  chromeos::BluetoothMediaTransportClient *transport =
-      chromeos::DBusThreadManager::Get()->GetBluetoothMediaTransportClient();
-  DCHECK(transport);
+  BluetoothMediaTransportClient* transport =
+      DBusThreadManager::Get()->GetBluetoothMediaTransportClient();
+  CHECK(transport);
   transport->AddObserver(this);
 
   StateChanged(device::BluetoothAudioSink::STATE_DISCONNECTED);
 }
 
 BluetoothAudioSinkChromeOS::~BluetoothAudioSinkChromeOS() {
   VLOG(1) << "BluetoothAudioSinkChromeOS 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 =
+  BluetoothMediaClient* media =
       DBusThreadManager::Get()->GetBluetoothMediaClient();
-  DCHECK(media);
+  CHECK(media);
   media->RemoveObserver(this);
 
-  chromeos::BluetoothMediaTransportClient *transport =
-      chromeos::DBusThreadManager::Get()->GetBluetoothMediaTransportClient();
-  DCHECK(transport);
+  BluetoothMediaTransportClient* transport =
+      DBusThreadManager::Get()->GetBluetoothMediaTransportClient();
+  CHECK(transport);
   transport->RemoveObserver(this);
 }
 
 void BluetoothAudioSinkChromeOS::Unregister(
     const base::Closure& callback,
     const device::BluetoothAudioSink::ErrorCallback& error_callback) {
   VLOG(1) << "Unregister";
 
   if (!DBusThreadManager::IsInitialized())
     error_callback.Run(BluetoothAudioSink::ERROR_NOT_UNREGISTERED);
 
-  chromeos::BluetoothMediaClient* media =
+  BluetoothMediaClient* media =
       DBusThreadManager::Get()->GetBluetoothMediaClient();
-  DCHECK(media);
+  CHECK(media);
 
   media->UnregisterEndpoint(
       media_path_,
       endpoint_path_,
       base::Bind(&BluetoothAudioSinkChromeOS::OnUnregisterSucceeded,
                  weak_ptr_factory_.GetWeakPtr(), callback),
       base::Bind(&BluetoothAudioSinkChromeOS::OnUnregisterFailed,
                  weak_ptr_factory_.GetWeakPtr(), error_callback));
 }
 
 void BluetoothAudioSinkChromeOS::AddObserver(
     BluetoothAudioSink::Observer* observer) {
-  DCHECK(observer);
+  CHECK(observer);
   observers_.AddObserver(observer);
 }
 
 void BluetoothAudioSinkChromeOS::RemoveObserver(
     BluetoothAudioSink::Observer* observer) {
-  DCHECK(observer);
+  CHECK(observer);
   observers_.RemoveObserver(observer);
 }
 
 BluetoothAudioSink::State BluetoothAudioSinkChromeOS::GetState() const {
   return state_;
 }
 
 uint16_t BluetoothAudioSinkChromeOS::GetVolume() const {
   return volume_;
 }
 
+void BluetoothAudioSinkChromeOS::Register(
+    const BluetoothAudioSink::Options& options,
+    const base::Closure& callback,
+    const BluetoothAudioSink::ErrorCallback& error_callback) {
+  VLOG(1) << "Register";
+
+  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(
+          system_bus, endpoint_path_, this));
+
+  DCHECK(media_endpoint_.get());
+
+  // Creates endpoint properties with |options|.
+  options_ = options;
+  chromeos::BluetoothMediaClient::EndpointProperties endpoint_properties;
+  endpoint_properties.uuid = BluetoothMediaClient::kBluetoothAudioSinkUUID;
+  endpoint_properties.codec = options_.codec;
+  endpoint_properties.capabilities = options_.capabilities;
+
+  media_path_ = static_cast<BluetoothAdapterChromeOS*>(
+      adapter_.get())->object_path();
+
+  BluetoothMediaClient* media =
+      DBusThreadManager::Get()->GetBluetoothMediaClient();
+  CHECK(media);
+  media->RegisterEndpoint(
+      media_path_,
+      endpoint_path_,
+      endpoint_properties,
+      base::Bind(&BluetoothAudioSinkChromeOS::OnRegisterSucceeded,
+                 weak_ptr_factory_.GetWeakPtr(), callback),
+      base::Bind(&BluetoothAudioSinkChromeOS::OnRegisterFailed,
+                 weak_ptr_factory_.GetWeakPtr(), error_callback));
+}
+
+BluetoothMediaEndpointServiceProvider*
+    BluetoothAudioSinkChromeOS::GetEndpointServiceProvider() {
+  return media_endpoint_.get();
+}
+
 void BluetoothAudioSinkChromeOS::AdapterPresentChanged(
     device::BluetoothAdapter* adapter, bool present) {
   VLOG(1) << "AdapterPresentChanged: " << present;
 
   if (adapter->IsPresent()) {
     StateChanged(BluetoothAudioSink::STATE_DISCONNECTED);
   } else {
     adapter_->RemoveObserver(this);
     StateChanged(BluetoothAudioSink::STATE_INVALID);
   }
@@ skipping 31 matching lines @@
 
 void BluetoothAudioSinkChromeOS::MediaTransportPropertyChanged(
     const ObjectPath& object_path,
     const std::string& property_name) {
   if (object_path != transport_path_)
     return;
 
   VLOG(1) << "MediaTransportPropertyChanged: " << property_name;
 
   // Retrieves the property set of the transport object with |object_path|.
-  chromeos::BluetoothMediaTransportClient::Properties* properties =
+  BluetoothMediaTransportClient::Properties* properties =
       DBusThreadManager::Get()
           ->GetBluetoothMediaTransportClient()
           ->GetProperties(object_path);
 
   // Dispatches a property changed event to the corresponding handler.
   if (property_name == properties->state.name()) {
     if (properties->state.value() ==
         BluetoothMediaTransportClient::kStateIdle) {
       StateChanged(BluetoothAudioSink::STATE_IDLE);
     } else if (properties->state.value() ==
@@ skipping 32 matching lines @@
     const std::vector<uint8_t>& capabilities,
     const SelectConfigurationCallback& callback) {
   VLOG(1) << "SelectConfiguration";
   callback.Run(options_.capabilities);
 }
 
 void BluetoothAudioSinkChromeOS::ClearConfiguration(
     const ObjectPath& transport_path) {
   if (transport_path != transport_path_)
     return;
+
   VLOG(1) << "ClearConfiguration";
   StateChanged(BluetoothAudioSink::STATE_DISCONNECTED);
 }
 
 void BluetoothAudioSinkChromeOS::Released() {
   VLOG(1) << "Released";
   StateChanged(BluetoothAudioSink::STATE_INVALID);
 }
 
-void BluetoothAudioSinkChromeOS::Register(
-    const BluetoothAudioSink::Options& options,
-    const base::Closure& callback,
-    const BluetoothAudioSink::ErrorCallback& error_callback) {
-  VLOG(1) << "Register";
-
-  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(
-          system_bus, endpoint_path_, this));
-
-  DCHECK(media_endpoint_.get());
-
-  // Creates endpoint properties with |options|.
-  options_ = options;
-  chromeos::BluetoothMediaClient::EndpointProperties endpoint_properties;
-  endpoint_properties.uuid = BluetoothMediaClient::kBluetoothAudioSinkUUID;
-  endpoint_properties.codec = options_.codec;
-  endpoint_properties.capabilities = options_.capabilities;
-
-  media_path_ = static_cast<BluetoothAdapterChromeOS*>(
-      adapter_.get())->object_path();
-
-  chromeos::BluetoothMediaClient* media =
-      DBusThreadManager::Get()->GetBluetoothMediaClient();
-  DCHECK(media);
-  media->RegisterEndpoint(
-      media_path_,
-      endpoint_path_,
-      endpoint_properties,
-      base::Bind(&BluetoothAudioSinkChromeOS::OnRegisterSucceeded,
-                 weak_ptr_factory_.GetWeakPtr(), callback),
-      base::Bind(&BluetoothAudioSinkChromeOS::OnRegisterFailed,
-                 weak_ptr_factory_.GetWeakPtr(), error_callback));
+void BluetoothAudioSinkChromeOS::OnFileCanReadWithoutBlocking(int fd) {
+  ReadFromFile();
 }
 
-BluetoothMediaEndpointServiceProvider*
-    BluetoothAudioSinkChromeOS::GetEndpointServiceProvider() {
-  return media_endpoint_.get();
+void BluetoothAudioSinkChromeOS::OnFileCanWriteWithoutBlocking(int fd) {
+  // Do nothing for now.
+}
+
+void BluetoothAudioSinkChromeOS::AcquireFD() {
+  VLOG(1) << "AcquireFD - transport path: " << transport_path_.value();
+
+  read_has_failed_ = false;
+
+  DBusThreadManager::Get()->GetBluetoothMediaTransportClient()->Acquire(
+      transport_path_,
+      base::Bind(&BluetoothAudioSinkChromeOS::OnAcquireSucceeded,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&BluetoothAudioSinkChromeOS::OnAcquireFailed,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void BluetoothAudioSinkChromeOS::WatchFD() {
+  CHECK(file_.get() && file_->IsValid());
+
+  VLOG(1) << "WatchFD - file: " << file_->GetPlatformFile()
+          << ", file validity: " << file_->IsValid();
+
+  base::MessageLoopForIO::current()->WatchFileDescriptor(
+      file_->GetPlatformFile(), true, base::MessageLoopForIO::WATCH_READ,
+      &fd_read_watcher_, this);
+}
+
+void BluetoothAudioSinkChromeOS::StopWatchingFD() {
+  if (!file_.get()) {
+    VLOG(1) << "StopWatchingFD - skip";
+    return;
+  }
+
+  bool stopped = fd_read_watcher_.StopWatchingFileDescriptor();
+  VLOG(1) << "StopWatchingFD - watch stopped: " << stopped;
+  CHECK(stopped);
+
+  read_mtu_ = kInvalidReadMtu;
+  write_mtu_ = kInvalidWriteMtu;
+  file_.reset();  // This will close the file descriptor.
+}
+
+void BluetoothAudioSinkChromeOS::ReadFromFile() {
+  DCHECK(file_.get() && file_->IsValid());
+  DCHECK(data_.get());
+
+  int size = file_->ReadAtCurrentPosNoBestEffort(data_.get(), read_mtu_);
+
+  if (size == -1) {
+    // To reduce the number of logs, log only once for multiple failures.
+    if (!read_has_failed_) {
+      VLOG(1) << "ReadFromFile - failed";
+      read_has_failed_ = true;
+    }
+    return;
+  }
+
+  VLOG(1) << "ReadFromFile - read " << size << " bytes";
+  FOR_EACH_OBSERVER(BluetoothAudioSink::Observer, observers_,
+                    BluetoothAudioSinkDataAvailable(this, data_.get(), size));
 }
 
 void BluetoothAudioSinkChromeOS::StateChanged(
     BluetoothAudioSink::State state) {
   if (state == state_)
     return;
 
-  VLOG(1) << "StateChnaged: " << StateToString(state);
+  VLOG(1) << "StateChanged - state: " << StateToString(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.
-      // Stop watching on file descriptor if there is one.
+      StopWatchingFD();
       break;
     case BluetoothAudioSink::STATE_PENDING:
-      // TODO(mcchou): BUG=441581
-      // Call BluetoothMediaTransportClient::Acquire() to get fd and mtus.
+      AcquireFD();
       break;
     case BluetoothAudioSink::STATE_ACTIVE:
-      // TODO(mcchou): BUG=441581
-      // Read from fd and call DataAvailable.
-      ReadFromFD();
+      WatchFD();
       break;
     default:
       break;
   }
 
   state_ = state;
   FOR_EACH_OBSERVER(BluetoothAudioSink::Observer, observers_,
                     BluetoothAudioSinkStateChanged(this, state_));
 }
 
@@ skipping 23 matching lines @@
     const std::string& error_message) {
   VLOG(1) << "OnRegisterFailed - error name: " << error_name
           << ", error message: " << error_message;
 
   ResetEndpoint();
   error_callback.Run(BluetoothAudioSink::ERROR_NOT_REGISTERED);
 }
 
 void BluetoothAudioSinkChromeOS::OnUnregisterSucceeded(
     const base::Closure& callback) {
-  VLOG(1) << "Unregisterd";
+  VLOG(1) << "Unregistered - endpoint: " << endpoint_path_.value();
 
   // 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) << "OnUnregisterFailed - error name: " << error_name
           << ", error message: " << error_message;
 
   error_callback.Run(BluetoothAudioSink::ERROR_NOT_UNREGISTERED);
 }
 
-void BluetoothAudioSinkChromeOS::ReadFromFD() {
-  DCHECK_GE(fd_.value(), 0);
+void BluetoothAudioSinkChromeOS::OnAcquireSucceeded(
+    dbus::FileDescriptor* fd,
+    const uint16_t read_mtu,
+    const uint16_t write_mtu) {
+  CHECK(fd);
+  fd->CheckValidity();
+  CHECK(fd->is_valid() && fd->value() != kInvalidFd);
+  CHECK_GT(read_mtu, kInvalidReadMtu);
+  CHECK_GT(write_mtu, kInvalidWriteMtu);
 
-  // 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.
+  // Avoids unnecessary memory reallocation if read MTU doesn't change.
+  if (read_mtu != read_mtu_) {
+    read_mtu_ = read_mtu;
+    data_.reset(new char[read_mtu_]);
+    VLOG(1) << "OnAcquireSucceeded - allocate " << read_mtu_
+            << " bytes of memory";
+  }
+
+  write_mtu_ = write_mtu;
+
+  // Avoids closing the same file descriptor caused by reassignment.
+  if (!file_.get() || file_->GetPlatformFile() != fd->value()) {
+    // Takes ownership of the file descriptor.
+    file_.reset(new base::File(fd->TakeValue()));
+    DCHECK(file_->IsValid());
+    VLOG(1) << "OnAcquireSucceeded - update file";
+  }
+
+  VLOG(1) << "OnAcquireSucceeded - file: " << file_->GetPlatformFile()
+          << ", read MTU: " << read_mtu_ << ", write MTU: " << write_mtu_;
+}
+
+void BluetoothAudioSinkChromeOS::OnAcquireFailed(
+    const std::string& error_name,
+    const std::string& error_message) {
+  VLOG(1) << "OnAcquireFailed - error name: " << error_name
+          << ", error message: " << error_message;
+}
+
+void BluetoothAudioSinkChromeOS::OnReleaseFDSucceeded() {
+  VLOG(1) << "OnReleaseFDSucceeded";
+}
+
+void BluetoothAudioSinkChromeOS::OnReleaseFDFailed(
+    const std::string& error_name,
+    const std::string& error_message) {
+  VLOG(1) << "OnReleaseFDFailed - error name: " << error_name
+          << ", error message: " << error_message;
 }
 
 void BluetoothAudioSinkChromeOS::ResetMedia() {
   VLOG(1) << "ResetMedia";
 
   media_path_ = dbus::ObjectPath("");
 }
 
 void BluetoothAudioSinkChromeOS::ResetTransport() {
-  VLOG(1) << "ResetTransport";
+  if (!transport_path_.IsValid()) {
+    VLOG(1) << "ResetTransport - skip";
+    return;
+  }
 
-  if (transport_path_.value() == "")
-    return;
+  VLOG(1) << "ResetTransport - clean-up";
+
+  VolumeChanged(BluetoothAudioSink::kInvalidVolume);
   transport_path_ = dbus::ObjectPath("");
-  VolumeChanged(BluetoothAudioSink::kInvalidVolume);
-  read_mtu_ = 0;
-  write_mtu_ = 0;
-  fd_.PutValue(-1);
+  read_mtu_ = kInvalidReadMtu;
+  write_mtu_ = kInvalidWriteMtu;
+  file_.reset();
 }
 
 void BluetoothAudioSinkChromeOS::ResetEndpoint() {
   VLOG(1) << "ResetEndpoint";
 
   endpoint_path_ = ObjectPath("");
   media_endpoint_ = nullptr;
 }
 
 }  // namespace chromeos