MachMultiprocess test: the child process must wait for the parent to finish

util/mach/mach_message_server_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 705 matching lines @@
 
 TEST(MachMessageServer, Complex) {
   // The client allocates a new receive right and sends a complex request
   // message to the server with a send right made out of this receive right. The
   // server receives this message and is instructed to destroy the send right
   // when it is done handling the request-reply transaction. The former send
   // right is verified to be invalid after the server runs. This test ensures
   // that resources transferred to a server process temporarily aren’t leaked.
   TestMachMessageServer::Options options;
   options.client_send_complex = true;
-  options.child_wait_for_parent_pipe = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, ComplexNotDestroyed) {
   // As in MachMessageServer.Complex, but the server is instructed not to
   // destroy the send right. After the server runs, the send right is verified
   // to continue to exist in the server task. The client process is then
   // signalled by pipe that it’s safe to exit so that the send right in the
   // server task doesn’t prematurely become a dead name. This test ensures that
   // rights that are expected to be retained in the server task are properly
   // retained.
   TestMachMessageServer::Options options;
   options.server_destroy_complex = false;
   options.expect_server_destroyed_complex = false;
   options.client_send_complex = true;
-  options.child_wait_for_parent_pipe = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, ComplexDestroyedInvalidArgument) {
   // As in MachMessageServer.ComplexNotDestroyed, but the server does not return
   // a successful code via MIG. The server is expected to destroy resources in
   // this case, because server_destroy_complex = false is only honored when a
   // MIG request is handled successfully or with no reply.
   TestMachMessageServer::Options options;
   options.server_mig_retcode = KERN_INVALID_TASK;
   options.server_destroy_complex = false;
   options.client_send_complex = true;
-  options.child_wait_for_parent_pipe = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, ComplexNotDestroyedNoReply) {
   // As in MachMessageServer.ComplexNotDestroyed, but the server does not send
   // a reply message and is expected to retain the send right in the server
   // task.
   TestMachMessageServer::Options options;
   options.server_mig_retcode = MIG_NO_REPLY;
@@ skipping 26 matching lines @@
   // so a new buffer is allocated to receive the message. The server receives
   // the large request message, processes it, and returns a reply to the client.
   TestMachMessageServer::Options options;
   options.server_options = MACH_RCV_LARGE;
   options.client_send_large = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 }  // namespace