src/mojo/public/cpp/system/message_pipe.h

   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_