src/mojo/public/platform/native/system_thunks.cc

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