Add histograms for observing UMA throttling effect.

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 <stdint.h>
 
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 39 matching lines @@
   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",

[Alexei Svitkine (slow), 2016/04/08 20:07:12]

I'm not convinced we should stop logging this yet. Let's keep it for now.

[gayane -on leave until 09-2017, 2016/04/08 20:40:14]

Done.

-                             interval.InMinutes(),
-                             1,
-                             base::TimeDelta::FromHours(12).InMinutes(),
-                             50);
-}
-
 }  // anonymous namespace
 
 MetricsReportingScheduler::MetricsReportingScheduler(
     const base::Closure& upload_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),
@@ skipping 32 matching lines @@
   callback_pending_ = false;
   // If the server is having issues, back off. Otherwise, reset to default
   // (unless there are more logs to send, in which case the next upload should
   // happen sooner).
   if (!server_is_healthy) {
     BackOffUploadInterval();
   } else if (more_logs_remaining) {
     upload_interval_ = TimeDelta::FromSeconds(kUnsentLogsIntervalSeconds);
   } else {
     upload_interval_ = GetStandardUploadInterval();
-    last_upload_finish_time_ = base::TimeTicks::Now();
   }
 
   if (running_)
     ScheduleNextUpload();
 }
 
 void MetricsReportingScheduler::UploadCancelled() {
   DCHECK(callback_pending_);
   callback_pending_ = false;
   if (running_)
     ScheduleNextUpload();
 }
 
 void MetricsReportingScheduler::SetUploadIntervalForTesting(
     base::TimeDelta interval) {
   upload_interval_ = interval;
 }
 
 void MetricsReportingScheduler::TriggerUpload() {
   // If the timer fired before the init task has completed, don't trigger the
   // upload yet - wait for the init task to complete and do it then.
   if (!init_task_complete_) {
     LogMetricsInitSequence(TIMER_FIRED_FIRST);
     waiting_for_init_task_complete_ = true;
     return;
   }
 
-  if (!last_upload_finish_time_.is_null()) {
-    LogActualUploadInterval(base::TimeTicks::Now() - last_upload_finish_time_);
-    last_upload_finish_time_ = base::TimeTicks();
-  }
-
   callback_pending_ = true;
   upload_callback_.Run();
 }
 
 void MetricsReportingScheduler::ScheduleNextUpload() {
   DCHECK(running_);
   if (upload_timer_.IsRunning() || callback_pending_)
     return;
 
   upload_timer_.Start(FROM_HERE, upload_interval_, this,
                       &MetricsReportingScheduler::TriggerUpload);
 }
 
 void MetricsReportingScheduler::BackOffUploadInterval() {
   DCHECK_GT(kBackoffMultiplier, 1.0);
   upload_interval_ = TimeDelta::FromMicroseconds(static_cast<int64_t>(
       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() {
   return upload_interval_callback_.Run();
 }
 
 }  // namespace metrics