Switch to standard integer types in base/process/.

base/process/process_metrics_linux.cc

 // Copyright (c) 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 "base/process/process_metrics.h"
 
 #include <dirent.h>
 #include <fcntl.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <utility>
 
 #include "base/files/dir_reader_posix.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/process/internal_linux.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_restrictions.h"
+#include "build/build_config.h"
 
 namespace base {
 
 namespace {
 
 void TrimKeyValuePairs(StringPairs* pairs) {
   DCHECK(pairs);
   StringPairs& p_ref = *pairs;
   for (size_t i = 0; i < p_ref.size(); ++i) {
     TrimWhitespaceASCII(p_ref[i].first, TRIM_ALL, &p_ref[i].first);
     TrimWhitespaceASCII(p_ref[i].second, TRIM_ALL, &p_ref[i].second);
   }
 }
 
 #if defined(OS_CHROMEOS)
-// Read a file with a single number string and return the number as a uint64.
-static uint64 ReadFileToUint64(const FilePath file) {
+// Read a file with a single number string and return the number as a uint64_t.
+static uint64_t ReadFileToUint64(const FilePath file) {
   std::string file_as_string;
   if (!ReadFileToString(file, &file_as_string))
     return 0;
   TrimWhitespaceASCII(file_as_string, TRIM_ALL, &file_as_string);
-  uint64 file_as_uint64 = 0;
+  uint64_t file_as_uint64 = 0;
   if (!StringToUint64(file_as_string, &file_as_uint64))
     return 0;
   return file_as_uint64;
 }
 #endif
 
 // Read /proc/<pid>/status and return the value for |field|, or 0 on failure.
 // Only works for fields in the form of "Field: value kB".
 size_t ReadProcStatusAndGetFieldAsSizeT(pid_t pid, const std::string& field) {
   std::string status;
@@ skipping 29 matching lines @@
   NOTREACHED();
   return 0;
 }
 
 #if defined(OS_LINUX)
 // Read /proc/<pid>/sched and look for |field|. On succes, return true and
 // write the value for |field| into |result|.
 // Only works for fields in the form of "field    :     uint_value"
 bool ReadProcSchedAndGetFieldAsUint64(pid_t pid,
                                       const std::string& field,
-                                      uint64* result) {
+                                      uint64_t* result) {
   std::string sched_data;
   {
     // Synchronously reading files in /proc does not hit the disk.
     ThreadRestrictions::ScopedAllowIO allow_io;
     FilePath sched_file = internal::GetProcPidDir(pid).Append("sched");
     if (!ReadFileToString(sched_file, &sched_data))
       return false;
   }
 
   StringPairs pairs;
   SplitStringIntoKeyValuePairs(sched_data, ':', '\n', &pairs);
   TrimKeyValuePairs(&pairs);
   for (size_t i = 0; i < pairs.size(); ++i) {
     const std::string& key = pairs[i].first;
     const std::string& value_str = pairs[i].second;
     if (key == field) {
-      uint64 value;
+      uint64_t value;
       if (!StringToUint64(value_str, &value))
         return false;
       *result = value;
       return true;
     }
   }
   return false;
 }
 #endif  // defined(OS_LINUX)
 
@@ skipping 139 matching lines @@
 
   io_counters->OtherOperationCount = 0;
   io_counters->OtherTransferCount = 0;
 
   StringPairs pairs;
   SplitStringIntoKeyValuePairs(proc_io_contents, ':', '\n', &pairs);
   TrimKeyValuePairs(&pairs);
   for (size_t i = 0; i < pairs.size(); ++i) {
     const std::string& key = pairs[i].first;
     const std::string& value_str = pairs[i].second;
-    uint64* target_counter = NULL;
+    uint64_t* target_counter = NULL;
     if (key == "syscr")
       target_counter = &io_counters->ReadOperationCount;
     else if (key == "syscw")
       target_counter = &io_counters->WriteOperationCount;
     else if (key == "rchar")
       target_counter = &io_counters->ReadTransferCount;
     else if (key == "wchar")
       target_counter = &io_counters->WriteTransferCount;
     if (!target_counter)
       continue;
@@ skipping 475 matching lines @@
   sectors_written = 0;
   write_time = 0;
   io = 0;
   io_time = 0;
   weighted_io_time = 0;
 }
 
 scoped_ptr<Value> SystemDiskInfo::ToValue() const {
   scoped_ptr<DictionaryValue> res(new DictionaryValue());
 
-  // Write out uint64 variables as doubles.
+  // Write out uint64_t variables as doubles.
   // Note: this may discard some precision, but for JS there's no other option.
   res->SetDouble("reads", static_cast<double>(reads));
   res->SetDouble("reads_merged", static_cast<double>(reads_merged));
   res->SetDouble("sectors_read", static_cast<double>(sectors_read));
   res->SetDouble("read_time", static_cast<double>(read_time));
   res->SetDouble("writes", static_cast<double>(writes));
   res->SetDouble("writes_merged", static_cast<double>(writes_merged));
   res->SetDouble("sectors_written", static_cast<double>(sectors_written));
   res->SetDouble("write_time", static_cast<double>(write_time));
   res->SetDouble("io", static_cast<double>(io));
@@ skipping 54 matching lines @@
   diskinfo->sectors_read = 0;
   diskinfo->read_time = 0;
   diskinfo->writes = 0;
   diskinfo->writes_merged = 0;
   diskinfo->sectors_written = 0;
   diskinfo->write_time = 0;
   diskinfo->io = 0;
   diskinfo->io_time = 0;
   diskinfo->weighted_io_time = 0;
 
-  uint64 reads = 0;
-  uint64 reads_merged = 0;
-  uint64 sectors_read = 0;
-  uint64 read_time = 0;
-  uint64 writes = 0;
-  uint64 writes_merged = 0;
-  uint64 sectors_written = 0;
-  uint64 write_time = 0;
-  uint64 io = 0;
-  uint64 io_time = 0;
-  uint64 weighted_io_time = 0;
+  uint64_t reads = 0;
+  uint64_t reads_merged = 0;
+  uint64_t sectors_read = 0;
+  uint64_t read_time = 0;
+  uint64_t writes = 0;
+  uint64_t writes_merged = 0;
+  uint64_t sectors_written = 0;
+  uint64_t write_time = 0;
+  uint64_t io = 0;
+  uint64_t io_time = 0;
+  uint64_t weighted_io_time = 0;
 
   for (const StringPiece& line : diskinfo_lines) {
     std::vector<StringPiece> disk_fields = SplitStringPiece(
         line, kWhitespaceASCII, TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
 
     // Fields may have overflowed and reset to zero.
     if (IsValidDiskName(disk_fields[kDiskDriveName].as_string())) {
       StringToUint64(disk_fields[kDiskReads], &reads);
       StringToUint64(disk_fields[kDiskReadsMerged], &reads_merged);
       StringToUint64(disk_fields[kDiskSectorsRead], &sectors_read);
@@ skipping 20 matching lines @@
     }
   }
 
   return true;
 }
 
 #if defined(OS_CHROMEOS)
 scoped_ptr<Value> SwapInfo::ToValue() const {
   scoped_ptr<DictionaryValue> res(new DictionaryValue());
 
-  // Write out uint64 variables as doubles.
+  // Write out uint64_t variables as doubles.
   // Note: this may discard some precision, but for JS there's no other option.
   res->SetDouble("num_reads", static_cast<double>(num_reads));
   res->SetDouble("num_writes", static_cast<double>(num_writes));
   res->SetDouble("orig_data_size", static_cast<double>(orig_data_size));
   res->SetDouble("compr_data_size", static_cast<double>(compr_data_size));
   res->SetDouble("mem_used_total", static_cast<double>(mem_used_total));
   if (compr_data_size > 0)
     res->SetDouble("compression_ratio", static_cast<double>(orig_data_size) /
                                         static_cast<double>(compr_data_size));
   else
     res->SetDouble("compression_ratio", 0);
 
   return std::move(res);
 }
 
 void GetSwapInfo(SwapInfo* swap_info) {
   // Synchronously reading files in /sys/block/zram0 does not hit the disk.
   ThreadRestrictions::ScopedAllowIO allow_io;
 
   FilePath zram_path("/sys/block/zram0");
-  uint64 orig_data_size = ReadFileToUint64(zram_path.Append("orig_data_size"));
+  uint64_t orig_data_size =
+      ReadFileToUint64(zram_path.Append("orig_data_size"));
   if (orig_data_size <= 4096) {
     // A single page is compressed at startup, and has a high compression
     // ratio. We ignore this as it doesn't indicate any real swapping.
     swap_info->orig_data_size = 0;
     swap_info->num_reads = 0;
     swap_info->num_writes = 0;
     swap_info->compr_data_size = 0;
     swap_info->mem_used_total = 0;
     return;
   }
   swap_info->orig_data_size = orig_data_size;
   swap_info->num_reads = ReadFileToUint64(zram_path.Append("num_reads"));
   swap_info->num_writes = ReadFileToUint64(zram_path.Append("num_writes"));
   swap_info->compr_data_size =
       ReadFileToUint64(zram_path.Append("compr_data_size"));
   swap_info->mem_used_total =
       ReadFileToUint64(zram_path.Append("mem_used_total"));
 }
 #endif  // defined(OS_CHROMEOS)
 
 #if defined(OS_LINUX)
 int ProcessMetrics::GetIdleWakeupsPerSecond() {
-  uint64 wake_ups;
+  uint64_t wake_ups;
   const char kWakeupStat[] = "se.statistics.nr_wakeups";
   return ReadProcSchedAndGetFieldAsUint64(process_, kWakeupStat, &wake_ups) ?
       CalculateIdleWakeupsPerSecond(wake_ups) : 0;
 }
 #endif  // defined(OS_LINUX)
 
 }  // namespace base