UMA: use a more frequent upload interval for Chromecast.

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 <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
+#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/google/google_brand.h"
@@ skipping 67 matching lines @@
       return metrics::SystemProfileProto::CHANNEL_DEV;
     case chrome::VersionInfo::CHANNEL_BETA:
       return metrics::SystemProfileProto::CHANNEL_BETA;
     case chrome::VersionInfo::CHANNEL_STABLE:
       return metrics::SystemProfileProto::CHANNEL_STABLE;
   }
   NOTREACHED();
   return metrics::SystemProfileProto::CHANNEL_UNKNOWN;
 }
 
+// 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
+
+#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
+
 }  // namespace
 
 ChromeMetricsServiceClient::ChromeMetricsServiceClient(
     metrics::MetricsStateManager* state_manager)
     : metrics_state_manager_(state_manager),
       chromeos_metrics_provider_(NULL),
       waiting_for_collect_final_metrics_step_(false),
       num_async_histogram_fetches_in_progress_(0),
       weak_ptr_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 128 matching lines @@
 ChromeMetricsServiceClient::CreateUploader(
     const base::Callback<void(int)>& on_upload_complete) {
   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) || defined(OS_IOS)
+  bool is_cellular = false;
+  if (!cellular_callback_.is_null())
+    cellular_callback_.Run(&is_cellular);
+
+  if (is_cellular && IsCellularEnabledByExperiment())
+    return base::TimeDelta::FromSeconds(kStandardUploadIntervalCellularSeconds);
+#endif
+  return base::TimeDelta::FromSeconds(kStandardUploadIntervalSeconds);
+}
+
 base::string16 ChromeMetricsServiceClient::GetRegistryBackupKey() {
 #if defined(OS_WIN)
   return L"Software\\" PRODUCT_STRING_PATH L"\\StabilityMetrics";
 #else
   return base::string16();
 #endif
 }
 
 void ChromeMetricsServiceClient::LogPluginLoadingError(
     const base::FilePath& plugin_path) {
@@ skipping 10 matching lines @@
 
   // Register metrics providers.
 #if defined(ENABLE_EXTENSIONS)
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(
           new ExtensionsMetricsProvider(metrics_state_manager_)));
 #endif
   scoped_ptr<metrics::NetworkMetricsProvider> network_metrics_provider(
       new metrics::NetworkMetricsProvider(
           content::BrowserThread::GetBlockingPool()));
-  base::Callback<void(bool*)> cellular_callback =
-      network_metrics_provider->GetConnectionCallback();
-  metrics_service_->SetConnectionTypeCallback(cellular_callback);
+  cellular_callback_ = network_metrics_provider->GetConnectionCallback();

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

Instead of having this callback, how about just keeping a pointer to the
NetworkMetricsProvider? Then, you can call it directly from
GetStandardUploadInterval().

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

In that case we need to think about how to pass a callback to
ProfilerMetricsProvider.

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

Ah you're right. I guess it's fine keeping the callback as-is then.

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

Acknowledged.

   metrics_service_->RegisterMetricsProvider(network_metrics_provider.Pass());
 
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new OmniboxMetricsProvider));
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new ChromeStabilityMetricsProvider));
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(new metrics::GPUMetricsProvider()));
 
   profiler_metrics_provider_ =
-      new metrics::ProfilerMetricsProvider(cellular_callback);
+      new metrics::ProfilerMetricsProvider(cellular_callback_);
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(profiler_metrics_provider_));
 
 #if defined(OS_ANDROID)
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr<metrics::MetricsProvider>(
           new AndroidMetricsProvider(g_browser_process->local_state())));
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_WIN)
@@ skipping 250 matching lines @@
   // Capture the histogram samples.
   if (dumps_with_crash != 0)
     UMA_HISTOGRAM_COUNTS("Chrome.BrowserDumpsWithCrash", dumps_with_crash);
   if (dumps_with_no_crash != 0)
     UMA_HISTOGRAM_COUNTS("Chrome.BrowserDumpsWithNoCrash", dumps_with_no_crash);
   int total_dumps = dumps_with_crash + dumps_with_no_crash;
   if (total_dumps != 0)
     UMA_HISTOGRAM_COUNTS("Chrome.BrowserCrashDumpAttempts", total_dumps);
 }
 #endif  // defined(OS_WIN)