Create Ukm ReportingService implementation.

components/metrics/data_use_tracker.cc

 // Copyright 2016 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/data_use_tracker.h"
 
 #include <string>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/variations/variations_associated_data.h"
 
 namespace metrics {
 
 namespace {
 
 // Default weekly quota and allowed UMA ratio for UMA log uploads for Android.
 // These defaults will not be used for non-Android as |DataUseTracker| will not
 // be initialized. Default values can be overridden by variation params.
 const int kDefaultUMAWeeklyQuotaBytes = 204800;
 const double kDefaultUMARatio = 0.05;
 
+struct CellDataUsePrefs {
+  const MetricsLogUploader::MetricServiceType service_type;
+  const char* service_name;
+  const char* pref_name;
+};
+
+const CellDataUsePrefs data_use_prefs[] = {
+    {MetricsLogUploader::UMA, "UMA", metrics::prefs::kUmaCellDataUse},
+    {MetricsLogUploader::UKM, "UKM", metrics::prefs::kUkmCellDataUse},
+};
+
+const char* GetPrefByServiceName(const std::string& service_name) {
+  for (const auto& pref : data_use_prefs) {
+    if (service_name == pref.service_name)
+      return pref.pref_name;
+  }
+  return nullptr;
+}
+
+const char* GetPrefByServiceType(
+    MetricsLogUploader::MetricServiceType service_type) {
+  for (const auto& pref : data_use_prefs) {
+    if (service_type == pref.service_type)
+      return pref.pref_name;
+  }
+  return nullptr;
+}
+
 }  // namespace
 
 DataUseTracker::DataUseTracker(PrefService* local_state)
     : local_state_(local_state) {}
 
 DataUseTracker::~DataUseTracker() {}
 
 // static
 std::unique_ptr<DataUseTracker> DataUseTracker::Create(
     PrefService* local_state) {
   std::unique_ptr<DataUseTracker> data_use_tracker;
 #if defined(OS_ANDROID)
   data_use_tracker.reset(new DataUseTracker(local_state));
 #endif
   return data_use_tracker;
 }
 
 // static
 void DataUseTracker::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(metrics::prefs::kUserCellDataUse);
-  registry->RegisterDictionaryPref(metrics::prefs::kUmaCellDataUse);
+  for (const auto& pref : data_use_prefs) {
+    registry->RegisterDictionaryPref(pref.pref_name);
+  }
 }
 
 void DataUseTracker::UpdateMetricsUsagePrefs(const std::string& service_name,
                                              int message_size,
                                              bool is_cellular) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!is_cellular)
     return;
 
   UpdateUsagePref(prefs::kUserCellDataUse, message_size);
-  if (service_name == "UMA")
-    UpdateUsagePref(prefs::kUmaCellDataUse, message_size);
+  const char* pref_name = GetPrefByServiceName(service_name);
+  if (pref_name)
+    UpdateUsagePref(pref_name, message_size);
 }
 
-bool DataUseTracker::ShouldUploadLogOnCellular(int log_bytes) {
+bool DataUseTracker::ShouldUploadLogOnCellular(
+    int log_bytes,
+    MetricsLogUploader::MetricServiceType service_type) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  const char* pref_name = GetPrefByServiceType(service_type);
+  if (!pref_name)
+    return false;
 
   RemoveExpiredEntries();
 
   int uma_weekly_quota_bytes;
   if (!GetUmaWeeklyQuota(&uma_weekly_quota_bytes))

[Alexei Svitkine (slow), 2017/03/24 18:27:21]

This function and variable names still say "uma". Please rename them.

Also, this is currently still using the same thresholds as UMA - I assume you're
OK with this for now, but please add TODOs around it, so we revise it. Also,
this is effectively doubling the allowed data use - since both UMA and UKM use
the same threshold but track their data separately. Mention this in a TODO.
....

Separately I also wonder if we should still track them together - e.g. both are
types of metrics and probably it makes sense to have an overall limit for Chrome
metrics data - rather than separate for UMA and UKM. Maybe it would be better to
start off that way until we discuss in a meeting with us and Rob and others? If
so, I suggest reverting the changes to this file for now in this CL other than
making UpdateMetricsUsagePrefs() check for both "UMA" and "UKM" - so their use
is tracked in the same pref for now.

     return true;
 
-  int uma_total_data_use = ComputeTotalDataUse(prefs::kUmaCellDataUse);
+  int uma_total_data_use = ComputeTotalDataUse(pref_name);
   int new_uma_total_data_use = log_bytes + uma_total_data_use;
   // If the new log doesn't increase the total UMA traffic to be above the
   // allowed quota then the log should be uploaded.
   if (new_uma_total_data_use <= uma_weekly_quota_bytes)
     return true;
 
   double uma_ratio;
   if (!GetUmaRatio(&uma_ratio))
     return true;
 
@@ skipping 14 matching lines @@
   std::string todays_key = GetCurrentMeasurementDateAsString();
 
   const base::DictionaryValue* user_pref_dict =
       local_state_->GetDictionary(pref_name);
   user_pref_dict->GetInteger(todays_key, &todays_traffic);
   pref_updater->SetInteger(todays_key, todays_traffic + message_size);
 }
 
 void DataUseTracker::RemoveExpiredEntries() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  RemoveExpiredEntriesForPref(prefs::kUmaCellDataUse);
+  for (const auto& pref : data_use_prefs) {
+    RemoveExpiredEntriesForPref(pref.pref_name);
+  }
   RemoveExpiredEntriesForPref(prefs::kUserCellDataUse);
 }
 
 void DataUseTracker::RemoveExpiredEntriesForPref(const std::string& pref_name) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const base::DictionaryValue* user_pref_dict =
       local_state_->GetDictionary(pref_name);
   const base::Time current_date = GetCurrentMeasurementDate();
   const base::Time week_ago = current_date - base::TimeDelta::FromDays(7);
@@ skipping 59 matching lines @@
 std::string DataUseTracker::GetCurrentMeasurementDateAsString() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   base::Time::Exploded today_exploded;
   GetCurrentMeasurementDate().LocalExplode(&today_exploded);
   return base::StringPrintf("%04d-%02d-%02d", today_exploded.year,
                             today_exploded.month, today_exploded.day_of_month);
 }
 
 }  // namespace metrics