| OLD | NEW |
|---|
| (Empty) |
| 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/c/system/thunks.h" | |
| 6 | |
| 7 #include <assert.h> | |
| 8 #include <stddef.h> | |
| 9 #include <stdint.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 struct MojoHandleSignalsState* signals_state) { | |
| 29 assert(g_thunks.Wait); | |
| 30 return g_thunks.Wait(handle, signals, deadline, signals_state); | |
| 31 } | |
| 32 | |
| 33 MojoResult MojoWaitMany(const MojoHandle* handles, | |
| 34 const MojoHandleSignals* signals, | |
| 35 uint32_t num_handles, | |
| 36 MojoDeadline deadline, | |
| 37 uint32_t* result_index, | |
| 38 struct MojoHandleSignalsState* signals_states) { | |
| 39 assert(g_thunks.WaitMany); | |
| 40 return g_thunks.WaitMany(handles, signals, num_handles, deadline, | |
| 41 result_index, signals_states); | |
| 42 } | |
| 43 | |
| 44 MojoResult MojoCreateMessagePipe(const MojoCreateMessagePipeOptions* options, | |
| 45 MojoHandle* message_pipe_handle0, | |
| 46 MojoHandle* message_pipe_handle1) { | |
| 47 assert(g_thunks.CreateMessagePipe); | |
| 48 return g_thunks.CreateMessagePipe(options, message_pipe_handle0, | |
| 49 message_pipe_handle1); | |
| 50 } | |
| 51 | |
| 52 MojoResult MojoWriteMessage(MojoHandle message_pipe_handle, | |
| 53 const void* bytes, | |
| 54 uint32_t num_bytes, | |
| 55 const MojoHandle* handles, | |
| 56 uint32_t num_handles, | |
| 57 MojoWriteMessageFlags flags) { | |
| 58 assert(g_thunks.WriteMessage); | |
| 59 return g_thunks.WriteMessage(message_pipe_handle, bytes, num_bytes, handles, | |
| 60 num_handles, flags); | |
| 61 } | |
| 62 | |
| 63 MojoResult MojoReadMessage(MojoHandle message_pipe_handle, | |
| 64 void* bytes, | |
| 65 uint32_t* num_bytes, | |
| 66 MojoHandle* handles, | |
| 67 uint32_t* num_handles, | |
| 68 MojoReadMessageFlags flags) { | |
| 69 assert(g_thunks.ReadMessage); | |
| 70 return g_thunks.ReadMessage(message_pipe_handle, bytes, num_bytes, handles, | |
| 71 num_handles, flags); | |
| 72 } | |
| 73 | |
| 74 MojoResult MojoCreateDataPipe(const MojoCreateDataPipeOptions* options, | |
| 75 MojoHandle* data_pipe_producer_handle, | |
| 76 MojoHandle* data_pipe_consumer_handle) { | |
| 77 assert(g_thunks.CreateDataPipe); | |
| 78 return g_thunks.CreateDataPipe(options, data_pipe_producer_handle, | |
| 79 data_pipe_consumer_handle); | |
| 80 } | |
| 81 | |
| 82 MojoResult MojoWriteData(MojoHandle data_pipe_producer_handle, | |
| 83 const void* elements, | |
| 84 uint32_t* num_elements, | |
| 85 MojoWriteDataFlags flags) { | |
| 86 assert(g_thunks.WriteData); | |
| 87 return g_thunks.WriteData(data_pipe_producer_handle, elements, num_elements, | |
| 88 flags); | |
| 89 } | |
| 90 | |
| 91 MojoResult MojoBeginWriteData(MojoHandle data_pipe_producer_handle, | |
| 92 void** buffer, | |
| 93 uint32_t* buffer_num_elements, | |
| 94 MojoWriteDataFlags flags) { | |
| 95 assert(g_thunks.BeginWriteData); | |
| 96 return g_thunks.BeginWriteData(data_pipe_producer_handle, buffer, | |
| 97 buffer_num_elements, flags); | |
| 98 } | |
| 99 | |
| 100 MojoResult MojoEndWriteData(MojoHandle data_pipe_producer_handle, | |
| 101 uint32_t num_elements_written) { | |
| 102 assert(g_thunks.EndWriteData); | |
| 103 return g_thunks.EndWriteData(data_pipe_producer_handle, num_elements_written); | |
| 104 } | |
| 105 | |
| 106 MojoResult MojoReadData(MojoHandle data_pipe_consumer_handle, | |
| 107 void* elements, | |
| 108 uint32_t* num_elements, | |
| 109 MojoReadDataFlags flags) { | |
| 110 assert(g_thunks.ReadData); | |
| 111 return g_thunks.ReadData(data_pipe_consumer_handle, elements, num_elements, | |
| 112 flags); | |
| 113 } | |
| 114 | |
| 115 MojoResult MojoBeginReadData(MojoHandle data_pipe_consumer_handle, | |
| 116 const void** buffer, | |
| 117 uint32_t* buffer_num_elements, | |
| 118 MojoReadDataFlags flags) { | |
| 119 assert(g_thunks.BeginReadData); | |
| 120 return g_thunks.BeginReadData(data_pipe_consumer_handle, buffer, | |
| 121 buffer_num_elements, flags); | |
| 122 } | |
| 123 | |
| 124 MojoResult MojoEndReadData(MojoHandle data_pipe_consumer_handle, | |
| 125 uint32_t num_elements_read) { | |
| 126 assert(g_thunks.EndReadData); | |
| 127 return g_thunks.EndReadData(data_pipe_consumer_handle, num_elements_read); | |
| 128 } | |
| 129 | |
| 130 MojoResult MojoCreateSharedBuffer( | |
| 131 const struct MojoCreateSharedBufferOptions* options, | |
| 132 uint64_t num_bytes, | |
| 133 MojoHandle* shared_buffer_handle) { | |
| 134 assert(g_thunks.CreateSharedBuffer); | |
| 135 return g_thunks.CreateSharedBuffer(options, num_bytes, shared_buffer_handle); | |
| 136 } | |
| 137 | |
| 138 MojoResult MojoDuplicateBufferHandle( | |
| 139 MojoHandle buffer_handle, | |
| 140 const struct MojoDuplicateBufferHandleOptions* options, | |
| 141 MojoHandle* new_buffer_handle) { | |
| 142 assert(g_thunks.DuplicateBufferHandle); | |
| 143 return g_thunks.DuplicateBufferHandle(buffer_handle, options, | |
| 144 new_buffer_handle); | |
| 145 } | |
| 146 | |
| 147 MojoResult MojoMapBuffer(MojoHandle buffer_handle, | |
| 148 uint64_t offset, | |
| 149 uint64_t num_bytes, | |
| 150 void** buffer, | |
| 151 MojoMapBufferFlags flags) { | |
| 152 assert(g_thunks.MapBuffer); | |
| 153 return g_thunks.MapBuffer(buffer_handle, offset, num_bytes, buffer, flags); | |
| 154 } | |
| 155 | |
| 156 MojoResult MojoUnmapBuffer(void* buffer) { | |
| 157 assert(g_thunks.UnmapBuffer); | |
| 158 return g_thunks.UnmapBuffer(buffer); | |
| 159 } | |
| 160 | |
| 161 MojoResult MojoCreateWaitSet(MojoHandle* wait_set) { | |
| 162 assert(g_thunks.CreateWaitSet); | |
| 163 return g_thunks.CreateWaitSet(wait_set); | |
| 164 } | |
| 165 | |
| 166 MojoResult MojoAddHandle(MojoHandle wait_set, | |
| 167 MojoHandle handle, | |
| 168 MojoHandleSignals signals) { | |
| 169 assert(g_thunks.AddHandle); | |
| 170 return g_thunks.AddHandle(wait_set, handle, signals); | |
| 171 } | |
| 172 | |
| 173 MojoResult MojoRemoveHandle(MojoHandle wait_set, MojoHandle handle) { | |
| 174 assert(g_thunks.RemoveHandle); | |
| 175 return g_thunks.RemoveHandle(wait_set, handle); | |
| 176 } | |
| 177 | |
| 178 MojoResult MojoGetReadyHandles(MojoHandle wait_set, | |
| 179 uint32_t* count, | |
| 180 MojoHandle* handles, | |
| 181 MojoResult* results, | |
| 182 struct MojoHandleSignalsState* signals_states) { | |
| 183 assert(g_thunks.GetReadyHandles); | |
| 184 return g_thunks.GetReadyHandles(wait_set, count, handles, results, | |
| 185 signals_states); | |
| 186 } | |
| 187 | |
| 188 MojoResult MojoWatch(MojoHandle handle, | |
| 189 MojoHandleSignals signals, | |
| 190 MojoWatchCallback callback, | |
| 191 uintptr_t context) { | |
| 192 assert(g_thunks.Watch); | |
| 193 return g_thunks.Watch(handle, signals, callback, context); | |
| 194 } | |
| 195 | |
| 196 MojoResult MojoCancelWatch(MojoHandle handle, uintptr_t context) { | |
| 197 assert(g_thunks.CancelWatch); | |
| 198 return g_thunks.CancelWatch(handle, context); | |
| 199 } | |
| 200 | |
| 201 MojoResult MojoFuseMessagePipes(MojoHandle handle0, MojoHandle handle1) { | |
| 202 assert(g_thunks.FuseMessagePipes); | |
| 203 return g_thunks.FuseMessagePipes(handle0, handle1); | |
| 204 } | |
| 205 | |
| 206 MojoResult MojoWriteMessageNew(MojoHandle message_pipe_handle, | |
| 207 MojoMessageHandle message, | |
| 208 MojoWriteMessageFlags flags) { | |
| 209 assert(g_thunks.WriteMessageNew); | |
| 210 return g_thunks.WriteMessageNew(message_pipe_handle, message, flags); | |
| 211 } | |
| 212 | |
| 213 MojoResult MojoReadMessageNew(MojoHandle message_pipe_handle, | |
| 214 MojoMessageHandle* message, | |
| 215 uint32_t* num_bytes, | |
| 216 MojoHandle* handles, | |
| 217 uint32_t* num_handles, | |
| 218 MojoReadMessageFlags flags) { | |
| 219 assert(g_thunks.ReadMessageNew); | |
| 220 return g_thunks.ReadMessageNew(message_pipe_handle, message, num_bytes, | |
| 221 handles, num_handles, flags); | |
| 222 } | |
| 223 | |
| 224 MojoResult MojoAllocMessage(uint32_t num_bytes, | |
| 225 const MojoHandle* handles, | |
| 226 uint32_t num_handles, | |
| 227 MojoAllocMessageFlags flags, | |
| 228 MojoMessageHandle* message) { | |
| 229 assert(g_thunks.AllocMessage); | |
| 230 return g_thunks.AllocMessage( | |
| 231 num_bytes, handles, num_handles, flags, message); | |
| 232 } | |
| 233 | |
| 234 MojoResult MojoFreeMessage(MojoMessageHandle message) { | |
| 235 assert(g_thunks.FreeMessage); | |
| 236 return g_thunks.FreeMessage(message); | |
| 237 } | |
| 238 | |
| 239 MojoResult MojoGetMessageBuffer(MojoMessageHandle message, void** buffer) { | |
| 240 assert(g_thunks.GetMessageBuffer); | |
| 241 return g_thunks.GetMessageBuffer(message, buffer); | |
| 242 } | |
| 243 | |
| 244 MojoResult MojoWrapPlatformHandle( | |
| 245 const struct MojoPlatformHandle* platform_handle, | |
| 246 MojoHandle* mojo_handle) { | |
| 247 assert(g_thunks.WrapPlatformHandle); | |
| 248 return g_thunks.WrapPlatformHandle(platform_handle, mojo_handle); | |
| 249 } | |
| 250 | |
| 251 MojoResult MojoUnwrapPlatformHandle( | |
| 252 MojoHandle mojo_handle, | |
| 253 struct MojoPlatformHandle* platform_handle) { | |
| 254 assert(g_thunks.UnwrapPlatformHandle); | |
| 255 return g_thunks.UnwrapPlatformHandle(mojo_handle, platform_handle); | |
| 256 } | |
| 257 | |
| 258 MojoResult MojoWrapPlatformSharedBufferHandle( | |
| 259 const struct MojoPlatformHandle* platform_handle, | |
| 260 size_t num_bytes, | |
| 261 MojoPlatformSharedBufferHandleFlags flags, | |
| 262 MojoHandle* mojo_handle) { | |
| 263 assert(g_thunks.WrapPlatformSharedBufferHandle); | |
| 264 return g_thunks.WrapPlatformSharedBufferHandle(platform_handle, num_bytes, | |
| 265 flags, mojo_handle); | |
| 266 } | |
| 267 | |
| 268 MojoResult MojoUnwrapPlatformSharedBufferHandle( | |
| 269 MojoHandle mojo_handle, | |
| 270 struct MojoPlatformHandle* platform_handle, | |
| 271 size_t* num_bytes, | |
| 272 MojoPlatformSharedBufferHandleFlags* flags) { | |
| 273 assert(g_thunks.UnwrapPlatformSharedBufferHandle); | |
| 274 return g_thunks.UnwrapPlatformSharedBufferHandle(mojo_handle, platform_handle, | |
| 275 num_bytes, flags); | |
| 276 } | |
| 277 | |
| 278 } // extern "C" | |
| 279 | |
| 280 size_t MojoEmbedderSetSystemThunks(const MojoSystemThunks* system_thunks) { | |
| 281 if (system_thunks->size >= sizeof(g_thunks)) | |
| 282 g_thunks = *system_thunks; | |
| 283 return sizeof(g_thunks); | |
| 284 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2054513002:
Revert of Mojo: Eliminate duplicate C API symbols (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master