Add a partial Mojo serial connection interface and implementation.

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/threading/non_thread_safe.h"
 #include "device/serial/serial.mojom.h"
 #include "net/base/io_buffer.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();
+  static scoped_refptr<SerialIoHandler> Create(
+      scoped_refptr<base::MessageLoopProxy> file_thread_message_loop);
 
   typedef base::Callback<void(bool success)> OpenCompleteCallback;
 
   // Called with a string of bytes read, and a result code. Note that an error
   // result does not necessarily imply 0 bytes read.
   typedef base::Callback<void(const std::string& data,
                               serial::ReceiveError error)> ReadCompleteCallback;
 
   // Called with the number of bytes written and a result code. Note that an
   // error result does not necessarily imply 0 bytes written.
   typedef base::Callback<void(int bytes_written, serial::SendError error)>
       WriteCompleteCallback;
 
   // Initializes the handler on the current message loop. Must be called exactly
   // once before performing any I/O through the handler.
-  virtual void Initialize(
-      const ReadCompleteCallback& read_callback,
-      const WriteCompleteCallback& write_callback,
-      scoped_refptr<base::MessageLoopProxy> file_thread_message_loop);
+  virtual void Initialize(const ReadCompleteCallback& read_callback,
+                          const WriteCompleteCallback& write_callback);
 
   // Initiates an asynchronous Open of the device.
   virtual void Open(const std::string& port,
                     const OpenCompleteCallback& callback);
 
   // Performs an async Read operation. Behavior is undefined if this is called
   // while a Read is already pending. Otherwise, the ReadCompleteCallback
   // (see above) will eventually be called with a result.
   void Read(int max_bytes);
 
@@ skipping 31 matching lines @@
   // Performs platform-specific port configuration. Returns |true| iff
   // configuration was successful.
   virtual bool ConfigurePort(const serial::ConnectionOptions& options) = 0;
 
   // 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:
-  SerialIoHandler();
+  explicit SerialIoHandler(
+      scoped_refptr<base::MessageLoopProxy> file_thread_message_loop);
   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
@@ skipping 95 matching lines @@
   OpenCompleteCallback open_complete_;
 
   scoped_refptr<base::MessageLoopProxy> file_thread_message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(SerialIoHandler);
 };
 
 }  // namespace device
 
 #endif  // DEVICE_SERIAL_SERIAL_IO_HANDLER_H_