Simple shell that loads a dll and calls an entrypoint function passing in a handle to a pipe create…

mojo/public/system/core.h

 // 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.
 
 #ifndef MOJO_PUBLIC_SYSTEM_CORE_H_
 #define MOJO_PUBLIC_SYSTEM_CORE_H_
 
 // Note: This header should be compilable as C.
 
 #include <stdint.h>
 
+#include "mojo/public/system/system_export.h"
+
 // Types -----------------------------------------------------------------------
 
 // TODO(vtl): Notes: Use of undefined flags will lead to undefined behavior
 // (typically they'll be ignored), not necessarily an error.
 
 // Handles to Mojo objects.
 typedef uint32_t MojoHandle;
 
 // Result codes for Mojo operations. Non-negative values are success codes;
 // negative values are error/failure codes.
@@ skipping 161 matching lines @@
 // Closes the given |handle|.
 //
 // Returns:
 //    |MOJO_RESULT_OK| on success.
 //    |MOJO_RESULT_INVALID_ARGUMENT| if |handle| is not a valid handle.
 //
 // Concurrent operations on |handle| may succeed (or fail as usual) if they
 // happen before the close, be cancelled with result |MOJO_RESULT_CANCELLED| if
 // they properly overlap (this is likely the case with |MojoWait()|, etc.), or
 // fail with |MOJO_RESULT_INVALID_ARGUMENT| if they happen after.
-MojoResult MojoClose(MojoHandle handle);
+MOJO_SYSTEM_EXPORT MojoResult MojoClose(MojoHandle handle);
 
 // Waits on the given handle until the state indicated by |flags| is satisfied
 // or until |deadline| has passed.
 //
 // Returns:
 //    |MOJO_RESULT_OK| if some flag in |flags| was satisfied (or is already
 //        satisfied).
 //    |MOJO_RESULT_INVALID_ARGUMENT| if |handle| is not a valid handle (e.g., if
 //        it has already been closed).
 //    |MOJO_RESULT_DEADLINE_EXCEEDED| if the deadline has passed without any of
 //        the flags being satisfied.
 //    |MOJO_RESULT_FAILED_PRECONDITION| if it is or becomes impossible that any
 //        flag in |flags| will ever be satisfied.
 //
 // If there are multiple waiters (on different threads, obviously) waiting on
 // the same handle and flag and that flag becomes set, all waiters will be
 // awoken.
-MojoResult MojoWait(MojoHandle handle,
-                    MojoWaitFlags flags,
-                    MojoDeadline deadline);
+MOJO_SYSTEM_EXPORT MojoResult MojoWait(MojoHandle handle,
+                                       MojoWaitFlags flags,
+                                       MojoDeadline deadline);
 
 // Waits on |handles[0]|, ..., |handles[num_handles-1]| for at least one of them
 // to satisfy the state indicated by |flags[0]|, ..., |flags[num_handles-1]|,
 // respectively, or until |deadline| has passed.
 //
 // Returns:
 //    The index |i| (from 0 to |num_handles-1|) if |handle[i]| satisfies
 //        |flags[i]|.
 //    |MOJO_RESULT_INVALID_ARGUMENT| if some |handle[i]| is not a valid handle
 //        (e.g., if it has already been closed).
 //    |MOJO_RESULT_DEADLINE_EXCEEDED| if the deadline has passed without any of
 //        handles satisfying any of its flags.
 //    |MOJO_RESULT_FAILED_PRECONDITION| if it is or becomes impossible that SOME
 //        |handle[i]| will ever satisfy any of its flags |flags[i]|.
-MojoResult MojoWaitMany(const MojoHandle* handles,
-                        const MojoWaitFlags* flags,
-                        uint32_t num_handles,
-                        MojoDeadline deadline);
+MOJO_SYSTEM_EXPORT MojoResult MojoWaitMany(const MojoHandle* handles,
+                                           const MojoWaitFlags* flags,
+                                           uint32_t num_handles,
+                                           MojoDeadline deadline);
 
 // TODO(vtl): flags? other params (e.g., queue sizes, max message sizes?)
-MojoResult MojoCreateMessagePipe(MojoHandle* handle_0, MojoHandle* handle_1);
+MOJO_SYSTEM_EXPORT MojoResult MojoCreateMessagePipe(MojoHandle* handle_0,
+                                                    MojoHandle* handle_1);
 
-MojoResult MojoWriteMessage(MojoHandle handle,
-                            const void* bytes, uint32_t num_bytes,
-                            const MojoHandle* handles, uint32_t num_handles,
-                            MojoWriteMessageFlags flags);
+MOJO_SYSTEM_EXPORT MojoResult MojoWriteMessage(
+    MojoHandle handle,
+    const void* bytes, uint32_t num_bytes,
+    const MojoHandle* handles,
+    uint32_t num_handles,
+    MojoWriteMessageFlags flags);
 
-MojoResult MojoReadMessage(MojoHandle handle,
-                           void* bytes, uint32_t* num_bytes,
-                           MojoHandle* handles, uint32_t* num_handles,
-                           MojoReadMessageFlags flags);
+MOJO_SYSTEM_EXPORT MojoResult MojoReadMessage(MojoHandle handle,
+                                              void* bytes, uint32_t* num_bytes,
+                                              MojoHandle* handles,
+                                              uint32_t* num_handles,
+                                              MojoReadMessageFlags flags);
 
 #ifdef __cplusplus
 }  // extern "C"
 #endif
 
 // C++ wrapper functions -------------------------------------------------------
 
 #ifdef __cplusplus
 
 namespace mojo {
@@ skipping 51 matching lines @@
   return MojoReadMessage(handle.value,
                          bytes, num_bytes,
                          &handles[0].value, num_handles,
                          flags);
 }
 
 }  // namespace mojo
 #endif
 
 #endif  // MOJO_PUBLIC_SYSTEM_CORE_H_