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