WebView Metrics client implementation (Chromium part)

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/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/variations/variations_associated_data.h"
@@ skipping 61 matching lines @@
       running_(false),
       callback_pending_(false),
       init_task_complete_(false),
       waiting_for_init_task_complete_(false),
       upload_interval_callback_(upload_interval_callback) {
 }
 
 MetricsReportingScheduler::~MetricsReportingScheduler() {}
 
 void MetricsReportingScheduler::Start() {
+  LOG(WARNING) << "metrix MetricsReportingScheduler::Start";
   running_ = true;
   ScheduleNextUpload();
 }
 
 void MetricsReportingScheduler::Stop() {
+  LOG(WARNING) << "metrix MetricsReportingScheduler::Stop";
   running_ = false;
   if (upload_timer_.IsRunning())
     upload_timer_.Stop();
 }
 
 // Callback from MetricsService when the startup init task has completed.
 void MetricsReportingScheduler::InitTaskComplete() {
   DCHECK(!init_task_complete_);
   init_task_complete_ = true;
   if (waiting_for_init_task_complete_) {
@@ skipping 30 matching lines @@
   if (running_)
     ScheduleNextUpload();
 }
 
 void MetricsReportingScheduler::SetUploadIntervalForTesting(
     base::TimeDelta interval) {
   upload_interval_ = interval;
 }
 
 void MetricsReportingScheduler::TriggerUpload() {
+  LOG(WARNING) << "metrix TriggerUpload " << init_task_complete_ << " " << last_upload_finish_time_;
   // 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_);
+  LOG(WARNING) << "metrix ScheduleNextUpload" << " " << upload_timer_.IsRunning()
+    << " " << callback_pending_ << " interval:" << upload_interval_;
   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>(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