Switch to standard integer types in base/.

base/tracked_objects_unittest.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.
 
 // Test of classes in the tracked_objects.h classes.
 
 #include "base/tracked_objects.h"
 
 #include <stddef.h>
+#include <stdint.h>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/process/process_handle.h"
 #include "base/time/time.h"
 #include "base/tracking_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 const int kLineNumber = 1776;
 const char kFile[] = "FixedUnitTestFileName";
 const char kWorkerThreadName[] = "WorkerThread-1";
@@ skipping 157 matching lines @@
   data->SnapshotMaps(0, &birth_map, &deaths);
   EXPECT_EQ(1u, birth_map.size());                         // 1 birth location.
   EXPECT_EQ(1, birth_map.begin()->second->birth_count());  // 1 birth.
   EXPECT_EQ(0u, deaths.size());                            // No deaths.
 
 
   // Now instigate another birth, while we are timing the run of the first
   // execution.
   // Create a child (using the same birth location).
   // TrackingInfo will call TallyABirth() during construction.
-  const int32 start_time = 1;
+  const int32_t start_time = 1;
   base::TimeTicks kBogusBirthTime = base::TimeTicks() +
       base::TimeDelta::FromMilliseconds(start_time);
   base::TrackingInfo pending_task(location, kBogusBirthTime);
   SetTestTime(1);
   TaskStopwatch stopwatch;
   stopwatch.Start();
   // Finally conclude the outer run.
-  const int32 time_elapsed = 1000;
+  const int32_t time_elapsed = 1000;
   SetTestTime(start_time + time_elapsed);
   stopwatch.Stop();
 
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, stopwatch);
 
   birth_map.clear();
   deaths.clear();
   data->SnapshotMaps(0, &birth_map, &deaths);
   EXPECT_EQ(1u, birth_map.size());                         // 1 birth location.
   EXPECT_EQ(2, birth_map.begin()->second->birth_count());  // 2 births.
@@ skipping 37 matching lines @@
   ASSERT_NE(data, nullptr);
   EXPECT_EQ(data->run_duration_sum(), 0);
   EXPECT_EQ(data->run_duration_max(), 0);
   EXPECT_EQ(data->run_duration_sample(), 0);
   EXPECT_EQ(data->queue_duration_sum(), 0);
   EXPECT_EQ(data->queue_duration_max(), 0);
   EXPECT_EQ(data->queue_duration_sample(), 0);
   EXPECT_EQ(data->count(), 0);
   EXPECT_EQ(nullptr, data->last_phase_snapshot());
 
-  int32 run_ms = 42;
-  int32 queue_ms = 8;
+  int32_t run_ms = 42;
+  int32_t queue_ms = 8;
 
   const int kUnrandomInt = 0;  // Fake random int that ensure we sample data.
   data->RecordDeath(queue_ms, run_ms, kUnrandomInt);
   EXPECT_EQ(data->run_duration_sum(), run_ms);
   EXPECT_EQ(data->run_duration_max(), run_ms);
   EXPECT_EQ(data->run_duration_sample(), run_ms);
   EXPECT_EQ(data->queue_duration_sum(), queue_ms);
   EXPECT_EQ(data->queue_duration_max(), queue_ms);
   EXPECT_EQ(data->queue_duration_sample(), queue_ms);
   EXPECT_EQ(data->count(), 1);
   EXPECT_EQ(nullptr, data->last_phase_snapshot());
 
   data->RecordDeath(queue_ms, run_ms, kUnrandomInt);
   EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms);
   EXPECT_EQ(data->run_duration_max(), run_ms);
   EXPECT_EQ(data->run_duration_sample(), run_ms);
   EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms);
   EXPECT_EQ(data->queue_duration_max(), queue_ms);
   EXPECT_EQ(data->queue_duration_sample(), queue_ms);
   EXPECT_EQ(data->count(), 2);
   EXPECT_EQ(nullptr, data->last_phase_snapshot());
 }
 
 TEST_F(TrackedObjectsTest, DeathDataTest2Phases) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   scoped_ptr<DeathData> data(new DeathData());
   ASSERT_NE(data, nullptr);
 
-  int32 run_ms = 42;
-  int32 queue_ms = 8;
+  int32_t run_ms = 42;
+  int32_t queue_ms = 8;
 
   const int kUnrandomInt = 0;  // Fake random int that ensure we sample data.
   data->RecordDeath(queue_ms, run_ms, kUnrandomInt);
   data->RecordDeath(queue_ms, run_ms, kUnrandomInt);
 
   data->OnProfilingPhaseCompleted(123);
   EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms);
   EXPECT_EQ(data->run_duration_max(), 0);
   EXPECT_EQ(data->run_duration_sample(), run_ms);
   EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms);
   EXPECT_EQ(data->queue_duration_max(), 0);
   EXPECT_EQ(data->queue_duration_sample(), queue_ms);
   EXPECT_EQ(data->count(), 2);
   ASSERT_NE(nullptr, data->last_phase_snapshot());
   EXPECT_EQ(123, data->last_phase_snapshot()->profiling_phase);
   EXPECT_EQ(2, data->last_phase_snapshot()->death_data.count);
   EXPECT_EQ(2 * run_ms,
             data->last_phase_snapshot()->death_data.run_duration_sum);
   EXPECT_EQ(run_ms, data->last_phase_snapshot()->death_data.run_duration_max);
   EXPECT_EQ(run_ms,
             data->last_phase_snapshot()->death_data.run_duration_sample);
   EXPECT_EQ(2 * queue_ms,
             data->last_phase_snapshot()->death_data.queue_duration_sum);
   EXPECT_EQ(queue_ms,
             data->last_phase_snapshot()->death_data.queue_duration_max);
   EXPECT_EQ(queue_ms,
             data->last_phase_snapshot()->death_data.queue_duration_sample);
   EXPECT_EQ(nullptr, data->last_phase_snapshot()->prev);
 
-  int32 run_ms1 = 21;
-  int32 queue_ms1 = 4;
+  int32_t run_ms1 = 21;
+  int32_t queue_ms1 = 4;
 
   data->RecordDeath(queue_ms1, run_ms1, kUnrandomInt);
   EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms + run_ms1);
   EXPECT_EQ(data->run_duration_max(), run_ms1);
   EXPECT_EQ(data->run_duration_sample(), run_ms1);
   EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms + queue_ms1);
   EXPECT_EQ(data->queue_duration_max(), queue_ms1);
   EXPECT_EQ(data->queue_duration_sample(), queue_ms1);
   EXPECT_EQ(data->count(), 3);
   ASSERT_NE(nullptr, data->last_phase_snapshot());
@@ skipping 850 matching lines @@
   EXPECT_EQ(2, process_data_phase.tasks[t1].death_data.run_duration_max);
   EXPECT_EQ(2, process_data_phase.tasks[t1].death_data.run_duration_sample);
   EXPECT_EQ(1, process_data_phase.tasks[t1].death_data.queue_duration_sum);
   EXPECT_EQ(1, process_data_phase.tasks[t1].death_data.queue_duration_max);
   EXPECT_EQ(1, process_data_phase.tasks[t1].death_data.queue_duration_sample);
   EXPECT_EQ(kMainThreadName, process_data_phase.tasks[t1].death_thread_name);
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
 }  // namespace tracked_objects