Removing file_thread_task_runner parameter from SerialIoHandler

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>
@@ skipping 12 matching lines @@
 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::RefCountedThreadSafe<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)
@@ skipping 61 matching lines @@
   // Initiates a BREAK signal. Places the transmission line in a break state
   // until the |ClearBreak| is called.
   virtual bool SetBreak() = 0;
 
   // Terminates the BREAK signal. Places the transmission line in a nonbreak
   // state.
   virtual bool ClearBreak() = 0;
 
  protected:
   explicit SerialIoHandler(
-      scoped_refptr<base::SingleThreadTaskRunner> file_thread_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner);
   virtual ~SerialIoHandler();
 
   // Performs a platform-specific read operation. This must guarantee that
   // ReadCompleted is called when the underlying async operation is completed
   // or the SerialIoHandler instance will leak.
   // NOTE: Implementations of ReadImpl should never call ReadCompleted directly.
   // Use QueueReadCompleted instead to avoid reentrancy.
   virtual void ReadImpl() = 0;
 
@@ skipping 62 matching lines @@
 
   serial::SendError write_cancel_reason() const { return write_cancel_reason_; }
 
   bool write_canceled() const { return write_canceled_; }
 
   const serial::ConnectionOptions& options() const { return options_; }
 
   // Possibly fixes up a serial port path name in a platform-specific manner.
   static std::string MaybeFixUpPortName(const std::string& port_name);
 
-  base::SingleThreadTaskRunner* file_thread_task_runner() const {
-    return file_thread_task_runner_.get();
-  }
-
   base::SingleThreadTaskRunner* ui_thread_task_runner() const {
     return ui_thread_task_runner_.get();
   }
 
   const std::string& port() const { return port_; }
 
   SEQUENCE_CHECKER(sequence_checker_);
 
  private:
   friend class base::RefCountedThreadSafe<SerialIoHandler>;
@@ skipping 23 matching lines @@
   serial::ReceiveError read_cancel_reason_;
   bool read_canceled_;
 
   std::unique_ptr<ReadOnlyBuffer> pending_write_buffer_;
   serial::SendError write_cancel_reason_;
   bool write_canceled_;
 
   // Callback to handle the completion of a pending Open() request.
   OpenCompleteCallback open_complete_;
 
-  scoped_refptr<base::SingleThreadTaskRunner> file_thread_task_runner_;
   // On Chrome OS, PermissionBrokerClient should be called on the UI thread.
   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_