| // 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. |
| |
| #include "mojo/system/entrypoints.h" |
| |
| #include "base/logging.h" |
| #include "mojo/public/c/system/buffer.h" |
| #include "mojo/public/c/system/data_pipe.h" |
| #include "mojo/public/c/system/functions.h" |
| #include "mojo/public/c/system/message_pipe.h" |
| #include "mojo/system/core.h" |
| |
| static mojo::system::Core* g_core = NULL; |
| |
| using mojo::system::MakeUserPointer; |
| |
| namespace mojo { |
| namespace system { |
| namespace entrypoints { |
| |
| void SetCore(Core* core) { |
| g_core = core; |
| } |
| |
| Core* GetCore() { |
| return g_core; |
| } |
| |
| } // namespace entrypoints |
| } // namepace system |
| } // namespace mojo |
| |
| // Definitions of the system functions. |
| extern "C" { |
| MojoTimeTicks MojoGetTimeTicksNow() { |
| return g_core->GetTimeTicksNow(); |
| } |
| |
| MojoResult MojoClose(MojoHandle handle) { |
| return g_core->Close(handle); |
| } |
| |
| MojoResult MojoWait(MojoHandle handle, |
| MojoHandleSignals signals, |
| MojoDeadline deadline) { |
| return g_core->Wait( |
| handle, signals, deadline, mojo::system::NullUserPointer()); |
| } |
| |
| MojoResult MojoWaitMany(const MojoHandle* handles, |
| const MojoHandleSignals* signals, |
| uint32_t num_handles, |
| MojoDeadline deadline) { |
| uint32_t result_index = static_cast<uint32_t>(-1); |
| MojoResult result = g_core->WaitMany(MakeUserPointer(handles), |
| MakeUserPointer(signals), |
| num_handles, |
| deadline, |
| MakeUserPointer(&result_index), |
| mojo::system::NullUserPointer()); |
| return (result == MOJO_RESULT_OK) ? static_cast<MojoResult>(result_index) |
| : result; |
| } |
| |
| MojoResult MojoCreateMessagePipe(const MojoCreateMessagePipeOptions* options, |
| MojoHandle* message_pipe_handle0, |
| MojoHandle* message_pipe_handle1) { |
| return g_core->CreateMessagePipe(MakeUserPointer(options), |
| MakeUserPointer(message_pipe_handle0), |
| MakeUserPointer(message_pipe_handle1)); |
| } |
| |
| MojoResult MojoWriteMessage(MojoHandle message_pipe_handle, |
| const void* bytes, |
| uint32_t num_bytes, |
| const MojoHandle* handles, |
| uint32_t num_handles, |
| MojoWriteMessageFlags flags) { |
| return g_core->WriteMessage(message_pipe_handle, |
| MakeUserPointer(bytes), |
| num_bytes, |
| MakeUserPointer(handles), |
| num_handles, |
| flags); |
| } |
| |
| MojoResult MojoReadMessage(MojoHandle message_pipe_handle, |
| void* bytes, |
| uint32_t* num_bytes, |
| MojoHandle* handles, |
| uint32_t* num_handles, |
| MojoReadMessageFlags flags) { |
| return g_core->ReadMessage(message_pipe_handle, |
| MakeUserPointer(bytes), |
| MakeUserPointer(num_bytes), |
| MakeUserPointer(handles), |
| MakeUserPointer(num_handles), |
| flags); |
| } |
| |
| MojoResult MojoCreateDataPipe(const MojoCreateDataPipeOptions* options, |
| MojoHandle* data_pipe_producer_handle, |
| MojoHandle* data_pipe_consumer_handle) { |
| return g_core->CreateDataPipe(MakeUserPointer(options), |
| MakeUserPointer(data_pipe_producer_handle), |
| MakeUserPointer(data_pipe_consumer_handle)); |
| } |
| |
| MojoResult MojoWriteData(MojoHandle data_pipe_producer_handle, |
| const void* elements, |
| uint32_t* num_elements, |
| MojoWriteDataFlags flags) { |
| return g_core->WriteData(data_pipe_producer_handle, |
| MakeUserPointer(elements), |
| MakeUserPointer(num_elements), |
| flags); |
| } |
| |
| MojoResult MojoBeginWriteData(MojoHandle data_pipe_producer_handle, |
| void** buffer, |
| uint32_t* buffer_num_elements, |
| MojoWriteDataFlags flags) { |
| return g_core->BeginWriteData(data_pipe_producer_handle, |
| MakeUserPointer(buffer), |
| MakeUserPointer(buffer_num_elements), |
| flags); |
| } |
| |
| MojoResult MojoEndWriteData(MojoHandle data_pipe_producer_handle, |
| uint32_t num_elements_written) { |
| return g_core->EndWriteData(data_pipe_producer_handle, num_elements_written); |
| } |
| |
| MojoResult MojoReadData(MojoHandle data_pipe_consumer_handle, |
| void* elements, |
| uint32_t* num_elements, |
| MojoReadDataFlags flags) { |
| return g_core->ReadData(data_pipe_consumer_handle, |
| MakeUserPointer(elements), |
| MakeUserPointer(num_elements), |
| flags); |
| } |
| |
| MojoResult MojoBeginReadData(MojoHandle data_pipe_consumer_handle, |
| const void** buffer, |
| uint32_t* buffer_num_elements, |
| MojoReadDataFlags flags) { |
| return g_core->BeginReadData(data_pipe_consumer_handle, |
| MakeUserPointer(buffer), |
| MakeUserPointer(buffer_num_elements), |
| flags); |
| } |
| |
| MojoResult MojoEndReadData(MojoHandle data_pipe_consumer_handle, |
| uint32_t num_elements_read) { |
| return g_core->EndReadData(data_pipe_consumer_handle, num_elements_read); |
| } |
| |
| MojoResult MojoCreateSharedBuffer( |
| const struct MojoCreateSharedBufferOptions* options, |
| uint64_t num_bytes, |
| MojoHandle* shared_buffer_handle) { |
| return g_core->CreateSharedBuffer(MakeUserPointer(options), |
| num_bytes, |
| MakeUserPointer(shared_buffer_handle)); |
| } |
| |
| MojoResult MojoDuplicateBufferHandle( |
| MojoHandle buffer_handle, |
| const struct MojoDuplicateBufferHandleOptions* options, |
| MojoHandle* new_buffer_handle) { |
| return g_core->DuplicateBufferHandle(buffer_handle, |
| MakeUserPointer(options), |
| MakeUserPointer(new_buffer_handle)); |
| } |
| |
| MojoResult MojoMapBuffer(MojoHandle buffer_handle, |
| uint64_t offset, |
| uint64_t num_bytes, |
| void** buffer, |
| MojoMapBufferFlags flags) { |
| return g_core->MapBuffer( |
| buffer_handle, offset, num_bytes, MakeUserPointer(buffer), flags); |
| } |
| |
| MojoResult MojoUnmapBuffer(void* buffer) { |
| return g_core->UnmapBuffer(MakeUserPointer(buffer)); |
| } |
| |
| } // extern "C" |