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" 165
