NaCl: create a separate namespace for Mojo handles.

mojo/public/platform/native/system_impl_private_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/system_impl_private_thunks.h"
+
+#include <assert.h>
+
+#include "mojo/public/platform/native/thunk_export.h"
+
+extern "C" {
+
+static MojoSystemImplThunksPrivate g_system_impl_thunks = {0};
+static MojoExplicitSystemThunksPrivate g_explicit_system_thunks = {0};
+
+MojoSystemImpl MojoSystemImplGetDefaultImpl() {
+  assert(g_system_impl_thunks.GetDefaultSystemImpl);
+  return g_system_impl_thunks.GetDefaultSystemImpl();
+}
+
+MojoSystemImpl MojoSystemImplCreateImpl() {
+  assert(g_system_impl_thunks.CreateSystemImpl);
+  return g_system_impl_thunks.CreateSystemImpl();
+}
+
+MojoResult MojoSystemImplTransferHandle(MojoSystemImpl from_system,
+                                        MojoHandle handle,
+                                        MojoSystemImpl to_system,
+                                        MojoHandle* result_handle) {
+  assert(g_system_impl_thunks.TransferHandle);
+  return g_system_impl_thunks.TransferHandle(from_system, handle, to_system,
+                                             result_handle);
+}
+
+MojoTimeTicks MojoSystemImplGetTimeTicksNow(MojoSystemImpl system) {
+  assert(g_explicit_system_thunks.GetTimeTicksNow);
+  return g_explicit_system_thunks.GetTimeTicksNow(system);
+}
+
+MojoResult MojoSystemImplClose(MojoSystemImpl system, MojoHandle handle) {
+  assert(g_explicit_system_thunks.Close);
+  return g_explicit_system_thunks.Close(system, handle);
+}
+
+MojoResult MojoSystemImplWait(MojoSystemImpl system,
+                              MojoHandle handle,
+                              MojoHandleSignals signals,
+                              MojoDeadline deadline,
+                              struct MojoHandleSignalsState* signals_state) {
+  assert(g_explicit_system_thunks.Wait);
+  return g_explicit_system_thunks.Wait(system, handle, signals, deadline,
+                                       signals_state);
+}
+
+MojoResult MojoSystemImplWaitMany(
+    MojoSystemImpl system,
+    const MojoHandle* handles,
+    const MojoHandleSignals* signals,
+    uint32_t num_handles,
+    MojoDeadline deadline,
+    uint32_t* result_index,
+    struct MojoHandleSignalsState* signals_states) {
+  assert(g_explicit_system_thunks.WaitMany);
+  return g_explicit_system_thunks.WaitMany(system, handles, signals,
+                                           num_handles, deadline, result_index,
+                                           signals_states);
+}
+
+MojoResult MojoSystemImplCreateMessagePipe(
+    MojoSystemImpl system,
+    const struct MojoCreateMessagePipeOptions* options,
+    MojoHandle* message_pipe_handle0,
+    MojoHandle* message_pipe_handle1) {
+  assert(g_explicit_system_thunks.CreateMessagePipe);
+  return g_explicit_system_thunks.CreateMessagePipe(
+      system, options, message_pipe_handle0, message_pipe_handle1);
+}
+
+MojoResult MojoSystemImplWriteMessage(MojoSystemImpl system,
+                                      MojoHandle message_pipe_handle,
+                                      const void* bytes,
+                                      uint32_t num_bytes,
+                                      const MojoHandle* handles,
+                                      uint32_t num_handles,
+                                      MojoWriteMessageFlags flags) {
+  assert(g_explicit_system_thunks.WriteMessage);
+  return g_explicit_system_thunks.WriteMessage(system, message_pipe_handle,
+                                               bytes, num_bytes, handles,
+                                               num_handles, flags);
+}
+
+MojoResult MojoSystemImplReadMessage(MojoSystemImpl system,
+                                     MojoHandle message_pipe_handle,
+                                     void* bytes,
+                                     uint32_t* num_bytes,
+                                     MojoHandle* handles,
+                                     uint32_t* num_handles,
+                                     MojoReadMessageFlags flags) {
+  assert(g_explicit_system_thunks.ReadMessage);
+  return g_explicit_system_thunks.ReadMessage(system, message_pipe_handle,
+                                              bytes, num_bytes, handles,
+                                              num_handles, flags);
+}
+
+MojoResult MojoSystemImplCreateDataPipe(
+    MojoSystemImpl system,
+    const struct MojoCreateDataPipeOptions* options,
+    MojoHandle* data_pipe_producer_handle,
+    MojoHandle* data_pipe_consumer_handle) {
+  assert(g_explicit_system_thunks.CreateDataPipe);
+  return g_explicit_system_thunks.CreateDataPipe(
+      system, options, data_pipe_producer_handle, data_pipe_consumer_handle);
+}
+
+MojoResult MojoSystemImplWriteData(MojoSystemImpl system,
+                                   MojoHandle data_pipe_producer_handle,
+                                   const void* elements,
+                                   uint32_t* num_elements,
+                                   MojoWriteDataFlags flags) {
+  assert(g_explicit_system_thunks.WriteData);
+  return g_explicit_system_thunks.WriteData(system, data_pipe_producer_handle,
+                                            elements, num_elements, flags);
+}
+
+MojoResult MojoSystemImplBeginWriteData(MojoSystemImpl system,
+                                        MojoHandle data_pipe_producer_handle,
+                                        void** buffer,
+                                        uint32_t* buffer_num_elements,
+                                        MojoWriteDataFlags flags) {
+  assert(g_explicit_system_thunks.BeginWriteData);
+  return g_explicit_system_thunks.BeginWriteData(
+      system, data_pipe_producer_handle, buffer, buffer_num_elements, flags);
+}
+
+MojoResult MojoSystemImplEndWriteData(MojoSystemImpl system,
+                                      MojoHandle data_pipe_producer_handle,
+                                      uint32_t num_elements_written) {
+  assert(g_explicit_system_thunks.EndWriteData);
+  return g_explicit_system_thunks.EndWriteData(
+      system, data_pipe_producer_handle, num_elements_written);
+}
+
+MojoResult MojoSystemImplReadData(MojoSystemImpl system,
+                                  MojoHandle data_pipe_consumer_handle,
+                                  void* elements,
+                                  uint32_t* num_elements,
+                                  MojoReadDataFlags flags) {
+  assert(g_explicit_system_thunks.ReadData);
+  return g_explicit_system_thunks.ReadData(system, data_pipe_consumer_handle,
+                                           elements, num_elements, flags);
+}
+
+MojoResult MojoSystemImplBeginReadData(MojoSystemImpl system,
+                                       MojoHandle data_pipe_consumer_handle,
+                                       const void** buffer,
+                                       uint32_t* buffer_num_elements,
+                                       MojoReadDataFlags flags) {
+  assert(g_explicit_system_thunks.BeginReadData);
+  return g_explicit_system_thunks.BeginReadData(
+      system, data_pipe_consumer_handle, buffer, buffer_num_elements, flags);
+}
+
+MojoResult MojoSystemImplEndReadData(MojoSystemImpl system,
+                                     MojoHandle data_pipe_consumer_handle,
+                                     uint32_t num_elements_read) {
+  assert(g_explicit_system_thunks.EndReadData);
+  return g_explicit_system_thunks.EndReadData(system, data_pipe_consumer_handle,
+                                              num_elements_read);
+}
+
+MojoResult MojoSystemImplCreateSharedBuffer(
+    MojoSystemImpl system,
+    const struct MojoCreateSharedBufferOptions* options,
+    uint64_t num_bytes,
+    MojoHandle* shared_buffer_handle) {
+  assert(g_explicit_system_thunks.CreateSharedBuffer);
+  return g_explicit_system_thunks.CreateSharedBuffer(system, options, num_bytes,
+                                                     shared_buffer_handle);
+}
+
+MojoResult MojoSystemImplDuplicateBufferHandle(
+    MojoSystemImpl system,
+    MojoHandle buffer_handle,
+    const struct MojoDuplicateBufferHandleOptions* options,
+    MojoHandle* new_buffer_handle) {
+  assert(g_explicit_system_thunks.DuplicateBufferHandle);
+  return g_explicit_system_thunks.DuplicateBufferHandle(
+      system, buffer_handle, options, new_buffer_handle);
+}
+
+MojoResult MojoSystemImplMapBuffer(MojoSystemImpl system,
+                                   MojoHandle buffer_handle,
+                                   uint64_t offset,
+                                   uint64_t num_bytes,
+                                   void** buffer,
+                                   MojoMapBufferFlags flags) {
+  assert(g_explicit_system_thunks.MapBuffer);
+  return g_explicit_system_thunks.MapBuffer(system, buffer_handle, offset,
+                                            num_bytes, buffer, flags);
+}
+
+MojoResult MojoSystemImplUnmapBuffer(MojoSystemImpl system, void* buffer) {
+  assert(g_explicit_system_thunks.UnmapBuffer);
+  return g_explicit_system_thunks.UnmapBuffer(system, buffer);
+}
+
+extern "C" THUNK_EXPORT size_t MojoSetSystemImplThunksPrivate(
+    const MojoSystemImplThunksPrivate* system_thunks) {
+  if (system_thunks->size >= sizeof(g_system_impl_thunks))
+    g_system_impl_thunks = *system_thunks;
+  return sizeof(g_system_impl_thunks);
+}
+
+extern "C" THUNK_EXPORT size_t MojoSetExplicitSystemThunksPrivate(
+    const MojoExplicitSystemThunksPrivate* system_thunks) {
+  if (system_thunks->size >= sizeof(g_explicit_system_thunks))
+    g_explicit_system_thunks = *system_thunks;
+  return sizeof(g_explicit_system_thunks);
+}
+
+}  // extern "C"