[mojo-edk] Add explicit message object APIs

mojo/edk/embedder/entrypoints.cc

Index: mojo/edk/embedder/entrypoints.cc
diff --git a/mojo/edk/embedder/entrypoints.cc b/mojo/edk/embedder/entrypoints.cc
index 6acd98571ddf58ab7c4512d93c3521fe32e9dc58..1f99a0ec83aa53b1d25cb6cb65def8969d2e1bb7 100644
--- a/mojo/edk/embedder/entrypoints.cc
+++ b/mojo/edk/embedder/entrypoints.cc
@@ -53,6 +53,22 @@ MojoResult MojoCancelWatch(MojoHandle handle, uintptr_t context) {
   return g_core->CancelWatch(handle, context);
 }
 
+MojoResult MojoCreateMessage(uint32_t num_bytes,
+                             const MojoHandle* handles,

[Anand Mistry (off Chromium), 2016/04/14 10:25:03]

I know why you have this, but I'm really not a fan of exposing this. And
besides, the common case will be 0 handles and I think we can afford another
malloc/memcpy in the case you have a non-zero number of handles. Or, when you do
have handles, it'll likely be 1, so you could always reserve room for 1 handle.

+                             uint32_t num_handles,
+                             MojoCreateMessageFlags flags,
+                             void** message) {
+  return g_core->CreateMessage(num_bytes, handles, num_handles, flags, message);
+}
+
+MojoResult MojoDestroyMessage(void* message) {
+  return g_core->DestroyMessage(message);
+}
+
+MojoResult MojoGetMessageBuffer(void* message, void** buffer) {

[Anand Mistry (off Chromium), 2016/04/14 10:25:03]

Sorry, but not a fan. Two reasons:
1. Exposes internal details to the user. But also, a "Buffer API" should expose
just the buffer. The message itself is an implementation detail.
2. I'm concerned about the security aspect of making it easier to access the
message metadata. If an attacker compromises the process, it's easier for them
to re-route the message if they have easy access to the header.

Something to think about is crbug.com/590980. Having separate buffers for the
header and payload would make things simple. Even if you don't, you can always
map buffer address to message internally.

+  return g_core->GetMessageBuffer(message, buffer);
+}
+
 MojoResult MojoCreateWaitSet(MojoHandle* wait_set_handle) {
   return g_core->CreateWaitSet(wait_set_handle);
 }
@@ -93,6 +109,12 @@ MojoResult MojoWriteMessage(MojoHandle message_pipe_handle,
                               num_handles, flags);
 }
 
+MojoResult MojoWriteMessageNew(MojoHandle message_pipe_handle,
+                               void* message,
+                               MojoWriteMessageFlags flags) {
+  return g_core->WriteMessageNew(message_pipe_handle, message, flags);
+}
+
 MojoResult MojoReadMessage(MojoHandle message_pipe_handle,
                            void* bytes,
                            uint32_t* num_bytes,
@@ -103,6 +125,16 @@ MojoResult MojoReadMessage(MojoHandle message_pipe_handle,
       message_pipe_handle, bytes, num_bytes, handles, num_handles, flags);
 }
 
+MojoResult MojoReadMessageNew(MojoHandle message_pipe_handle,
+                              void** message,
+                              uint32_t* num_bytes,
+                              MojoHandle* handles,
+                              uint32_t* num_handles,
+                              MojoReadMessageFlags flags) {
+  return g_core->ReadMessageNew(
+      message_pipe_handle, message, num_bytes, handles, num_handles, flags);
+}
+
 MojoResult MojoFuseMessagePipes(MojoHandle handle0, MojoHandle handle1) {
   return g_core->FuseMessagePipes(handle0, handle1);
 }