src/mojo/system/entrypoints.cc

   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 #include "mojo/system/core.h"
   6
   7 static mojo::system::Core* g_core = NULL;
   8
   9 namespace mojo {
  10 namespace system {
  11 namespace entrypoints {
  12
  13 void SetCore(Core* core) {
  14   g_core = core;
  15 }
  16
  17 Core* GetCore() {
  18   return g_core;
  19 }
  20
  21 }  // namespace entrypoints
  22 }  // namepace system
  23 }  // namespace mojo
  24
  25 // Definitions of the system functions.
  26 extern "C" {
  27
  28 MojoTimeTicks MojoGetTimeTicksNow() {
  29   return g_core->GetTimeTicksNow();
  30 }
  31
  32 MojoResult MojoClose(MojoHandle handle) {
  33   return g_core->Close(handle);
  34 }
  35
  36 MojoResult MojoWait(MojoHandle handle,
  37                     MojoWaitFlags flags,
  38                     MojoDeadline deadline) {
  39   return g_core->Wait(handle, flags, deadline);
  40 }
  41
  42 MojoResult MojoWaitMany(const MojoHandle* handles,
  43                         const MojoWaitFlags* flags,
  44                         uint32_t num_handles,
  45                         MojoDeadline deadline) {
  46   return g_core->WaitMany(handles, flags, num_handles, deadline);
  47 }
  48
  49 MojoResult MojoCreateMessagePipe(MojoHandle* message_pipe_handle0,
  50                                  MojoHandle* message_pipe_handle1) {
  51   return g_core->CreateMessagePipe(message_pipe_handle0, message_pipe_handle1);
  52 }
  53
  54 MojoResult MojoWriteMessage(MojoHandle message_pipe_handle,
  55                             const void* bytes,
  56                             uint32_t num_bytes,
  57                             const MojoHandle* handles,
  58                             uint32_t num_handles,
  59                             MojoWriteMessageFlags flags) {
  60   return g_core->WriteMessage(
  61       message_pipe_handle, bytes, num_bytes, handles, num_handles, flags);
  62 }
  63
  64 MojoResult MojoReadMessage(MojoHandle message_pipe_handle,
  65                            void* bytes,
  66                            uint32_t* num_bytes,
  67                            MojoHandle* handles,
  68                          uint32_t* num_handles,
  69                            MojoReadMessageFlags flags) {
  70   return g_core->ReadMessage(
  71       message_pipe_handle, bytes, num_bytes, handles, num_handles, flags);
  72 }
  73
  74 MojoResult MojoCreateDataPipe(const MojoCreateDataPipeOptions* options,
  75                               MojoHandle* data_pipe_producer_handle,
  76                               MojoHandle* data_pipe_consumer_handle) {
  77   return g_core->CreateDataPipe(
  78       options, data_pipe_producer_handle, data_pipe_consumer_handle);
  79 }
  80
  81 MojoResult MojoWriteData(MojoHandle data_pipe_producer_handle,
  82                          const void* elements,
  83                          uint32_t* num_elements,
  84                          MojoWriteDataFlags flags) {
  85   return g_core->WriteData(
  86       data_pipe_producer_handle, elements, num_elements, flags);
  87 }
  88
  89 MojoResult MojoBeginWriteData(MojoHandle data_pipe_producer_handle,
  90                               void** buffer,
  91                               uint32_t* buffer_num_elements,
  92                               MojoWriteDataFlags flags) {
  93   return g_core->BeginWriteData(
  94       data_pipe_producer_handle, buffer, buffer_num_elements, flags);
  95 }
  96
  97 MojoResult MojoEndWriteData(MojoHandle data_pipe_producer_handle,
  98                             uint32_t num_elements_written) {
  99   return g_core->EndWriteData(data_pipe_producer_handle, num_elements_written);
 100 }
 101
 102 MojoResult MojoReadData(MojoHandle data_pipe_consumer_handle,
 103                         void* elements,
 104                         uint32_t* num_elements,
 105                         MojoReadDataFlags flags) {
 106   return g_core->ReadData(
 107       data_pipe_consumer_handle, elements, num_elements, flags);
 108 }
 109
 110 MojoResult MojoBeginReadData(MojoHandle data_pipe_consumer_handle,
 111                              const void** buffer,
 112                              uint32_t* buffer_num_elements,
 113                              MojoReadDataFlags flags) {
 114   return g_core->BeginReadData(
 115       data_pipe_consumer_handle, buffer, buffer_num_elements, flags);
 116 }
 117
 118 MojoResult MojoEndReadData(MojoHandle data_pipe_consumer_handle,
 119                            uint32_t num_elements_read) {
 120   return g_core->EndReadData(data_pipe_consumer_handle, num_elements_read);
 121 }
 122
 123 MojoResult MojoCreateSharedBuffer(
 124     const struct MojoCreateSharedBufferOptions* options,
 125     uint64_t num_bytes,
 126     MojoHandle* shared_buffer_handle) {
 127   return g_core->CreateSharedBuffer(options, num_bytes, shared_buffer_handle);
 128 }
 129
 130 MojoResult MojoDuplicateBufferHandle(
 131     MojoHandle buffer_handle,
 132     const struct MojoDuplicateBufferHandleOptions* options,
 133     MojoHandle* new_buffer_handle) {
 134   return g_core->DuplicateBufferHandle(
 135       buffer_handle, options, new_buffer_handle);
 136 }
 137
 138 MojoResult MojoMapBuffer(MojoHandle buffer_handle,
 139                          uint64_t offset,
 140                          uint64_t num_bytes,
 141                          void** buffer,
 142                          MojoMapBufferFlags flags) {
 143   return g_core->MapBuffer(buffer_handle, offset, num_bytes, buffer, flags);
 144 }
 145
 146 MojoResult MojoUnmapBuffer(void* buffer) {
 147   return g_core->UnmapBuffer(buffer);
 148 }
 149
 150 }  // extern "C"