Mojo + NaCl prototype.

mojo/monacl/generator/NOT_FOR_COMMIT/mojo_syscall.cc

Index: mojo/monacl/generator/NOT_FOR_COMMIT/mojo_syscall.cc
diff --git a/mojo/monacl/generator/NOT_FOR_COMMIT/mojo_syscall.cc b/mojo/monacl/generator/NOT_FOR_COMMIT/mojo_syscall.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0af4654ea89fb172fcf4bc7825318cac95e2652d
--- /dev/null
+++ b/mojo/monacl/generator/NOT_FOR_COMMIT/mojo_syscall.cc
@@ -0,0 +1,752 @@
+// 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_monacl_bindings.py
+// Do not edit by hand.
+
+#include "mojo/monacl/mojo_syscall.h"
+
+#include <stdio.h>
+
+#include "mojo/monacl/mojo_syscall_internal.h"

[Mark Seaborn, 2014/09/09 19:13:11]

This header seems to be missing from your changeset.

[Nick Bray (chromium), 2014/09/09 23:12:32]

Done.

+#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) {
+  UNREFERENCED_PARAMETER(handle);
+}
+
+ssize_t MojoDescSendMsg(void* handle,
+                        const struct NaClImcTypedMsgHdr* msg,
+                        int flags) {
+  UNREFERENCED_PARAMETER(flags);
+
+  struct NaClApp* nap = static_cast<struct NaClApp*>(handle);
+
+  if (msg->iov_length != 1 || msg->iov[0].length < 8 || msg->ndesc_length != 0) {
+    return -1;
+  }
+
+  uint32_t* params = static_cast<uint32_t*>(msg->iov[0].base);
+  uint32_t numParams = msg->iov[0].length / sizeof(*params);
+
+  uint32_t msgType = params[0];
+  switch (msgType) {
+  case 0:
+    {
+      if (numParams != 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 (!ConvertStruct(nap, params[1], true, &options)) {
+          return -1;
+        }
+        if (!ConvertScalarInput(nap, params[2], &num_bytes_value)) {
+          return -1;
+        }
+        if (!ConvertScalarOutput(nap, params[3], &shared_buffer_handle_ptr)) {
+          return -1;
+        }
+        if (!ConvertScalarOutput(nap, params[4], &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 (numParams != 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 (!ConvertStruct(nap, params[2], true, &options)) {
+          return -1;
+        }
+        if (!ConvertScalarOutput(nap, params[3], &new_buffer_handle_ptr)) {
+          return -1;
+        }
+        if (!ConvertScalarOutput(nap, params[4], &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 (numParams != 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], &buffer_ptr)) {
+          return -1;
+        }
+        if (!ConvertScalarInput(nap, params[5], &flags_value)) {
+          return -1;
+        }
+        if (!ConvertScalarOutput(nap, params[6], &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 (numParams != 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], &result_ptr)) {
+          return -1;
+        }
+      }
+
+      result_value = MojoUnmapBuffer(buffer_value);
+
+      {
+        ScopedCopyLock copy_lock(nap);
+        *result_ptr = result_value;
+      }
+
+      return 0;
+    }
+  case 4:
+    {
+      if (numParams != 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 (!ConvertStruct(nap, params[1], true, &options)) {
+          return -1;
+        }
+        if (!ConvertScalarOutput(nap, params[2], &data_pipe_producer_handle_ptr)) {
+          return -1;
+        }
+        if (!ConvertScalarOutput(nap, params[3], &data_pipe_consumer_handle_ptr)) {
+          return -1;
+        }
+        if (!ConvertScalarOutput(nap, params[4], &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 (numParams != 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], &result_ptr)) {
+          return -1;
+        }
+        if (!ConvertBytes(nap, params[2], num_bytes_value, 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 (numParams != 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], &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], &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 (numParams != 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], &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 (numParams != 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], &result_ptr)) {
+          return -1;
+        }
+        if (!ConvertBytes(nap, params[2], num_bytes_value, 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 (numParams != 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], &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], &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 (numParams != 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], &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 (numParams != 2) {
+        return -1;
+      }
+      MojoTimeTicks volatile* result_ptr;
+      MojoTimeTicks result_value;
+      {
+        ScopedCopyLock copy_lock(nap);
+        if (!ConvertScalarOutput(nap, params[1], &result_ptr)) {
+          return -1;
+        }
+      }
+
+      result_value = MojoGetTimeTicksNow();
+
+      {
+        ScopedCopyLock copy_lock(nap);
+        *result_ptr = result_value;
+      }
+
+      return 0;
+    }
+  case 12:
+    {
+      if (numParams != 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], &result_ptr)) {
+          return -1;
+        }
+      }
+
+      result_value = MojoClose(handle_value);
+
+      {
+        ScopedCopyLock copy_lock(nap);
+        *result_ptr = result_value;
+      }
+
+      return 0;
+    }
+  case 13:
+    {
+      if (numParams != 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], &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 (numParams != 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], &result_ptr)) {
+          return -1;
+        }
+        if (!ConvertArray(nap, params[1], num_handles_value, false, &handles)) {
+          return -1;
+        }
+        if (!ConvertArray(nap, params[2], num_handles_value, 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 (numParams != 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 (!ConvertStruct(nap, params[1], true, &options)) {
+          return -1;
+        }
+        if (!ConvertScalarOutput(nap, params[2], &message_pipe_handle0_ptr)) {
+          return -1;
+        }
+        if (!ConvertScalarOutput(nap, params[3], &message_pipe_handle1_ptr)) {
+          return -1;
+        }
+        if (!ConvertScalarOutput(nap, params[4], &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 16:
+    {
+      if (numParams != 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], &result_ptr)) {
+          return -1;
+        }
+        if (!ConvertBytes(nap, params[2], num_bytes_value, true, &bytes)) {
+          return -1;
+        }
+        if (!ConvertArray(nap, params[4], num_handles_value, 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 17:
+    {
+      if (numParams != 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], &result_ptr)) {
+          return -1;
+        }
+        if (!ConvertBytes(nap, params[2], num_bytes_value, true, &bytes)) {
+          return -1;
+        }
+        if (!ConvertArray(nap, params[4], num_handles_value, 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;
+    }
+
+  default:
+    return -1;
+  }
+
+  return -1;
+}
+
+ssize_t MojoDescRecvMsg(void* handle,
+                           struct NaClImcTypedMsgHdr* msg,
+                           int flags) {
+  UNREFERENCED_PARAMETER(handle);
+  UNREFERENCED_PARAMETER(msg);
+  UNREFERENCED_PARAMETER(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);
+}
+
+} // namespace
+
+#define NACL_MOJO_DESC (NACL_CHROME_DESC_BASE + 2)
+
+void InjectMojo(struct NaClApp* nap) {
+  NaClAppSetDesc(nap, NACL_MOJO_DESC, MakeMojoDesc(nap));
+}