[mojo-edk] Add explicit message object APIs

mojo/edk/system/message_pipe_unittest.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 <stdint.h>
+#include <string.h>
 
 #include "base/memory/ref_counted.h"
 #include "mojo/edk/system/test_utils.h"
 #include "mojo/edk/test/mojo_test_base.h"
 #include "mojo/public/c/system/core.h"
 #include "mojo/public/c/system/types.h"
 
 namespace mojo {
 namespace edk {
 namespace {
@@ skipping 386 matching lines @@
 
   // Now port 1 should no longer be readable.
   hss = MojoHandleSignalsState();
   ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             MojoWait(pipe1_, MOJO_HANDLE_SIGNAL_READABLE,
                      MOJO_DEADLINE_INDEFINITE, &hss));
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals);
   ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals);
 }
 
+TEST_F(MessagePipeTest, InvalidMessageObjects) {
+  // null message
+  ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            MojoDestroyMessage(nullptr));
+
+  // null message
+  ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            MojoGetMessageBuffer(nullptr, nullptr));
+
+  // Non-zero num_handles with null handles array.
+  ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            MojoCreateMessage(0, nullptr, 1, MOJO_CREATE_MESSAGE_FLAG_NONE,
+                              nullptr));
+}
+
+TEST_F(MessagePipeTest, CreateAndDestroyMessage) {
+  const std::string kMessage = "Hello, world.";
+  void* message = nullptr;
+  ASSERT_EQ(MOJO_RESULT_OK,
+            MojoCreateMessage(static_cast<uint32_t>(kMessage.size()),
+                              nullptr, 0, MOJO_CREATE_MESSAGE_FLAG_NONE,
+                              &message));
+  ASSERT_TRUE(message);
+
+  ASSERT_EQ(MOJO_RESULT_OK, MojoDestroyMessage(message));
+}
+
+TEST_F(MessagePipeTest, WriteAndReadMessageObject) {
+  const std::string kMessage = "Hello, world.";
+  void* message = nullptr;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoCreateMessage(static_cast<uint32_t>(kMessage.size()),
+                              nullptr, 0, MOJO_CREATE_MESSAGE_FLAG_NONE,
+                              &message));
+  ASSERT_TRUE(message);
+
+  void* buffer = nullptr;
+  EXPECT_EQ(MOJO_RESULT_OK, MojoGetMessageBuffer(message, &buffer));
+  ASSERT_TRUE(buffer);
+  memcpy(buffer, kMessage.data(), kMessage.size());
+
+  MojoHandle a, b;
+  CreateMessagePipe(&a, &b);
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoWriteMessageNew(a, message, MOJO_WRITE_MESSAGE_FLAG_NONE));
+
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoWait(b, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE,
+                     nullptr));
+  uint32_t num_bytes = 0;
+  uint32_t num_handles = 0;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoReadMessageNew(b, &message, &num_bytes, nullptr, &num_handles,
+                               MOJO_READ_MESSAGE_FLAG_NONE));
+  ASSERT_TRUE(message);
+  EXPECT_EQ(static_cast<uint32_t>(kMessage.size()), num_bytes);
+  EXPECT_EQ(0u, num_handles);
+
+  EXPECT_EQ(MOJO_RESULT_OK, MojoGetMessageBuffer(message, &buffer));
+  ASSERT_TRUE(buffer);
+
+  EXPECT_EQ(0, strncmp(static_cast<const char*>(buffer), kMessage.data(),
+                       num_bytes));
+
+  EXPECT_EQ(MOJO_RESULT_OK, MojoDestroyMessage(message));
+  EXPECT_EQ(MOJO_RESULT_OK, MojoClose(a));
+  EXPECT_EQ(MOJO_RESULT_OK, MojoClose(b));
+}
+
 #if !defined(OS_IOS)
 
 const size_t kPingPongHandlesPerIteration = 50;
 const size_t kPingPongIterations = 500;
 
 DEFINE_TEST_CLIENT_TEST_WITH_PIPE(HandlePingPong, MessagePipeTest, h) {
   // Waits for a handle to become readable and writes it back to the sender.
   for (size_t i = 0; i < kPingPongIterations; i++) {
     MojoHandle handles[kPingPongHandlesPerIteration];
     ReadMessageWithHandles(h, handles, kPingPongHandlesPerIteration);
@@ skipping 219 matching lines @@
   EXPECT_EQ(kTestMessage, ReadMessage(d));
   EXPECT_EQ(MOJO_RESULT_OK, MojoWait(d, MOJO_HANDLE_SIGNAL_PEER_CLOSED,
                                      MOJO_DEADLINE_INDEFINITE, nullptr));
 
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(d));
 }
 
 }  // namespace
 }  // namespace edk
 }  // namespace mojo