MachMessageServer: eliminate argument redundancy

util/mach/mach_message.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.h"
 
 #include <limits>
 
 #include "base/basictypes.h"
 #include "util/misc/clock.h"
 
 namespace crashpad {
 
 namespace {
 
 const int kNanosecondsPerMillisecond = 1E6;
 
 // TimerRunning() determines whether |deadline| has passed. If |deadline| is
-// kMachMessageWaitIndefinitely, |*timeout_options| is set to
+// kMachMessageDeadlineWaitIndefinitely, |*timeout_options| is set to
 // MACH_MSG_OPTION_NONE, |*remaining_ms| is set to MACH_MSG_TIMEOUT_NONE, and
 // this function returns true. When used with mach_msg(), this will cause
 // indefinite waiting. In any other case, |*timeout_options| is set to
 // MACH_SEND_TIMEOUT | MACH_RCV_TIMEOUT, so mach_msg() will enforce a timeout
 // specified by |*remaining_ms|. If |deadline| is in the future, |*remaining_ms|
 // is set to the number of milliseconds remaining, which will always be a
 // positive value, and this function returns true. If |deadline| is
-// kMachMessageNonblocking (indicating that no timer is in effect),
+// kMachMessageDeadlineNonblocking (indicating that no timer is in effect),
 // |*remaining_ms| is set to zero and this function returns true. Otherwise,
 // this function sets |*remaining_ms| to zero and returns false.
 bool TimerRunning(uint64_t deadline,
                   mach_msg_timeout_t* remaining_ms,
                   mach_msg_option_t* timeout_options) {
-  if (deadline == kMachMessageWaitIndefinitely) {
+  if (deadline == kMachMessageDeadlineWaitIndefinitely) {
     *remaining_ms = MACH_MSG_TIMEOUT_NONE;
     *timeout_options = MACH_MSG_OPTION_NONE;
     return true;
   }
 
   *timeout_options = MACH_SEND_TIMEOUT | MACH_RCV_TIMEOUT;
 
-  if (deadline == kMachMessageNonblocking) {
+  if (deadline == kMachMessageDeadlineNonblocking) {
     *remaining_ms = 0;
     return true;
   }
 
   uint64_t now = ClockMonotonicNanoseconds();
 
   if (now >= deadline) {
     *remaining_ms = 0;
   } else {
     uint64_t remaining = deadline - now;
@@ skipping 48 matching lines @@
       receive_size,
       receive_port,
       remaining_ms,
       notify_port);
 }
 
 }  // namespace
 
 MachMessageDeadline MachMessageDeadlineFromTimeout(
     mach_msg_timeout_t timeout_ms) {
-  if (timeout_ms == 0) {
-    return kMachMessageNonblocking;
+  switch (timeout_ms) {
+    case kMachMessageTimeoutNonblocking:
+      return kMachMessageDeadlineNonblocking;
+    case kMachMessageTimeoutWaitIndefinitely:
+      return kMachMessageDeadlineWaitIndefinitely;
+    default:
+      return ClockMonotonicNanoseconds() +
+             implicit_cast<uint64_t>(timeout_ms) * kNanosecondsPerMillisecond;
   }
-
-  return ClockMonotonicNanoseconds() +
-         implicit_cast<uint64_t>(timeout_ms) * kNanosecondsPerMillisecond;
 }
 
 mach_msg_return_t MachMessageWithDeadline(mach_msg_header_t* message,
                                           mach_msg_option_t options,
                                           mach_msg_size_t receive_size,
                                           mach_port_name_t receive_port,
                                           MachMessageDeadline deadline,
                                           mach_port_name_t notify_port,
                                           bool run_even_if_expired) {
   // mach_msg() actaully does return MACH_MSG_SUCCESS when not asked to send or
@@ skipping 68 matching lines @@
 }
 
 const mach_msg_trailer_t* MachMessageTrailerFromHeader(
     const mach_msg_header_t* header) {
   vm_address_t header_address = reinterpret_cast<vm_address_t>(header);
   vm_address_t trailer_address = header_address + round_msg(header->msgh_size);
   return reinterpret_cast<const mach_msg_trailer_t*>(trailer_address);
 }
 
 }  // namespace crashpad