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;
+  }

[Alexei Svitkine (slow), 2017/03/24 16:26:16]

Nit: Add a NOTREACHED()?

[Steven Holte, 2017/03/24 18:13:29]

It is reached, in most cases.

+  return NULL;

[Alexei Svitkine (slow), 2017/03/24 16:26:17]

nullptr

[Steven Holte, 2017/03/24 18:13:29]

Done.

+}
+
+const char* GetPrefByServiceType(
+    const MetricsLogUploader::MetricServiceType service_type) {

[Alexei Svitkine (slow), 2017/03/24 16:26:17]

Nit: No need for const on the param since it's an enum.

[Steven Holte, 2017/03/24 18:13:29]

Done.

+  for (const auto& pref : data_use_prefs) {
+    if (service_type == pref.service_type)
+      return pref.pref_name;
+  }

[Alexei Svitkine (slow), 2017/03/24 16:26:17]

Nit: Add a NOTREACHED()?

[Steven Holte, 2017/03/24 18:13:29]

It is reached, in most cases.

[Steven Holte, 2017/03/24 18:16:36]

Actually, this one probably won't be reached.

[Steven Holte, 2017/03/24 18:20:13]

Added a DCHECK for non-null return to ShouldUploadLogOnCellular, which is where
this is called.

+  return NULL;

[Alexei Svitkine (slow), 2017/03/24 16:26:16]

nullptr

[Steven Holte, 2017/03/24 18:13:29]

Done.

+}
+
 }  // 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,
+    const MetricsLogUploader::MetricServiceType service_type) {

[Alexei Svitkine (slow), 2017/03/24 16:26:17]

Nit: Remove const

[Steven Holte, 2017/03/24 18:13:29]

Done.

   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))
     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