| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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/edk/embedder/embedder_internal.h" | |
| 6 #include "../../../../../../mojo/edk/system/core.h" | |
| 7 #include "base/command_line.h" | |
| 8 #include "base/lazy_instance.h" | |
| 9 #include "mojo/public/c/system/buffer.h" | |
| 10 #include "mojo/public/c/system/data_pipe.h" | |
| 11 #include "mojo/public/c/system/functions.h" | |
| 12 #include "mojo/public/c/system/message_pipe.h" | |
| 13 #include "mojo/public/c/system/wait_set.h" | |
| 14 #include "third_party/mojo/src/mojo/edk/embedder/embedder_internal.h" | |
| 15 #include "third_party/mojo/src/mojo/edk/system/core.h" | |
| 16 | |
| 17 using mojo::embedder::internal::g_core; | |
| 18 using mojo::system::MakeUserPointer; | |
| 19 | |
| 20 namespace { | |
| 21 | |
| 22 struct UseNewEDKChecker { | |
| 23 UseNewEDKChecker() { | |
| 24 use_new = base::CommandLine::ForCurrentProcess()->HasSwitch("use-new-edk"); | |
| 25 } | |
| 26 | |
| 27 bool use_new; | |
| 28 }; | |
| 29 | |
| 30 // This is Leaky to avoid a recursive lock acquisition in AtExitManager. | |
| 31 base::LazyInstance<UseNewEDKChecker>::Leaky g_use_new_checker = | |
| 32 LAZY_INSTANCE_INITIALIZER; | |
| 33 | |
| 34 bool UseNewEDK() { | |
| 35 return g_use_new_checker.Get().use_new; | |
| 36 } | |
| 37 | |
| 38 } // namespace | |
| 39 | |
| 40 // Definitions of the system functions. | |
| 41 extern "C" { | |
| 42 MojoTimeTicks MojoGetTimeTicksNow() { | |
| 43 if (UseNewEDK()) | |
| 44 return mojo::edk::internal::g_core->GetTimeTicksNow(); | |
| 45 return g_core->GetTimeTicksNow(); | |
| 46 } | |
| 47 | |
| 48 MojoResult MojoClose(MojoHandle handle) { | |
| 49 if (UseNewEDK()) | |
| 50 return mojo::edk::internal::g_core->Close(handle); | |
| 51 return g_core->Close(handle); | |
| 52 } | |
| 53 | |
| 54 MojoResult MojoWait(MojoHandle handle, | |
| 55 MojoHandleSignals signals, | |
| 56 MojoDeadline deadline, | |
| 57 MojoHandleSignalsState* signals_state) { | |
| 58 if (UseNewEDK()) | |
| 59 return mojo::edk::internal::g_core->Wait( | |
| 60 handle, signals, deadline, signals_state); | |
| 61 return g_core->Wait(handle, signals, deadline, | |
| 62 MakeUserPointer(signals_state)); | |
| 63 } | |
| 64 | |
| 65 MojoResult MojoWaitMany(const MojoHandle* handles, | |
| 66 const MojoHandleSignals* signals, | |
| 67 uint32_t num_handles, | |
| 68 MojoDeadline deadline, | |
| 69 uint32_t* result_index, | |
| 70 MojoHandleSignalsState* signals_states) { | |
| 71 if (UseNewEDK()) | |
| 72 return mojo::edk::internal::g_core->WaitMany( | |
| 73 handles, signals, num_handles, deadline, result_index, signals_states); | |
| 74 return g_core->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), | |
| 75 num_handles, deadline, MakeUserPointer(result_index), | |
| 76 MakeUserPointer(signals_states)); | |
| 77 } | |
| 78 | |
| 79 MojoResult MojoCreateWaitSet(MojoHandle* wait_set_handle) { | |
| 80 if (UseNewEDK()) | |
| 81 return mojo::edk::internal::g_core->CreateWaitSet(wait_set_handle); | |
| 82 return g_core->CreateWaitSet(MakeUserPointer(wait_set_handle)); | |
| 83 } | |
| 84 | |
| 85 MojoResult MojoAddHandle(MojoHandle wait_set_handle, | |
| 86 MojoHandle handle, | |
| 87 MojoHandleSignals signals) { | |
| 88 if (UseNewEDK()) | |
| 89 return mojo::edk::internal::g_core->AddHandle(wait_set_handle, handle, | |
| 90 signals); | |
| 91 return g_core->AddHandle(wait_set_handle, handle, signals); | |
| 92 } | |
| 93 | |
| 94 MojoResult MojoRemoveHandle(MojoHandle wait_set_handle, | |
| 95 MojoHandle handle) { | |
| 96 if (UseNewEDK()) | |
| 97 return mojo::edk::internal::g_core->RemoveHandle(wait_set_handle, handle); | |
| 98 return g_core->RemoveHandle(wait_set_handle, handle); | |
| 99 } | |
| 100 | |
| 101 MojoResult MojoGetReadyHandles(MojoHandle wait_set_handle, | |
| 102 uint32_t* count, | |
| 103 MojoHandle* handles, | |
| 104 MojoResult* results, | |
| 105 struct MojoHandleSignalsState *signals_states) { | |
| 106 if (UseNewEDK()) | |
| 107 return mojo::edk::internal::g_core->GetReadyHandles( | |
| 108 wait_set_handle, count, handles, results, signals_states); | |
| 109 return g_core->GetReadyHandles(wait_set_handle, MakeUserPointer(count), | |
| 110 MakeUserPointer(handles), | |
| 111 MakeUserPointer(results), | |
| 112 MakeUserPointer(signals_states)); | |
| 113 } | |
| 114 | |
| 115 MojoResult MojoCreateMessagePipe(const MojoCreateMessagePipeOptions* options, | |
| 116 MojoHandle* message_pipe_handle0, | |
| 117 MojoHandle* message_pipe_handle1) { | |
| 118 if (UseNewEDK()) | |
| 119 return mojo::edk::internal::g_core->CreateMessagePipe( | |
| 120 options, message_pipe_handle0, message_pipe_handle1); | |
| 121 return g_core->CreateMessagePipe(MakeUserPointer(options), | |
| 122 MakeUserPointer(message_pipe_handle0), | |
| 123 MakeUserPointer(message_pipe_handle1)); | |
| 124 } | |
| 125 | |
| 126 MojoResult MojoWriteMessage(MojoHandle message_pipe_handle, | |
| 127 const void* bytes, | |
| 128 uint32_t num_bytes, | |
| 129 const MojoHandle* handles, | |
| 130 uint32_t num_handles, | |
| 131 MojoWriteMessageFlags flags) { | |
| 132 if (UseNewEDK()) | |
| 133 return mojo::edk::internal::g_core->WriteMessage( | |
| 134 message_pipe_handle, bytes, num_bytes, handles, num_handles, flags); | |
| 135 return g_core->WriteMessage(message_pipe_handle, MakeUserPointer(bytes), | |
| 136 num_bytes, MakeUserPointer(handles), num_handles, | |
| 137 flags); | |
| 138 } | |
| 139 | |
| 140 MojoResult MojoReadMessage(MojoHandle message_pipe_handle, | |
| 141 void* bytes, | |
| 142 uint32_t* num_bytes, | |
| 143 MojoHandle* handles, | |
| 144 uint32_t* num_handles, | |
| 145 MojoReadMessageFlags flags) { | |
| 146 if (UseNewEDK()) | |
| 147 return mojo::edk::internal::g_core->ReadMessage( | |
| 148 message_pipe_handle, bytes, num_bytes, handles, num_handles, flags); | |
| 149 return g_core->ReadMessage( | |
| 150 message_pipe_handle, MakeUserPointer(bytes), MakeUserPointer(num_bytes), | |
| 151 MakeUserPointer(handles), MakeUserPointer(num_handles), flags); | |
| 152 } | |
| 153 | |
| 154 MojoResult MojoCreateDataPipe(const MojoCreateDataPipeOptions* options, | |
| 155 MojoHandle* data_pipe_producer_handle, | |
| 156 MojoHandle* data_pipe_consumer_handle) { | |
| 157 if (UseNewEDK()) | |
| 158 return mojo::edk::internal::g_core->CreateDataPipe( | |
| 159 options, data_pipe_producer_handle, data_pipe_consumer_handle); | |
| 160 return g_core->CreateDataPipe(MakeUserPointer(options), | |
| 161 MakeUserPointer(data_pipe_producer_handle), | |
| 162 MakeUserPointer(data_pipe_consumer_handle)); | |
| 163 } | |
| 164 | |
| 165 MojoResult MojoWriteData(MojoHandle data_pipe_producer_handle, | |
| 166 const void* elements, | |
| 167 uint32_t* num_elements, | |
| 168 MojoWriteDataFlags flags) { | |
| 169 if (UseNewEDK()) | |
| 170 return mojo::edk::internal::g_core->WriteData( | |
| 171 data_pipe_producer_handle, elements, num_elements, flags); | |
| 172 return g_core->WriteData(data_pipe_producer_handle, MakeUserPointer(elements), | |
| 173 MakeUserPointer(num_elements), flags); | |
| 174 } | |
| 175 | |
| 176 MojoResult MojoBeginWriteData(MojoHandle data_pipe_producer_handle, | |
| 177 void** buffer, | |
| 178 uint32_t* buffer_num_elements, | |
| 179 MojoWriteDataFlags flags) { | |
| 180 if (UseNewEDK()) | |
| 181 return mojo::edk::internal::g_core->BeginWriteData( | |
| 182 data_pipe_producer_handle, buffer, buffer_num_elements, flags); | |
| 183 return g_core->BeginWriteData(data_pipe_producer_handle, | |
| 184 MakeUserPointer(buffer), | |
| 185 MakeUserPointer(buffer_num_elements), flags); | |
| 186 } | |
| 187 | |
| 188 MojoResult MojoEndWriteData(MojoHandle data_pipe_producer_handle, | |
| 189 uint32_t num_elements_written) { | |
| 190 if (UseNewEDK()) | |
| 191 return mojo::edk::internal::g_core->EndWriteData( | |
| 192 data_pipe_producer_handle, num_elements_written); | |
| 193 return g_core->EndWriteData(data_pipe_producer_handle, num_elements_written); | |
| 194 } | |
| 195 | |
| 196 MojoResult MojoReadData(MojoHandle data_pipe_consumer_handle, | |
| 197 void* elements, | |
| 198 uint32_t* num_elements, | |
| 199 MojoReadDataFlags flags) { | |
| 200 if (UseNewEDK()) | |
| 201 return mojo::edk::internal::g_core->ReadData( | |
| 202 data_pipe_consumer_handle, elements, num_elements, flags); | |
| 203 return g_core->ReadData(data_pipe_consumer_handle, MakeUserPointer(elements), | |
| 204 MakeUserPointer(num_elements), flags); | |
| 205 } | |
| 206 | |
| 207 MojoResult MojoBeginReadData(MojoHandle data_pipe_consumer_handle, | |
| 208 const void** buffer, | |
| 209 uint32_t* buffer_num_elements, | |
| 210 MojoReadDataFlags flags) { | |
| 211 if (UseNewEDK()) | |
| 212 return mojo::edk::internal::g_core->BeginReadData( | |
| 213 data_pipe_consumer_handle, buffer, buffer_num_elements, flags); | |
| 214 return g_core->BeginReadData(data_pipe_consumer_handle, | |
| 215 MakeUserPointer(buffer), | |
| 216 MakeUserPointer(buffer_num_elements), flags); | |
| 217 } | |
| 218 | |
| 219 MojoResult MojoEndReadData(MojoHandle data_pipe_consumer_handle, | |
| 220 uint32_t num_elements_read) { | |
| 221 if (UseNewEDK()) | |
| 222 return mojo::edk::internal::g_core->EndReadData( | |
| 223 data_pipe_consumer_handle, num_elements_read); | |
| 224 return g_core->EndReadData(data_pipe_consumer_handle, num_elements_read); | |
| 225 } | |
| 226 | |
| 227 MojoResult MojoCreateSharedBuffer( | |
| 228 const struct MojoCreateSharedBufferOptions* options, | |
| 229 uint64_t num_bytes, | |
| 230 MojoHandle* shared_buffer_handle) { | |
| 231 if (UseNewEDK()) | |
| 232 return mojo::edk::internal::g_core->CreateSharedBuffer( | |
| 233 options, num_bytes, shared_buffer_handle); | |
| 234 return g_core->CreateSharedBuffer(MakeUserPointer(options), num_bytes, | |
| 235 MakeUserPointer(shared_buffer_handle)); | |
| 236 } | |
| 237 | |
| 238 MojoResult MojoDuplicateBufferHandle( | |
| 239 MojoHandle buffer_handle, | |
| 240 const struct MojoDuplicateBufferHandleOptions* options, | |
| 241 MojoHandle* new_buffer_handle) { | |
| 242 if (UseNewEDK()) | |
| 243 return mojo::edk::internal::g_core->DuplicateBufferHandle( | |
| 244 buffer_handle, options, new_buffer_handle); | |
| 245 return g_core->DuplicateBufferHandle(buffer_handle, MakeUserPointer(options), | |
| 246 MakeUserPointer(new_buffer_handle)); | |
| 247 } | |
| 248 | |
| 249 MojoResult MojoMapBuffer(MojoHandle buffer_handle, | |
| 250 uint64_t offset, | |
| 251 uint64_t num_bytes, | |
| 252 void** buffer, | |
| 253 MojoMapBufferFlags flags) { | |
| 254 if (UseNewEDK()) | |
| 255 return mojo::edk::internal::g_core->MapBuffer( | |
| 256 buffer_handle, offset, num_bytes, buffer, flags); | |
| 257 return g_core->MapBuffer(buffer_handle, offset, num_bytes, | |
| 258 MakeUserPointer(buffer), flags); | |
| 259 } | |
| 260 | |
| 261 MojoResult MojoUnmapBuffer(void* buffer) { | |
| 262 if (UseNewEDK()) | |
| 263 return mojo::edk::internal::g_core->UnmapBuffer(buffer); | |
| 264 return g_core->UnmapBuffer(MakeUserPointer(buffer)); | |
| 265 } | |
| 266 | |
| 267 } // extern "C" | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1676913002:
[mojo] Delete third_party/mojo (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master