Change UMA proto product field to be an int32.

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 <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 44 matching lines @@
 }
 
 // Returns the date at which the current metrics client ID was created as
 // a string containing seconds since the epoch, or "0" if none was found.
 std::string GetMetricsEnabledDate(PrefService* pref) {
   if (!pref) {
     NOTREACHED();
     return "0";
   }
 
-  return pref->GetString(metrics::prefs::kMetricsReportingEnabledTimestamp);
+  return pref->GetString(prefs::kMetricsReportingEnabledTimestamp);
 }
 
 // Computes a SHA-1 hash of |data| and returns it as a hex string.
 std::string ComputeSHA1(const std::string& data) {
   const std::string sha1 = base::SHA1HashString(data);
   return base::HexEncode(sha1.data(), sha1.size());
 }
 
 void WriteFieldTrials(const std::vector<ActiveGroupId>& field_trial_ids,
                       SystemProfileProto* system_profile) {
@@ skipping 11 matching lines @@
 // timestamps.
 int64 RoundSecondsToHour(int64 time_in_seconds) {
   return 3600 * (time_in_seconds / 3600);
 }
 
 }  // namespace
 
 MetricsLog::MetricsLog(const std::string& client_id,
                        int session_id,
                        LogType log_type,
-                       metrics::MetricsServiceClient* client,
+                       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();
+  // 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());
 }
 
 MetricsLog::~MetricsLog() {
 }
 
 // static
 void MetricsLog::RegisterPrefs(PrefRegistrySimple* registry) {
-  registry->RegisterIntegerPref(metrics::prefs::kStabilityLaunchCount, 0);
-  registry->RegisterIntegerPref(metrics::prefs::kStabilityCrashCount, 0);
+  registry->RegisterIntegerPref(prefs::kStabilityLaunchCount, 0);
+  registry->RegisterIntegerPref(prefs::kStabilityCrashCount, 0);
+  registry->RegisterIntegerPref(prefs::kStabilityIncompleteSessionEndCount, 0);
+  registry->RegisterIntegerPref(prefs::kStabilityBreakpadRegistrationFail, 0);
   registry->RegisterIntegerPref(
-      metrics::prefs::kStabilityIncompleteSessionEndCount, 0);
-  registry->RegisterIntegerPref(
-      metrics::prefs::kStabilityBreakpadRegistrationFail, 0);
-  registry->RegisterIntegerPref(
-      metrics::prefs::kStabilityBreakpadRegistrationSuccess, 0);
-  registry->RegisterIntegerPref(metrics::prefs::kStabilityDebuggerPresent, 0);
-  registry->RegisterIntegerPref(metrics::prefs::kStabilityDebuggerNotPresent,
-                                0);
-  registry->RegisterStringPref(metrics::prefs::kStabilitySavedSystemProfile,
+      prefs::kStabilityBreakpadRegistrationSuccess, 0);
+  registry->RegisterIntegerPref(prefs::kStabilityDebuggerPresent, 0);
+  registry->RegisterIntegerPref(prefs::kStabilityDebuggerNotPresent, 0);
+  registry->RegisterStringPref(prefs::kStabilitySavedSystemProfile,
                                std::string());
-  registry->RegisterStringPref(metrics::prefs::kStabilitySavedSystemProfileHash,
+  registry->RegisterStringPref(prefs::kStabilitySavedSystemProfileHash,
                                std::string());
 }
 
 // static
 uint64 MetricsLog::Hash(const std::string& value) {
-  uint64 hash = metrics::HashMetricName(value);
+  uint64 hash = 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;
@@ skipping 54 matching lines @@
     if (i + 1 < histogram_proto->bucket_size() &&
         bucket->max() == histogram_proto->bucket(i + 1).min()) {
       bucket->clear_max();
     } else if (bucket->max() == bucket->min() + 1) {
       bucket->clear_min();
     }
   }
 }
 
 void MetricsLog::RecordStabilityMetrics(
-    const std::vector<metrics::MetricsProvider*>& metrics_providers,
+    const std::vector<MetricsProvider*>& metrics_providers,
     base::TimeDelta incremental_uptime,
     base::TimeDelta uptime) {
   DCHECK(!closed_);
   DCHECK(HasEnvironment());
   DCHECK(!HasStabilityMetrics());
 
   PrefService* pref = local_state_;
   DCHECK(pref);
 
   // Get stability attributes out of Local State, zeroing out stored values.
@@ skipping 10 matching lines @@
 
   SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
   for (size_t i = 0; i < metrics_providers.size(); ++i)
     metrics_providers[i]->ProvideStabilityMetrics(system_profile);
 
   // Omit some stats unless this is the initial stability log.
   if (log_type() != INITIAL_STABILITY_LOG)
     return;
 
   int incomplete_shutdown_count =
-      pref->GetInteger(metrics::prefs::kStabilityIncompleteSessionEndCount);
-  pref->SetInteger(metrics::prefs::kStabilityIncompleteSessionEndCount, 0);
+      pref->GetInteger(prefs::kStabilityIncompleteSessionEndCount);
+  pref->SetInteger(prefs::kStabilityIncompleteSessionEndCount, 0);
   int breakpad_registration_success_count =
-      pref->GetInteger(metrics::prefs::kStabilityBreakpadRegistrationSuccess);
-  pref->SetInteger(metrics::prefs::kStabilityBreakpadRegistrationSuccess, 0);
+      pref->GetInteger(prefs::kStabilityBreakpadRegistrationSuccess);
+  pref->SetInteger(prefs::kStabilityBreakpadRegistrationSuccess, 0);
   int breakpad_registration_failure_count =
-      pref->GetInteger(metrics::prefs::kStabilityBreakpadRegistrationFail);
-  pref->SetInteger(metrics::prefs::kStabilityBreakpadRegistrationFail, 0);
+      pref->GetInteger(prefs::kStabilityBreakpadRegistrationFail);
+  pref->SetInteger(prefs::kStabilityBreakpadRegistrationFail, 0);
   int debugger_present_count =
-      pref->GetInteger(metrics::prefs::kStabilityDebuggerPresent);
-  pref->SetInteger(metrics::prefs::kStabilityDebuggerPresent, 0);
+      pref->GetInteger(prefs::kStabilityDebuggerPresent);
+  pref->SetInteger(prefs::kStabilityDebuggerPresent, 0);
   int debugger_not_present_count =
-      pref->GetInteger(metrics::prefs::kStabilityDebuggerNotPresent);
-  pref->SetInteger(metrics::prefs::kStabilityDebuggerNotPresent, 0);
+      pref->GetInteger(prefs::kStabilityDebuggerNotPresent);
+  pref->SetInteger(prefs::kStabilityDebuggerNotPresent, 0);
 
   // TODO(jar): The following are all optional, so we *could* optimize them for
   // values of zero (and not include them).
   SystemProfileProto::Stability* stability =
       system_profile->mutable_stability();
   stability->set_incomplete_shutdown_count(incomplete_shutdown_count);
   stability->set_breakpad_registration_success_count(
       breakpad_registration_success_count);
   stability->set_breakpad_registration_failure_count(
       breakpad_registration_failure_count);
   stability->set_debugger_present_count(debugger_present_count);
   stability->set_debugger_not_present_count(debugger_not_present_count);
 }
 
 void MetricsLog::RecordGeneralMetrics(
-    const std::vector<metrics::MetricsProvider*>& metrics_providers) {
+    const std::vector<MetricsProvider*>& metrics_providers) {
   for (size_t i = 0; i < metrics_providers.size(); ++i)
     metrics_providers[i]->ProvideGeneralMetrics(uma_proto());
 }
 
 void MetricsLog::GetFieldTrialIds(
     std::vector<ActiveGroupId>* field_trial_ids) const {
   variations::GetFieldTrialActiveGroupIds(field_trial_ids);
 }
 
 bool MetricsLog::HasEnvironment() const {
   return uma_proto()->system_profile().has_uma_enabled_date();
 }
 
 bool MetricsLog::HasStabilityMetrics() const {
   return uma_proto()->system_profile().stability().has_launch_count();
 }
 
 // The server refuses data that doesn't have certain values.  crashcount and
 // launchcount are currently "required" in the "stability" group.
 // TODO(isherman): Stop writing these attributes specially once the migration to
 // protobufs is complete.
 void MetricsLog::WriteRequiredStabilityAttributes(PrefService* pref) {
-  int launch_count = pref->GetInteger(metrics::prefs::kStabilityLaunchCount);
-  pref->SetInteger(metrics::prefs::kStabilityLaunchCount, 0);
-  int crash_count = pref->GetInteger(metrics::prefs::kStabilityCrashCount);
-  pref->SetInteger(metrics::prefs::kStabilityCrashCount, 0);
+  int launch_count = pref->GetInteger(prefs::kStabilityLaunchCount);
+  pref->SetInteger(prefs::kStabilityLaunchCount, 0);
+  int crash_count = pref->GetInteger(prefs::kStabilityCrashCount);
+  pref->SetInteger(prefs::kStabilityCrashCount, 0);
 
   SystemProfileProto::Stability* stability =
       uma_proto()->mutable_system_profile()->mutable_stability();
   stability->set_launch_count(launch_count);
   stability->set_crash_count(crash_count);
 }
 
 void MetricsLog::WriteRealtimeStabilityAttributes(
     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();
   if (incremental_uptime_sec)
     stability->set_incremental_uptime_sec(incremental_uptime_sec);
   const uint64 uptime_sec = uptime.InSeconds();
   if (uptime_sec)
     stability->set_uptime_sec(uptime_sec);
 }
 
 void MetricsLog::RecordEnvironment(
-    const std::vector<metrics::MetricsProvider*>& metrics_providers,
+    const std::vector<MetricsProvider*>& metrics_providers,
     const std::vector<variations::ActiveGroupId>& synthetic_trials,
     int64 install_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);
 
@@ skipping 50 matching lines @@
   WriteFieldTrials(synthetic_trials, system_profile);
 
   for (size_t i = 0; i < metrics_providers.size(); ++i)
     metrics_providers[i]->ProvideSystemProfileMetrics(system_profile);
 
   std::string serialied_system_profile;
   std::string base64_system_profile;
   if (system_profile->SerializeToString(&serialied_system_profile)) {
     base::Base64Encode(serialied_system_profile, &base64_system_profile);
     PrefService* local_state = local_state_;
-    local_state->SetString(metrics::prefs::kStabilitySavedSystemProfile,
+    local_state->SetString(prefs::kStabilitySavedSystemProfile,
                            base64_system_profile);
-    local_state->SetString(metrics::prefs::kStabilitySavedSystemProfileHash,
+    local_state->SetString(prefs::kStabilitySavedSystemProfileHash,
                            ComputeSHA1(serialied_system_profile));
   }
 }
 
 bool MetricsLog::LoadSavedEnvironmentFromPrefs() {
   PrefService* local_state = local_state_;
   const std::string base64_system_profile =
-      local_state->GetString(metrics::prefs::kStabilitySavedSystemProfile);
+      local_state->GetString(prefs::kStabilitySavedSystemProfile);
   if (base64_system_profile.empty())
     return false;
 
   const std::string system_profile_hash =
-      local_state->GetString(metrics::prefs::kStabilitySavedSystemProfileHash);
-  local_state->ClearPref(metrics::prefs::kStabilitySavedSystemProfile);
-  local_state->ClearPref(metrics::prefs::kStabilitySavedSystemProfileHash);
+      local_state->GetString(prefs::kStabilitySavedSystemProfileHash);
+  local_state->ClearPref(prefs::kStabilitySavedSystemProfile);
+  local_state->ClearPref(prefs::kStabilitySavedSystemProfileHash);
 
   SystemProfileProto* system_profile = uma_proto()->mutable_system_profile();
   std::string serialied_system_profile;
   return base::Base64Decode(base64_system_profile, &serialied_system_profile) &&
          ComputeSHA1(serialied_system_profile) == system_profile_hash &&
          system_profile->ParseFromString(serialied_system_profile);
 }
 
 void MetricsLog::CloseLog() {
   DCHECK(!closed_);
   closed_ = true;
 }
 
 void MetricsLog::GetEncodedLog(std::string* encoded_log) {
   DCHECK(closed_);
   uma_proto_.SerializeToString(encoded_log);
 }
 
 }  // namespace metrics