NaCl: create a separate namespace for Mojo handles.

nacl_bindings/mojo_syscall.cc

 // 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 "nacl_bindings/mojo_syscall.h"
 
 #include <stdio.h>
 
 #include "mojo/public/c/system/core.h"
+#include "mojo/public/platform/native/core_system_api.h"
 #include "nacl_bindings/mojo_syscall_internal.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"
 
 MojoHandle g_mojo_handle = MOJO_HANDLE_INVALID;
+MojoCoreHandle g_mojo_core = nullptr;
 
 namespace {
 
 MojoResult _MojoGetInitialHandle(MojoHandle* handle) {
   *handle = g_mojo_handle;
   return MOJO_RESULT_OK;
 }
 
 void MojoDescDestroy(void* handle) {
 }
@@ skipping 37 matching lines @@
         if (!ConvertScalarInOut(nap, params[3], false,
                                 &shared_buffer_handle_value,
                                 &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);
+      result_value = MojoCoreCreateSharedBuffer(
+          g_mojo_core, 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: {
@@ skipping 16 matching lines @@
         }
         if (!ConvertScalarInOut(nap, params[3], false, &new_buffer_handle_value,
                                 &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);
+      result_value = MojoCoreDuplicateBufferHandle(
+          g_mojo_core, 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:
@@ skipping 26 matching lines @@
         if (!ConvertScalarInOut(nap, params[3], false,
                                 &data_pipe_consumer_handle_value,
                                 &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);
+      result_value = MojoCoreCreateDataPipe(g_mojo_core, 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;
     }
@@ skipping 23 matching lines @@
         }
         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);
+      result_value =
+          MojoCoreWriteData(g_mojo_core, 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:
@@ skipping 14 matching lines @@
           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);
+      result_value =
+          MojoCoreEndWriteData(g_mojo_core, 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) {
@@ skipping 21 matching lines @@
         }
         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);
+      result_value =
+          MojoCoreReadData(g_mojo_core, 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:
@@ skipping 14 matching lines @@
           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);
+      result_value = MojoCoreEndReadData(
+          g_mojo_core, 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();
+      result_value = MojoCoreGetTimeTicksNow(g_mojo_core);
 
       {
         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);
+      result_value = MojoCoreClose(g_mojo_core, handle_value);
 
       {
         ScopedCopyLock copy_lock(nap);
         *result_ptr = result_value;
       }
 
       return 0;
     }
     case 13: {
       if (num_params != 6) {
@@ skipping 18 matching lines @@
           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 = MojoWait(handle_value, signals_value, deadline_value,
-                              signals_state_ptr ? &signals_state_value : NULL);
+      result_value =
+          MojoCoreWait(g_mojo_core, 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;
       }
 
@@ skipping 34 matching lines @@
         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 = MojoWaitMany(
-          handles, signals, num_handles_value, deadline_value,
+      result_value = MojoCoreWaitMany(
+          g_mojo_core, 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;
       }
 
@@ skipping 23 matching lines @@
         if (!ConvertScalarInOut(nap, params[3], false,
                                 &message_pipe_handle1_value,
                                 &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);
+      result_value = MojoCoreCreateMessagePipe(g_mojo_core, 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;
     }
@@ skipping 28 matching lines @@
         }
         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);
+      result_value = MojoCoreWriteMessage(
+          g_mojo_core, 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 (num_params != 8) {
@@ skipping 30 matching lines @@
         }
         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,
+      result_value = MojoCoreReadMessage(
+          g_mojo_core, 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;
@@ skipping 76 matching lines @@
   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));
-  g_mojo_handle = MOJO_HANDLE_INVALID;
-}
-
 void InjectMojo(struct NaClApp* nap, MojoHandle handle) {
   NaClAppSetDesc(nap, NACL_MOJO_DESC, MakeMojoDesc(nap));
-  g_mojo_handle = handle;
+  g_mojo_core = MojoCoreCreateCore();
+  // TODO handle errors?
+  MojoCoreTransferHandle(MojoCoreGetDefaultCore(), handle, g_mojo_core,
+                         &g_mojo_handle);
 }
 
 void InjectDisabledMojo(struct NaClApp* nap) {
   NaClAppSetDesc(nap, NACL_MOJO_DESC, MakeDisabledMojoDesc(nap));
 }