WebView Metrics client implementation (Chromium part)

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 300 matching lines @@
   if (install_date == 0)
     local_state_->SetInt64(prefs::kInstallDate, base::Time::Now().ToTimeT());
 }
 
 MetricsService::~MetricsService() {
   DisableRecording();
 }
 
 void MetricsService::InitializeMetricsRecordingState() {
   InitializeMetricsState();
-
+  LOG(WARNING) << "metrix InitializeMetricsRecordingState";
   base::Closure upload_callback =
       base::Bind(&MetricsService::StartScheduledUpload,
                  self_ptr_factory_.GetWeakPtr());
   scheduler_.reset(
       new MetricsReportingScheduler(
           upload_callback,
           // MetricsServiceClient outlives MetricsService, and
           // MetricsReportingScheduler is tied to the lifetime of |this|.
           base::Bind(&MetricsServiceClient::GetStandardUploadInterval,
                      base::Unretained(client_))));
 }
 
 void MetricsService::Start() {
+  LOG(WARNING) << "metrix starting metrics service";
   HandleIdleSinceLastTransmission(false);
   EnableRecording();
   EnableReporting();
 }
 
 void MetricsService::StartRecordingForTests() {
   test_mode_active_ = true;
   EnableRecording();
   DisableReporting();
 }
 
 void MetricsService::Stop() {
+  LOG(WARNING) << "metrix stopping metrics service";
   HandleIdleSinceLastTransmission(false);
   DisableReporting();
   DisableRecording();
 }
 
 void MetricsService::EnableReporting() {
+  LOG(WARNING) << "metrix enablereporting";
   if (reporting_active_)
     return;
   reporting_active_ = true;
   StartSchedulerIfNecessary();
 }
 
 void MetricsService::DisableReporting() {
   reporting_active_ = false;
 }
 
@@ skipping 15 matching lines @@
 
 scoped_ptr<const base::FieldTrial::EntropyProvider>
 MetricsService::CreateEntropyProvider() {
   // TODO(asvitkine): Refactor the code so that MetricsService does not expose
   // this method.
   return state_manager_->CreateEntropyProvider();
 }
 
 void MetricsService::EnableRecording() {
   DCHECK(IsSingleThreaded());
-
+  LOG(WARNING) << "metrix EnableRecording " << recording_state_;
   if (recording_state_ == ACTIVE)
     return;
   recording_state_ = ACTIVE;
 
   state_manager_->ForceClientIdCreation();
   client_->SetMetricsClientId(state_manager_->client_id());
   if (!log_manager_.current_log())
     OpenNewLog();
 
   for (size_t i = 0; i < metrics_providers_.size(); ++i)
@@ skipping 234 matching lines @@
 
   // Bookkeeping for the uninstall metrics.
   IncrementLongPrefsValue(prefs::kUninstallLaunchCount);
 
   // Kick off the process of saving the state (so the uptime numbers keep
   // getting updated) every n minutes.
   ScheduleNextStateSave();
 }
 
 void MetricsService::OnUserAction(const std::string& action) {
+  LOG(INFO) << "metrix metrics::MetricsService::OnUserAction action=" << action;
+
   if (!ShouldLogEvents())
     return;
 
   log_manager_.current_log()->RecordUserAction(action);
   HandleIdleSinceLastTransmission(false);
 }
 
 void MetricsService::FinishedInitTask() {
+  LOG(WARNING) << "metrix FinishedInitTask";
   DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
   state_ = INIT_TASK_DONE;
 
   // Create the initial log.
   if (!initial_metrics_log_.get()) {
     initial_metrics_log_ = CreateLog(MetricsLog::ONGOING_LOG);
     NotifyOnDidCreateMetricsLog();
   }
 
   scheduler_->InitTaskComplete();
@@ skipping 60 matching lines @@
     state_ = INIT_TASK_SCHEDULED;
 
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&MetricsService::StartInitTask,
                               self_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromSeconds(kInitializationDelaySeconds));
   }
 }
 
 void MetricsService::StartInitTask() {
+  LOG(WARNING) << "metrix StartInitTask";
   client_->InitializeSystemProfileMetrics(
       base::Bind(&MetricsService::FinishedInitTask,
                  self_ptr_factory_.GetWeakPtr()));
 }
 
 void MetricsService::CloseCurrentLog() {
   if (!log_manager_.current_log())
     return;
 
   // TODO(jar): Integrate bounds on log recording more consistently, so that we
@@ skipping 29 matching lines @@
     return;  // We didn't and still don't have time to get plugin list etc.
 
   CloseCurrentLog();
   log_manager_.PersistUnsentLogs();
 }
 
 //------------------------------------------------------------------------------
 // Transmission of logs methods
 
 void MetricsService::StartSchedulerIfNecessary() {
+  LOG(WARNING) << "metrix StartSchedulerIfNecessary";
   // Never schedule cutting or uploading of logs in test mode.
   if (test_mode_active_)
     return;
 
   // Even if reporting is disabled, the scheduler is needed to trigger the
   // creation of the initial log, which must be done in order for any logs to be
   // persisted on shutdown or backgrounding.
   if (recording_active() &&
       (reporting_active() || state_ < SENDING_LOGS)) {
     scheduler_->Start();
   }
 }
 
 void MetricsService::StartScheduledUpload() {
   DCHECK(state_ >= INIT_TASK_DONE);
+  LOG(WARNING) << " metrix StartScheduledUpload " <<  idle_since_last_transmission_
+    << " " << recording_active() << " " << state_;
   // If we're getting no notifications, then the log won't have much in it, and
   // it's possible the computer is about to go to sleep, so don't upload and
   // stop the scheduler.
   // If recording has been turned off, the scheduler doesn't need to run.
   // If reporting is off, proceed if the initial log hasn't been created, since
   // that has to happen in order for logs to be cut and stored when persisting.
   // TODO(stuartmorgan): Call Stop() on the scheduler when reporting and/or
   // recording are turned off instead of letting it fire and then aborting.
   if (idle_since_last_transmission_ ||
       !recording_active() ||
@@ skipping 35 matching lines @@
   } else {
     DCHECK_EQ(SENDING_LOGS, state_);
     CloseCurrentLog();
     OpenNewLog();
   }
   SendNextLog();
 }
 
 void MetricsService::SendNextLog() {
   DCHECK_EQ(SENDING_LOGS, state_);
+  LOG(WARNING) << "metrix SendNextLog";
   if (!reporting_active()) {
     scheduler_->Stop();
     scheduler_->UploadCancelled();
     return;
   }
   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());
@@ skipping 73 matching lines @@
   log_manager_.ResumePausedLog();
 
   // Store unsent logs, including the initial log that was just saved, so
   // that they're not lost in case of a crash before upload time.
   log_manager_.PersistUnsentLogs();
 
   state_ = SENDING_LOGS;
 }
 
 void MetricsService::SendStagedLog() {
+  LOG(WARNING) << "metrix SendStagedLog";
   DCHECK(log_manager_.has_staged_log());
   if (!log_manager_.has_staged_log())
     return;
 
   DCHECK(!log_upload_in_progress_);
   log_upload_in_progress_ = true;
 
   if (!ShouldUploadLog()) {
     SkipAndDiscardUpload();
     return;
@@ skipping 190 matching lines @@
                  base::Time::Now().ToTimeT());
 }
 
 void MetricsService::SkipAndDiscardUpload() {
   log_manager_.DiscardStagedLog();
   scheduler_->UploadCancelled();
   log_upload_in_progress_ = false;
 }
 
 }  // namespace metrics