Switch to standard integer types in base/trace_event/.

base/trace_event/process_memory_maps_dump_provider.cc

 // Copyright 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 "base/trace_event/process_memory_maps_dump_provider.h"
 
+#include <stdint.h>
+
 #include "base/files/scoped_file.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/process_memory_maps.h"
 
 namespace base {
 namespace trace_event {
 
 // static
 FILE* ProcessMemoryMapsDumpProvider::proc_smaps_for_testing = nullptr;
 
 namespace {
 
-const uint32 kMaxLineSize = 4096;
+const uint32_t kMaxLineSize = 4096;
 
 bool ParseSmapsHeader(const char* header_line,
                       ProcessMemoryMaps::VMRegion* region) {
   // e.g., "00400000-00421000 r-xp 00000000 fc:01 1234  /foo.so\n"
   bool res = true;  // Whether this region should be appended or skipped.
-  uint64 end_addr = 0;
+  uint64_t end_addr = 0;
   char protection_flags[5] = {0};
   char mapped_file[kMaxLineSize];
 
   if (sscanf(header_line, "%" SCNx64 "-%" SCNx64 " %4c %*s %*s %*s%4095[^\n]\n",
              &region->start_address, &end_addr, protection_flags,
              mapped_file) != 4)
     return false;
 
   if (end_addr > region->start_address) {
     region->size_in_bytes = end_addr - region->start_address;
@@ skipping 16 matching lines @@
     region->protection_flags |=
         ProcessMemoryMaps::VMRegion::kProtectionFlagsExec;
   }
 
   region->mapped_file = mapped_file;
   TrimWhitespaceASCII(region->mapped_file, TRIM_ALL, &region->mapped_file);
 
   return res;
 }
 
-uint64 ReadCounterBytes(char* counter_line) {
-  uint64 counter_value = 0;
+uint64_t ReadCounterBytes(char* counter_line) {
+  uint64_t counter_value = 0;
   int res = sscanf(counter_line, "%*s %" SCNu64 " kB", &counter_value);
   DCHECK_EQ(1, res);
   return counter_value * 1024;
 }
 
-uint32 ParseSmapsCounter(char* counter_line,
-                         ProcessMemoryMaps::VMRegion* region) {
+uint32_t ParseSmapsCounter(char* counter_line,
+                           ProcessMemoryMaps::VMRegion* region) {
   // A smaps counter lines looks as follows: "RSS:  0 Kb\n"
-  uint32 res = 1;
+  uint32_t res = 1;
   char counter_name[20];
   int did_read = sscanf(counter_line, "%19[^\n ]", counter_name);
   DCHECK_EQ(1, did_read);
 
   if (strcmp(counter_name, "Pss:") == 0) {
     region->byte_stats_proportional_resident = ReadCounterBytes(counter_line);
   } else if (strcmp(counter_name, "Private_Dirty:") == 0) {
     region->byte_stats_private_dirty_resident = ReadCounterBytes(counter_line);
   } else if (strcmp(counter_name, "Private_Clean:") == 0) {
     region->byte_stats_private_clean_resident = ReadCounterBytes(counter_line);
   } else if (strcmp(counter_name, "Shared_Dirty:") == 0) {
     region->byte_stats_shared_dirty_resident = ReadCounterBytes(counter_line);
   } else if (strcmp(counter_name, "Shared_Clean:") == 0) {
     region->byte_stats_shared_clean_resident = ReadCounterBytes(counter_line);
   } else if (strcmp(counter_name, "Swap:") == 0) {
     region->byte_stats_swapped = ReadCounterBytes(counter_line);
   } else {
     res = 0;
   }
 
   return res;
 }
 
-uint32 ReadLinuxProcSmapsFile(FILE* smaps_file, ProcessMemoryMaps* pmm) {
+uint32_t ReadLinuxProcSmapsFile(FILE* smaps_file, ProcessMemoryMaps* pmm) {
   if (!smaps_file)
     return 0;
 
   fseek(smaps_file, 0, SEEK_SET);
 
   char line[kMaxLineSize];
-  const uint32 kNumExpectedCountersPerRegion = 6;
-  uint32 counters_parsed_for_current_region = 0;
-  uint32 num_valid_regions = 0;
+  const uint32_t kNumExpectedCountersPerRegion = 6;
+  uint32_t counters_parsed_for_current_region = 0;
+  uint32_t num_valid_regions = 0;
   ProcessMemoryMaps::VMRegion region;
   bool should_add_current_region = false;
   for (;;) {
     line[0] = '\0';
     if (fgets(line, kMaxLineSize, smaps_file) == nullptr)
       break;
     DCHECK_GT(strlen(line), 0u);
     if (isxdigit(line[0]) && !isupper(line[0])) {
       region = ProcessMemoryMaps::VMRegion();
       counters_parsed_for_current_region = 0;
@@ skipping 29 matching lines @@
 }
 
 // Called at trace dump point time. Creates a snapshot of the memory maps for
 // the current process.
 bool ProcessMemoryMapsDumpProvider::OnMemoryDump(const MemoryDumpArgs& args,
                                                  ProcessMemoryDump* pmd) {
   // Snapshot of memory maps is not taken for light dump requests.
   if (args.level_of_detail == MemoryDumpLevelOfDetail::LIGHT)
     return true;
 
-  uint32 res = 0;
+  uint32_t res = 0;
   if (UNLIKELY(proc_smaps_for_testing)) {
     res = ReadLinuxProcSmapsFile(proc_smaps_for_testing, pmd->process_mmaps());
   } else {
     ScopedFILE smaps_file(fopen("/proc/self/smaps", "r"));
     res = ReadLinuxProcSmapsFile(smaps_file.get(), pmd->process_mmaps());
   }
 
   if (res > 0) {
     pmd->set_has_process_mmaps();
     return true;
   }
   return false;
 }
 
 }  // namespace trace_event
 }  // namespace base