chromeos: Remove dbus::FileDescriptor from PermissionBrokerClient

device/hid/hid_service_linux.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 "device/hid/hid_service_linux.h"
 
 #include <fcntl.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 236 matching lines @@
   file_task_runner_->PostTask(FROM_HERE,
                               base::Bind(&HidServiceLinux::OpenOnBlockingThread,
                                          base::Passed(&params)));
 #endif  // defined(OS_CHROMEOS)
 }
 
 #if defined(OS_CHROMEOS)
 
 // static
 void HidServiceLinux::OnPathOpenComplete(std::unique_ptr<ConnectParams> params,
-                                         dbus::FileDescriptor fd) {
+                                         base::ScopedFD fd) {
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner =
       params->file_task_runner;
-  file_task_runner->PostTask(
-      FROM_HERE, base::Bind(&HidServiceLinux::ValidateFdOnBlockingThread,
-                            base::Passed(&params), base::Passed(&fd)));
+  params->device_file = base::File(fd.release());
+  file_task_runner->PostTask(FROM_HERE, base::Bind(&HidServiceLinux::FinishOpen,
+                                                   base::Passed(&params)));
 }
 
 // static
 void HidServiceLinux::OnPathOpenError(const std::string& device_path,
                                       const ConnectCallback& callback,
                                       const std::string& error_name,
                                       const std::string& error_message) {
   HID_LOG(EVENT) << "Permission broker failed to open '" << device_path
                  << "': " << error_name << ": " << error_message;
   callback.Run(nullptr);
 }
 
-// static
-void HidServiceLinux::ValidateFdOnBlockingThread(
-    std::unique_ptr<ConnectParams> params,
-    dbus::FileDescriptor fd) {
-  base::ThreadRestrictions::AssertIOAllowed();
-  fd.CheckValidity();
-  DCHECK(fd.is_valid());
-  params->device_file = base::File(fd.TakeValue());
-  FinishOpen(std::move(params));
-}
-
 #else
 
 // static
 void HidServiceLinux::OpenOnBlockingThread(
     std::unique_ptr<ConnectParams> params) {
   base::ThreadRestrictions::AssertIOAllowed();
   scoped_refptr<base::SingleThreadTaskRunner> task_runner = params->task_runner;
 
   base::FilePath device_path(params->device_info->device_node());
   base::File& device_file = params->device_file;
@@ skipping 41 matching lines @@
 
 // static
 void HidServiceLinux::CreateConnection(std::unique_ptr<ConnectParams> params) {
   DCHECK(params->device_file.IsValid());
   params->callback.Run(make_scoped_refptr(new HidConnectionLinux(
       params->device_info, std::move(params->device_file),
       params->file_task_runner)));
 }
 
 }  // namespace device