Switch to standard integer types in base/.

base/time/time_mac.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/time/time.h"
 
 #include <CoreFoundation/CFDate.h>
 #include <CoreFoundation/CFTimeZone.h>
 #include <mach/mach.h>
 #include <mach/mach_time.h>
+#include <stddef.h>
 #include <stdint.h>
 #include <sys/sysctl.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <time.h>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/mac/mach_logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/mac/scoped_mach_port.h"
+#include "base/macros.h"
 #include "base/numerics/safe_conversions.h"
+#include "build/build_config.h"
 
 namespace {
 
 int64_t ComputeCurrentTicks() {
 #if defined(OS_IOS)
   // On iOS mach_absolute_time stops while the device is sleeping. Instead use
   // now - KERN_BOOTTIME to get a time difference that is not impacted by clock
   // changes. KERN_BOOTTIME will be updated by the system whenever the system
   // clock change.
   struct timeval boottime;
@@ skipping 77 matching lines @@
 // Time -----------------------------------------------------------------------
 
 // Core Foundation uses a double second count since 2001-01-01 00:00:00 UTC.
 // The UNIX epoch is 1970-01-01 00:00:00 UTC.
 // Windows uses a Gregorian epoch of 1601.  We need to match this internally
 // so that our time representations match across all platforms.  See bug 14734.
 //   irb(main):010:0> Time.at(0).getutc()
 //   => Thu Jan 01 00:00:00 UTC 1970
 //   irb(main):011:0> Time.at(-11644473600).getutc()
 //   => Mon Jan 01 00:00:00 UTC 1601
-static const int64 kWindowsEpochDeltaSeconds = INT64_C(11644473600);
+static const int64_t kWindowsEpochDeltaSeconds = INT64_C(11644473600);
 
 // static
-const int64 Time::kWindowsEpochDeltaMicroseconds =
+const int64_t Time::kWindowsEpochDeltaMicroseconds =
     kWindowsEpochDeltaSeconds * Time::kMicrosecondsPerSecond;
 
 // Some functions in time.cc use time_t directly, so we provide an offset
 // to convert from time_t (Unix epoch) and internal (Windows epoch).
 // static
-const int64 Time::kTimeTToMicrosecondsOffset = kWindowsEpochDeltaMicroseconds;
+const int64_t Time::kTimeTToMicrosecondsOffset = kWindowsEpochDeltaMicroseconds;
 
 // static
 Time Time::Now() {
   return FromCFAbsoluteTime(CFAbsoluteTimeGetCurrent());
 }
 
 // static
 Time Time::FromCFAbsoluteTime(CFAbsoluteTime t) {
   static_assert(std::numeric_limits<CFAbsoluteTime>::has_infinity,
                 "CFAbsoluteTime must have an infinity value");
   if (t == 0)
     return Time();  // Consider 0 as a null Time.
   if (t == std::numeric_limits<CFAbsoluteTime>::infinity())
     return Max();
-  return Time(static_cast<int64>(
-      (t + kCFAbsoluteTimeIntervalSince1970) * kMicrosecondsPerSecond) +
-      kWindowsEpochDeltaMicroseconds);
+  return Time(static_cast<int64_t>((t + kCFAbsoluteTimeIntervalSince1970) *
+                                   kMicrosecondsPerSecond) +
+              kWindowsEpochDeltaMicroseconds);
 }
 
 CFAbsoluteTime Time::ToCFAbsoluteTime() const {
   static_assert(std::numeric_limits<CFAbsoluteTime>::has_infinity,
                 "CFAbsoluteTime must have an infinity value");
   if (is_null())
     return 0;  // Consider 0 as a null Time.
   if (is_max())
     return std::numeric_limits<CFAbsoluteTime>::infinity();
   return (static_cast<CFAbsoluteTime>(us_ - kWindowsEpochDeltaMicroseconds) /
@@ skipping 14 matching lines @@
   date.minute = exploded.minute;
   date.hour = exploded.hour;
   date.day = exploded.day_of_month;
   date.month = exploded.month;
   date.year = exploded.year;
 
   base::ScopedCFTypeRef<CFTimeZoneRef> time_zone(
       is_local ? CFTimeZoneCopySystem() : NULL);
   CFAbsoluteTime seconds = CFGregorianDateGetAbsoluteTime(date, time_zone) +
       kCFAbsoluteTimeIntervalSince1970;
-  return Time(static_cast<int64>(seconds * kMicrosecondsPerSecond) +
-      kWindowsEpochDeltaMicroseconds);
+  return Time(static_cast<int64_t>(seconds * kMicrosecondsPerSecond) +
+              kWindowsEpochDeltaMicroseconds);
 }
 
 void Time::Explode(bool is_local, Exploded* exploded) const {
   // Avoid rounding issues, by only putting the integral number of seconds
   // (rounded towards -infinity) into a |CFAbsoluteTime| (which is a |double|).
-  int64 microsecond = us_ % kMicrosecondsPerSecond;
+  int64_t microsecond = us_ % kMicrosecondsPerSecond;
   if (microsecond < 0)
     microsecond += kMicrosecondsPerSecond;
   CFAbsoluteTime seconds = ((us_ - microsecond) / kMicrosecondsPerSecond) -
                            kWindowsEpochDeltaSeconds -
                            kCFAbsoluteTimeIntervalSince1970;
 
   base::ScopedCFTypeRef<CFTimeZoneRef> time_zone(
       is_local ? CFTimeZoneCopySystem() : NULL);
   CFGregorianDate date = CFAbsoluteTimeGetGregorianDate(seconds, time_zone);
   // 1 = Monday, ..., 7 = Sunday.
@@ skipping 26 matching lines @@
 bool TimeTicks::IsHighResolution() {
   return true;
 }
 
 // static
 ThreadTicks ThreadTicks::Now() {
   return ThreadTicks(ComputeThreadTicks());
 }
 
 }  // namespace base