NaCl: create a separate namespace for Mojo handles.

mojo/public/platform/native/core_system_thunks.cc

+// Copyright 2013 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.
+
+#include "mojo/public/platform/native/core_system_thunks.h"
+
+#include <assert.h>
+
+#include "mojo/public/platform/native/thunk_export.h"
+
+extern "C" {
+
+static MojoCoreSystemThunks g_core_thunks = {0};
+
+MojoCoreHandle MojoCoreGetDefaultCore() {
+  assert(g_core_thunks.GetDefaultCore);
+  return g_core_thunks.GetDefaultCore();
+}
+
+MojoCoreHandle MojoCoreCreateCore() {
+  assert(g_core_thunks.CreateCore);
+  return g_core_thunks.CreateCore();
+}
+
+MojoResult MojoCoreTransferHandle(MojoCoreHandle from_core,
+                                  MojoHandle handle,
+                                  MojoCoreHandle to_core,
+                                  MojoHandle* result_handle) {
+  assert(g_core_thunks.TransferHandle);
+  return g_core_thunks.TransferHandle(from_core, handle, to_core,
+                                      result_handle);
+}
+
+MojoResult MojoCoreCloseCore(MojoCoreHandle core) {
+  assert(g_core_thunks.CloseCore);
+  return g_core_thunks.CloseCore(core);
+}
+
+MojoTimeTicks MojoCoreGetTimeTicksNow(MojoCoreHandle core) {
+  assert(g_core_thunks.GetTimeTicksNow);
+  return g_core_thunks.GetTimeTicksNow(core);
+}
+
+MojoResult MojoCoreClose(MojoCoreHandle core, MojoHandle handle) {
+  assert(g_core_thunks.Close);
+  return g_core_thunks.Close(core, handle);
+}
+
+MojoResult MojoCoreWait(MojoCoreHandle core,
+                        MojoHandle handle,
+                        MojoHandleSignals signals,
+                        MojoDeadline deadline,
+                        struct MojoHandleSignalsState* signals_state) {
+  assert(g_core_thunks.Wait);
+  return g_core_thunks.Wait(core, handle, signals, deadline, signals_state);
+}
+
+MojoResult MojoCoreWaitMany(MojoCoreHandle core,
+                            const MojoHandle* handles,
+                            const MojoHandleSignals* signals,
+                            uint32_t num_handles,
+                            MojoDeadline deadline,
+                            uint32_t* result_index,
+                            struct MojoHandleSignalsState* signals_states) {
+  assert(g_core_thunks.WaitMany);
+  return g_core_thunks.WaitMany(core, handles, signals, num_handles, deadline,
+                                result_index, signals_states);
+}
+
+MojoResult MojoCoreCreateMessagePipe(
+    MojoCoreHandle core,
+    const struct MojoCreateMessagePipeOptions* options,
+    MojoHandle* message_pipe_handle0,
+    MojoHandle* message_pipe_handle1) {
+  assert(g_core_thunks.CreateMessagePipe);
+  return g_core_thunks.CreateMessagePipe(core, options, message_pipe_handle0,
+                                         message_pipe_handle1);
+}
+
+MojoResult MojoCoreWriteMessage(MojoCoreHandle core,
+                                MojoHandle message_pipe_handle,
+                                const void* bytes,
+                                uint32_t num_bytes,
+                                const MojoHandle* handles,
+                                uint32_t num_handles,
+                                MojoWriteMessageFlags flags) {
+  assert(g_core_thunks.WriteMessage);
+  return g_core_thunks.WriteMessage(core, message_pipe_handle, bytes, num_bytes,
+                                    handles, num_handles, flags);
+}
+
+MojoResult MojoCoreReadMessage(MojoCoreHandle core,
+                               MojoHandle message_pipe_handle,
+                               void* bytes,
+                               uint32_t* num_bytes,
+                               MojoHandle* handles,
+                               uint32_t* num_handles,
+                               MojoReadMessageFlags flags) {
+  assert(g_core_thunks.ReadMessage);
+  return g_core_thunks.ReadMessage(core, message_pipe_handle, bytes, num_bytes,
+                                   handles, num_handles, flags);
+}
+
+MojoResult MojoCoreCreateDataPipe(
+    MojoCoreHandle core,
+    const struct MojoCreateDataPipeOptions* options,
+    MojoHandle* data_pipe_producer_handle,
+    MojoHandle* data_pipe_consumer_handle) {
+  assert(g_core_thunks.CreateDataPipe);
+  return g_core_thunks.CreateDataPipe(core, options, data_pipe_producer_handle,
+                                      data_pipe_consumer_handle);
+}
+
+MojoResult MojoCoreWriteData(MojoCoreHandle core,
+                             MojoHandle data_pipe_producer_handle,
+                             const void* elements,
+                             uint32_t* num_elements,
+                             MojoWriteDataFlags flags) {
+  assert(g_core_thunks.WriteData);
+  return g_core_thunks.WriteData(core, data_pipe_producer_handle, elements,
+                                 num_elements, flags);
+}
+
+MojoResult MojoCoreBeginWriteData(MojoCoreHandle core,
+                                  MojoHandle data_pipe_producer_handle,
+                                  void** buffer,
+                                  uint32_t* buffer_num_elements,
+                                  MojoWriteDataFlags flags) {
+  assert(g_core_thunks.BeginWriteData);
+  return g_core_thunks.BeginWriteData(core, data_pipe_producer_handle, buffer,
+                                      buffer_num_elements, flags);
+}
+
+MojoResult MojoCoreEndWriteData(MojoCoreHandle core,
+                                MojoHandle data_pipe_producer_handle,
+                                uint32_t num_elements_written) {
+  assert(g_core_thunks.EndWriteData);
+  return g_core_thunks.EndWriteData(core, data_pipe_producer_handle,
+                                    num_elements_written);
+}
+
+MojoResult MojoCoreReadData(MojoCoreHandle core,
+                            MojoHandle data_pipe_consumer_handle,
+                            void* elements,
+                            uint32_t* num_elements,
+                            MojoReadDataFlags flags) {
+  assert(g_core_thunks.ReadData);
+  return g_core_thunks.ReadData(core, data_pipe_consumer_handle, elements,
+                                num_elements, flags);
+}
+
+MojoResult MojoCoreBeginReadData(MojoCoreHandle core,
+                                 MojoHandle data_pipe_consumer_handle,
+                                 const void** buffer,
+                                 uint32_t* buffer_num_elements,
+                                 MojoReadDataFlags flags) {
+  assert(g_core_thunks.BeginReadData);
+  return g_core_thunks.BeginReadData(core, data_pipe_consumer_handle, buffer,
+                                     buffer_num_elements, flags);
+}
+
+MojoResult MojoCoreEndReadData(MojoCoreHandle core,
+                               MojoHandle data_pipe_consumer_handle,
+                               uint32_t num_elements_read) {
+  assert(g_core_thunks.EndReadData);
+  return g_core_thunks.EndReadData(core, data_pipe_consumer_handle,
+                                   num_elements_read);
+}
+
+MojoResult MojoCoreCreateSharedBuffer(
+    MojoCoreHandle core,
+    const struct MojoCreateSharedBufferOptions* options,
+    uint64_t num_bytes,
+    MojoHandle* shared_buffer_handle) {
+  assert(g_core_thunks.CreateSharedBuffer);
+  return g_core_thunks.CreateSharedBuffer(core, options, num_bytes,
+                                          shared_buffer_handle);
+}
+
+MojoResult MojoCoreDuplicateBufferHandle(
+    MojoCoreHandle core,
+    MojoHandle buffer_handle,
+    const struct MojoDuplicateBufferHandleOptions* options,
+    MojoHandle* new_buffer_handle) {
+  assert(g_core_thunks.DuplicateBufferHandle);
+  return g_core_thunks.DuplicateBufferHandle(core, buffer_handle, options,
+                                             new_buffer_handle);
+}
+
+MojoResult MojoCoreMapBuffer(MojoCoreHandle core,
+                             MojoHandle buffer_handle,
+                             uint64_t offset,
+                             uint64_t num_bytes,
+                             void** buffer,
+                             MojoMapBufferFlags flags) {
+  assert(g_core_thunks.MapBuffer);
+  return g_core_thunks.MapBuffer(core, buffer_handle, offset, num_bytes, buffer,
+                                 flags);
+}
+
+MojoResult MojoCoreUnmapBuffer(MojoCoreHandle core, void* buffer) {
+  assert(g_core_thunks.UnmapBuffer);
+  return g_core_thunks.UnmapBuffer(core, buffer);
+}
+
+extern "C" THUNK_EXPORT size_t
+MojoSetCoreSystemThunks(const MojoCoreSystemThunks* system_thunks) {
+  if (system_thunks->size >= sizeof(g_core_thunks))
+    g_core_thunks = *system_thunks;
+  return sizeof(g_core_thunks);
+}
+
+}  // extern "C"