Switch to standard integer types in components/, part 2 of 4.

components/metrics/metrics_log.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 "components/metrics/metrics_log.h"
 
+#include <stddef.h>
+
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
-#include "base/basictypes.h"
 #include "base/build_time.h"
 #include "base/cpu.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/metrics_hashes.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
+#include "build/build_config.h"
 #include "components/metrics/histogram_encoder.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_provider.h"
 #include "components/metrics/metrics_service_client.h"
 #include "components/metrics/proto/histogram_event.pb.h"
 #include "components/metrics/proto/system_profile.pb.h"
 #include "components/metrics/proto/user_action_event.pb.h"
 #include "components/variations/active_field_trials.h"
 
 #if defined(OS_ANDROID)
@@ skipping 32 matching lines @@
     SystemProfileProto::FieldTrial* field_trial =
         system_profile->add_field_trial();
     field_trial->set_name_id(it->name);
     field_trial->set_group_id(it->group);
   }
 }
 
 // Round a timestamp measured in seconds since epoch to one with a granularity
 // of an hour. This can be used before uploaded potentially sensitive
 // timestamps.
-int64 RoundSecondsToHour(int64 time_in_seconds) {
+int64_t RoundSecondsToHour(int64_t time_in_seconds) {
   return 3600 * (time_in_seconds / 3600);
 }
 
 }  // namespace
 
 MetricsLog::MetricsLog(const std::string& client_id,
                        int session_id,
                        LogType log_type,
                        MetricsServiceClient* client,
                        PrefService* local_state)
     : closed_(false),
       log_type_(log_type),
       client_(client),
       creation_time_(base::TimeTicks::Now()),
       local_state_(local_state) {
   if (IsTestingID(client_id))
     uma_proto_.set_client_id(0);
   else
     uma_proto_.set_client_id(Hash(client_id));
 
   uma_proto_.set_session_id(session_id);
 
-  const int32 product = client_->GetProduct();
+  const int32_t product = client_->GetProduct();
   // Only set the product if it differs from the default value.
   if (product != uma_proto_.product())
     uma_proto_.set_product(product);
 
   SystemProfileProto* system_profile = uma_proto_.mutable_system_profile();
   system_profile->set_build_timestamp(GetBuildTime());
   system_profile->set_app_version(client_->GetVersionString());
   system_profile->set_channel(client_->GetChannel());
 #if defined(SYZYASAN)
   system_profile->set_is_asan_build(true);
@@ skipping 13 matching lines @@
       prefs::kStabilityBreakpadRegistrationSuccess, 0);
   registry->RegisterIntegerPref(prefs::kStabilityDebuggerPresent, 0);
   registry->RegisterIntegerPref(prefs::kStabilityDebuggerNotPresent, 0);
   registry->RegisterStringPref(prefs::kStabilitySavedSystemProfile,
                                std::string());
   registry->RegisterStringPref(prefs::kStabilitySavedSystemProfileHash,
                                std::string());
 }
 
 // static
-uint64 MetricsLog::Hash(const std::string& value) {
-  uint64 hash = base::HashMetricName(value);
+uint64_t MetricsLog::Hash(const std::string& value) {
+  uint64_t hash = base::HashMetricName(value);
 
   // The following log is VERY helpful when folks add some named histogram into
   // the code, but forgot to update the descriptive list of histograms.  When
   // that happens, all we get to see (server side) is a hash of the histogram
   // name.  We can then use this logging to find out what histogram name was
   // being hashed to a given MD5 value by just running the version of Chromium
   // in question with --enable-logging.
   DVLOG(1) << "Metrics: Hash numeric [" << value << "]=[" << hash << "]";
 
   return hash;
 }
 
 // static
-int64 MetricsLog::GetBuildTime() {
-  static int64 integral_build_time = 0;
+int64_t MetricsLog::GetBuildTime() {
+  static int64_t integral_build_time = 0;
   if (!integral_build_time)
-    integral_build_time = static_cast<int64>(base::GetBuildTime().ToTimeT());
+    integral_build_time = static_cast<int64_t>(base::GetBuildTime().ToTimeT());
   return integral_build_time;
 }
 
 // static
-int64 MetricsLog::GetCurrentTime() {
+int64_t MetricsLog::GetCurrentTime() {
   return (base::TimeTicks::Now() - base::TimeTicks()).InSeconds();
 }
 
 void MetricsLog::RecordUserAction(const std::string& key) {
   DCHECK(!closed_);
 
   UserActionEventProto* user_action = uma_proto_.add_user_action_event();
   user_action->set_name_hash(Hash(key));
   user_action->set_time(GetCurrentTime());
 }
@@ skipping 106 matching lines @@
     PrefService* pref,
     base::TimeDelta incremental_uptime,
     base::TimeDelta uptime) {
   // Update the stats which are critical for real-time stability monitoring.
   // Since these are "optional," only list ones that are non-zero, as the counts
   // are aggregated (summed) server side.
 
   SystemProfileProto::Stability* stability =
       uma_proto()->mutable_system_profile()->mutable_stability();
 
-  const uint64 incremental_uptime_sec = incremental_uptime.InSeconds();
+  const uint64_t incremental_uptime_sec = incremental_uptime.InSeconds();
   if (incremental_uptime_sec)
     stability->set_incremental_uptime_sec(incremental_uptime_sec);
-  const uint64 uptime_sec = uptime.InSeconds();
+  const uint64_t uptime_sec = uptime.InSeconds();
   if (uptime_sec)
     stability->set_uptime_sec(uptime_sec);
 }
 
 void MetricsLog::RecordEnvironment(
     const std::vector<MetricsProvider*>& metrics_providers,
     const std::vector<variations::ActiveGroupId>& synthetic_trials,
-    int64 install_date,
-    int64 metrics_reporting_enabled_date) {
+    int64_t install_date,
+    int64_t metrics_reporting_enabled_date) {
   DCHECK(!HasEnvironment());
 
   SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
 
   std::string brand_code;
   if (client_->GetBrand(&brand_code))
     system_profile->set_brand_code(brand_code);
 
   // Reduce granularity of the enabled_date field to nearest hour.
   system_profile->set_uma_enabled_date(
       RoundSecondsToHour(metrics_reporting_enabled_date));
 
   // Reduce granularity of the install_date field to nearest hour.
   system_profile->set_install_date(RoundSecondsToHour(install_date));
 
   system_profile->set_application_locale(client_->GetApplicationLocale());
 
   SystemProfileProto::Hardware* hardware = system_profile->mutable_hardware();
 
   // HardwareModelName() will return an empty string on platforms where it's
   // not implemented or if an error occured.
   hardware->set_hardware_class(base::SysInfo::HardwareModelName());
 
   hardware->set_cpu_architecture(base::SysInfo::OperatingSystemArchitecture());
   hardware->set_system_ram_mb(base::SysInfo::AmountOfPhysicalMemoryMB());
 #if defined(OS_WIN)
-  hardware->set_dll_base(reinterpret_cast<uint64>(&__ImageBase));
+  hardware->set_dll_base(reinterpret_cast<uint64_t>(&__ImageBase));
 #endif
 
   SystemProfileProto::OS* os = system_profile->mutable_os();
   std::string os_name = base::SysInfo::OperatingSystemName();
 #if defined(OS_WIN)
   // TODO(mad): This only checks whether the main process is a Metro process at
   // upload time; not whether the collected metrics were all gathered from
   // Metro.  This is ok as an approximation for now, since users will rarely be
   // switching from Metro to Desktop mode; but we should re-evaluate whether we
   // can distinguish metrics more cleanly in the future: http://crbug.com/140568
@@ skipping 56 matching lines @@
   DCHECK(!closed_);
   closed_ = true;
 }
 
 void MetricsLog::GetEncodedLog(std::string* encoded_log) {
   DCHECK(closed_);
   uma_proto_.SerializeToString(encoded_log);
 }
 
 }  // namespace metrics