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

chrome/browser/chromeos/policy/device_status_collector.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.
 
 #include "chrome/browser/chromeos/policy/device_status_collector.h"
 
+#include <stddef.h>
 #include <stdint.h>
+#include <sys/statvfs.h>
 #include <cstdio>
 #include <limits>
 #include <sstream>
-#include <sys/statvfs.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/values.h"
@@ skipping 59 matching lines @@
 const char kProcStat[] = "/proc/stat";
 
 // The location we read our CPU temperature and channel label from.
 const char kHwmonDir[] = "/sys/class/hwmon/";
 const char kDeviceDir[] = "device";
 const char kHwmonDirectoryPattern[] = "hwmon*";
 const char kCPUTempFilePattern[] = "temp*_input";
 
 // Determine the day key (milliseconds since epoch for corresponding day in UTC)
 // for a given |timestamp|.
-int64 TimestampToDayKey(Time timestamp) {
+int64_t TimestampToDayKey(Time timestamp) {
   Time::Exploded exploded;
   timestamp.LocalMidnight().LocalExplode(&exploded);
   return (Time::FromUTCExploded(exploded) - Time::UnixEpoch()).InMilliseconds();
 }
 
 // Helper function (invoked via blocking pool) to fetch information about
 // mounted disks.
 std::vector<em::VolumeInfo> GetVolumeInfo(
     const std::vector<std::string>& mount_points) {
   std::vector<em::VolumeInfo> result;
@@ skipping 71 matching lines @@
 
       // Read label.
       std::string label;
       if (!base::PathExists(base::FilePath(label_path)) ||
           !base::ReadFileToString(base::FilePath(label_path), &label)) {
         label = std::string();
       }
 
       // Read temperature in millidegree Celsius.
       std::string temperature_string;
-      int32 temperature = 0;
+      int32_t temperature = 0;
       if (base::ReadFileToString(temperature_path, &temperature_string) &&
           sscanf(temperature_string.c_str(), "%d", &temperature) == 1) {
         // CPU temp in millidegree Celsius to Celsius
         temperature /= 1000;
 
         em::CPUTempInfo info;
         info.set_cpu_label(label);
         info.set_cpu_temp(temperature);
         contents.push_back(info);
       } else {
@@ skipping 103 matching lines @@
   hardware_status_subscription_ = cros_settings_->AddSettingsObserver(
       chromeos::kReportDeviceHardwareStatus, callback);
   session_status_subscription_ = cros_settings_->AddSettingsObserver(
       chromeos::kReportDeviceSessionStatus, callback);
 
   // The last known location is persisted in local state. This makes location
   // information available immediately upon startup and avoids the need to
   // reacquire the location on every user session change or browser crash.
   content::Geoposition position;
   std::string timestamp_str;
-  int64 timestamp;
+  int64_t timestamp;
   const base::DictionaryValue* location =
       local_state_->GetDictionary(prefs::kDeviceLocation);
   if (location->GetDouble(kLatitude, &position.latitude) &&
       location->GetDouble(kLongitude, &position.longitude) &&
       location->GetDouble(kAltitude, &position.altitude) &&
       location->GetDouble(kAccuracy, &position.accuracy) &&
       location->GetDouble(kAltitudeAccuracy, &position.altitude_accuracy) &&
       location->GetDouble(kHeading, &position.heading) &&
       location->GetDouble(kSpeed, &position.speed) &&
       location->GetString(kTimestamp, &timestamp_str) &&
@@ skipping 114 matching lines @@
 // Remove all out-of-range activity times from the local store.
 void DeviceStatusCollector::PruneStoredActivityPeriods(Time base_time) {
   Time min_time =
       base_time - TimeDelta::FromDays(max_stored_past_activity_days_);
   Time max_time =
       base_time + TimeDelta::FromDays(max_stored_future_activity_days_);
   TrimStoredActivityPeriods(TimestampToDayKey(min_time), 0,
                             TimestampToDayKey(max_time));
 }
 
-void DeviceStatusCollector::TrimStoredActivityPeriods(int64 min_day_key,
+void DeviceStatusCollector::TrimStoredActivityPeriods(int64_t min_day_key,
                                                       int min_day_trim_duration,
-                                                      int64 max_day_key) {
+                                                      int64_t max_day_key) {
   const base::DictionaryValue* activity_times =
       local_state_->GetDictionary(prefs::kDeviceActivityTimes);
 
   scoped_ptr<base::DictionaryValue> copy(activity_times->DeepCopy());
   for (base::DictionaryValue::Iterator it(*activity_times); !it.IsAtEnd();
        it.Advance()) {
-    int64 timestamp;
+    int64_t timestamp;
     if (base::StringToInt64(it.key(), &timestamp)) {
       // Remove data that is too old, or too far in the future.
       if (timestamp >= min_day_key && timestamp < max_day_key) {
         if (timestamp == min_day_key) {
           int new_activity_duration = 0;
           if (it.value().GetAsInteger(&new_activity_duration)) {
             new_activity_duration =
                 std::max(new_activity_duration - min_day_trim_duration, 0);
           }
           copy->SetInteger(it.key(), new_activity_duration);
@@ skipping 11 matching lines @@
   DCHECK(start < end);
 
   // Maintain the list of active periods in a local_state pref.
   DictionaryPrefUpdate update(local_state_, prefs::kDeviceActivityTimes);
   base::DictionaryValue* activity_times = update.Get();
 
   // Assign the period to day buckets in local time.
   Time midnight = start.LocalMidnight();
   while (midnight < end) {
     midnight += TimeDelta::FromDays(1);
-    int64 activity = (std::min(end, midnight) - start).InMilliseconds();
+    int64_t activity = (std::min(end, midnight) - start).InMilliseconds();
     std::string day_key = base::Int64ToString(TimestampToDayKey(start));
     int previous_activity = 0;
     activity_times->GetInteger(day_key, &previous_activity);
     activity_times->SetInteger(day_key, previous_activity + activity);
     start = midnight;
   }
 }
 
 void DeviceStatusCollector::ClearCachedHardwareStatus() {
   volume_info_.clear();
@@ skipping 94 matching lines @@
     // The CPU usage values in /proc/stat are measured in the imprecise unit
     // "jiffies", but we just care about the relative magnitude of "active" vs
     // "idle" so the exact value of a jiffy is irrelevant.
     //
     // An example value for this line:
     //
     // cpu 123 456 789 012 345 678
     //
     // We only care about the first four numbers: user_time, nice_time,
     // sys_time, and idle_time.
-    uint64 user = 0, nice = 0, system = 0, idle = 0;
+    uint64_t user = 0, nice = 0, system = 0, idle = 0;
     int vals = sscanf(stats.c_str(),
                       "cpu %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64, &user,
                       &nice, &system, &idle);
     DCHECK_EQ(4, vals);
 
     // The values returned from /proc/stat are cumulative totals, so calculate
     // the difference between the last sample and this one.
-    uint64 active = user + nice + system;
-    uint64 total = active + idle;
-    uint64 last_total = last_cpu_active_ + last_cpu_idle_;
+    uint64_t active = user + nice + system;
+    uint64_t total = active + idle;
+    uint64_t last_total = last_cpu_active_ + last_cpu_idle_;
     DCHECK_GE(active, last_cpu_active_);
     DCHECK_GE(idle, last_cpu_idle_);
     DCHECK_GE(total, last_total);
 
     if ((total - last_total) > 0) {
       cpu_usage_percent =
           (100 * (active - last_cpu_active_)) / (total - last_total);
     }
     last_cpu_active_ = active;
     last_cpu_idle_ = idle;
@@ skipping 21 matching lines @@
     cpu_temp_info_ = info;
 }
 
 void DeviceStatusCollector::GetActivityTimes(
     em::DeviceStatusReportRequest* request) {
   DictionaryPrefUpdate update(local_state_, prefs::kDeviceActivityTimes);
   base::DictionaryValue* activity_times = update.Get();
 
   for (base::DictionaryValue::Iterator it(*activity_times); !it.IsAtEnd();
        it.Advance()) {
-    int64 start_timestamp;
+    int64_t start_timestamp;
     int activity_milliseconds;
     if (base::StringToInt64(it.key(), &start_timestamp) &&
         it.value().GetAsInteger(&activity_milliseconds)) {
       // This is correct even when there are leap seconds, because when a leap
       // second occurs, two consecutive seconds have the same timestamp.
-      int64 end_timestamp = start_timestamp + Time::kMillisecondsPerDay;
+      int64_t end_timestamp = start_timestamp + Time::kMillisecondsPerDay;
 
       em::ActiveTimePeriod* active_period = request->add_active_period();
       em::TimePeriod* period = active_period->mutable_time_period();
       period->set_start_timestamp(start_timestamp);
       period->set_end_timestamp(end_timestamp);
       active_period->set_active_duration(activity_milliseconds);
       if (start_timestamp >= last_reported_day_) {
         last_reported_day_ = start_timestamp;
         duration_for_last_reported_day_ = activity_milliseconds;
       }
@@ skipping 296 matching lines @@
       extensions::ExtensionRegistry::Get(profile);
   const extensions::Extension* const extension = registry->GetExtensionById(
       kiosk_app_id, extensions::ExtensionRegistry::EVERYTHING);
   if (!extension)
     return std::string();
   return extension->VersionString();
 }
 
 void DeviceStatusCollector::OnSubmittedSuccessfully() {
   TrimStoredActivityPeriods(last_reported_day_, duration_for_last_reported_day_,
-                            std::numeric_limits<int64>::max());
+                            std::numeric_limits<int64_t>::max());
 }
 
 void DeviceStatusCollector::OnOSVersion(const std::string& version) {
   os_version_ = version;
 }
 
 void DeviceStatusCollector::OnOSFirmware(const std::string& version) {
   firmware_version_ = version;
 }
 
@@ skipping 55 matching lines @@
   ScheduleGeolocationUpdateRequest();
 }
 
 void DeviceStatusCollector::ReceiveVolumeInfo(
     const std::vector<em::VolumeInfo>& info) {
   if (report_hardware_status_)
     volume_info_ = info;
 }
 
 }  // namespace policy