Switch to standard integer types in gpu/.

gpu/command_buffer/service/gpu_tracer_unittest.cc

 // Copyright 2014 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 <stdint.h>
+
 #include "base/bind.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/gpu_tracer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_mock.h"
 #include "ui/gl/gpu_timing.h"
 #include "ui/gl/gpu_timing_fake.h"
 
 namespace gpu {
 namespace gles2 {
 namespace {
 
 using ::testing::_;
 using ::testing::AtMost;
 using ::testing::Exactly;
 using ::testing::Invoke;
 using ::testing::Return;
 
-int64 g_fakeCPUTime = 0;
-int64 FakeCpuTime() {
+int64_t g_fakeCPUTime = 0;
+int64_t FakeCpuTime() {
   return g_fakeCPUTime;
 }
 
 class MockOutputter : public Outputter {
  public:
   MockOutputter() {}
   MOCK_METHOD5(TraceDevice,
                void(GpuTracerSource source,
-                    const std::string& category, const std::string& name,
-                    int64 start_time, int64 end_time));
+                    const std::string& category,
+                    const std::string& name,
+                    int64_t start_time,
+                    int64_t end_time));
 
   MOCK_METHOD3(TraceServiceBegin,
                void(GpuTracerSource source,
                     const std::string& category, const std::string& name));
 
   MOCK_METHOD3(TraceServiceEnd,
                void(GpuTracerSource source,
                     const std::string& category, const std::string& name));
 
  protected:
@@ skipping 90 matching lines @@
                                  GpuTracerSource source,
                                  const std::string& category,
                                  const std::string& name) {
     EXPECT_CALL(*outputter,
                 TraceServiceBegin(source, category, name));
   }
 
   void ExpectOutputterEndMocks(MockOutputter* outputter,
                                GpuTracerSource source,
                                const std::string& category,
-                               const std::string& name, int64 expect_start_time,
-                               int64 expect_end_time,
+                               const std::string& name,
+                               int64_t expect_start_time,
+                               int64_t expect_end_time,
                                bool trace_service,
                                bool trace_device) {
     if (trace_service) {
       EXPECT_CALL(*outputter,
                   TraceServiceEnd(source, category, name));
     }
 
     if (trace_device) {
       EXPECT_CALL(*outputter,
                   TraceDevice(source, category, name,
                               expect_start_time, expect_end_time))
           .Times(Exactly(1));
     } else {
       EXPECT_CALL(*outputter, TraceDevice(source, category, name,
                                           expect_start_time, expect_end_time))
           .Times(Exactly(0));
     }
   }
 
   void ExpectDisjointOutputMocks(MockOutputter* outputter,
-                                 int64 expect_start_time,
-                                 int64 expect_end_time) {
+                                 int64_t expect_start_time,
+                                 int64_t expect_end_time) {
     EXPECT_CALL(*outputter,
                 TraceDevice(kTraceDisjoint, "DisjointEvent", _,
                             expect_start_time, expect_end_time))
           .Times(Exactly(1));
   }
 
   void ExpectNoDisjointOutputMocks(MockOutputter* outputter) {
     EXPECT_CALL(*outputter,
                 TraceDevice(kTraceDisjoint, "DisjointEvent", _, _, _))
           .Times(Exactly(0));
   }
 
   void ExpectOutputterMocks(MockOutputter* outputter,
                             bool tracing_service,
                             bool tracing_device,
                             GpuTracerSource source,
                             const std::string& category,
-                            const std::string& name, int64 expect_start_time,
-                            int64 expect_end_time) {
+                            const std::string& name,
+                            int64_t expect_start_time,
+                            int64_t expect_end_time) {
     if (tracing_service)
       ExpectOutputterBeginMocks(outputter, source, category, name);
     const bool valid_timer = tracing_device &&
                              gpu_timing_client_->IsAvailable();
     ExpectOutputterEndMocks(outputter, source, category, name,
                             expect_start_time, expect_end_time,
                             tracing_service, valid_timer);
   }
 
   void ExpectTracerOffsetQueryMocks() {
@@ skipping 17 matching lines @@
 class BaseGpuTraceTest : public BaseGpuTest {
  public:
   explicit BaseGpuTraceTest(gfx::GPUTiming::TimerType test_timer_type)
       : BaseGpuTest(test_timer_type) {}
 
   void DoTraceTest(bool tracing_service, bool tracing_device) {
     // Expected results
     const GpuTracerSource tracer_source = kTraceCHROMIUM;
     const std::string category_name("trace_category");
     const std::string trace_name("trace_test");
-    const int64 offset_time = 3231;
+    const int64_t offset_time = 3231;
     const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
     const GLint64 end_timestamp = 32 * base::Time::kNanosecondsPerMicrosecond;
-    const int64 expect_start_time =
+    const int64_t expect_start_time =
         (start_timestamp / base::Time::kNanosecondsPerMicrosecond) +
         offset_time;
-    const int64 expect_end_time =
+    const int64_t expect_end_time =
         (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
 
     ExpectOutputterMocks(outputter_ref_.get(), tracing_service, tracing_device,
                          tracer_source, category_name, trace_name,
                          expect_start_time, expect_end_time);
 
     if (tracing_device)
       ExpectTraceQueryMocks();
 
     scoped_refptr<GPUTrace> trace = new GPUTrace(
@@ skipping 115 matching lines @@
     ASSERT_TRUE(tracer.End(source));
     ASSERT_TRUE(tracer.EndDecoding());
   }
 
   void DoTracerMarkersTest() {
     ExpectTracerOffsetQueryMocks();
     gl_fake_queries_.ExpectGetErrorCalls(*gl_);
 
     const std::string category_name("trace_category");
     const std::string trace_name("trace_test");
-    const int64 offset_time = 3231;
+    const int64_t offset_time = 3231;
     const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
     const GLint64 end_timestamp = 32 * base::Time::kNanosecondsPerMicrosecond;
-    const int64 expect_start_time =
+    const int64_t expect_start_time =
         (start_timestamp / base::Time::kNanosecondsPerMicrosecond) +
         offset_time;
-    const int64 expect_end_time =
+    const int64_t expect_end_time =
         (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
 
     MockGLES2Decoder decoder;
     EXPECT_CALL(decoder, GetGLContext()).WillOnce(Return(GetGLContext()));
     GPUTracerTester tracer(&decoder);
     tracer.SetTracingEnabled(true);
 
     tracer.SetOutputter(outputter_ref_);
 
     gl_fake_queries_.SetCurrentGLTime(start_timestamp);
@@ skipping 49 matching lines @@
     outputter_ref_ = NULL;
   }
 
   void DoOngoingTracerMarkerTest() {
     ExpectTracerOffsetQueryMocks();
     gl_fake_queries_.ExpectGetErrorCalls(*gl_);
 
     const std::string category_name("trace_category");
     const std::string trace_name("trace_test");
     const GpuTracerSource source = static_cast<GpuTracerSource>(0);
-    const int64 offset_time = 3231;
+    const int64_t offset_time = 3231;
     const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
-    const int64 expect_start_time =
+    const int64_t expect_start_time =
         (start_timestamp / base::Time::kNanosecondsPerMicrosecond) +
         offset_time;
     const bool valid_timer = gpu_timing_client_->IsAvailable();
 
     MockGLES2Decoder decoder;
     EXPECT_CALL(decoder, GetGLContext()).WillOnce(Return(GetGLContext()));
     GPUTracerTester tracer(&decoder);
     tracer.SetOutputter(outputter_ref_);
 
     // Create trace marker while traces are disabled.
@@ skipping 53 matching lines @@
   }
 
   void DoDisjointTest() {
     // Cause a disjoint in a middle of a trace and expect no output calls.
     ExpectTracerOffsetQueryMocks();
     gl_fake_queries_.ExpectGetErrorCalls(*gl_);
 
     const std::string category_name("trace_category");
     const std::string trace_name("trace_test");
     const GpuTracerSource source = static_cast<GpuTracerSource>(0);
-    const int64 offset_time = 3231;
+    const int64_t offset_time = 3231;
     const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
     const GLint64 end_timestamp = 32 * base::Time::kNanosecondsPerMicrosecond;
-    const int64 expect_start_time =
+    const int64_t expect_start_time =
         (start_timestamp / base::Time::kNanosecondsPerMicrosecond) +
         offset_time;
-    const int64 expect_end_time =
+    const int64_t expect_end_time =
         (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
 
     MockGLES2Decoder decoder;
     EXPECT_CALL(decoder, GetGLContext()).WillOnce(Return(GetGLContext()));
     GPUTracerTester tracer(&decoder);
     tracer.SetTracingEnabled(true);
 
     tracer.SetOutputter(outputter_ref_);
 
     gl_fake_queries_.SetCurrentGLTime(start_timestamp);
@@ skipping 35 matching lines @@
     outputter_ref_ = NULL;
   }
 
   void DoOutsideDisjointTest() {
     ExpectTracerOffsetQueryMocks();
     gl_fake_queries_.ExpectGetErrorCalls(*gl_);
 
     const std::string category_name("trace_category");
     const std::string trace_name("trace_test");
     const GpuTracerSource source = static_cast<GpuTracerSource>(0);
-    const int64 offset_time = 3231;
+    const int64_t offset_time = 3231;
     const GLint64 start_timestamp = 7 * base::Time::kNanosecondsPerMicrosecond;
     const GLint64 end_timestamp = 32 * base::Time::kNanosecondsPerMicrosecond;
-    const int64 expect_start_time =
+    const int64_t expect_start_time =
         (start_timestamp / base::Time::kNanosecondsPerMicrosecond) +
         offset_time;
-    const int64 expect_end_time =
+    const int64_t expect_end_time =
         (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
 
     MockGLES2Decoder decoder;
     EXPECT_CALL(decoder, GetGLContext()).WillOnce(Return(GetGLContext()));
     EXPECT_CALL(decoder, MakeCurrent()).WillRepeatedly(Return(true));
     GPUTracerTester tracer(&decoder);
     tracer.SetOutputter(outputter_ref_);
 
     // Start a trace before tracing is enabled.
     tracer.SetTracingEnabled(false);
@@ skipping 198 matching lines @@
   scoped_refptr<gfx::GPUTimingClient>  client3 =
       GetGLContext()->CreateGPUTimingClient();
   ASSERT_TRUE(client1->CheckAndResetTimerErrors());
   ASSERT_TRUE(client2->CheckAndResetTimerErrors());
   ASSERT_FALSE(client3->CheckAndResetTimerErrors());
 }
 
 }  // namespace
 }  // namespace gles2
 }  // namespace gpu