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