ipc/mojo/ipc_message_pipe_reader.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 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_