Switch to standard integer types in chrome/browser/chromeos/.

chrome/browser/chromeos/power/cpu_data_collector.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 "chrome/browser/chromeos/power/cpu_data_collector.h"
 
+#include <stddef.h>
+
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
@@ skipping 122 matching lines @@
             name_file_format.c_str(), cpu, state_count);
         DCHECK(base::PathExists(base::FilePath(name_file_path)));
 
         const std::string time_file_format = base::StringPrintf(
             "%s%s", kCpuDataPathBase, kCpuIdleStateTimePathSuffixFormat);
         const std::string time_file_path = base::StringPrintf(
             time_file_format.c_str(), cpu, state_count);
         DCHECK(base::PathExists(base::FilePath(time_file_path)));
 
         std::string state_name, occupancy_time_string;
-        int64 occupancy_time_usec;
+        int64_t occupancy_time_usec;
         if (!base::ReadFileToString(base::FilePath(name_file_path),
                                     &state_name) ||
             !base::ReadFileToString(base::FilePath(time_file_path),
                                     &occupancy_time_string)) {
           // If an error occurs reading/parsing single state data, drop all the
           // samples as an incomplete sample can mislead consumers of this
           // sample.
           LOG(ERROR) << "Error reading idle state from "
                      << idle_state_dir << ". Dropping sample.";
           idle_samples->clear();
           return;
         }
 
         base::TrimWhitespaceASCII(state_name, base::TRIM_ALL, &state_name);
         base::TrimWhitespaceASCII(occupancy_time_string, base::TRIM_ALL,
                                   &occupancy_time_string);
         if (base::StringToInt64(occupancy_time_string, &occupancy_time_usec)) {
           // idle state occupancy time in sysfs is recorded in microseconds.
-          int64 time_in_state_ms = occupancy_time_usec / 1000;
+          int64_t time_in_state_ms = occupancy_time_usec / 1000;
           size_t index = IndexInVector(state_name, cpu_idle_state_names);
           if (index >= idle_sample.time_in_state.size())
             idle_sample.time_in_state.resize(index + 1);
           idle_sample.time_in_state[index] = time_in_state_ms;
         } else {
           LOG(ERROR) << "Bad format in " << time_file_path << ". "
                      << "Dropping sample.";
           idle_samples->clear();
           return;
         }
       }
     }
 
     idle_samples->push_back(idle_sample);
   }
 
   // If there was an interruption in sampling (like system suspended),
   // discard the samples!
-  int64 delay =
+  int64_t delay =
       base::TimeDelta(base::Time::Now() - start_time).InMilliseconds();
   if (delay > kSamplingDurationLimitMs) {
     idle_samples->clear();
     LOG(WARNING) << "Dropped an idle state sample due to excessive time delay: "
                  << delay << "milliseconds.";
   }
 }
 
 bool ReadCpuFreqFromOldFile(
     const std::string& path,
@@ skipping 11 matching lines @@
 
   std::vector<base::StringPiece> lines = base::SplitStringPiece(
       time_in_state_string, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   // The last line could end with '\n'. Ignore the last empty string in
   // such cases.
   size_t state_count = lines.size();
   if (state_count > 0 && lines.back().empty())
     state_count -= 1;
   for (size_t state = 0; state < state_count; ++state) {
     int freq_in_khz;
-    int64 occupancy_time_centisecond;
+    int64_t occupancy_time_centisecond;
 
     // Occupancy of each state is in the format "<state> <time>"
     std::vector<base::StringPiece> pair = base::SplitStringPiece(
         lines[state], " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (pair.size() == 2 && base::StringToInt(pair[0], &freq_in_khz) &&
         base::StringToInt64(pair[1], &occupancy_time_centisecond)) {
       const std::string state_name = base::IntToString(freq_in_khz / 1000);
       size_t index = IndexInVector(state_name, cpu_freq_state_names);
       if (index >= freq_sample->time_in_state.size())
         freq_sample->time_in_state.resize(index + 1);
@@ skipping 49 matching lines @@
         freq_samples->clear();
         return;
       }
     }
 
     freq_samples->push_back(freq_sample);
   }
 
   // If there was an interruption in sampling (like system suspended),
   // discard the samples!
-  int64 delay =
+  int64_t delay =
       base::TimeDelta(base::Time::Now() - start_time).InMilliseconds();
   if (delay > kSamplingDurationLimitMs) {
     freq_samples->clear();
     LOG(WARNING) << "Dropped a freq state sample due to excessive time delay: "
                  << delay << "milliseconds.";
   }
 }
 
 // Samples CPU idle and CPU freq data from sysfs. This function should run on
 // the blocking pool as reading from sysfs is a blocking task. Elements at
@@ skipping 137 matching lines @@
 }
 
 CpuDataCollector::StateOccupancySample::StateOccupancySample()
     : cpu_online(false) {
 }
 
 CpuDataCollector::StateOccupancySample::~StateOccupancySample() {
 }
 
 }  // namespace chromeos