Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1887)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: mojo/nacl/NOT_FOR_COMMIT/mojo_syscall.cc

Issue 776643004: Update NaCl's generator to support new wait APIs. (Closed) Base URL: git@github.com:domokit/mojo.git@master
Patch Set: The Change Created 6 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « mojo/nacl/NOT_FOR_COMMIT/libmojo.cc ('k') | mojo/nacl/generator/generate_nacl_bindings.py » ('j') | mojo/nacl/generator/generate_nacl_bindings.py » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: mojo/nacl/NOT_FOR_COMMIT/mojo_syscall.cc
diff --git a/mojo/nacl/NOT_FOR_COMMIT/mojo_syscall.cc b/mojo/nacl/NOT_FOR_COMMIT/mojo_syscall.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8f28c58c41c2df69490cf74fc5bafcbfee7669c8
--- /dev/null
+++ b/mojo/nacl/NOT_FOR_COMMIT/mojo_syscall.cc
@@ -0,0 +1,873 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// WARNING this file was generated by generate_nacl_bindings.py
+// Do not edit by hand.
+
+#include "mojo/nacl/mojo_syscall.h"
+
+#include <stdio.h>
+
+#include "mojo/nacl/mojo_syscall_internal.h"
+#include "mojo/public/c/system/core.h"
+#include "native_client/src/public/chrome_main.h"
+#include "native_client/src/public/nacl_app.h"
+#include "native_client/src/trusted/desc/nacl_desc_custom.h"
+
+namespace {
+
+void MojoDescDestroy(void* handle) {
+}
+
+ssize_t MojoDescSendMsg(void* handle,
+ const struct NaClImcTypedMsgHdr* msg,
+ int flags) {
+ struct NaClApp* nap = static_cast<struct NaClApp*>(handle);
+
+ if (msg->iov_length != 1 || msg->ndesc_length != 0) {
+ return -1;
+ }
+
+ uint32_t volatile* params = static_cast<uint32_t volatile*>(msg->iov[0].base);
+ size_t num_params = msg->iov[0].length / sizeof(*params);
+
+ if (num_params < 1) {
+ return -1;
+ }
+
+ uint32_t msg_type = params[0];
+ switch (msg_type) {
+ case 0:
+ {
+ if (num_params != 5) {
+ return -1;
+ }
+ const struct MojoCreateSharedBufferOptions* options;
+ uint64_t num_bytes_value;
+ MojoHandle volatile* shared_buffer_handle_ptr;
+ MojoHandle shared_buffer_handle_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertExtensibleStructInput(nap, params[1], true, &options)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[2], &num_bytes_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[3], false, &shared_buffer_handle_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoCreateSharedBuffer(options, num_bytes_value, &shared_buffer_handle_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *shared_buffer_handle_ptr = shared_buffer_handle_value;
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 1:
+ {
+ if (num_params != 5) {
+ return -1;
+ }
+ MojoHandle buffer_handle_value;
+ const struct MojoDuplicateBufferHandleOptions* options;
+ MojoHandle volatile* new_buffer_handle_ptr;
+ MojoHandle new_buffer_handle_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarInput(nap, params[1], &buffer_handle_value)) {
+ return -1;
+ }
+ if (!ConvertExtensibleStructInput(nap, params[2], true, &options)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[3], false, &new_buffer_handle_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoDuplicateBufferHandle(buffer_handle_value, options, &new_buffer_handle_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *new_buffer_handle_ptr = new_buffer_handle_value;
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 2:
+ {
+ if (num_params != 7) {
+ return -1;
+ }
+ MojoHandle buffer_handle_value;
+ uint64_t offset_value;
+ uint64_t num_bytes_value;
+ void* volatile* buffer_ptr;
+ void* buffer_value;
+ MojoMapBufferFlags flags_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarInput(nap, params[1], &buffer_handle_value)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[2], &offset_value)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[3], &num_bytes_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[4], false, &buffer_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[5], &flags_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[6], false, &result_ptr)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoMapBuffer(buffer_handle_value, offset_value, num_bytes_value, &buffer_value, flags_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *buffer_ptr = buffer_value;
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 3:
+ {
+ if (num_params != 3) {
+ return -1;
+ }
+ void* buffer_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarInput(nap, params[1], &buffer_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[2], false, &result_ptr)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoUnmapBuffer(buffer_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 4:
+ {
+ if (num_params != 5) {
+ return -1;
+ }
+ const struct MojoCreateDataPipeOptions* options;
+ MojoHandle volatile* data_pipe_producer_handle_ptr;
+ MojoHandle data_pipe_producer_handle_value;
+ MojoHandle volatile* data_pipe_consumer_handle_ptr;
+ MojoHandle data_pipe_consumer_handle_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertExtensibleStructInput(nap, params[1], true, &options)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[2], false, &data_pipe_producer_handle_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[3], false, &data_pipe_consumer_handle_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoCreateDataPipe(options, &data_pipe_producer_handle_value, &data_pipe_consumer_handle_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *data_pipe_producer_handle_ptr = data_pipe_producer_handle_value;
+ *data_pipe_consumer_handle_ptr = data_pipe_consumer_handle_value;
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 5:
+ {
+ if (num_params != 6) {
+ return -1;
+ }
+ MojoHandle data_pipe_producer_handle_value;
+ const void* elements;
+ uint32_t volatile* num_bytes_ptr;
+ uint32_t num_bytes_value;
+ MojoWriteDataFlags flags_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarInput(nap, params[1], &data_pipe_producer_handle_value)) {
+ return -1;
+ }
+ if (!ConvertScalarInOut(nap, params[3], false, &num_bytes_value, &num_bytes_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[4], &flags_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) {
+ return -1;
+ }
+ if (!ConvertArray(nap, params[2], num_bytes_value, 1, false, &elements)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoWriteData(data_pipe_producer_handle_value, elements, &num_bytes_value, flags_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *num_bytes_ptr = num_bytes_value;
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 6:
+ {
+ if (num_params != 6) {
+ return -1;
+ }
+ MojoHandle data_pipe_producer_handle_value;
+ void* volatile* buffer_ptr;
+ void* buffer_value;
+ uint32_t volatile* buffer_num_bytes_ptr;
+ uint32_t buffer_num_bytes_value;
+ MojoWriteDataFlags flags_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarInput(nap, params[1], &data_pipe_producer_handle_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[2], false, &buffer_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarInOut(nap, params[3], false, &buffer_num_bytes_value, &buffer_num_bytes_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[4], &flags_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoBeginWriteData(data_pipe_producer_handle_value, &buffer_value, &buffer_num_bytes_value, flags_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *buffer_ptr = buffer_value;
+ *buffer_num_bytes_ptr = buffer_num_bytes_value;
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 7:
+ {
+ if (num_params != 4) {
+ return -1;
+ }
+ MojoHandle data_pipe_producer_handle_value;
+ uint32_t num_bytes_written_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarInput(nap, params[1], &data_pipe_producer_handle_value)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[2], &num_bytes_written_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[3], false, &result_ptr)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoEndWriteData(data_pipe_producer_handle_value, num_bytes_written_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 8:
+ {
+ if (num_params != 6) {
+ return -1;
+ }
+ MojoHandle data_pipe_consumer_handle_value;
+ void* elements;
+ uint32_t volatile* num_bytes_ptr;
+ uint32_t num_bytes_value;
+ MojoReadDataFlags flags_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarInput(nap, params[1], &data_pipe_consumer_handle_value)) {
+ return -1;
+ }
+ if (!ConvertScalarInOut(nap, params[3], false, &num_bytes_value, &num_bytes_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[4], &flags_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) {
+ return -1;
+ }
+ if (!ConvertArray(nap, params[2], num_bytes_value, 1, false, &elements)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoReadData(data_pipe_consumer_handle_value, elements, &num_bytes_value, flags_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *num_bytes_ptr = num_bytes_value;
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 9:
+ {
+ if (num_params != 6) {
+ return -1;
+ }
+ MojoHandle data_pipe_consumer_handle_value;
+ const void* volatile* buffer_ptr;
+ const void* buffer_value;
+ uint32_t volatile* buffer_num_bytes_ptr;
+ uint32_t buffer_num_bytes_value;
+ MojoReadDataFlags flags_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarInput(nap, params[1], &data_pipe_consumer_handle_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[2], false, &buffer_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarInOut(nap, params[3], false, &buffer_num_bytes_value, &buffer_num_bytes_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[4], &flags_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoBeginReadData(data_pipe_consumer_handle_value, &buffer_value, &buffer_num_bytes_value, flags_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *buffer_ptr = buffer_value;
+ *buffer_num_bytes_ptr = buffer_num_bytes_value;
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 10:
+ {
+ if (num_params != 4) {
+ return -1;
+ }
+ MojoHandle data_pipe_consumer_handle_value;
+ uint32_t num_bytes_read_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarInput(nap, params[1], &data_pipe_consumer_handle_value)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[2], &num_bytes_read_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[3], false, &result_ptr)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoEndReadData(data_pipe_consumer_handle_value, num_bytes_read_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 11:
+ {
+ if (num_params != 2) {
+ return -1;
+ }
+ MojoTimeTicks volatile* result_ptr;
+ MojoTimeTicks result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarOutput(nap, params[1], false, &result_ptr)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoGetTimeTicksNow();
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 12:
+ {
+ if (num_params != 3) {
+ return -1;
+ }
+ MojoHandle handle_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarInput(nap, params[1], &handle_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[2], false, &result_ptr)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoClose(handle_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 13:
+ {
+ if (num_params != 5) {
+ return -1;
+ }
+ MojoHandle handle_value;
+ MojoHandleSignals signals_value;
+ MojoDeadline deadline_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarInput(nap, params[1], &handle_value)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[2], &signals_value)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[3], &deadline_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoWait(handle_value, signals_value, deadline_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 14:
+ {
+ if (num_params != 6) {
+ return -1;
+ }
+ const MojoHandle* handles;
+ const MojoHandleSignals* signals;
+ uint32_t num_handles_value;
+ MojoDeadline deadline_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarInput(nap, params[3], &num_handles_value)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[4], &deadline_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) {
+ return -1;
+ }
+ if (!ConvertArray(nap, params[1], num_handles_value, sizeof(*handles), false, &handles)) {
+ return -1;
+ }
+ if (!ConvertArray(nap, params[2], num_handles_value, sizeof(*signals), false, &signals)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoWaitMany(handles, signals, num_handles_value, deadline_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 15:
+ {
+ if (num_params != 6) {
+ return -1;
+ }
+ MojoHandle handle_value;
+ MojoHandleSignals signals_value;
+ MojoDeadline deadline_value;
+ MojoHandleSignalsState volatile* signals_state_ptr;
+ MojoHandleSignalsState signals_state_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarInput(nap, params[1], &handle_value)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[2], &signals_value)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[3], &deadline_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[4], true, &signals_state_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoNewWait(handle_value, signals_value, deadline_value, signals_state_ptr ? &signals_state_value : NULL);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (signals_state_ptr != NULL) {
+ memcpy_volatile_out(signals_state_ptr, &signals_state_value, sizeof(MojoHandleSignalsState));
+ }
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 16:
+ {
+ if (num_params != 8) {
+ return -1;
+ }
+ const MojoHandle* handles;
+ const MojoHandleSignals* signals;
+ uint32_t num_handles_value;
+ MojoDeadline deadline_value;
+ uint32_t volatile* result_index_ptr;
+ uint32_t result_index_value;
+ MojoHandleSignalsState* signals_states;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarInput(nap, params[3], &num_handles_value)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[4], &deadline_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[5], true, &result_index_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[7], false, &result_ptr)) {
+ return -1;
+ }
+ if (!ConvertArray(nap, params[1], num_handles_value, sizeof(*handles), false, &handles)) {
+ return -1;
+ }
+ if (!ConvertArray(nap, params[2], num_handles_value, sizeof(*signals), false, &signals)) {
+ return -1;
+ }
+ if (!ConvertArray(nap, params[6], num_handles_value, sizeof(*signals_states), true, &signals_states)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoNewWaitMany(handles, signals, num_handles_value, deadline_value, result_index_ptr ? &result_index_value : NULL, signals_states);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (result_index_ptr != NULL) {
+ *result_index_ptr = result_index_value;
+ }
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 17:
+ {
+ if (num_params != 5) {
+ return -1;
+ }
+ const struct MojoCreateMessagePipeOptions* options;
+ MojoHandle volatile* message_pipe_handle0_ptr;
+ MojoHandle message_pipe_handle0_value;
+ MojoHandle volatile* message_pipe_handle1_ptr;
+ MojoHandle message_pipe_handle1_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertExtensibleStructInput(nap, params[1], true, &options)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[2], false, &message_pipe_handle0_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[3], false, &message_pipe_handle1_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoCreateMessagePipe(options, &message_pipe_handle0_value, &message_pipe_handle1_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *message_pipe_handle0_ptr = message_pipe_handle0_value;
+ *message_pipe_handle1_ptr = message_pipe_handle1_value;
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 18:
+ {
+ if (num_params != 8) {
+ return -1;
+ }
+ MojoHandle message_pipe_handle_value;
+ const void* bytes;
+ uint32_t num_bytes_value;
+ const MojoHandle* handles;
+ uint32_t num_handles_value;
+ MojoWriteMessageFlags flags_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarInput(nap, params[1], &message_pipe_handle_value)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[3], &num_bytes_value)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[5], &num_handles_value)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[6], &flags_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[7], false, &result_ptr)) {
+ return -1;
+ }
+ if (!ConvertArray(nap, params[2], num_bytes_value, 1, true, &bytes)) {
+ return -1;
+ }
+ if (!ConvertArray(nap, params[4], num_handles_value, sizeof(*handles), true, &handles)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoWriteMessage(message_pipe_handle_value, bytes, num_bytes_value, handles, num_handles_value, flags_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+ case 19:
+ {
+ if (num_params != 8) {
+ return -1;
+ }
+ MojoHandle message_pipe_handle_value;
+ void* bytes;
+ uint32_t volatile* num_bytes_ptr;
+ uint32_t num_bytes_value;
+ MojoHandle* handles;
+ uint32_t volatile* num_handles_ptr;
+ uint32_t num_handles_value;
+ MojoReadMessageFlags flags_value;
+ MojoResult volatile* result_ptr;
+ MojoResult result_value;
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (!ConvertScalarInput(nap, params[1], &message_pipe_handle_value)) {
+ return -1;
+ }
+ if (!ConvertScalarInOut(nap, params[3], true, &num_bytes_value, &num_bytes_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarInOut(nap, params[5], true, &num_handles_value, &num_handles_ptr)) {
+ return -1;
+ }
+ if (!ConvertScalarInput(nap, params[6], &flags_value)) {
+ return -1;
+ }
+ if (!ConvertScalarOutput(nap, params[7], false, &result_ptr)) {
+ return -1;
+ }
+ if (!ConvertArray(nap, params[2], num_bytes_value, 1, true, &bytes)) {
+ return -1;
+ }
+ if (!ConvertArray(nap, params[4], num_handles_value, sizeof(*handles), true, &handles)) {
+ return -1;
+ }
+ }
+
+ result_value = MojoReadMessage(message_pipe_handle_value, bytes, num_bytes_ptr ? &num_bytes_value : NULL, handles, num_handles_ptr ? &num_handles_value : NULL, flags_value);
+
+ {
+ ScopedCopyLock copy_lock(nap);
+ if (num_bytes_ptr != NULL) {
+ *num_bytes_ptr = num_bytes_value;
+ }
+ if (num_handles_ptr != NULL) {
+ *num_handles_ptr = num_handles_value;
+ }
+ *result_ptr = result_value;
+ }
+
+ return 0;
+ }
+
+ }
+
+ return -1;
+}
+
+ssize_t MojoDescRecvMsg(void* handle,
+ struct NaClImcTypedMsgHdr* msg,
+ int flags) {
+ return -1;
+}
+
+struct NaClDesc* MakeMojoDesc(struct NaClApp* nap) {
+ struct NaClDescCustomFuncs funcs = NACL_DESC_CUSTOM_FUNCS_INITIALIZER;
+ funcs.Destroy = MojoDescDestroy;
+ funcs.SendMsg = MojoDescSendMsg;
+ funcs.RecvMsg = MojoDescRecvMsg;
+ return NaClDescMakeCustomDesc(nap, &funcs);
+}
+
+void MojoDisabledDescDestroy(void* handle) {
+}
+
+ssize_t MojoDisabledDescSendMsg(void* handle,
+ const struct NaClImcTypedMsgHdr* msg,
+ int flags) {
+ fprintf(stderr, "Mojo is not currently supported.");
+ abort();
+}
+
+ssize_t MojoDisabledDescRecvMsg(void* handle,
+ struct NaClImcTypedMsgHdr* msg,
+ int flags) {
+ fprintf(stderr, "Mojo is not currently supported.");
+ abort();
+}
+
+struct NaClDesc* MakeDisabledMojoDesc(struct NaClApp* nap) {
+ struct NaClDescCustomFuncs funcs = NACL_DESC_CUSTOM_FUNCS_INITIALIZER;
+ funcs.Destroy = MojoDisabledDescDestroy;
+ funcs.SendMsg = MojoDisabledDescSendMsg;
+ funcs.RecvMsg = MojoDisabledDescRecvMsg;
+ return NaClDescMakeCustomDesc(nap, &funcs);
+}
+
+} // namespace
+
+// The value for this FD must not conflict with uses inside Chromium. However,
+// mojo/nacl doesn't depend on any Chromium headers, so we can't use a #define
+// from there.
+#define NACL_MOJO_DESC (NACL_CHROME_DESC_BASE + 3)
+
+void InjectMojo(struct NaClApp* nap) {
+ NaClAppSetDesc(nap, NACL_MOJO_DESC, MakeMojoDesc(nap));
+}
+
+void InjectDisabledMojo(struct NaClApp* nap) {
+ NaClAppSetDesc(nap, NACL_MOJO_DESC, MakeDisabledMojoDesc(nap));
+}
« no previous file with comments | « mojo/nacl/NOT_FOR_COMMIT/libmojo.cc ('k') | mojo/nacl/generator/generate_nacl_bindings.py » ('j') | mojo/nacl/generator/generate_nacl_bindings.py » ('J')

Powered by Google App Engine
This is Rietveld 408576698