Implement UMA log throttling for cellular connections

components/metrics/metrics_service.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.
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
 // A MetricsService instance is typically created at application startup.  It is
@@ skipping 131 matching lines @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "base/tracked_objects.h"
 #include "base/values.h"
 #include "build/build_config.h"
+#include "components/metrics/data_use_tracker.h"
 #include "components/metrics/metrics_log.h"
 #include "components/metrics/metrics_log_manager.h"
 #include "components/metrics/metrics_log_uploader.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_reporting_scheduler.h"
 #include "components/metrics/metrics_service_client.h"
 #include "components/metrics/metrics_state_manager.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/variations/entropy_provider.h"
@@ skipping 89 matching lines @@
     MetricsService::CLEANLY_SHUTDOWN;
 
 MetricsService::ExecutionPhase MetricsService::execution_phase_ =
     MetricsService::UNINITIALIZED_PHASE;
 
 // static
 void MetricsService::RegisterPrefs(PrefRegistrySimple* registry) {
   DCHECK(IsSingleThreaded());
   MetricsStateManager::RegisterPrefs(registry);
   MetricsLog::RegisterPrefs(registry);
+  DataUseTracker::RegisterPrefs(registry);
 
   registry->RegisterInt64Pref(prefs::kInstallDate, 0);
 
   registry->RegisterInt64Pref(prefs::kStabilityLaunchTimeSec, 0);
   registry->RegisterInt64Pref(prefs::kStabilityLastTimestampSec, 0);
   registry->RegisterStringPref(prefs::kStabilityStatsVersion, std::string());
   registry->RegisterInt64Pref(prefs::kStabilityStatsBuildTime, 0);
   registry->RegisterBooleanPref(prefs::kStabilityExitedCleanly, true);
   registry->RegisterIntegerPref(prefs::kStabilityExecutionPhase,
                                 UNINITIALIZED_PHASE);
@@ skipping 27 matching lines @@
       state_saver_factory_(this) {
   DCHECK(IsSingleThreaded());
   DCHECK(state_manager_);
   DCHECK(client_);
   DCHECK(local_state_);
 
   // Set the install date if this is our first run.
   int64_t install_date = local_state_->GetInt64(prefs::kInstallDate);
   if (install_date == 0)
     local_state_->SetInt64(prefs::kInstallDate, base::Time::Now().ToTimeT());
+  data_use_tracker_.reset(new DataUseTracker(local_state_));

[Alexei Svitkine (slow), 2016/04/06 18:37:43]

We only want to do this logic if enabled via variations params, right?

So, to avoid doing it on other platforms where we don't need it - I suggest not
constructing this object at all. To do that, I suggest moving the creation of
the object to DataUseTracker file itself - i.e. via a Create() function that
will check the variations params. Then, in GetDataUseForwardingCallback(), you
can return a nil callback if the object doesn't exist.

[gayane -on leave until 09-2017, 2016/04/07 15:30:39]

Done.

 }
 
 MetricsService::~MetricsService() {
   DisableRecording();
 }
 
 void MetricsService::InitializeMetricsRecordingState() {
   InitializeMetricsState();
 
   base::Closure upload_callback =
@@ skipping 220 matching lines @@
                            UNINITIALIZED_PHASE);
   local_state_->SetInteger(prefs::kStabilityIncompleteSessionEndCount, 0);
   local_state_->SetInteger(prefs::kStabilityLaunchCount, 0);
   local_state_->SetBoolean(prefs::kStabilitySessionEndCompleted, true);
 }
 
 void MetricsService::PushExternalLog(const std::string& log) {
   log_manager_.StoreLog(log, MetricsLog::ONGOING_LOG);
 }
 
+UpdateUsagePrefCallbackType MetricsService::GetDataUseForwardingCallback() {
+  DCHECK(IsSingleThreaded());
+  return data_use_tracker_->GetDataUseForwardingCallback(
+      base::ThreadTaskRunnerHandle::Get());
+}
+
 //------------------------------------------------------------------------------
 // private methods
 //------------------------------------------------------------------------------
 
 
 //------------------------------------------------------------------------------
 // Initialization methods
 
 void MetricsService::InitializeMetricsState() {
   const int64_t buildtime = MetricsLog::GetBuildTime();
@@ skipping 301 matching lines @@
   }
   if (!log_manager_.has_unsent_logs()) {
     // Should only get here if serializing the log failed somehow.
     // Just tell the scheduler it was uploaded and wait for the next log
     // interval.
     scheduler_->UploadFinished(true, log_manager_.has_unsent_logs());
     return;
   }
   if (!log_manager_.has_staged_log())
     log_manager_.StageNextLogForUpload();
-  SendStagedLog();
+
+  // Proceed to stage the log for upload if log size satisfies cellular log
+  // upload constrains.
+  if (client_->IsUMACellularUploadLogicEnabled() &&
+      !data_use_tracker_->ShouldUploadLogOnCellular(
+          log_manager_.staged_log_hash().size())) {
+    scheduler_->UploadCancelled();
+  } else {
+    SendStagedLog();
+  }
 }
 
 bool MetricsService::ProvidersHaveInitialStabilityMetrics() {
   // Check whether any metrics provider has initial stability metrics.
   for (MetricsProvider* provider : metrics_providers_) {
     if (provider->HasInitialStabilityMetrics())
       return true;
   }
 
   return false;
@@ skipping 281 matching lines @@
                  base::Time::Now().ToTimeT());
 }
 
 void MetricsService::SkipAndDiscardUpload() {
   log_manager_.DiscardStagedLog();
   scheduler_->UploadCancelled();
   log_upload_in_progress_ = false;
 }
 
 }  // namespace metrics