Implement UMA log throttling for cellular connections

chrome/browser/metrics/chrome_metrics_service_client.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 "chrome/browser/metrics/chrome_metrics_service_client.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 88 matching lines @@
 const int kMaxHistogramGatheringWaitDuration = 60000;  // 60 seconds.
 
 // Standard interval between log uploads, in seconds.
 #if defined(OS_ANDROID)
 const int kStandardUploadIntervalSeconds = 5 * 60;  // Five minutes.
 const int kStandardUploadIntervalCellularSeconds = 15 * 60;  // Fifteen minutes.
 #else
 const int kStandardUploadIntervalSeconds = 30 * 60;  // Thirty minutes.
 #endif
 
-// Returns true if current connection type is cellular and user is assigned to
-// experimental group for enabled cellular uploads.
-bool IsCellularLogicEnabled() {
-  if (variations::GetVariationParamValue("UMA_EnableCellularLogUpload",
-                                         "Enabled") != "true" ||
-      variations::GetVariationParamValue("UMA_EnableCellularLogUpload",
-                                         "Optimize") == "false") {
-    return false;
-  }
-
-  return net::NetworkChangeNotifier::IsConnectionCellular(
-      net::NetworkChangeNotifier::GetConnectionType());
-}
 
 // Checks whether it is the first time that cellular uploads logic should be
 // enabled based on whether the the preference for that logic is initialized.
 // This should happen only once as the used preference will be initialized
 // afterwards in |UmaSessionStats.java|.
 bool ShouldClearSavedMetrics() {
 #if BUILDFLAG(ANDROID_JAVA_UI)
   PrefService* local_state = g_browser_process->local_state();
   return !local_state->HasPrefPath(metrics::prefs::kMetricsReportingEnabled) &&
          variations::GetVariationParamValue("UMA_EnableCellularLogUpload",
@@ skipping 172 matching lines @@
   return scoped_ptr<metrics::MetricsLogUploader>(
       new metrics::NetMetricsLogUploader(
           g_browser_process->system_request_context(),
           metrics::kDefaultMetricsServerUrl,
           metrics::kDefaultMetricsMimeType,
           on_upload_complete));
 }
 
 base::TimeDelta ChromeMetricsServiceClient::GetStandardUploadInterval() {
 #if defined(OS_ANDROID)
-  if (IsCellularLogicEnabled())
+  bool is_cellular = false;
+  IsCellularLogicEnabled(&is_cellular);
+  if (is_cellular)
     return base::TimeDelta::FromSeconds(kStandardUploadIntervalCellularSeconds);
 #endif
   return base::TimeDelta::FromSeconds(kStandardUploadIntervalSeconds);
 }
 
 base::string16 ChromeMetricsServiceClient::GetRegistryBackupKey() {
 #if defined(OS_WIN)
   BrowserDistribution* distribution = BrowserDistribution::GetDistribution();
   return distribution->GetRegistryPath().append(L"\\StabilityMetrics");
 #else
@@ skipping 23 matching lines @@
   // Clear metrics reports if it is the first time cellular upload logic should
   // apply to avoid sudden bulk uploads. It needs to be done before initializing
   // metrics service so that metrics log manager is initialized correctly.
   if (ShouldClearSavedMetrics()) {
     PrefService* local_state = g_browser_process->local_state();
     local_state->ClearPref(metrics::prefs::kMetricsInitialLogs);
     local_state->ClearPref(metrics::prefs::kMetricsOngoingLogs);
   }
 
   metrics_service_.reset(new metrics::MetricsService(
-      metrics_state_manager_, this, g_browser_process->local_state()));
+      metrics_state_manager_, this, g_browser_process->local_state(),
+      base::Bind(&ChromeMetricsServiceClient::IsCellularLogicEnabled,
+                 weak_ptr_factory_.GetWeakPtr())));
 
   // Register metrics providers.
 #if defined(ENABLE_EXTENSIONS)
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(
           new ExtensionsMetricsProvider(metrics_state_manager_)));
 #endif
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new metrics::NetworkMetricsProvider(
           content::BrowserThread::GetBlockingPool())));
@@ skipping 15 matching lines @@
 
   RegisterInstallerFileMetricsProvider(metrics_service_.get());
 
   drive_metrics_provider_ = new metrics::DriveMetricsProvider(
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::FILE),
       chrome::FILE_LOCAL_STATE);
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(drive_metrics_provider_));
 
-  profiler_metrics_provider_ =
-      new metrics::ProfilerMetricsProvider(base::Bind(&IsCellularLogicEnabled));
+  profiler_metrics_provider_ = new metrics::ProfilerMetricsProvider(
+      base::Bind(&ChromeMetricsServiceClient::IsCellularLogicEnabled,
+                 weak_ptr_factory_.GetWeakPtr()));
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(profiler_metrics_provider_));
 
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(
           new metrics::CallStackProfileMetricsProvider));
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(
@@ skipping 271 matching lines @@
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 void ChromeMetricsServiceClient::OnURLOpenedFromOmnibox(OmniboxLog* log) {
   metrics_service_->OnApplicationNotIdle();
 }
+
+// Assigns true to output param if current connection type is cellular and user
+// is assigned to experimental group for enabled cellular uploads.
+void ChromeMetricsServiceClient::IsCellularLogicEnabled(bool* out_is_enabled) {
+  if (variations::GetVariationParamValue("UMA_EnableCellularLogUpload",
+                                         "Enabled") != "true" ||
+      variations::GetVariationParamValue("UMA_EnableCellularLogUpload",
+                                         "Optimize") == "false") {
+    *out_is_enabled = false;
+  } else {
+    *out_is_enabled = net::NetworkChangeNotifier::IsConnectionCellular(
+        net::NetworkChangeNotifier::GetConnectionType());
+  }
+}