UMA: use a more frequent upload interval for Chromecast.

components/metrics/metrics_reporting_scheduler.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_reporting_scheduler.h"
 
 #include "base/compiler_specific.h"
-#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/variations/variations_associated_data.h"
 
 using base::TimeDelta;
 
 namespace metrics {
 
 namespace {
 
 // The delay, in seconds, after startup before sending the first log message.
 #if defined(OS_ANDROID) || defined(OS_IOS)
 // Sessions are more likely to be short on a mobile device, so handle the
 // initial log quickly.
 const int kInitialUploadIntervalSeconds = 15;
 #else
 const int kInitialUploadIntervalSeconds = 60;
 #endif
 
 // The delay, in seconds, between uploading when there are queued logs from
 // previous sessions to send.
 #if defined(OS_ANDROID) || defined(OS_IOS)
 // Sending in a burst is better on a mobile device, since keeping the radio on
 // is very expensive.
 const int kUnsentLogsIntervalSeconds = 3;
 #else
 const int kUnsentLogsIntervalSeconds = 15;
 #endif
 
-// Standard interval between log uploads, in seconds.
-#if defined(OS_ANDROID) || defined(OS_IOS)
-const int kStandardUploadIntervalSeconds = 5 * 60;  // Five minutes.
-const int kStandardUploadIntervalCellularSeconds = 15 * 60;  // Fifteen minutes.
-#else
-const int kStandardUploadIntervalSeconds = 30 * 60;  // Thirty minutes.
-#endif
-
 // When uploading metrics to the server fails, we progressively wait longer and
 // longer before sending the next log. This backoff process helps reduce load
 // on a server that is having issues.
 // The following is the multiplier we use to expand that inter-log duration.
 const double kBackoffMultiplier = 1.1;
 
 // The maximum backoff multiplier.
 const int kMaxBackoffMultiplier = 10;
 
 enum InitSequence {
   TIMER_FIRED_FIRST,
   INIT_TASK_COMPLETED_FIRST,
   INIT_SEQUENCE_ENUM_SIZE,
 };
 
 void LogMetricsInitSequence(InitSequence sequence) {
   UMA_HISTOGRAM_ENUMERATION("UMA.InitSequence", sequence,
                             INIT_SEQUENCE_ENUM_SIZE);
 }
 
 void LogActualUploadInterval(TimeDelta interval) {
   UMA_HISTOGRAM_CUSTOM_COUNTS("UMA.ActualLogUploadInterval",
                              interval.InMinutes(),
                              1,
                              base::TimeDelta::FromHours(12).InMinutes(),
                              50);
 }
 
-// Returns upload interval specified for the current experiment running.
-// TODO(gayane): Only for experimenting with upload interval for Android
-// (bug: 17391128). Should be removed once the experiments are done.
-base::TimeDelta GetUploadIntervalFromExperiment() {
-  std::string interval_str = variations::GetVariationParamValue(
-      "UMALogUploadInterval", "interval");
-  int interval;
-  if (interval_str.empty() || !base::StringToInt(interval_str, &interval))
-    return TimeDelta::FromSeconds(kStandardUploadIntervalSeconds);
-
-  return TimeDelta::FromMinutes(interval);
-}
-
-#if defined(OS_ANDROID) || defined(OS_IOS)
-// Returns true if the user is assigned to the experiment group for enabled
-// cellular uploads.
-bool IsCellularEnabledByExperiment() {
-  const std::string group_name =
-      base::FieldTrialList::FindFullName("UMA_EnableCellularLogUpload");
-  return group_name == "Enabled";
-}
-#endif
-
 }  // anonymous namespace
 
 MetricsReportingScheduler::MetricsReportingScheduler(
     const base::Closure& upload_callback,
-    const base::Callback<void(bool*)>& cellular_callback)
+    const base::Callback<base::TimeDelta(void)>& upload_interval_callback)
     : upload_callback_(upload_callback),
       upload_interval_(TimeDelta::FromSeconds(kInitialUploadIntervalSeconds)),
       running_(false),
       callback_pending_(false),
       init_task_complete_(false),
       waiting_for_init_task_complete_(false),
-      cellular_callback_(cellular_callback) {
+      upload_interval_callback_(upload_interval_callback) {
 }
 
 MetricsReportingScheduler::~MetricsReportingScheduler() {}
 
 void MetricsReportingScheduler::Start() {
   GetUploadIntervalFromExperiment();
   running_ = true;
   ScheduleNextUpload();
 }
 
@@ skipping 80 matching lines @@
       static_cast<int64>(kBackoffMultiplier *
                          upload_interval_.InMicroseconds()));
 
   TimeDelta max_interval = kMaxBackoffMultiplier * GetStandardUploadInterval();
   if (upload_interval_ > max_interval || upload_interval_.InSeconds() < 0) {
     upload_interval_ = max_interval;
   }
 }
 
 base::TimeDelta MetricsReportingScheduler::GetStandardUploadInterval() {
-#if defined(OS_ANDROID) || defined(OS_IOS)
-  bool is_cellular = false;
-  if (!cellular_callback_.is_null())
-    cellular_callback_.Run(&is_cellular);
+  return upload_interval_callback_.Run();
+}
 
-  if (is_cellular && IsCellularEnabledByExperiment())
-    return TimeDelta::FromSeconds(kStandardUploadIntervalCellularSeconds);
-#endif
-  return TimeDelta::FromSeconds(kStandardUploadIntervalSeconds);
+base::TimeDelta MetricsReportingScheduler::GetUploadIntervalFromExperiment() {

[Alexei Svitkine (slow), 2015/03/09 17:26:17]

Hmm, I don't think we need this here anymore. Looks like it's just being called
from Start() and the return value is being ignored.

gayane@ - could you remind me why Start() is calling this? If we're doing it
just for the side effect of this call, then this can be done in another way
(e.g. in the client). So I suggest removing this method from this file.

[gayane -on leave until 09-2017, 2015/03/09 18:18:36]

Right, we don't need that anymore. The experiment expired and I already closed
that issue. We are safe to remove it. I could do that now if needed. 

[Alexei Svitkine (slow), 2015/03/09 18:20:42]

Got it - I think given that this CL is already changing this file - it makes to
do the clean up as part of it.

[gunsch, 2015/03/13 00:48:25]

Done.

+  std::string interval_str = variations::GetVariationParamValue(
+      "UMALogUploadInterval", "interval");
+  int interval;
+  if (interval_str.empty() || !base::StringToInt(interval_str, &interval))
+    return GetStandardUploadInterval();
+
+  return TimeDelta::FromMinutes(interval);
 }
 
 }  // namespace metrics