Introduce ChannelMojo

This CL introduces ChannelMojo IPC::Channel implementation
and optionally applies it for renderer-browser IPC channel.

Current stability is like 5-seconds browser and There are rough edges.
It often closes the channel so needs to be more robust.
Even though the level of stability, having it in the tree will helps
team to try and improve it.

BUG=377980
R=darin@chromium.org,jam@chromium.org,viettrungluu@chromium.org
TEST=ipc_channel_mojo_unittest.cc

Review URL: https://codereview.chromium.org/382333002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@287402 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 98 insertions, 0 deletions

diff --git a/ipc/mojo/ipc_message_pipe_reader.h b/ipc/mojo/ipc_message_pipe_reader.h
new file mode 100644
index 0000000..ecfa018
--- /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_