Add Go build support for GN.

mojo/public/platform/native/system_thunks.h

 // 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.
 

[viettrungluu, 2014/09/23 13:44:43]

Probably you should add a comment indicating that this header should be valid C
(just like the headers in mojo/public/c/system have such a comment).

[tburkard, 2014/09/23 13:52:21]

Done.

 #ifndef MOJO_PUBLIC_PLATFORM_NATIVE_SYSTEM_THUNKS_H_
 #define MOJO_PUBLIC_PLATFORM_NATIVE_SYSTEM_THUNKS_H_
 
 #include <stddef.h>
 
 #include "mojo/public/c/system/core.h"
 
 // The embedder needs to bind the basic Mojo Core functions of a DSO to those of
 // the embedder when loading a DSO that is dependent on mojo_system.
 // The typical usage would look like:
@@ skipping 21 matching lines @@
   size_t size;  // Should be set to sizeof(MojoSystemThunks).
   MojoTimeTicks (*GetTimeTicksNow)();
   MojoResult (*Close)(MojoHandle handle);
   MojoResult (*Wait)(MojoHandle handle,
                      MojoHandleSignals signals,
                      MojoDeadline deadline);
   MojoResult (*WaitMany)(const MojoHandle* handles,
                          const MojoHandleSignals* signals,
                          uint32_t num_handles,
                          MojoDeadline deadline);
-  MojoResult (*CreateMessagePipe)(const MojoCreateMessagePipeOptions* options,
-                                  MojoHandle* message_pipe_handle0,
-                                  MojoHandle* message_pipe_handle1);
+  MojoResult (*CreateMessagePipe)(
+      const struct MojoCreateMessagePipeOptions* options,
+      MojoHandle* message_pipe_handle0,
+      MojoHandle* message_pipe_handle1);
   MojoResult (*WriteMessage)(MojoHandle message_pipe_handle,
                              const void* bytes,
                              uint32_t num_bytes,
                              const MojoHandle* handles,
                              uint32_t num_handles,
                              MojoWriteMessageFlags flags);
   MojoResult (*ReadMessage)(MojoHandle message_pipe_handle,
                             void* bytes,
                             uint32_t* num_bytes,
                             MojoHandle* handles,
                             uint32_t* num_handles,
                             MojoReadMessageFlags flags);
-  MojoResult (*CreateDataPipe)(const MojoCreateDataPipeOptions* options,
+  MojoResult (*CreateDataPipe)(const struct MojoCreateDataPipeOptions* options,
                                MojoHandle* data_pipe_producer_handle,
                                MojoHandle* data_pipe_consumer_handle);
   MojoResult (*WriteData)(MojoHandle data_pipe_producer_handle,
                           const void* elements,
                           uint32_t* num_elements,
                           MojoWriteDataFlags flags);
   MojoResult (*BeginWriteData)(MojoHandle data_pipe_producer_handle,
                                void** buffer,
                                uint32_t* buffer_num_elements,
                                MojoWriteDataFlags flags);
   MojoResult (*EndWriteData)(MojoHandle data_pipe_producer_handle,
                              uint32_t num_elements_written);
   MojoResult (*ReadData)(MojoHandle data_pipe_consumer_handle,
                          void* elements,
                          uint32_t* num_elements,
                          MojoReadDataFlags flags);
   MojoResult (*BeginReadData)(MojoHandle data_pipe_consumer_handle,
                               const void** buffer,
                               uint32_t* buffer_num_elements,
                               MojoReadDataFlags flags);
   MojoResult (*EndReadData)(MojoHandle data_pipe_consumer_handle,
                             uint32_t num_elements_read);
   MojoResult (*CreateSharedBuffer)(
-      const MojoCreateSharedBufferOptions* options,
+      const struct MojoCreateSharedBufferOptions* options,
       uint64_t num_bytes,
       MojoHandle* shared_buffer_handle);
   MojoResult (*DuplicateBufferHandle)(
       MojoHandle buffer_handle,
-      const MojoDuplicateBufferHandleOptions* options,
+      const struct MojoDuplicateBufferHandleOptions* options,
       MojoHandle* new_buffer_handle);
   MojoResult (*MapBuffer)(MojoHandle buffer_handle,
                           uint64_t offset,
                           uint64_t num_bytes,
                           void** buffer,
                           MojoMapBufferFlags flags);
   MojoResult (*UnmapBuffer)(void* buffer);
 };
 #pragma pack(pop)
 
 // Intended to be called from the embedder. Returns a |MojoCore| initialized
 // to contain pointers to each of the embedder's MojoCore functions.
-inline MojoSystemThunks MojoMakeSystemThunks() {
-  MojoSystemThunks system_thunks = {
-    sizeof(MojoSystemThunks),
+inline struct MojoSystemThunks MojoMakeSystemThunks() {

[viettrungluu, 2014/09/23 13:44:43]

... though "inline" requires either C99 (or a compiler extension), if it's C.

Also, if it's to be C, you need an explicit "void" parameter.

The interpretation of |inline| also differs between C99 and C++. This is
troublesome since C99 seems to require that you say "extern inline struct
MojoSystemThunks MojoMakeSystemThunks(void)" in exactly one .c file (compilation
unit).

Since this is only called from the embedder, you shouldn't need it and the best
thing to do is to simply put it inside |#ifndef __cplusplus ... #endif|, and not
change it at all.

[tburkard, 2014/09/23 13:52:21]

Done.

[tburkard, 2014/09/23 13:54:57]

Should it really be ifndef? or ifdef?

Thanks.

+  struct MojoSystemThunks system_thunks = {
+    sizeof(struct MojoSystemThunks),
     MojoGetTimeTicksNow,
     MojoClose,
     MojoWait,
     MojoWaitMany,
     MojoCreateMessagePipe,
     MojoWriteMessage,
     MojoReadMessage,
     MojoCreateDataPipe,
     MojoWriteData,
     MojoBeginWriteData,
     MojoEndWriteData,
     MojoReadData,
     MojoBeginReadData,
     MojoEndReadData,
     MojoCreateSharedBuffer,
     MojoDuplicateBufferHandle,
     MojoMapBuffer,
     MojoUnmapBuffer
   };
   return system_thunks;
 }
 
 // Use this type for the function found by dynamically discovering it in
 // a DSO linked with mojo_system. For example:
 // MojoSetSystemThunksFn mojo_set_system_thunks_fn =
 //     reinterpret_cast<MojoSetSystemThunksFn>(app_library.GetFunctionPointer(
 //         "MojoSetSystemThunks"));
 // The expected size of |system_thunks} is returned.
 // The contents of |system_thunks| are copied.
-typedef size_t (*MojoSetSystemThunksFn)(const MojoSystemThunks* system_thunks);
+typedef size_t (*MojoSetSystemThunksFn)(
+    const struct MojoSystemThunks* system_thunks);
 
 #endif  // MOJO_PUBLIC_PLATFORM_NATIVE_SYSTEM_THUNKS_H_