Switch to standard integer types in ui/gl/.

ui/gl/sync_control_vsync_provider.cc

 // Copyright 2013 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 "ui/gl/sync_control_vsync_provider.h"
 
 #include <math.h>
 
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
+#include "build/build_config.h"
 
 #if defined(OS_LINUX)
 // These constants define a reasonable range for a calculated refresh interval.
 // Calculating refreshes out of this range will be considered a fatal error.
-const int64 kMinVsyncIntervalUs = base::Time::kMicrosecondsPerSecond / 400;
-const int64 kMaxVsyncIntervalUs = base::Time::kMicrosecondsPerSecond / 10;
+const int64_t kMinVsyncIntervalUs = base::Time::kMicrosecondsPerSecond / 400;
+const int64_t kMaxVsyncIntervalUs = base::Time::kMicrosecondsPerSecond / 10;
 
 // How much noise we'll tolerate between successive computed intervals before
 // we think the latest computed interval is invalid (noisey due to
 // monitor configuration change, moving a window between monitors, etc.).
 const double kRelativeIntervalDifferenceThreshold = 0.05;
 #endif
 
 namespace gfx {
 
 SyncControlVSyncProvider::SyncControlVSyncProvider()
@@ skipping 12 matching lines @@
 #if defined(OS_LINUX)
   base::TimeTicks timebase;
 
   // The actual clock used for the system time returned by glXGetSyncValuesOML
   // is unspecified. In practice, the clock used is likely to be either
   // CLOCK_REALTIME or CLOCK_MONOTONIC, so we compare the returned time to the
   // current time according to both clocks, and assume that the returned time
   // was produced by the clock whose current time is closest to it, subject
   // to the restriction that the returned time must not be in the future
   // (since it is the time of a vblank that has already occurred).
-  int64 system_time;
-  int64 media_stream_counter;
-  int64 swap_buffer_counter;
+  int64_t system_time;
+  int64_t media_stream_counter;
+  int64_t swap_buffer_counter;
   if (!GetSyncValues(&system_time, &media_stream_counter, &swap_buffer_counter))
     return;
 
   // Both Intel and Mali drivers will return TRUE for GetSyncValues
   // but a value of 0 for MSC if they cannot access the CRTC data structure
   // associated with the surface. crbug.com/231945
   bool prev_invalid_msc = invalid_msc_;
   invalid_msc_ = (media_stream_counter == 0);
   if (invalid_msc_) {
     LOG_IF(ERROR, !prev_invalid_msc) << "glXGetSyncValuesOML "
         "should not return TRUE with a media stream counter of 0.";
     return;
   }
 
   struct timespec real_time;
   struct timespec monotonic_time;
   clock_gettime(CLOCK_REALTIME, &real_time);
   clock_gettime(CLOCK_MONOTONIC, &monotonic_time);
 
-  int64 real_time_in_microseconds =
+  int64_t real_time_in_microseconds =
       real_time.tv_sec * base::Time::kMicrosecondsPerSecond +
       real_time.tv_nsec / base::Time::kNanosecondsPerMicrosecond;
-  int64 monotonic_time_in_microseconds =
+  int64_t monotonic_time_in_microseconds =
       monotonic_time.tv_sec * base::Time::kMicrosecondsPerSecond +
       monotonic_time.tv_nsec / base::Time::kNanosecondsPerMicrosecond;
 
   // We need the time according to CLOCK_MONOTONIC, so if we've been given
   // a time from CLOCK_REALTIME, we need to convert.
   bool time_conversion_needed =
       llabs(system_time - real_time_in_microseconds) <
       llabs(system_time - monotonic_time_in_microseconds);
 
   if (time_conversion_needed)
     system_time += monotonic_time_in_microseconds - real_time_in_microseconds;
 
   // Return if |system_time| is more than 1 frames in the future.
-  int64 interval_in_microseconds = last_good_interval_.InMicroseconds();
+  int64_t interval_in_microseconds = last_good_interval_.InMicroseconds();
   if (system_time > monotonic_time_in_microseconds + interval_in_microseconds)
     return;
 
   // If |system_time| is slightly in the future, adjust it to the previous
   // frame and use the last frame counter to prevent issues in the callback.
   if (system_time > monotonic_time_in_microseconds) {
     system_time -= interval_in_microseconds;
     media_stream_counter--;
   }
   if (monotonic_time_in_microseconds - system_time >
       base::Time::kMicrosecondsPerSecond)
     return;
 
   timebase = base::TimeTicks::FromInternalValue(system_time);
 
   // Only need the previous calculated interval for our filtering.
   while (last_computed_intervals_.size() > 1)
     last_computed_intervals_.pop();
 
-  int32 numerator, denominator;
+  int32_t numerator, denominator;
   if (GetMscRate(&numerator, &denominator)) {
     last_computed_intervals_.push(base::TimeDelta::FromSeconds(denominator) /
                                   numerator);
   } else if (!last_timebase_.is_null()) {
     base::TimeDelta timebase_diff = timebase - last_timebase_;
-    int64 counter_diff = media_stream_counter - last_media_stream_counter_;
+    int64_t counter_diff = media_stream_counter - last_media_stream_counter_;
     if (counter_diff > 0 && timebase > last_timebase_)
       last_computed_intervals_.push(timebase_diff / counter_diff);
   }
 
   if (last_computed_intervals_.size() == 2) {
     const base::TimeDelta& old_interval = last_computed_intervals_.front();
     const base::TimeDelta& new_interval = last_computed_intervals_.back();
 
     double relative_change =
         fabs(old_interval.InMillisecondsF() - new_interval.InMillisecondsF()) /
@@ skipping 24 matching lines @@
     }
   }
 
   last_timebase_ = timebase;
   last_media_stream_counter_ = media_stream_counter;
   callback.Run(timebase, last_good_interval_);
 #endif  // defined(OS_LINUX)
 }
 
 }  // namespace gfx