[device] Replace MessageLoopProxy usage with ThreadTaskRunnerHandle

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 "base/callback.h"
 #include "base/files/file.h"
 #include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/non_thread_safe.h"
 #include "device/serial/buffer.h"
 #include "device/serial/serial.mojom.h"
 
 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::MessageLoopProxy> file_thread_message_loop,
-      scoped_refptr<base::MessageLoopProxy> ui_thread_message_loop);
+      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);
 
   // Signals that the access request for |port| is complete.
   void OnRequestAccessComplete(const std::string& port, bool success);
@@ skipping 38 matching lines @@
   // configuration was successful.
   bool ConfigurePort(const serial::ConnectionOptions& options);
 
   // Performs a platform-specific port configuration query. Fills values in an
   // existing ConnectionInfo. Returns |true| iff port configuration was
   // successfully retrieved.
   virtual serial::ConnectionInfoPtr GetPortInfo() const = 0;
 
  protected:
   explicit SerialIoHandler(
-      scoped_refptr<base::MessageLoopProxy> file_thread_message_loop,
-      scoped_refptr<base::MessageLoopProxy> ui_thread_message_loop);
+      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;
 
   // Performs a platform-specific write operation. This must guarantee that
   // WriteCompleted is called when the underlying async operation is completed
   // or the SerialIoHandler instance will leak.
   // NOTE: Implementations of WriteImpl should never call WriteCompleted
   // directly. Use QueueWriteCompleted instead to avoid reentrancy.
   virtual void WriteImpl() = 0;
 
   // Platform-specific read cancelation.
   virtual void CancelReadImpl() = 0;
 
   // Platform-specific write cancelation.
   virtual void CancelWriteImpl() = 0;
 
   // Platform-specific port configuration applies options_ to the device.
   virtual bool ConfigurePortImpl() = 0;
 
   // Requests access to the underlying serial device, if needed.
   virtual void RequestAccess(
       const std::string& port,
-      scoped_refptr<base::MessageLoopProxy> file_message_loop,
-      scoped_refptr<base::MessageLoopProxy> ui_message_loop);
+      scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
 
   // Performs platform-specific, one-time port configuration on open.
   virtual bool PostOpen();
 
   // Called by the implementation to signal that the active read has completed.
   // WARNING: Calling this method can destroy the SerialIoHandler instance
   // if the associated I/O operation was the only thing keeping it alive.
   void ReadCompleted(int bytes_read, serial::ReceiveError error);
 
   // Called by the implementation to signal that the active write has completed.
@@ skipping 44 matching lines @@
   // Possibly fixes up a serial port path name in a platform-specific manner.
   static std::string MaybeFixUpPortName(const std::string& port_name);
 
  private:
   friend class base::RefCounted<SerialIoHandler>;
 
   void MergeConnectionOptions(const serial::ConnectionOptions& options);
 
   // Continues an Open operation on the FILE thread.
   void StartOpen(const std::string& port,
-                 scoped_refptr<base::MessageLoopProxy> io_message_loop);
+                 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner);
 
   // Finalizes an Open operation (continued from StartOpen) on the IO thread.
   void FinishOpen(base::File file);
 
   void Close();
 
   // Continues a Close operation on the FILE thread.
   static void DoClose(base::File port);
 
   // File for the opened serial device. This value is only modified from the IO
   // thread.
   base::File file_;
 
   // Currently applied connection options.
   serial::ConnectionOptions options_;
 
   scoped_ptr<WritableBuffer> pending_read_buffer_;
   serial::ReceiveError read_cancel_reason_;
   bool read_canceled_;
 
   scoped_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::MessageLoopProxy> file_thread_message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> file_thread_task_runner_;
   // On Chrome OS, PermissionBrokerClient should be called on the UI thread.
-  scoped_refptr<base::MessageLoopProxy> ui_thread_message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(SerialIoHandler);
 };
 
 }  // namespace device
 
 #endif  // DEVICE_SERIAL_SERIAL_IO_HANDLER_H_