Refactor metrics callback functions

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 744 matching lines @@
   // 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);
   // 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() ||
       (!reporting_active() && state_ >= SENDING_LOGS)) {
     scheduler_->Stop();
     scheduler_->UploadCancelled();
     return;
   }
 
   // If there are unsent logs, send the next one. If not, start the asynchronous
   // process of finalizing the current log for upload.
   if (state_ == SENDING_LOGS && log_manager_.has_unsent_logs()) {
-    log_manager_.StageNextLogForUpload();
-    SendStagedLog();
+    SendNextLog();
   } else {
+    // There are no logs left to send, so start creating a new one.
     client_->CollectFinalMetrics(
         base::Bind(&MetricsService::OnFinalLogInfoCollectionDone,
                    self_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void MetricsService::OnFinalLogInfoCollectionDone() {
   // If somehow there is a log upload in progress, we return and hope things
   // work out. The scheduler isn't informed since if this happens, the scheduler
   // will get a response from the upload.
   DCHECK(!log_upload_in_progress_);
   if (log_upload_in_progress_)
     return;
 
   // Abort if metrics were turned off during the final info gathering.
   if (!recording_active()) {
     scheduler_->Stop();
     scheduler_->UploadCancelled();
     return;
   }
 
-  StageNewLog();
+  if (state_ == INIT_TASK_DONE) {
+    PrepareInitialMetricsLog();
+  } else {
+    DCHECK_EQ(SENDING_LOGS, state_);
+    CloseCurrentLog();
+    OpenNewLog();
+  }
+  SendNextLog();
+}
 
-  // If logs shouldn't be uploaded, stop here. It's important that this check
-  // be after StageNewLog(), otherwise the previous logs will never be loaded,
-  // and thus the open log won't be persisted.
-  // TODO(stuartmorgan): This is unnecessarily complicated; restructure loading
-  // of previous logs to not require running part of the upload logic.
-  // http://crbug.com/157337
+void MetricsService::SendNextLog() {
+  DCHECK_EQ(SENDING_LOGS, state_);
   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());
+    return;
+  }
+  if (!log_manager_.has_staged_log())
+    log_manager_.StageNextLogForUpload();
   SendStagedLog();
 }
 
-void MetricsService::StageNewLog() {
-  if (log_manager_.has_staged_log())
-    return;
-
-  switch (state_) {
-    case INITIALIZED:
-    case INIT_TASK_SCHEDULED:  // We should be further along by now.
-      NOTREACHED();
-      return;
-
-    case INIT_TASK_DONE:
-      PrepareInitialMetricsLog();
-      // Stage the first log, which could be a stability log (either one
-      // for created in this session or from a previous session) or the
-      // initial metrics log that was just created.
-      log_manager_.StageNextLogForUpload();
-      state_ = SENDING_LOGS;
-      break;
-
-    case SENDING_LOGS:
-      CloseCurrentLog();
-      OpenNewLog();
-      log_manager_.StageNextLogForUpload();
-      break;
-
-    default:
-      NOTREACHED();
-      return;
-  }
-
-  DCHECK(log_manager_.has_staged_log());
-}
-
 bool MetricsService::ProvidersHaveStabilityMetrics() {
   // Check whether any metrics provider has stability metrics.
   for (size_t i = 0; i < metrics_providers_.size(); ++i) {
     if (metrics_providers_[i]->HasStabilityMetrics())
       return true;
   }
 
   return false;
 }
 
@@ skipping 51 matching lines @@
                                       base::TimeDelta(), base::TimeDelta());
   current_log->RecordGeneralMetrics(metrics_providers_.get());
   RecordCurrentHistograms();
 
   log_manager_.FinishCurrentLog();
   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() {
   DCHECK(log_manager_.has_staged_log());
   if (!log_manager_.has_staged_log())
     return;
 
   DCHECK(!log_upload_in_progress_);
   log_upload_in_progress_ = true;
 
@@ skipping 190 matching lines @@
   local_state_->SetBoolean(path, value);
   RecordCurrentState(local_state_);
 }
 
 void MetricsService::RecordCurrentState(PrefService* pref) {
   pref->SetInt64(prefs::kStabilityLastTimestampSec,
                  base::Time::Now().ToTimeT());
 }
 
 }  // namespace metrics