MachMessageServer: eliminate argument redundancy

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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "util/mach/mach_message_server.h"
 
 #include <mach/mach.h>
 #include <string.h>
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/mac/scoped_mach_port.h"
 #include "gtest/gtest.h"
 #include "util/file/fd_io.h"
 #include "util/mach/mach_extensions.h"
+#include "util/mach/mach_message.h"
 #include "util/test/mac/mach_errors.h"
 #include "util/test/mac/mach_multiprocess.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 class TestMachMessageServer : public MachMessageServer::Interface,
                               public MachMultiprocess {
  public:
@@ skipping 15 matching lines @@
       // server processes the request. The server should return
       // MACH_SEND_INVALID_DEST, and the client will not expect a reply.
       kReplyPortDead,
     };
 
     Options()
         : expect_server_interface_method_called(true),
           parent_wait_for_child_pipe(false),
           server_options(MACH_MSG_OPTION_NONE),
           server_persistent(MachMessageServer::kOneShot),
-          server_nonblocking(MachMessageServer::kBlocking),
           server_receive_large(MachMessageServer::kReceiveLargeError),
-          server_timeout_ms(MACH_MSG_TIMEOUT_NONE),
+          server_timeout_ms(kMachMessageTimeoutWaitIndefinitely),
           server_mig_retcode(KERN_SUCCESS),
           server_destroy_complex(true),
           expect_server_destroyed_complex(true),
           expect_server_result(KERN_SUCCESS),
           expect_server_transaction_count(1),
           child_wait_for_parent_pipe_early(false),
           client_send_request_count(1),
           client_send_complex(false),
           client_send_large(false),
           client_reply_port_type(kReplyPortNormal),
@@ skipping 11 matching lines @@
     // be something in the server’s queue before attempting a nonblocking
     // receive if the receive is to be successful.
     bool parent_wait_for_child_pipe;
 
     // Options to pass to MachMessageServer::Run() as the |options| parameter.
     mach_msg_options_t server_options;
 
     // Whether the server should run in one-shot or persistent mode.
     MachMessageServer::Persistent server_persistent;
 
-    // Whether the server should run in blocking or nonblocking mode.
-    MachMessageServer::Nonblocking server_nonblocking;
-
     // The strategy for handling large messages.
     MachMessageServer::ReceiveLarge server_receive_large;
 
-    // The server’s timeout.
+    // The server’s timeout in milliseconds, or kMachMessageTimeoutNonblocking
+    // or kMachMessageTimeoutWaitIndefinitely.
     mach_msg_timeout_t server_timeout_ms;
 
     // The return code that the server returns to the client via the
     // mig_reply_error_t::RetCode field. A client would normally see this as
     // a Mach RPC return value.
     kern_return_t server_mig_retcode;
 
     // The value that the server function should set its destroy_complex_request
     // parameter to. This is true if resources sent in complex request messages
     // should be destroyed, and false if they should not be destroyed, assuming
@@ skipping 232 matching lines @@
       char c;
       CheckedReadFD(ReadPipeFD(), &c, 1);
       EXPECT_EQ('\0', c);
     }
 
     ASSERT_EQ(options_.expect_server_result,
               (kr = MachMessageServer::Run(this,
                                            local_port,
                                            options_.server_options,
                                            options_.server_persistent,
-                                           options_.server_nonblocking,
                                            options_.server_receive_large,
                                            options_.server_timeout_ms)))
         << MachErrorMessage(kr, "MachMessageServer");
 
     if (options_.client_send_complex) {
       EXPECT_NE(kMachPortNull, parent_complex_message_port_);
       mach_port_type_t type;
 
       if (!options_.expect_server_destroyed_complex) {
         // MachMessageServer should not have destroyed the resources sent in the
@@ skipping 243 matching lines @@
   TestMachMessageServer::Options options;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, NonblockingNoMessage) {
   // The server waits in nonblocking mode and the client sends nothing, so the
   // server should return immediately without processing any message.
   TestMachMessageServer::Options options;
   options.expect_server_interface_method_called = false;
-  options.server_nonblocking = MachMessageServer::kNonblocking;
+  options.server_timeout_ms = kMachMessageTimeoutNonblocking;
   options.expect_server_result = MACH_RCV_TIMED_OUT;
   options.expect_server_transaction_count = 0;
   options.client_send_request_count = 0;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, TimeoutNoMessage) {
   // The server waits in blocking mode for one message, but with a timeout. The
   // client sends no message, so the server returns after the timeout.
   TestMachMessageServer::Options options;
   options.expect_server_interface_method_called = false;
   options.server_timeout_ms = 10;
   options.expect_server_result = MACH_RCV_TIMED_OUT;
   options.expect_server_transaction_count = 0;
   options.client_send_request_count = 0;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, Nonblocking) {
   // The client sends one message to the server and then signals the server that
   // it’s safe to start waiting for it in nonblocking mode. The message is in
   // the server’s queue, so it’s able to receive it when it begins listening in
   // nonblocking mode.
   TestMachMessageServer::Options options;
   options.parent_wait_for_child_pipe = true;
-  options.server_nonblocking = MachMessageServer::kNonblocking;
+  options.server_timeout_ms = kMachMessageTimeoutNonblocking;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, Timeout) {
   // The client sends one message to the server, which will wait in blocking
   // mode for it up to a specific timeout.
   TestMachMessageServer::Options options;
   options.server_timeout_ms = 10;
   TestMachMessageServer test_mach_message_server(options);
@@ skipping 33 matching lines @@
   // child is allowed to begin sending messages, so
   // child_wait_for_parent_pipe_early is used to make the child wait until the
   // parent is ready.
   const size_t kTransactionCount = 4;
   static_assert(kTransactionCount <= MACH_PORT_QLIMIT_DEFAULT,
                 "must not exceed queue limit");
 
   TestMachMessageServer::Options options;
   options.parent_wait_for_child_pipe = true;
   options.server_persistent = MachMessageServer::kPersistent;
-  options.server_nonblocking = MachMessageServer::kNonblocking;
+  options.server_timeout_ms = kMachMessageTimeoutNonblocking;
   options.expect_server_result = MACH_RCV_TIMED_OUT;
   options.expect_server_transaction_count = kTransactionCount;
   options.child_wait_for_parent_pipe_early = true;
   options.client_send_request_count = kTransactionCount;
   options.child_send_all_requests_before_receiving_any_replies = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, ReturnCodeInvalidArgument) {
@@ skipping 141 matching lines @@
   options.expect_server_transaction_count = 0;
   options.client_send_large = true;
   options.client_expect_reply = false;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad