Add, test, and use clock utilities

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,
 // 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_time.h>
-
 #include <limits>
 
-#include "base/mac/mach_logging.h"
 #include "base/mac/scoped_mach_vm.h"
+#include "util/misc/clock.h"
 
 namespace crashpad {
 
 namespace {
 
-mach_timebase_info_data_t* TimebaseInternal() {
-  mach_timebase_info_data_t* timebase_info = new mach_timebase_info_data_t;
-  kern_return_t kr = mach_timebase_info(timebase_info);
-  MACH_CHECK(kr == KERN_SUCCESS, kr) << "mach_timebase_info";
-  return timebase_info;
-}
-
-mach_timebase_info_data_t* Timebase() {
-  static mach_timebase_info_data_t* timebase_info = TimebaseInternal();
-  return timebase_info;
-}
-
-uint64_t NanosecondTicks() {
-  uint64_t absolute_time = mach_absolute_time();
-  mach_timebase_info_data_t* timebase_info = Timebase();
-  return absolute_time * timebase_info->numer / timebase_info->denom;
-}
-
 const int kNanosecondsPerMillisecond = 1E6;
 
 // TimerRunning determines whether |deadline| has passed. 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 zero (indicating that no timer is in effect), |*remaining_ms|
 // is set to zero and this function returns true. Otherwise, this function
 // returns false. |deadline| is specified on the same time base as is returned
-// by NanosecondTicks().
+// by ClockMonotonicNanoseconds().
 bool TimerRunning(uint64_t deadline, mach_msg_timeout_t* remaining_ms) {
   if (!deadline) {
     *remaining_ms = MACH_MSG_TIMEOUT_NONE;
     return true;
   }
 
-  uint64_t now = NanosecondTicks();
+  uint64_t now = ClockMonotonicNanoseconds();
 
   if (now >= deadline) {
     return false;
   }
 
   uint64_t remaining = deadline - now;
 
   // Round to the nearest millisecond, taking care not to overflow.
   const int kHalfMillisecondInNanoseconds = kNanosecondsPerMillisecond / 2;
   mach_msg_timeout_t remaining_mach;
@@ skipping 35 matching lines @@
 
   mach_msg_options_t timeout_options = MACH_RCV_TIMEOUT | MACH_SEND_TIMEOUT |
                                        MACH_RCV_INTERRUPT | MACH_SEND_INTERRUPT;
 
   uint64_t deadline;
   if (nonblocking == kNonblocking) {
     options |= timeout_options;
     deadline = 0;
   } else if (timeout_ms != MACH_MSG_TIMEOUT_NONE) {
     options |= timeout_options;
-    deadline = NanosecondTicks() +
+    deadline = ClockMonotonicNanoseconds() +
                static_cast<uint64_t>(timeout_ms) * kNanosecondsPerMillisecond;
   } else {
     options &= ~timeout_options;
     deadline = 0;
   }
 
   mach_msg_size_t trailer_alloc = REQUESTED_TRAILER_SIZE(options);
   mach_msg_size_t max_request_size = interface->MachMessageServerRequestSize();
   mach_msg_size_t request_alloc = round_page(max_request_size + trailer_alloc);
   mach_msg_size_t request_size = (options & MACH_RCV_LARGE)
@@ skipping 149 matching lines @@
         // persistent mode, and just return success when not in persistent mode.
         return (persistent == kPersistent) ? MACH_RCV_TIMED_OUT : kr;
       }
     }
   } while (persistent == kPersistent);
 
   return kr;
 }
 
 }  // namespace crashpad