dbus: No dbus::FileDescriptor in BluetoothMediaTransportClient

device/bluetooth/bluez/bluetooth_audio_sink_bluez.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/bluez/bluetooth_audio_sink_bluez.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 "dbus/message.h"
 #include "device/bluetooth/bluez/bluetooth_adapter_bluez.h"
 #include "device/bluetooth/dbus/bluez_dbus_manager.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());
 }
@@ skipping 443 matching lines @@
 void BluetoothAudioSinkBlueZ::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 BluetoothAudioSinkBlueZ::OnAcquireSucceeded(dbus::FileDescriptor* fd,
+void BluetoothAudioSinkBlueZ::OnAcquireSucceeded(base::ScopedFD fd,
                                                  const uint16_t read_mtu,
                                                  const uint16_t write_mtu) {
-  CHECK(fd);
-  fd->CheckValidity();
-  CHECK(fd->is_valid() && fd->value() != kInvalidFd);
+  CHECK(fd.is_valid());
   CHECK_GT(read_mtu, kInvalidReadMtu);
   CHECK_GT(write_mtu, kInvalidWriteMtu);
 
   // 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()) {
+  if (!file_.get() || file_->GetPlatformFile() != fd.get()) {
     // Takes ownership of the file descriptor.
-    file_.reset(new base::File(fd->TakeValue()));
+    file_.reset(new base::File(fd.release()));
     DCHECK(file_->IsValid());
     VLOG(1) << "OnAcquireSucceeded - update file";
   }
 
   VLOG(1) << "OnAcquireSucceeded - file: " << file_->GetPlatformFile()
           << ", read MTU: " << read_mtu_ << ", write MTU: " << write_mtu_;
 }
 
 void BluetoothAudioSinkBlueZ::OnAcquireFailed(
     const std::string& error_name,
@@ skipping 35 matching lines @@
 }
 
 void BluetoothAudioSinkBlueZ::ResetEndpoint() {
   VLOG(1) << "ResetEndpoint";
 
   endpoint_path_ = ObjectPath("");
   media_endpoint_ = nullptr;
 }
 
 }  // namespace bluez