Enable UMA log uploads for cellular networks.

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"
@@ skipping 20 matching lines @@
 // 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;
 
@@ skipping 25 matching lines @@
 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);
 }
 
+// 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";
+}
+
 }  // anonymous namespace
 
 MetricsReportingScheduler::MetricsReportingScheduler(
-    const base::Closure& upload_callback)
+    const base::Closure& upload_callback,
+    const base::Callback<void(bool*)>& cellular_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) {
+      waiting_for_init_task_complete_(false),
+      cellular_callback_(cellular_callback) {
 }
 
 MetricsReportingScheduler::~MetricsReportingScheduler() {}
 
 void MetricsReportingScheduler::Start() {
   GetUploadIntervalFromExperiment();
   running_ = true;
   ScheduleNextUpload();
 }
 
@@ skipping 81 matching lines @@
                          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)
-  return GetUploadIntervalFromExperiment();
-#else
+  bool is_cellular = false;
+  cellular_callback_.Run(&is_cellular);
+  if (is_cellular && IsCellularEnabledByExperiment())
+    return TimeDelta::FromSeconds(kStandardUploadIntervalCellularSeconds);
+#endif
   return TimeDelta::FromSeconds(kStandardUploadIntervalSeconds);
-#endif
+}
+
+void MetricsReportingScheduler::SetConnectionType(bool is_cellular) {
+  is_cellular_connection_ = is_cellular;
 }
 
 }  // namespace metrics