Changing SpawnChild to return a struct.

mojo/edk/system/multiprocess_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 <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <string>
@@ skipping 13 matching lines @@
 #include "build/build_config.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/edk/system/handle_signals_state.h"
 #include "mojo/edk/system/test_utils.h"
 #include "mojo/edk/test/mojo_test_base.h"
 #include "mojo/edk/test/test_utils.h"
 #include "mojo/public/c/system/buffer.h"
 #include "mojo/public/c/system/functions.h"
 #include "mojo/public/c/system/types.h"
+#include "mojo/public/cpp/system/platform_handle.h"
 #include "mojo/public/cpp/system/watcher.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#if defined(OS_ANDROID)
+#include "base/test/android/jni_test_util.h"
+#endif
 
 namespace mojo {
 namespace edk {
 namespace {
 
 class MultiprocessMessagePipeTest : public test::MojoTestBase {
  protected:
   // Convenience class for tests which will control command-driven children.
   // See the CommandDrivenClient definition below.
   class CommandDrivenClientController {
@@ skipping 53 matching lines @@
       CHECK_EQ(hss.satisfied_signals, MOJO_HANDLE_SIGNAL_PEER_CLOSED);
       CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_PEER_CLOSED);
       break;
     } else {
       CHECK((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
       CHECK((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
     }
 
     std::string read_buffer(1000, '\0');
     uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
-    CHECK_EQ(MojoReadMessage(h, &read_buffer[0],
-                             &read_buffer_size, nullptr,
-                             0, MOJO_READ_MESSAGE_FLAG_NONE),
+    MojoHandle handles[10];
+    uint32_t num_handles = 10;
+    CHECK_EQ(MojoReadMessage(h, &read_buffer[0], &read_buffer_size, handles,
+                             &num_handles, MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     read_buffer.resize(read_buffer_size);
+
     VLOG(2) << "Child got: " << read_buffer;
 
     if (read_buffer == quitquitquit) {
       VLOG(2) << "Child quitting.";
       break;
     }
 
     std::string write_buffer = read_buffer + read_buffer;
-    CHECK_EQ(MojoWriteMessage(h, write_buffer.data(),
-                              static_cast<uint32_t>(write_buffer.size()),
-                              nullptr, 0u, MOJO_WRITE_MESSAGE_FLAG_NONE),
-             MOJO_RESULT_OK);
+    CHECK_EQ(
+        MojoWriteMessage(h, write_buffer.data(),
+                         static_cast<uint32_t>(write_buffer.size()), handles,
+                         num_handles, MOJO_WRITE_MESSAGE_FLAG_NONE),
+        MOJO_RESULT_OK);
   }
 
   return rv;
 }
 
 TEST_P(MultiprocessMessagePipeTestWithPeerSupport, Basic) {
   RUN_CHILD_ON_PIPE(EchoEcho, h)
     std::string hello("hello");
     ASSERT_EQ(MOJO_RESULT_OK,
               MojoWriteMessage(h, hello.data(),
@@ skipping 1184 matching lines @@
   MojoHandle pipe;
   EXPECT_EQ("hi", ReadMessageWithHandles(parent, &pipe, 1));
   WriteMessage(pipe, "derp");
   EXPECT_EQ("bye", ReadMessage(parent));
 }
 
 void OnProcessError(std::string* out_error, const std::string& error) {
   *out_error = error;
 }
 
+#if defined(OS_ANDROID)
+TEST_F(MultiprocessMessagePipeTest, BasicParcelable) {
+  RUN_CHILD_ON_PIPE(EchoEcho, h)
+  MojoHandle handles[2];
+  base::android::ScopedJavaLocalRef<jobject> parcelable1 =
+      base::android::test::CreateJavaPoint(11, 22);
+  base::android::ScopedJavaLocalRef<jobject> parcelable2 =
+      base::android::test::CreateJavaPoint(88, 99);
+  ScopedHandle parcelable1_handle = WrapParcelable(parcelable1);
+  handles[0] = parcelable1_handle.release().value();
+  ScopedHandle parcelable2_handle = WrapParcelable(parcelable2);
+  handles[1] = parcelable2_handle.release().value();
+
+  std::string hello("hello");
+  WriteMessageWithHandles(h, hello, handles, 2u);
+
+  HandleSignalsState hss;
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(h, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &hss));
+  // The child may or may not have closed its end of the message pipe and died
+  // (and we may or may not know it yet), so our end may or may not appear as
+  // writable.
+  EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE));
+  EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE));
+
+  std::string read_buffer(1000, '\0');
+  uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
+  MojoHandle received_handles[10];
+  uint32_t num_received_handles = 10;
+  CHECK_EQ(
+      MojoReadMessage(h, &read_buffer[0], &read_buffer_size, received_handles,
+                      &num_received_handles, MOJO_READ_MESSAGE_FLAG_NONE),
+      MOJO_RESULT_OK);
+  read_buffer.resize(read_buffer_size);
+  VLOG(2) << "Parent got: " << read_buffer;
+  ASSERT_EQ(hello + hello, read_buffer);
+
+  ASSERT_EQ(2U, num_received_handles);
+  base::android::ScopedJavaLocalRef<jobject> received_parcelable1;
+  ASSERT_EQ(MOJO_RESULT_OK,
+            UnwrapParcelable(MakeScopedHandle(Handle(received_handles[0])),
+                             &received_parcelable1));
+  EXPECT_TRUE(base::android::test::AreJavaObjectsEqual(
+      parcelable1.obj(), received_parcelable1.obj()));
+
+  base::android::ScopedJavaLocalRef<jobject> received_parcelable2;
+  ASSERT_EQ(MOJO_RESULT_OK,
+            UnwrapParcelable(MakeScopedHandle(Handle(received_handles[1])),
+                             &received_parcelable2));
+  EXPECT_TRUE(base::android::test::AreJavaObjectsEqual(
+      parcelable2.obj(), received_parcelable2.obj()));
+
+  std::string quitquitquit("quitquitquit");
+  CHECK_EQ(MojoWriteMessage(h, quitquitquit.data(),
+                            static_cast<uint32_t>(quitquitquit.size()), nullptr,
+                            0u, MOJO_WRITE_MESSAGE_FLAG_NONE),
+           MOJO_RESULT_OK);
+  END_CHILD_AND_EXPECT_EXIT_CODE(1 % 100);
+}
+
+#endif  // defined(OS_ANDROID)
+
 TEST_F(MultiprocessMessagePipeTest, NotifyBadMessage) {
   const std::string kFirstErrorMessage = "everything is terrible!";
   const std::string kSecondErrorMessage = "not the bits you're looking for";
 
   std::string first_process_error;
   std::string second_process_error;
 
   set_process_error_callback(base::Bind(&OnProcessError, &first_process_error));
   RUN_CHILD_ON_PIPE(BadMessageClient, child1)
     set_process_error_callback(base::Bind(&OnProcessError,
@@ skipping 42 matching lines @@
 INSTANTIATE_TEST_CASE_P(
     ,
     MultiprocessMessagePipeTestWithPeerSupport,
     testing::Values(test::MojoTestBase::LaunchType::CHILD,
                     test::MojoTestBase::LaunchType::PEER,
                     test::MojoTestBase::LaunchType::NAMED_CHILD,
                     test::MojoTestBase::LaunchType::NAMED_PEER));
 }  // namespace
 }  // namespace edk
 }  // namespace mojo