Switch to standard integer types in ui/gl/.

ui/gl/gpu_timing.cc

 // Copyright (c) 2015 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/gpu_timing.h"
 
+#include "base/macros.h"
 #include "base/time/time.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_version_info.h"
 
 namespace gfx {
 
 class TimeElapsedTimerQuery;
 class TimerQuery;
 
 int64_t NanoToMicro(uint64_t nano_seconds) {
   const uint64_t up = nano_seconds + base::Time::kNanosecondsPerMicrosecond / 2;
   return static_cast<int64_t>(up / base::Time::kNanosecondsPerMicrosecond);
 }
 
 class GPUTimingImpl : public GPUTiming {
  public:
    GPUTimingImpl(GLContextReal* context);
   ~GPUTimingImpl() override;
 
   void ForceTimeElapsedQuery() { force_time_elapsed_query_ = true; }
   bool IsForceTimeElapsedQuery() { return force_time_elapsed_query_; }
 
   GPUTiming::TimerType GetTimerType() const { return timer_type_; }
 
   uint32_t GetDisjointCount();
-  int64 CalculateTimerOffset();
+  int64_t CalculateTimerOffset();
 
   scoped_refptr<QueryResult> BeginElapsedTimeQuery();
   void EndElapsedTimeQuery(scoped_refptr<QueryResult> result);
 
   scoped_refptr<QueryResult> DoTimeStampQuery();
 
-  int64 GetCurrentCPUTime() {
+  int64_t GetCurrentCPUTime() {
     return cpu_time_for_testing_.is_null()
            ? (base::TimeTicks::Now() - base::TimeTicks()).InMicroseconds()
            : cpu_time_for_testing_.Run();
   }
-  void SetCpuTimeForTesting(const base::Callback<int64(void)>& cpu_time) {
+  void SetCpuTimeForTesting(const base::Callback<int64_t(void)>& cpu_time) {
     cpu_time_for_testing_ = cpu_time;
   }
 
   void UpdateQueryResults();
 
   int64_t GetMaxTimeStamp() { return max_time_stamp_; }
   void UpdateMaxTimeStamp(int64_t value) {
     max_time_stamp_ = std::max(max_time_stamp_, value);
   }
 
   uint32_t GetElapsedQueryCount() { return elapsed_query_count_; }
   void IncElapsedQueryCount() { elapsed_query_count_++; }
   void DecElapsedQueryCount() { elapsed_query_count_--; }
 
   void SetLastElapsedQuery(scoped_refptr<TimeElapsedTimerQuery> query);
   scoped_refptr<TimeElapsedTimerQuery> GetLastElapsedQuery();
 
   void HandleBadQuery();
   bool IsGoodQueryID(uint32_t query_id);
 
  private:
   scoped_refptr<GPUTimingClient> CreateGPUTimingClient() override;
 
-  base::Callback<int64(void)> cpu_time_for_testing_;
+  base::Callback<int64_t(void)> cpu_time_for_testing_;
   GPUTiming::TimerType timer_type_ = GPUTiming::kTimerTypeInvalid;
   uint32_t disjoint_counter_ = 0;
-  int64 offset_ = 0;  // offset cache when timer_type_ == kTimerTypeARB
+  int64_t offset_ = 0;  // offset cache when timer_type_ == kTimerTypeARB
   bool offset_valid_ = false;
   bool force_time_elapsed_query_ = false;
 
   uint32_t next_timer_query_id_ = 0;
   uint32_t next_good_timer_query_id_ = 0; // identify bad ids for disjoints.
   uint32_t query_disjoint_count_ = 0;
 
   // Extra state tracking data for elapsed timer queries.
   int64_t max_time_stamp_ = 0;
   uint32_t elapsed_query_count_ = 0;
@@ skipping 201 matching lines @@
   }
 
   // Fills out query result start and end, called after IsAvailable() is true.
   void UpdateQueryResults(GPUTimingImpl* gpu_timing) override {
     DCHECK(IsAvailable(gpu_timing));
 
     GLuint64 result_value = 0;
     glGetQueryObjectui64v(gl_query_id_, GL_QUERY_RESULT, &result_value);
     const int64_t micro_results = NanoToMicro(result_value);
 
-    const int64 offset = gpu_timing->CalculateTimerOffset();
+    const int64_t offset = gpu_timing->CalculateTimerOffset();
     const int64_t adjusted_result = micro_results + offset;
     DCHECK(query_result_.get());
     query_result_->SetStartValue(adjusted_result);
     query_result_->SetEndValue(adjusted_result);
     time_stamp_ = adjusted_result;
   }
 
  private:
   ~TimeStampTimerQuery() override {}
   uint32_t gl_query_id_ = 0;
@@ skipping 23 matching lines @@
     GLint disjoint_value = 0;
     glGetIntegerv(GL_GPU_DISJOINT_EXT, &disjoint_value);
     if (disjoint_value) {
       offset_valid_ = false;
       disjoint_counter_++;
     }
   }
   return disjoint_counter_;
 }
 
-int64 GPUTimingImpl::CalculateTimerOffset() {
+int64_t GPUTimingImpl::CalculateTimerOffset() {
   if (!offset_valid_) {
     if (timer_type_ == GPUTiming::kTimerTypeDisjoint ||
         timer_type_ == GPUTiming::kTimerTypeARB) {
       GLint64 gl_now = 0;
       glGetInteger64v(GL_TIMESTAMP, &gl_now);
       int64_t micro_now = NanoToMicro(gl_now);
       offset_ = GetCurrentCPUTime() - micro_now;
       offset_valid_ = (timer_type_ == GPUTiming::kTimerTypeARB);
     } else {
       offset_ = 0;
@@ skipping 178 matching lines @@
     } else {
       gpu_timing_client_->gpu_timing_->UpdateQueryResults();
       if (result->IsAvailable())
         timer_state_ = kTimerState_ResultAvailable;
     }
   }
 
   return (timer_state_ == kTimerState_ResultAvailable);
 }
 
-void GPUTimer::GetStartEndTimestamps(int64* start, int64* end) {
+void GPUTimer::GetStartEndTimestamps(int64_t* start, int64_t* end) {
   DCHECK(start && end);
   DCHECK(elapsed_timer_result_.get() || time_stamp_result_.get());
   DCHECK(IsAvailable());
   const int64_t time_stamp = time_stamp_result_.get() ?
                              time_stamp_result_->GetStartValue() :
                              elapsed_timer_result_->GetStartValue();
   const int64_t elapsed_time = elapsed_timer_result_.get() ?
                                elapsed_timer_result_->GetDelta() :
                                0;
 
   *start = time_stamp;
   *end = time_stamp + elapsed_time;
 }
 
-int64 GPUTimer::GetDeltaElapsed() {
+int64_t GPUTimer::GetDeltaElapsed() {
   DCHECK(IsAvailable());
   if (elapsed_timer_result_.get())
     return elapsed_timer_result_->GetDelta();
   return 0;
 }
 
 GPUTimer::GPUTimer(scoped_refptr<GPUTimingClient> gpu_timing_client,
                    bool use_elapsed_timer)
     : use_elapsed_timer_(use_elapsed_timer),
       gpu_timing_client_(gpu_timing_client) {
@@ skipping 36 matching lines @@
   if (timer_type_ == GPUTiming::kTimerTypeDisjoint) {
     DCHECK(gpu_timing_ != nullptr);
     const uint32_t total_disjoint_count = gpu_timing_->GetDisjointCount();
     const bool disjoint_triggered = total_disjoint_count != disjoint_counter_;
     disjoint_counter_ = total_disjoint_count;
     return disjoint_triggered;
   }
   return false;
 }
 
-int64 GPUTimingClient::GetCurrentCPUTime() {
+int64_t GPUTimingClient::GetCurrentCPUTime() {
   DCHECK(gpu_timing_);
   return gpu_timing_->GetCurrentCPUTime();
 }
 
 void GPUTimingClient::SetCpuTimeForTesting(
-    const base::Callback<int64(void)>& cpu_time) {
+    const base::Callback<int64_t(void)>& cpu_time) {
   DCHECK(gpu_timing_);
   gpu_timing_->SetCpuTimeForTesting(cpu_time);
 }
 
 bool GPUTimingClient::IsForceTimeElapsedQuery() {
   DCHECK(gpu_timing_);
   return gpu_timing_->IsForceTimeElapsedQuery();
 }
 
 void GPUTimingClient::ForceTimeElapsedQuery() {
   DCHECK(gpu_timing_);
   gpu_timing_->ForceTimeElapsedQuery();
 }
 
 GPUTimingClient::~GPUTimingClient() {
 }
 
 }  // namespace gfx