NaCl: create a separate namespace for Mojo handles.

mojo/public/platform/native/core_system_api.h

Index: mojo/public/platform/native/core_system_api.h
diff --git a/mojo/public/platform/native/core_system_api.h b/mojo/public/platform/native/core_system_api.h
new file mode 100644
index 0000000000000000000000000000000000000000..85ed73b590ca68361b369689507ebb5a8184ea0a
--- /dev/null
+++ b/mojo/public/platform/native/core_system_api.h
@@ -0,0 +1,134 @@
+// Copyright 2015 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.
+
+// Note: This header should be compilable as C.
+
+#ifndef MOJO_PUBLIC_PLATFORM_NATIVE_CORE_SYSTEM_API_H_
+#define MOJO_PUBLIC_PLATFORM_NATIVE_CORE_SYSTEM_API_H_
+
+#include <stddef.h>

[viettrungluu, 2015/04/01 23:36:19]

nit: You don't need this include in this file.

[Nick Bray (chromium), 2015/04/04 00:09:09]

Done.

+
+#include "mojo/public/c/system/core.h"
+
+// This interface is similar to system_thunks.h, except that it allows Mojo

[viettrungluu, 2015/04/01 23:36:19]

nit: reformat comment to fill 80 columns

[Nick Bray (chromium), 2015/04/04 00:09:09]

git cl format really wants me to do it this way.  :/

[viettrungluu, 2015/04/06 17:39:25]

It's actually correctly filled. I was just confused by rietveld's inability to
render 80 columns correctly (for new files, when there's no side-by-side diff).

+// calls to be confined into different namespaces.
+
+typedef void* MojoCoreHandle;

[viettrungluu, 2015/04/01 23:36:19]

To avoid confusion, don't call it a "handle".

... which leads to a naming bikeshed:

* I don't think you should call this "core (system)"; that's confusing.
* Probably the name "private" should appear in the name of the API/thunks
somewhere. (I think I'd just call this file system_impl_private.h.)

I suggest calling these "system impls". Thus:

typedef void* MojoSystemImpl;

MojoGetDefaultSystemImpl()
MojoCreateSystemImpl()

etc.

[Nick Bray (chromium), 2015/04/04 00:09:09]

Done.

+
+typedef MojoCoreHandle(GetDefaultCoreFn)();

[viettrungluu, 2015/04/01 23:36:19]

Please don't pollute the namespace with all these typedefs. They're unnecessary
(also see below).

[Nick Bray (chromium), 2015/04/04 00:09:09]

Done.

+typedef MojoCoreHandle(CreateCoreFn)();
+typedef MojoResult(TransferHandleFn)(MojoCoreHandle from_core,
+                                     MojoHandle handle,
+                                     MojoCoreHandle to_core,
+                                     MojoHandle* result_handle);
+typedef MojoResult(CloseCoreFn)(MojoCoreHandle core);

[viettrungluu, 2015/04/01 23:36:19]

In general, it'd be useful to separate the "added" functions from the "standard"
ones.

[Nick Bray (chromium), 2015/04/04 00:09:09]

Done.

+typedef MojoTimeTicks(GetTimeTicksNowFn)(MojoCoreHandle core);
+typedef MojoResult(CloseFn)(MojoCoreHandle core, MojoHandle handle);
+typedef MojoResult(WaitFn)(MojoCoreHandle core,
+                           MojoHandle handle,
+                           MojoHandleSignals signals,
+                           MojoDeadline deadline,
+                           struct MojoHandleSignalsState* signals_state);
+typedef MojoResult(WaitManyFn)(MojoCoreHandle core,
+                               const MojoHandle* handles,
+                               const MojoHandleSignals* signals,
+                               uint32_t num_handles,
+                               MojoDeadline deadline,
+                               uint32_t* result_index,
+                               struct MojoHandleSignalsState* signals_states);
+typedef MojoResult(CreateMessagePipeFn)(
+    MojoCoreHandle core,
+    const struct MojoCreateMessagePipeOptions* options,
+    MojoHandle* message_pipe_handle0,
+    MojoHandle* message_pipe_handle1);
+typedef MojoResult(WriteMessageFn)(MojoCoreHandle core,
+                                   MojoHandle message_pipe_handle,
+                                   const void* bytes,
+                                   uint32_t num_bytes,
+                                   const MojoHandle* handles,
+                                   uint32_t num_handles,
+                                   MojoWriteMessageFlags flags);
+typedef MojoResult(ReadMessageFn)(MojoCoreHandle core,
+                                  MojoHandle message_pipe_handle,
+                                  void* bytes,
+                                  uint32_t* num_bytes,
+                                  MojoHandle* handles,
+                                  uint32_t* num_handles,
+                                  MojoReadMessageFlags flags);
+typedef MojoResult(CreateDataPipeFn)(
+    MojoCoreHandle core,
+    const struct MojoCreateDataPipeOptions* options,
+    MojoHandle* data_pipe_producer_handle,
+    MojoHandle* data_pipe_consumer_handle);
+typedef MojoResult(WriteDataFn)(MojoCoreHandle core,
+                                MojoHandle data_pipe_producer_handle,
+                                const void* elements,
+                                uint32_t* num_elements,
+                                MojoWriteDataFlags flags);
+typedef MojoResult(BeginWriteDataFn)(MojoCoreHandle core,
+                                     MojoHandle data_pipe_producer_handle,
+                                     void** buffer,
+                                     uint32_t* buffer_num_elements,
+                                     MojoWriteDataFlags flags);
+typedef MojoResult(EndWriteDataFn)(MojoCoreHandle core,
+                                   MojoHandle data_pipe_producer_handle,
+                                   uint32_t num_elements_written);
+typedef MojoResult(ReadDataFn)(MojoCoreHandle core,
+                               MojoHandle data_pipe_consumer_handle,
+                               void* elements,
+                               uint32_t* num_elements,
+                               MojoReadDataFlags flags);
+typedef MojoResult(BeginReadDataFn)(MojoCoreHandle core,
+                                    MojoHandle data_pipe_consumer_handle,
+                                    const void** buffer,
+                                    uint32_t* buffer_num_elements,
+                                    MojoReadDataFlags flags);
+typedef MojoResult(EndReadDataFn)(MojoCoreHandle core,
+                                  MojoHandle data_pipe_consumer_handle,
+                                  uint32_t num_elements_read);
+typedef MojoResult(CreateSharedBufferFn)(
+    MojoCoreHandle core,
+    const struct MojoCreateSharedBufferOptions* options,
+    uint64_t num_bytes,
+    MojoHandle* shared_buffer_handle);
+typedef MojoResult(DuplicateBufferHandleFn)(
+    MojoCoreHandle core,
+    MojoHandle buffer_handle,
+    const struct MojoDuplicateBufferHandleOptions* options,
+    MojoHandle* new_buffer_handle);
+typedef MojoResult(MapBufferFn)(MojoCoreHandle core,
+                                MojoHandle buffer_handle,
+                                uint64_t offset,
+                                uint64_t num_bytes,
+                                void** buffer,
+                                MojoMapBufferFlags flags);
+typedef MojoResult(UnmapBufferFn)(MojoCoreHandle core, void* buffer);
+
+extern "C" {
+
+GetDefaultCoreFn MojoCoreGetDefaultCore;

[viettrungluu, 2015/04/01 23:36:19]

Please declare these not as variables, but as actual functions -- they're
semantically slightly different (e.g., "&MojoCoreGetDefaultCore" would mean
different things).

(This is, I believe, strictly speaking incorrect.)

[Nick Bray (chromium), 2015/04/04 00:09:09]

I knew this was a little odd, but I've found nothing to indicate this doesn't
result in a plain-old forward declaration of a function.  Somewhat moot when I
get rid of the typedefs, but I'd be interested to know why these are variables.

[viettrungluu, 2015/04/06 17:39:25]

I was just confused. I thought your typedefs were for function pointers, not
functions....

+CreateCoreFn MojoCoreCreateCore;
+TransferHandleFn MojoCoreTransferHandle;
+CloseCoreFn MojoCoreCloseCore;
+GetTimeTicksNowFn MojoCoreGetTimeTicksNow;
+CloseFn MojoCoreClose;
+WaitFn MojoCoreWait;
+WaitManyFn MojoCoreWaitMany;
+CreateMessagePipeFn MojoCoreCreateMessagePipe;
+WriteMessageFn MojoCoreWriteMessage;
+ReadMessageFn MojoCoreReadMessage;
+CreateDataPipeFn MojoCoreCreateDataPipe;
+WriteDataFn MojoCoreWriteData;
+BeginWriteDataFn MojoCoreBeginWriteData;
+EndWriteDataFn MojoCoreEndWriteData;
+ReadDataFn MojoCoreReadData;
+BeginReadDataFn MojoCoreBeginReadData;
+EndReadDataFn MojoCoreEndReadData;
+CreateSharedBufferFn MojoCoreCreateSharedBuffer;
+DuplicateBufferHandleFn MojoCoreDuplicateBufferHandle;
+MapBufferFn MojoCoreMapBuffer;
+UnmapBufferFn MojoCoreUnmapBuffer;
+}
+
+#endif  // MOJO_PUBLIC_PLATFORM_NATIVE_CORE_SYSTEM_API_H_