1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef MOJO_PUBLIC_CPP_SYSTEM_MESSAGE_PIPE_H_
6#define MOJO_PUBLIC_CPP_SYSTEM_MESSAGE_PIPE_H_
7
8#include <assert.h>
9
10#include "mojo/public/c/system/message_pipe.h"
11#include "mojo/public/cpp/system/handle.h"
12#include "mojo/public/cpp/system/macros.h"
13
14namespace mojo {
15
16// MessagePipeHandle -----------------------------------------------------------
17
18class MessagePipeHandle : public Handle {
19 public:
20  MessagePipeHandle() {}
21  explicit MessagePipeHandle(MojoHandle value) : Handle(value) {}
22
23  // Copying and assignment allowed.
24};
25
26MOJO_COMPILE_ASSERT(sizeof(MessagePipeHandle) == sizeof(Handle),
27                    bad_size_for_cpp_MessagePipeHandle);
28
29typedef ScopedHandleBase<MessagePipeHandle> ScopedMessagePipeHandle;
30MOJO_COMPILE_ASSERT(sizeof(ScopedMessagePipeHandle) ==
31                        sizeof(MessagePipeHandle),
32                    bad_size_for_cpp_ScopedMessagePipeHandle);
33
34inline MojoResult CreateMessagePipe(const MojoCreateMessagePipeOptions* options,
35                                    ScopedMessagePipeHandle* message_pipe0,
36                                    ScopedMessagePipeHandle* message_pipe1) {
37  assert(message_pipe0);
38  assert(message_pipe1);
39  MessagePipeHandle handle0;
40  MessagePipeHandle handle1;
41  MojoResult rv = MojoCreateMessagePipe(options,
42                                        handle0.mutable_value(),
43                                        handle1.mutable_value());
44  // Reset even on failure (reduces the chances that a "stale"/incorrect handle
45  // will be used).
46  message_pipe0->reset(handle0);
47  message_pipe1->reset(handle1);
48  return rv;
49}
50
51// These "raw" versions fully expose the underlying API, but don't help with
52// ownership of handles (especially when writing messages).
53// TODO(vtl): Write "baked" versions.
54inline MojoResult WriteMessageRaw(MessagePipeHandle message_pipe,
55                                  const void* bytes,
56                                  uint32_t num_bytes,
57                                  const MojoHandle* handles,
58                                  uint32_t num_handles,
59                                  MojoWriteMessageFlags flags) {
60  return MojoWriteMessage(message_pipe.value(), bytes, num_bytes, handles,
61                          num_handles, flags);
62}
63
64inline MojoResult ReadMessageRaw(MessagePipeHandle message_pipe,
65                                 void* bytes,
66                                 uint32_t* num_bytes,
67                                 MojoHandle* handles,
68                                 uint32_t* num_handles,
69                                 MojoReadMessageFlags flags) {
70  return MojoReadMessage(message_pipe.value(), bytes, num_bytes, handles,
71                         num_handles, flags);
72}
73
74// A wrapper class that automatically creates a message pipe and owns both
75// handles.
76class MessagePipe {
77 public:
78  MessagePipe();
79  explicit MessagePipe(const MojoCreateMessagePipeOptions& options);
80  ~MessagePipe();
81
82  ScopedMessagePipeHandle handle0;
83  ScopedMessagePipeHandle handle1;
84};
85
86inline MessagePipe::MessagePipe() {
87  MojoResult result MOJO_ALLOW_UNUSED =
88      CreateMessagePipe(NULL, &handle0, &handle1);
89  assert(result == MOJO_RESULT_OK);
90}
91
92inline MessagePipe::MessagePipe(const MojoCreateMessagePipeOptions& options) {
93  MojoResult result MOJO_ALLOW_UNUSED =
94      CreateMessagePipe(&options, &handle0, &handle1);
95  assert(result == MOJO_RESULT_OK);
96}
97
98inline MessagePipe::~MessagePipe() {
99}
100
101}  // namespace mojo
102
103#endif  // MOJO_PUBLIC_CPP_SYSTEM_MESSAGE_PIPE_H_
104