Moterm part 2: Add MotermDriver, a terminal "driver".

apps/moterm/moterm_driver.h

Index: apps/moterm/moterm_driver.h
diff --git a/apps/moterm/moterm_driver.h b/apps/moterm/moterm_driver.h
new file mode 100644
index 0000000000000000000000000000000000000000..b8c07e7ba33ebc29f7212db1a4efc41a802cebbf
--- /dev/null
+++ b/apps/moterm/moterm_driver.h
@@ -0,0 +1,169 @@
+// Copyright 2015 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.
+
+// |MotermDriver| is a class providing a |mojo.files.File| interface,
+// implementing termios-type features (e.g., line editing; TODO(vtl): lots to do
+// here), and appropriately processing bytes to/from the terminal (which gets
+// and sends "raw" data). In essence, this class includes what would
+// traditionally be called the terminal driver in a Unix kernel.
+
+#ifndef APPS_MOTERM_MOTERM_DRIVER_H_
+#define APPS_MOTERM_MOTERM_DRIVER_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <deque>
+
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "mojo/public/cpp/bindings/interface_request.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/services/files/public/interfaces/file.mojom.h"
+
+// TODO(vtl): Maybe we should Mojo-fy the driver and run it as a separate app?
+class MotermDriver : public mojo::files::File {
+ public:
+  // The |Client| is basically the terminal implementation itself, to which
+  // processed output (from an application, to the "file", through the driver)
+  // is sent. It also receives other notifications (e.g., when the "file" is
+  // closed or otherwise "broken").
+  class Client {
+   public:
+    // Called when we receive data (for the client to "display").
+    // TODO(vtl): Maybe add a way to throttle (e.g., for the client to not
+    // accept all the data).
+    // TODO(vtl): It's "probably OK" to call |Detach()| from inside this method,
+    // but not verified.
+    virtual void OnDataReceived(const void* bytes, size_t num_bytes) = 0;
+
+    // Called when the terminal "file" is closed (via |Close()|. (The client may
+    // optionally call |Detach()| in response.)
+    virtual void OnClosed() = 0;
+
+    // Called when this object is destroyed (which will happen if the other end
+    // of the message pipe is closed). The client must not call |Detach()| in
+    // response. (Obviously, this will only be called if the client has not
+    // called |Detach()|.)
+    virtual void OnDestroyed() = 0;
+  };
+
+  // Static factory method. |client| must either outlive us, or if not call
+  // |Detach()| before being destroyed.
+  static base::WeakPtr<MotermDriver> Create(
+      Client* client,
+      mojo::InterfaceRequest<mojo::files::File> request);
+
+  // Called by the client when it wishes to detach (i.e., no longer receive
+  // calls). This will terminate the connection and us.
+  void Detach();
+
+  // Called by the client when it has data to send.
+  // TODO(vtl): Add a way to throttle. (We could do this via an |OnDataSent()|
+  // ack, or in other ways as well, e.g., reporting how much data we have
+  // enqueued.) For now, just queue data infinitely.
+  // TODO(vtl): This is misnamed -- it's really "here's some input".
+  void SendData(const void* bytes, size_t num_bytes);
+
+ private:
+  struct PendingRead {
+    PendingRead(uint32_t num_bytes, const ReadCallback& callback);
+    ~PendingRead();
+
+    uint32_t num_bytes;
+    ReadCallback callback;
+  };
+
+  MotermDriver(Client* client,
+               mojo::InterfaceRequest<mojo::files::File> request);
+
+  // We should only be deleted by "ourself" (via the strong binding).
+  friend class mojo::StrongBinding<mojo::files::File>;
+  ~MotermDriver() override;
+
+  void HandleCanonicalModeInput(uint8_t ch);
+  void CompletePendingReads();
+  void FlushInputLine();
+
+  void HandleOutput(const uint8_t* bytes, size_t num_bytes);
+
+  // |mojo::files::File| implementation:
+  void Close(const CloseCallback& callback) override;
+  void Read(uint32_t num_bytes_to_read,
+            int64_t offset,
+            mojo::files::Whence whence,
+            const ReadCallback& callback) override;
+  void Write(mojo::Array<uint8_t> bytes_to_write,
+             int64_t offset,
+             mojo::files::Whence whence,
+             const WriteCallback& callback) override;
+  void ReadToStream(mojo::ScopedDataPipeProducerHandle source,
+                    int64_t offset,
+                    mojo::files::Whence whence,
+                    int64_t num_bytes_to_read,
+                    const ReadToStreamCallback& callback) override;
+  void WriteFromStream(mojo::ScopedDataPipeConsumerHandle sink,
+                       int64_t offset,
+                       mojo::files::Whence whence,
+                       const WriteFromStreamCallback& callback) override;
+  void Tell(const TellCallback& callback) override;
+  void Seek(int64_t offset,
+            mojo::files::Whence whence,
+            const SeekCallback& callback) override;
+  void Stat(const StatCallback& callback) override;
+  void Truncate(int64_t size, const TruncateCallback& callback) override;
+  void Touch(mojo::files::TimespecOrNowPtr atime,
+             mojo::files::TimespecOrNowPtr mtime,
+             const TouchCallback& callback) override;
+  void Dup(mojo::InterfaceRequest<mojo::files::File> file,
+           const DupCallback& callback) override;
+  void Reopen(mojo::InterfaceRequest<mojo::files::File> file,
+              uint32_t open_flags,
+              const ReopenCallback& callback) override;
+  void AsBuffer(const AsBufferCallback& callback) override;
+  void Ioctl(uint32_t request,
+             mojo::Array<uint32_t> in_values,
+             const IoctlCallback& callback) override;
+
+  Client* client_;  // Set until |Detach()| is called.
+  bool is_closed_;
+
+  std::deque<uint8_t> send_data_queue_;
+  // For canonical mode. Feeds into |send_data_queue_|.
+  std::deque<uint8_t> input_line_queue_;
+  std::deque<PendingRead> pending_read_queue_;
+
+  // Note: This binding must be after |pending_read_queue_|, so that it gets
+  // torn down before the callbacks in |pending_read_queue_| are destroyed
+  // (otherwise we'll get |DCHECK()| failures).
+  mojo::StrongBinding<mojo::files::File> binding_;
+
+  // Terminal driver settings:
+  // (Names roughly correspond to termios names.)
+  // TODO(vtl): Add a way to set/change settings (including using ioctls).
+  // TODO(vtl): Our support for termios requirements is very far from complete.
+
+  // Input settings:
+
+  // Canonical, a.k.a. "cooked", mode. If true, will echo, line buffer, etc. If
+  // false, no input processing is done (other than perhaps to slightly
+  // time-delay the availability of input -- we don't do this).
+  bool icanon_;
+
+  // If true, will convert input CRs to NLs (in canonical mode).
+  bool icrnl_;
+
+  uint8_t veof_;
+  uint8_t verase_;
+
+  // Output settings:
+  // If true, will convert output CRs to CR-NL pairs.
+  bool onlcr_;
+
+  base::WeakPtrFactory<MotermDriver> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(MotermDriver);
+};
+
+#endif  // APPS_MOTERM_MOTERM_DRIVER_H_