Make the launch params the default client behavior for UMA 3g

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. Can be
+// overridden by variation params.
+const int kDefaultUMAWeeklyQuotaBytes = 204800;
+const double kDefaultUMARatio = 0.05;

[Alexei Svitkine (slow), 2016/05/13 20:46:47]

Are these defaults safe for non-Android platforms? I noticed you stopped
returning false from either of the functions below.

[gayane -on leave until 09-2017, 2016/05/13 20:57:12]

It is not obvious. The functions will be called only if data_use_tracker was
initialized and it will not be initialized for non-Android. I can add explicit
ifdefs in those functions as well. What do you think ?

[Alexei Svitkine (slow), 2016/05/13 20:59:43]

Just having a comment explaining this above these two defaults should be good
fine, but I'm ok with ifdefs too.

[gayane -on leave until 09-2017, 2016/05/16 15:33:04]

Done.

+
 // This function is for forwarding metrics usage pref changes to the appropriate
 // callback on the appropriate thread.
 // TODO(gayane): Reduce the frequency of posting tasks from IO to UI thread.
 void UpdateMetricsUsagePrefs(
     const UpdateUsagePrefCallbackType& update_on_ui_callback,
     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
     const std::string& service_name,
     int message_size,
     bool is_cellular) {
   ui_task_runner->PostTask(
       FROM_HERE, base::Bind(update_on_ui_callback, service_name, message_size,
                             is_cellular));
 }
 
 }  // namespace
 
 DataUseTracker::DataUseTracker(PrefService* local_state)
     : local_state_(local_state), weak_ptr_factory_(this) {}
 
 DataUseTracker::~DataUseTracker() {}
 
 // static
 std::unique_ptr<DataUseTracker> DataUseTracker::Create(
     PrefService* local_state) {
   std::unique_ptr<DataUseTracker> data_use_tracker;
   if (variations::GetVariationParamValue("UMA_EnableCellularLogUpload",
                                          "Uma_Quota") != "" &&
       variations::GetVariationParamValue("UMA_EnableCellularLogUpload",
                                          "Uma_Ratio") != "") {

[Alexei Svitkine (slow), 2016/05/13 20:46:47]

We would want this logic to be changed too, since we want this to apply even
when the experiment config doesn't exist/specify these params.

[gayane -on leave until 09-2017, 2016/05/13 20:57:12]

Done.

[Alexei Svitkine (slow), 2016/05/13 20:59:43]

(Waiting to see this in your next patchset.)

[gayane -on leave until 09-2017, 2016/05/16 15:33:04]

Acknowledged.

     data_use_tracker.reset(new DataUseTracker(local_state));
   }
   return data_use_tracker;
 }
 
 // static
 void DataUseTracker::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(metrics::prefs::kUserCellDataUse);
   registry->RegisterDictionaryPref(metrics::prefs::kUmaCellDataUse);
 }
@@ skipping 108 matching lines @@
   }
   return total_data_use;
 }
 
 bool DataUseTracker::GetUmaWeeklyQuota(int* uma_weekly_quota_bytes) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::string param_value_str = variations::GetVariationParamValue(
       "UMA_EnableCellularLogUpload", "Uma_Quota");
   if (param_value_str.empty())
-    return false;
-
-  base::StringToInt(param_value_str, uma_weekly_quota_bytes);
+    *uma_weekly_quota_bytes = kDefaultUMAWeeklyQuotaBytes;
+  else
+    base::StringToInt(param_value_str, uma_weekly_quota_bytes);
   return true;
 }
 
 bool DataUseTracker::GetUmaRatio(double* ratio) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::string param_value_str = variations::GetVariationParamValue(
       "UMA_EnableCellularLogUpload", "Uma_Ratio");
   if (param_value_str.empty())
-    return false;
-  base::StringToDouble(param_value_str, ratio);
+    *ratio = kDefaultUMARatio;
+  else
+    base::StringToDouble(param_value_str, ratio);
   return true;
 }
 
 base::Time DataUseTracker::GetCurrentMeasurementDate() const {
   return base::Time::Now().LocalMidnight();
 }
 
 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