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..ecfa018b5e02ba8712df8c17259f77c1c1f9355b
--- /dev/null
+++ b/ipc/mojo/ipc_message_pipe_reader.h
@@ -0,0 +1,98 @@
+// 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 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.
+//  * Create the subclass instance with a MessagePipeHandle.
+//    The constructor automatically start listening on the pipe.
+//
+// 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;
+  };
+
+  explicit MessagePipeReader(mojo::ScopedMessagePipeHandle handle);
+  virtual ~MessagePipeReader();
+
+  MojoHandle handle() const { return pipe_.get().value(); }
+
+  // Returns received bytes.
+  const std::vector<char>& data_buffer() const {
+    return data_buffer_;
+  }
+
+  // Delegate received handles ownership. The subclass should take the
+  // ownership over in its OnMessageReceived(). They will leak otherwise.
+  void TakeHandleBuffer(std::vector<MojoHandle>* handle_buffer) {
+    handle_buffer_.swap(*handle_buffer);
+  }
+
+  // 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 OnMessageReceived() = 0;
+  virtual void OnPipeClosed() = 0;
+  virtual void OnPipeError(MojoResult error) = 0;
+
+ private:
+  static void InvokePipeIsReady(void* closure, MojoResult result);
+
+  MojoResult ReadMessageBytes();
+  void PipeIsReady(MojoResult wait_result);
+  void StartWaiting();
+  void StopWaiting();
+
+  std::vector<char>  data_buffer_;
+  std::vector<MojoHandle> handle_buffer_;
+  MojoAsyncWaitID pipe_wait_id_;
+  mojo::ScopedMessagePipeHandle pipe_;
+
+  DISALLOW_COPY_AND_ASSIGN(MessagePipeReader);
+};
+
+}  // namespace internal
+}  // namespace IPC
+
+#endif  // IPC_IPC_MESSAGE_PIPE_READER_H_