chromeos: Remove dbus::FileDescriptor from PermissionBrokerClient

device/serial/serial_io_handler.h

 // 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.
 
 #ifndef DEVICE_SERIAL_SERIAL_IO_HANDLER_H_
 #define DEVICE_SERIAL_SERIAL_IO_HANDLER_H_
 
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "device/serial/buffer.h"
 #include "device/serial/serial.mojom.h"
 
-namespace dbus {
-class FileDescriptor;
-}
-
 namespace device {
 
 // Provides a simplified interface for performing asynchronous I/O on serial
 // devices by hiding platform-specific MessageLoop interfaces. Pending I/O
 // operations hold a reference to this object until completion so that memory
 // doesn't disappear out from under the OS.
 class SerialIoHandler : public base::NonThreadSafe,
                         public base::RefCounted<SerialIoHandler> {
  public:
   // Constructs an instance of some platform-specific subclass.
   static scoped_refptr<SerialIoHandler> Create(
       scoped_refptr<base::SingleThreadTaskRunner> file_thread_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner);
 
   typedef base::Callback<void(bool success)> OpenCompleteCallback;
 
   // Initiates an asynchronous Open of the device.
   virtual void Open(const std::string& port,
                     const serial::ConnectionOptions& options,
                     const OpenCompleteCallback& callback);
 
 #if defined(OS_CHROMEOS)
   // Signals that the port has been opened.
   void OnPathOpened(
-      scoped_refptr<base::SingleThreadTaskRunner> file_thread_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> io_thread_task_runner,
-      dbus::FileDescriptor fd);
+      base::ScopedFD fd);
 
   // Signals that the permission broker failed to open the port.
   void OnPathOpenError(
       scoped_refptr<base::SingleThreadTaskRunner> io_thread_task_runner,
       const std::string& error_name,
       const std::string& error_message);
 
-  // Validates the file descriptor provided by the permission broker.
-  void ValidateOpenPort(
-      scoped_refptr<base::SingleThreadTaskRunner> io_thread_task_runner,
-      dbus::FileDescriptor fd);
-
   // Reports the open error from the permission broker.
   void ReportPathOpenError(const std::string& error_name,
                            const std::string& error_message);
 #endif  // defined(OS_CHROMEOS)
 
   // Performs an async Read operation. Behavior is undefined if this is called
   // while a Read is already pending. Otherwise, the Done or DoneWithError
   // method on |buffer| will eventually be called with a result.
   void Read(std::unique_ptr<WritableBuffer> buffer);
 
@@ skipping 180 matching lines @@
   scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner_;
 
   std::string port_;
 
   DISALLOW_COPY_AND_ASSIGN(SerialIoHandler);
 };
 
 }  // namespace device
 
 #endif  // DEVICE_SERIAL_SERIAL_IO_HANDLER_H_