Introduce ChannelMojo

ipc/mojo/ipc_message_pipe_reader.h

Index: ipc/mojo/ipc_message_pipe_reader.h
diff --git a/ipc/mojo/ipc_message_pipe_reader.h b/ipc/mojo/ipc_message_pipe_reader.h
new file mode 100644
index 0000000000000000000000000000000000000000..b3cec8c468788ac9fe228dac5e692522b916f5a3
--- /dev/null
+++ b/ipc/mojo/ipc_message_pipe_reader.h
@@ -0,0 +1,101 @@
+// Copyright (c) 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 IPC_IPC_MESSAGE_PIPE_READER_H_
+#define IPC_IPC_MESSAGE_PIPE_READER_H_
+
+#include <vector>
+
+#include "base/memory/scoped_ptr.h"
+#include "mojo/public/c/environment/async_waiter.h"
+#include "mojo/public/cpp/system/core.h"
+
+namespace IPC {
+namespace internal {
+
+// A helper class to handle bytestream directly over mojo::MessagePipe
+// in template-method pattern. MessagePipeReader manages the lifetime
+// of given MessagePipe and participates the event loop, and
+// read the stream and call the client when it is ready.
+//
+// Each client has to:
+//
+//  * Provide a subclass implemenation of a specific use of a MessagePipe
+//    and implement callbacks.
+//  * SetPipe() to activate the reader.
+//
+// MessageReader has to be used in IO thread. It isn't thread-safe.
+//
+class MessagePipeReader {
+ public:
+  // Delay the object deletion using the current message loop.
+  // This is intended to used by MessagePipeReader owners.
+  class DelayedDeleter {
+   public:
+    typedef base::DefaultDeleter<MessagePipeReader> DefaultType;
+
+    static void DeleteNow(MessagePipeReader* ptr) { delete ptr; }
+
+    DelayedDeleter() {}
+    DelayedDeleter(const DefaultType&) {}
+    DelayedDeleter& operator=(const DefaultType&) { return *this; }
+
+    void operator()(MessagePipeReader* ptr) const;
+  };
+
+  MessagePipeReader();
+  virtual ~MessagePipeReader();
+
+  MojoHandle handle() const { return pipe_.get().value(); }
+
+  // Returns received bytes.
+  const std::vector<char>& data_buffer() const {
+    return data_buffer_;
+  }
+
+  // Returns received handles. The lifetime should be taken over by
+  // the client before next OnMessageArrived(). They will leak
+  // otherwise.
+  const std::vector<MojoHandle>& handle_buffer() const {
+    return handle_buffer_;
+  }
+
+  // The the pipe and participate to current event loop with the pipe.
+  void SetPipe(mojo::ScopedMessagePipeHandle handle);
+
+  // Close and destroy the MessagePipe.
+  void Close();
+  // Close the mesage pipe with notifying the client with the error.
+  void CloseWithError(MojoResult error);
+  // Return true if the MessagePipe is alive.
+  bool IsValid() { return pipe_.is_valid(); }
+
+  //
+  // The client have to implment these callback to get the readiness
+  // event from the reader
+  //
+  virtual void OnMessageArrived() {}
+  virtual void OnPipeClosed() {}
+  virtual void OnPipeError(MojoResult error) {}
+
+ protected:
+  std::vector<char>  data_buffer_;
+  std::vector<MojoHandle> handle_buffer_;
+
+ private:
+  static void InvokePipeIsReady(void* closure, MojoResult result);
+
+  MojoResult ReadMessageBytes();
+  void PipeIsReady(MojoResult wait_result);
+  void StartWaiting();
+  void StopWaiting();
+
+  MojoAsyncWaitID pipe_wait_id_;
+  mojo::ScopedMessagePipeHandle pipe_;
+};
+
+}  // namespace internal
+}  // namespace IPC
+
+#endif  // IPC_IPC_MESSAGE_PIPE_READER_H_