MachMessageServer: eliminate argument redundancy

util/mach/mach_message_server.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 98 matching lines @@
                                  notify_port,
                                  run_even_if_expired);
 }
 
 }  // namespace
 
 // This method implements a server similar to 10.9.4
 // xnu-2422.110.17/libsyscall/mach/mach_msg.c mach_msg_server_once(). The server
 // callback function and |max_size| parameter have been replaced with a C++
 // interface. The |persistent| parameter has been added, allowing this method to
-// serve as a stand-in for mach_msg_server(). The |nonblocking| parameter has
-// been added, allowing blocking to be controlled directly. The |timeout_ms|
-// parameter has been added, allowing this function to not block indefinitely.
+// serve as a stand-in for mach_msg_server(). The |timeout_ms| parameter has
+// been added, allowing this function to not block indefinitely.
 //
 // static
 mach_msg_return_t MachMessageServer::Run(Interface* interface,
                                          mach_port_t receive_port,
                                          mach_msg_options_t options,
                                          Persistent persistent,
-                                         Nonblocking nonblocking,
                                          ReceiveLarge receive_large,
                                          mach_msg_timeout_t timeout_ms) {
   options &= ~(MACH_RCV_MSG | MACH_SEND_MSG);
 
-  MachMessageDeadline deadline;
-  if (nonblocking == kNonblocking) {
-    deadline = kMachMessageNonblocking;
-  } else if (timeout_ms == MACH_MSG_TIMEOUT_NONE) {
-    deadline = kMachMessageWaitIndefinitely;
-  } else {
-    deadline = MachMessageDeadlineFromTimeout(timeout_ms);
-  }
+  const MachMessageDeadline deadline =
+      MachMessageDeadlineFromTimeout(timeout_ms);
 
   if (receive_large == kReceiveLargeResize) {
     options |= MACH_RCV_LARGE;
   } else {
     options &= ~MACH_RCV_LARGE;
   }
 
   const mach_msg_size_t trailer_alloc = REQUESTED_TRAILER_SIZE(options);
   const mach_msg_size_t expected_receive_size =
       round_msg(interface->MachMessageServerRequestSize()) + trailer_alloc;
@@ skipping 101 matching lines @@
     }
 
     if (reply_header->msgh_remote_port != MACH_PORT_NULL) {
       // Avoid blocking indefinitely. This duplicates the logic in 10.9.5
       // xnu-2422.115.4/libsyscall/mach/mach_msg.c mach_msg_server_once(),
       // although the special provision for sending to a send-once right is not
       // made, because kernel keeps sends to a send-once right on the fast path
       // without considering the user-specified timeout. See 10.9.5
       // xnu-2422.115.4/osfmk/ipc/ipc_mqueue.c ipc_mqueue_send().
       const MachMessageDeadline send_deadline =
-          deadline == kMachMessageWaitIndefinitely ? kMachMessageNonblocking
-                                                   : deadline;
+          deadline == kMachMessageDeadlineWaitIndefinitely
+              ? kMachMessageDeadlineNonblocking
+              : deadline;
 
       kr = MachMessageWithDeadline(reply_header,
                                    options | MACH_SEND_MSG,
                                    0,
                                    MACH_PORT_NULL,
                                    send_deadline,
                                    MACH_PORT_NULL,
                                    true);
 
       if (kr != MACH_MSG_SUCCESS) {
         if (kr == MACH_SEND_INVALID_DEST ||
             kr == MACH_SEND_TIMED_OUT ||
             kr == MACH_SEND_INTERRUPTED) {
           mach_msg_destroy(reply_header);
         }
         return kr;
       }
     }
   } while (persistent == kPersistent || retry);
 
   return kr;
 }
 
 }  // namespace crashpad