metrics: Use integer types from stdint.h

  }

  // On OS version change, clear version stats (which are reported daily).

  int32 version = GetOsVersionHash();

  int32_t version = GetOsVersionHash();

  if (version_cycle_->Get() != version) {

    version_cycle_->Set(version);

    kernel_crashes_version_count_->Set(0);

  upload_service_->UploadEvent();

}

uint32 MetricsDaemon::GetOsVersionHash() {

  static uint32 cached_version_hash = 0;

uint32_t MetricsDaemon::GetOsVersionHash() {

  static uint32_t cached_version_hash = 0;

  static bool version_hash_is_cached = false;

  if (version_hash_is_cached)

    return cached_version_hash;

  std::vector<std::string> proc_stat_totals;

  base::SplitStringAlongWhitespace(proc_stat_lines[0], &proc_stat_totals);

  uint64 user_ticks, user_nice_ticks, system_ticks;

  uint64_t user_ticks, user_nice_ticks, system_ticks;

  if (proc_stat_totals.size() != kMetricsProcStatFirstLineItemsCount ||

      proc_stat_totals[0] != "cpu" ||

      !base::StringToUint64(proc_stat_totals[1], &user_ticks) ||

    return TimeDelta(base::TimeDelta::FromSeconds(0));

  }

  uint64 total_cpu_use_ticks = user_ticks + user_nice_ticks + system_ticks;

  uint64_t total_cpu_use_ticks = user_ticks + user_nice_ticks + system_ticks;

  // Sanity check.

  if (total_cpu_use_ticks < latest_cpu_use_ticks_) {

    return TimeDelta();

  }

  uint64 diff = total_cpu_use_ticks - latest_cpu_use_ticks_;

  uint64_t diff = total_cpu_use_ticks - latest_cpu_use_ticks_;

  latest_cpu_use_ticks_ = total_cpu_use_ticks;

  // Use microseconds to avoid significant truncations.

  return base::TimeDelta::FromMicroseconds(

  g_timeout_add_seconds(wait, StatsCallbackStatic, this);

}

bool MetricsDaemon::DiskStatsReadStats(uint64* read_sectors,

                                       uint64* write_sectors) {

bool MetricsDaemon::DiskStatsReadStats(uint64_t* read_sectors,

                                       uint64_t* write_sectors) {

  int nchars;

  int nitems;

  bool success = false;

// Collects disk and vm stats alternating over a short and a long interval.

void MetricsDaemon::StatsCallback() {

  uint64 read_sectors_now, write_sectors_now;

  uint64_t read_sectors_now, write_sectors_now;

  struct VmstatRecord vmstats_now;

  double time_now = GetActiveTime();

  double delta_time = time_now - stats_initial_time_;

// static

bool MetricsDaemon::ReadFileToUint64(const base::FilePath& path,

                                     uint64* value) {

                                     uint64_t* value) {

  std::string content;

  if (!base::ReadFileToString(path, &content)) {

    PLOG(WARNING) << "cannot read " << path.MaybeAsASCII();

bool MetricsDaemon::ReportZram(const base::FilePath& zram_dir) {

  // Data sizes are in bytes.  |zero_pages| is in number of pages.

  uint64 compr_data_size, orig_data_size, zero_pages;

  uint64_t compr_data_size, orig_data_size, zero_pages;

  const size_t page_size = 4096;

  if (!ReadFileToUint64(zram_dir.Append(kComprDataSizeName),

void MetricsDaemon::SendKernelCrashesCumulativeCountStats() {

  // Report the number of crashes for this OS version, but don't clear the

  // counter.  It is cleared elsewhere on version change.

  int64 crashes_count = kernel_crashes_version_count_->Get();

  int64_t crashes_count = kernel_crashes_version_count_->Get();

  SendSample(kernel_crashes_version_count_->Name(),

             crashes_count,

             1,                         // value of first bucket

             100);                      // number of buckets

  int64 cpu_use_ms = version_cumulative_cpu_use_->Get();

  int64_t cpu_use_ms = version_cumulative_cpu_use_->Get();

  SendSample(version_cumulative_cpu_use_->Name(),

             cpu_use_ms / 1000,         // stat is in seconds

             1,                         // device may be used very little...

               100);

  }

  int64 active_use_seconds = version_cumulative_active_use_->Get();

  int64_t active_use_seconds = version_cumulative_active_use_->Get();

  if (active_use_seconds > 0) {

    SendSample(version_cumulative_active_use_->Name(),

               active_use_seconds / 1000,  // stat is in seconds

#ifndef METRICS_METRICS_DAEMON_H_

#define METRICS_METRICS_DAEMON_H_

#include <stdint.h>

#include <dbus/dbus.h>

#include <glib.h>

#include <map>

  void ScheduleStatsCallback(int wait);

  // Reads cumulative disk statistics from sysfs.  Returns true for success.

  bool DiskStatsReadStats(uint64* read_sectors, uint64* write_sectors);

  bool DiskStatsReadStats(uint64_t* read_sectors, uint64_t* write_sectors);

  // Reads cumulative vm statistics from procfs.  Returns true for success.

  bool VmStatsReadStats(struct VmstatRecord* stats);

  // Reads the current OS version from /etc/lsb-release and hashes it

  // to a unsigned 32-bit int.

  uint32 GetOsVersionHash();

  uint32_t GetOsVersionHash();

  // Updates stats, additionally sending them to UMA if enough time has elapsed

  // since the last report.

  // Reports zram statistics.

  bool ReportZram(const base::FilePath& zram_dir);

  // Reads a string from a file and converts it to uint64.

  static bool ReadFileToUint64(const base::FilePath& path, uint64* value);

  // Reads a string from a file and converts it to uint64_t.

  static bool ReadFileToUint64(const base::FilePath& path, uint64_t* value);

  // VARIABLES

  unsigned int memuse_interval_index_;

  // Contain the most recent disk and vm cumulative stats.

  uint64 read_sectors_;

  uint64 write_sectors_;

  uint64_t read_sectors_;

  uint64_t write_sectors_;

  struct VmstatRecord vmstats_;

  StatsState stats_state_;

  // The system "HZ", or frequency of ticks.  Some system data uses ticks as a

  // unit, and this is used to convert to standard time units.

  uint32 ticks_per_second_;

  uint32_t ticks_per_second_;

  // Used internally by GetIncrementalCpuUse() to return the CPU utilization

  // between calls.

  uint64 latest_cpu_use_ticks_;

  uint64_t latest_cpu_use_ticks_;

  // Persistent values and accumulators for crash statistics.

  scoped_ptr<PersistentInteger> daily_cycle_;

    "    1793     1788    %" PRIu64 "d   105580    "

    "    196      175     %" PRIu64 "d    30290    "

    "    0    44060   135850\n";

static const uint64 kFakeReadSectors[] = {80000, 100000};

static const uint64 kFakeWriteSectors[] = {3000, 4000};

static const uint64_t kFakeReadSectors[] = {80000, 100000};

static const uint64_t kFakeWriteSectors[] = {3000, 4000};

static const char kFakeVmStatsName[] = "fake-vm-stats";

static const char kFakeScalingMaxFreqPath[] = "fake-scaling-max-freq";

  // Creates or overwrites the file in |path| so that it contains the printable

  // representation of |value|.

  void CreateUint64ValueFile(const base::FilePath& path, uint64 value) {

  void CreateUint64ValueFile(const base::FilePath& path, uint64_t value) {

    base::DeleteFile(path, false);

    std::string value_string = base::Uint64ToString(value);

    ASSERT_EQ(value_string.length(),

}

TEST_F(MetricsDaemonTest, ReportDiskStats) {

  uint64 read_sectors_now, write_sectors_now;

  uint64_t read_sectors_now, write_sectors_now;

  CreateFakeDiskStatsFile(kFakeDiskStats1.c_str());

  daemon_.DiskStatsReadStats(&read_sectors_now, &write_sectors_now);

  EXPECT_TRUE(daemon_.testing_);

  // |compr_data_size| is the size in bytes of compressed data.

  const uint64 compr_data_size = 50 * 1000 * 1000;

  const uint64_t compr_data_size = 50 * 1000 * 1000;

  // The constant '3' is a realistic but random choice.

  // |orig_data_size| does not include zero pages.

  const uint64 orig_data_size = compr_data_size * 3;

  const uint64 page_size = 4096;

  const uint64 zero_pages = 10 * 1000 * 1000 / page_size;

  const uint64_t orig_data_size = compr_data_size * 3;

  const uint64_t page_size = 4096;

  const uint64_t zero_pages = 10 * 1000 * 1000 / page_size;

  CreateUint64ValueFile(base::FilePath(MetricsDaemon::kComprDataSizeName),

                        compr_data_size);

  CreateUint64ValueFile(base::FilePath(MetricsDaemon::kZeroPagesName),

                        zero_pages);

  const uint64 real_orig_size = orig_data_size + zero_pages * page_size;

  const uint64 zero_ratio_percent =

  const uint64_t real_orig_size = orig_data_size + zero_pages * page_size;

  const uint64_t zero_ratio_percent =

      zero_pages * page_size * 100 / real_orig_size;

  // Ratio samples are in percents.

  const uint64 actual_ratio_sample = real_orig_size * 100 / compr_data_size;

  const uint64_t actual_ratio_sample = real_orig_size * 100 / compr_data_size;

  EXPECT_CALL(metrics_lib_, SendToUMA(_, compr_data_size >> 20, _, _, _));

  EXPECT_CALL(metrics_lib_,

PersistentInteger::~PersistentInteger() {}

void PersistentInteger::Set(int64 value) {

void PersistentInteger::Set(int64_t value) {

  value_ = value;

  Write();

}

int64 PersistentInteger::Get() {

int64_t PersistentInteger::Get() {

  // If not synced, then read.  If the read fails, it's a good idea to write.

  if (!synced_ && !Read())

    Write();

  return value_;

}

int64 PersistentInteger::GetAndClear() {

  int64 v = Get();

int64_t PersistentInteger::GetAndClear() {

  int64_t v = Get();

  Set(0);

  return v;

}

void PersistentInteger::Add(int64 x) {

void PersistentInteger::Add(int64_t x) {

  Set(Get() + x);

}

    PLOG(WARNING) << "cannot open " << backing_file_name_ << " for reading";

    return false;

  }

  int32 version;

  int64 value;

  int32_t version;

  int64_t value;

  bool read_succeeded = false;

  if (HANDLE_EINTR(read(fd, &version, sizeof(version))) == sizeof(version) &&

      version == version_ &&

#ifndef METRICS_PERSISTENT_INTEGER_H_

#define METRICS_PERSISTENT_INTEGER_H_

#include <base/basictypes.h>

#include <stdint.h>

#include <string>

namespace chromeos_metrics {

  virtual ~PersistentInteger();

  // Sets the value.  This writes through to the backing file.

  void Set(int64 v);

  void Set(int64_t v);

  // Gets the value.  May sync from backing file first.

  int64 Get();

  int64_t Get();

  // Returns the name of the object.

  std::string Name() { return name_; }

  // Convenience function for Get() followed by Set(0).

  int64 GetAndClear();

  int64_t GetAndClear();

  // Convenience function for v = Get, Set(v + x).

  // Virtual only because of mock.

  virtual void Add(int64 x);

  virtual void Add(int64_t x);

  // After calling with |testing| = true, changes some behavior for the purpose

  // of testing.  For instance: instances created while testing use the current

  // a valid backing file as a side effect.

  bool Read();

  int64 value_;

  int32 version_;

  int64_t value_;

  int32_t version_;

  std::string name_;

  std::string backing_file_name_;

  bool synced_;