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 14namespace mojo { 15 16// SharedBufferHandle ---------------------------------------------------------- 17 18class SharedBufferHandle : public Handle { 19 public: 20 SharedBufferHandle() {} 21 explicit SharedBufferHandle(MojoHandle value) : Handle(value) {} 22 23 // Copying and assignment allowed. 24}; 25 26MOJO_COMPILE_ASSERT(sizeof(SharedBufferHandle) == sizeof(Handle), 27 bad_size_for_cpp_SharedBufferHandle); 28 29typedef ScopedHandleBase<SharedBufferHandle> ScopedSharedBufferHandle; 30MOJO_COMPILE_ASSERT(sizeof(ScopedSharedBufferHandle) == 31 sizeof(SharedBufferHandle), 32 bad_size_for_cpp_ScopedSharedBufferHandle); 33 34inline 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.) 52template <class BufferHandleType> 53inline 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 67template <class BufferHandleType> 68inline 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 77inline 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. 84class 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 94inline 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 100inline 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 108inline SharedBuffer::~SharedBuffer() { 109} 110 111} // namespace mojo 112 113#endif // MOJO_PUBLIC_CPP_SYSTEM_BUFFER_H_ 114