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_BUFFER_H_
6 #define MOJO_PUBLIC_CPP_SYSTEM_BUFFER_H_
7
8 #include <assert.h>
9
10 #include "mojo/public/c/system/buffer.h"
11 #include "mojo/public/cpp/system/handle.h"
12 #include "mojo/public/cpp/system/macros.h"
13
14 namespace mojo {
15
16 // SharedBufferHandle ----------------------------------------------------------
17
18 class SharedBufferHandle : public Handle {
19 public:
SharedBufferHandle()20 SharedBufferHandle() {}
SharedBufferHandle(MojoHandle value)21 explicit SharedBufferHandle(MojoHandle value) : Handle(value) {}
22
23 // Copying and assignment allowed.
24 };
25
26 MOJO_COMPILE_ASSERT(sizeof(SharedBufferHandle) == sizeof(Handle),
27 bad_size_for_cpp_SharedBufferHandle);
28
29 typedef ScopedHandleBase<SharedBufferHandle> ScopedSharedBufferHandle;
30 MOJO_COMPILE_ASSERT(sizeof(ScopedSharedBufferHandle) ==
31 sizeof(SharedBufferHandle),
32 bad_size_for_cpp_ScopedSharedBufferHandle);
33
CreateSharedBuffer(const MojoCreateSharedBufferOptions * options,uint64_t num_bytes,ScopedSharedBufferHandle * shared_buffer)34 inline MojoResult CreateSharedBuffer(
35 const MojoCreateSharedBufferOptions* options,
36 uint64_t num_bytes,
37 ScopedSharedBufferHandle* shared_buffer) {
38 assert(shared_buffer);
39 SharedBufferHandle handle;
40 MojoResult rv = MojoCreateSharedBuffer(options, num_bytes,
41 handle.mutable_value());
42 // Reset even on failure (reduces the chances that a "stale"/incorrect handle
43 // will be used).
44 shared_buffer->reset(handle);
45 return rv;
46 }
47
48 // TODO(vtl): This (and also the functions below) are templatized to allow for
49 // future/other buffer types. A bit "safer" would be to overload this function
50 // manually. (The template enforces that the in and out handles to be of the
51 // same type.)
52 template <class BufferHandleType>
DuplicateBuffer(BufferHandleType buffer,const MojoDuplicateBufferHandleOptions * options,ScopedHandleBase<BufferHandleType> * new_buffer)53 inline MojoResult DuplicateBuffer(
54 BufferHandleType buffer,
55 const MojoDuplicateBufferHandleOptions* options,
56 ScopedHandleBase<BufferHandleType>* new_buffer) {
57 assert(new_buffer);
58 BufferHandleType handle;
59 MojoResult rv = MojoDuplicateBufferHandle(
60 buffer.value(), options, handle.mutable_value());
61 // Reset even on failure (reduces the chances that a "stale"/incorrect handle
62 // will be used).
63 new_buffer->reset(handle);
64 return rv;
65 }
66
67 template <class BufferHandleType>
MapBuffer(BufferHandleType buffer,uint64_t offset,uint64_t num_bytes,void ** pointer,MojoMapBufferFlags flags)68 inline MojoResult MapBuffer(BufferHandleType buffer,
69 uint64_t offset,
70 uint64_t num_bytes,
71 void** pointer,
72 MojoMapBufferFlags flags) {
73 assert(buffer.is_valid());
74 return MojoMapBuffer(buffer.value(), offset, num_bytes, pointer, flags);
75 }
76
UnmapBuffer(void * pointer)77 inline MojoResult UnmapBuffer(void* pointer) {
78 assert(pointer);
79 return MojoUnmapBuffer(pointer);
80 }
81
82 // A wrapper class that automatically creates a shared buffer and owns the
83 // handle.
84 class SharedBuffer {
85 public:
86 explicit SharedBuffer(uint64_t num_bytes);
87 SharedBuffer(uint64_t num_bytes,
88 const MojoCreateSharedBufferOptions& options);
89 ~SharedBuffer();
90
91 ScopedSharedBufferHandle handle;
92 };
93
SharedBuffer(uint64_t num_bytes)94 inline SharedBuffer::SharedBuffer(uint64_t num_bytes) {
95 MojoResult result MOJO_ALLOW_UNUSED =
96 CreateSharedBuffer(NULL, num_bytes, &handle);
97 assert(result == MOJO_RESULT_OK);
98 }
99
SharedBuffer(uint64_t num_bytes,const MojoCreateSharedBufferOptions & options)100 inline SharedBuffer::SharedBuffer(
101 uint64_t num_bytes,
102 const MojoCreateSharedBufferOptions& options) {
103 MojoResult result MOJO_ALLOW_UNUSED =
104 CreateSharedBuffer(&options, num_bytes, &handle);
105 assert(result == MOJO_RESULT_OK);
106 }
107
~SharedBuffer()108 inline SharedBuffer::~SharedBuffer() {
109 }
110
111 } // namespace mojo
112
113 #endif // MOJO_PUBLIC_CPP_SYSTEM_BUFFER_H_
114