1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
// 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.
// This file provides a C++ wrapping around the Mojo C API for shared buffers,
// replacing the prefix of "Mojo" with a "mojo" namespace, and using more
// strongly-typed representations of |MojoHandle|s.
//
// Please see "mojo/public/c/system/buffer.h" for complete documentation of the
// API.
#ifndef MOJO_PUBLIC_CPP_SYSTEM_BUFFER_H_
#define MOJO_PUBLIC_CPP_SYSTEM_BUFFER_H_
#include <stdint.h>
#include "base/compiler_specific.h"
#include "base/logging.h"
#include "mojo/public/c/system/buffer.h"
#include "mojo/public/cpp/system/handle.h"
namespace mojo {
// A strongly-typed representation of a |MojoHandle| referring to a shared
// buffer.
class SharedBufferHandle : public Handle {
public:
SharedBufferHandle() {}
explicit SharedBufferHandle(MojoHandle value) : Handle(value) {}
// Copying and assignment allowed.
};
static_assert(sizeof(SharedBufferHandle) == sizeof(Handle),
"Bad size for C++ SharedBufferHandle");
typedef ScopedHandleBase<SharedBufferHandle> ScopedSharedBufferHandle;
static_assert(sizeof(ScopedSharedBufferHandle) == sizeof(SharedBufferHandle),
"Bad size for C++ ScopedSharedBufferHandle");
// Creates a shared buffer. See |MojoCreateSharedBuffer()| for complete
// documentation.
inline MojoResult CreateSharedBuffer(
const MojoCreateSharedBufferOptions* options,
uint64_t num_bytes,
ScopedSharedBufferHandle* shared_buffer) {
DCHECK(shared_buffer);
SharedBufferHandle handle;
MojoResult rv =
MojoCreateSharedBuffer(options, num_bytes, handle.mutable_value());
// Reset even on failure (reduces the chances that a "stale"/incorrect handle
// will be used).
shared_buffer->reset(handle);
return rv;
}
// Duplicates a handle to a buffer, most commonly so that the buffer can be
// shared with other applications. See |MojoDuplicateBufferHandle()| for
// complete documentation.
//
// TODO(ggowan): Rename this to DuplicateBufferHandle since it is making another
// handle to the same buffer, not duplicating the buffer itself.
//
// TODO(vtl): This (and also the functions below) are templatized to allow for
// future/other buffer types. A bit "safer" would be to overload this function
// manually. (The template enforces that the in and out handles be of the same
// type.)
template <class BufferHandleType>
inline MojoResult DuplicateBuffer(
BufferHandleType buffer,
const MojoDuplicateBufferHandleOptions* options,
ScopedHandleBase<BufferHandleType>* new_buffer) {
DCHECK(new_buffer);
BufferHandleType handle;
MojoResult rv = MojoDuplicateBufferHandle(
buffer.value(), options, handle.mutable_value());
// Reset even on failure (reduces the chances that a "stale"/incorrect handle
// will be used).
new_buffer->reset(handle);
return rv;
}
// Maps a part of a buffer (specified by |buffer|, |offset|, and |num_bytes|)
// into memory. See |MojoMapBuffer()| for complete documentation.
template <class BufferHandleType>
inline MojoResult MapBuffer(BufferHandleType buffer,
uint64_t offset,
uint64_t num_bytes,
void** pointer,
MojoMapBufferFlags flags) {
DCHECK(buffer.is_valid());
return MojoMapBuffer(buffer.value(), offset, num_bytes, pointer, flags);
}
// Unmaps a part of a buffer that was previously mapped with |MapBuffer()|.
// See |MojoUnmapBuffer()| for complete documentation.
inline MojoResult UnmapBuffer(void* pointer) {
DCHECK(pointer);
return MojoUnmapBuffer(pointer);
}
// A wrapper class that automatically creates a shared buffer and owns the
// handle.
class SharedBuffer {
public:
explicit SharedBuffer(uint64_t num_bytes);
SharedBuffer(uint64_t num_bytes,
const MojoCreateSharedBufferOptions& options);
~SharedBuffer();
ScopedSharedBufferHandle handle;
};
inline SharedBuffer::SharedBuffer(uint64_t num_bytes) {
MojoResult result = CreateSharedBuffer(nullptr, num_bytes, &handle);
ALLOW_UNUSED_LOCAL(result);
DCHECK_EQ(MOJO_RESULT_OK, result);
}
inline SharedBuffer::SharedBuffer(
uint64_t num_bytes,
const MojoCreateSharedBufferOptions& options) {
MojoResult result = CreateSharedBuffer(&options, num_bytes, &handle);
ALLOW_UNUSED_LOCAL(result);
DCHECK_EQ(MOJO_RESULT_OK, result);
}
inline SharedBuffer::~SharedBuffer() {
}
} // namespace mojo
#endif // MOJO_PUBLIC_CPP_SYSTEM_BUFFER_H_
|
