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 14 namespace mojo { 15 16 // MessagePipeHandle ----------------------------------------------------------- 17 18 class MessagePipeHandle : public Handle { 19 public: 20 MessagePipeHandle() {} 21 explicit MessagePipeHandle(MojoHandle value) : Handle(value) {} 22 23 // Copying and assignment allowed. 24 }; 25 26 MOJO_COMPILE_ASSERT(sizeof(MessagePipeHandle) == sizeof(Handle), 27 bad_size_for_cpp_MessagePipeHandle); 28 29 typedef ScopedHandleBase<MessagePipeHandle> ScopedMessagePipeHandle; 30 MOJO_COMPILE_ASSERT(sizeof(ScopedMessagePipeHandle) == 31 sizeof(MessagePipeHandle), 32 bad_size_for_cpp_ScopedMessagePipeHandle); 33 34 inline 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. 54 inline 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 64 inline 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. 76 class MessagePipe { 77 public: 78 MessagePipe(); 79 explicit MessagePipe(const MojoCreateMessagePipeOptions& options); 80 ~MessagePipe(); 81 82 ScopedMessagePipeHandle handle0; 83 ScopedMessagePipeHandle handle1; 84 }; 85 86 inline MessagePipe::MessagePipe() { 87 MojoResult result MOJO_ALLOW_UNUSED = 88 CreateMessagePipe(NULL, &handle0, &handle1); 89 assert(result == MOJO_RESULT_OK); 90 } 91 92 inline MessagePipe::MessagePipe(const MojoCreateMessagePipeOptions& options) { 93 MojoResult result MOJO_ALLOW_UNUSED = 94 CreateMessagePipe(&options, &handle0, &handle1); 95 assert(result == MOJO_RESULT_OK); 96 } 97 98 inline MessagePipe::~MessagePipe() { 99 } 100 101 } // namespace mojo 102 103 #endif // MOJO_PUBLIC_CPP_SYSTEM_MESSAGE_PIPE_H_ 104