Switch to standard integer types in base/.

base/time/time_win_unittest.cc

Index: base/time/time_win_unittest.cc
diff --git a/base/time/time_win_unittest.cc b/base/time/time_win_unittest.cc
index e2bb893c199f5413747ef3fd1204e1db65a90149..ad5e0beb40adfe7c258fc0eb3578c69bb478963a 100644
--- a/base/time/time_win_unittest.cc
+++ b/base/time/time_win_unittest.cc
@@ -5,6 +5,7 @@
 #include <windows.h>
 #include <mmsystem.h>
 #include <process.h>
+#include <stdint.h>
 
 #include <cmath>
 #include <limits>
@@ -44,14 +45,14 @@ MockTimeTicks::TickFunctionType MockTimeTicks::old_tick_function_;
 HANDLE g_rollover_test_start;
 
 unsigned __stdcall RolloverTestThreadMain(void* param) {
-  int64 counter = reinterpret_cast<int64>(param);
+  int64_t counter = reinterpret_cast<int64_t>(param);
   DWORD rv = WaitForSingleObject(g_rollover_test_start, INFINITE);
   EXPECT_EQ(rv, WAIT_OBJECT_0);
 
   TimeTicks last = TimeTicks::Now();
   for (int index = 0; index < counter; index++) {
     TimeTicks now = TimeTicks::Now();
-    int64 milliseconds = (now - last).InMilliseconds();
+    int64_t milliseconds = (now - last).InMilliseconds();
     // This is a tight loop; we could have looped faster than our
     // measurements, so the time might be 0 millis.
     EXPECT_GE(milliseconds, 0);
@@ -81,8 +82,8 @@ TEST(TimeTicks, MAYBE_WinRollover) {
   //   5) Each thread verifies integrity of result.
 
   const int kThreads = 8;
-  // Use int64 so we can cast into a void* without a compiler warning.
-  const int64 kChecks = 10;
+  // Use int64_t so we can cast into a void* without a compiler warning.
+  const int64_t kChecks = 10;
 
   // It takes a lot of iterations to reproduce the bug!
   // (See bug 1081395)
@@ -240,18 +241,18 @@ TEST(TimeTicks, FromQPCValue) {
 
   LARGE_INTEGER frequency;
   ASSERT_TRUE(QueryPerformanceFrequency(&frequency));
-  const int64 ticks_per_second = frequency.QuadPart;
+  const int64_t ticks_per_second = frequency.QuadPart;
   ASSERT_GT(ticks_per_second, 0);
 
   // Generate the tick values to convert, advancing the tick count by varying
   // amounts.  These values will ensure that both the fast and overflow-safe
   // conversion logic in FromQPCValue() is tested, and across the entire range
   // of possible QPC tick values.
-  std::vector<int64> test_cases;
+  std::vector<int64_t> test_cases;
   test_cases.push_back(0);
   const int kNumAdvancements = 100;
-  int64 ticks = 0;
-  int64 ticks_increment = 10;
+  int64_t ticks = 0;
+  int64_t ticks_increment = 10;
   for (int i = 0; i < kNumAdvancements; ++i) {
     test_cases.push_back(ticks);
     ticks += ticks_increment;
@@ -267,14 +268,14 @@ TEST(TimeTicks, FromQPCValue) {
     ticks += ticks_increment;
     ticks_increment = ticks_increment * 6 / 5;
   }
-  test_cases.push_back(std::numeric_limits<int64>::max());
+  test_cases.push_back(std::numeric_limits<int64_t>::max());
 
   // Test that the conversions using FromQPCValue() match those computed here
   // using simple floating-point arithmetic.  The floating-point math provides
   // enough precision to confirm the implementation is correct to the
   // microsecond for all |test_cases| (though it would be insufficient to
   // confirm many "very large" tick values which are not being tested here).
-  for (int64 ticks : test_cases) {
+  for (int64_t ticks : test_cases) {
     const double expected_microseconds_since_origin =
         (static_cast<double>(ticks) * Time::kMicrosecondsPerSecond) /
             ticks_per_second;