Begin to separate the MetricsService logic for creating vs uploading logs

chrome/browser/metrics/metrics_service.cc

 // Copyright (c) 2012 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
@@ skipping 779 matching lines @@
 }
 
 
 //------------------------------------------------------------------------------
 // Recording control methods
 
 void MetricsService::StartRecording() {
   if (log_manager_.current_log())
     return;
 
-  log_manager_.BeginLoggingWithLog(new MetricsLog(client_id_, session_id_));
+  log_manager_.BeginLoggingWithLog(new MetricsLog(client_id_, session_id_),
+                                   MetricsLogManager::ONGOING_LOG);
   if (state_ == INITIALIZED) {
     // We only need to schedule that run once.
     state_ = INIT_TASK_SCHEDULED;
 
     // Schedules a task on the file thread for execution of slower
     // initialization steps (such as plugin list generation) necessary
     // for sending the initial log.  This avoids blocking the main UI
     // thread.
     BrowserThread::PostDelayedTask(
         BrowserThread::FILE,
@@ skipping 24 matching lines @@
   // Put incremental data (histogram deltas, and realtime stats deltas) at the
   // end of all log transmissions (initial log handles this separately).
   // RecordIncrementalStabilityElements only exists on the derived
   // MetricsLog class.
   MetricsLog* current_log =
       static_cast<MetricsLog*>(log_manager_.current_log());
   DCHECK(current_log);
   current_log->RecordIncrementalStabilityElements();
   RecordCurrentHistograms();
 
-  log_manager_.StageCurrentLogForUpload();
+  log_manager_.FinishCurrentLog();
 }
 
 void MetricsService::PushPendingLogsToPersistentStorage() {
   if (state_ < INITIAL_LOG_READY)
     return;  // We didn't and still don't have time to get plugin list etc.
 
   if (log_manager_.has_staged_log()) {
-    if (state_ == INITIAL_LOG_READY) {
-      // We may race here, and send second copy of initial log later.
-      log_manager_.StoreStagedLogAsUnsent(MetricsLogManager::INITIAL_LOG);
+    // We may race here, and send second copy of initial log later.
+    if (state_ == INITIAL_LOG_READY)
       state_ = SENDING_OLD_LOGS;
-    } else {
-      // TODO(jar): Verify correctness in other states, including sending unsent
-      // initial logs.
-      log_manager_.StoreStagedLogAsUnsent(MetricsLogManager::ONGOING_LOG);
-    }
+    log_manager_.StoreStagedLogAsUnsent();
   }
   DCHECK(!log_manager_.has_staged_log());
   StopRecording();
-  log_manager_.StoreStagedLogAsUnsent(MetricsLogManager::ONGOING_LOG);
   StoreUnsentLogs();
 }
 
 //------------------------------------------------------------------------------
 // Transmission of logs methods
 
 void MetricsService::StartSchedulerIfNecessary() {
   if (reporting_active() && recording_active())
     scheduler_->Start();
 }
 
 void MetricsService::StartScheduledUpload() {
   // If reporting has been turned off, the scheduler doesn't need to run.
   if (!reporting_active() || !recording_active()) {
     scheduler_->Stop();
     scheduler_->UploadCancelled();
     return;
   }
 
+  StartFinalLogInfoCollection();
+}
+
+void MetricsService::StartFinalLogInfoCollection() {
+  // Begin the multi-step process of collecting memory usage histograms:
+  // First spawn a task to collect the memory details; when that task is
+  // finished, it will call OnMemoryDetailCollectionDone. That will in turn
+  // call HistogramSynchronization to collect histograms from all renderers and
+  // then call OnHistogramSynchronizationDone to continue processing.
   DCHECK(!waiting_for_asynchronus_reporting_step_);
   waiting_for_asynchronus_reporting_step_ = true;
 
   base::Closure callback =
       base::Bind(&MetricsService::OnMemoryDetailCollectionDone,
                  log_sender_factory_.GetWeakPtr());
 
   scoped_refptr<MetricsMemoryDetails> details(
       new MetricsMemoryDetails(callback));
   details->StartFetch();
 
   // Collect WebCore cache information to put into a histogram.
   for (content::RenderProcessHost::iterator i(
           content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance())
     i.GetCurrentValue()->Send(new ChromeViewMsg_GetCacheResourceStats());
 }
 
 void MetricsService::OnMemoryDetailCollectionDone() {
   DCHECK(IsSingleThreaded());
   // This function should only be called as the callback from an ansynchronous
   // step.
   DCHECK(waiting_for_asynchronus_reporting_step_);
 
-  // Right before the UMA transmission gets started, there's one more thing we'd
-  // like to record: the histogram of memory usage, so we spawn a task to
-  // collect the memory details and when that task is finished, it will call
-  // OnMemoryDetailCollectionDone, which will call HistogramSynchronization to
-  // collect histograms from all renderers and then we will call
-  // OnHistogramSynchronizationDone to continue processing.
-
   // Create a callback_task for OnHistogramSynchronizationDone.
   base::Closure callback = base::Bind(
       &MetricsService::OnHistogramSynchronizationDone,
       log_sender_factory_.GetWeakPtr());
 
   base::StatisticsRecorder::CollectHistogramStats("Browser");
 
   // Set up the callback to task to call after we receive histograms from all
   // renderer processes. Wait time specifies how long to wait before absolutely
   // calling us back on the task.
   HistogramSynchronizer::FetchRendererHistogramsAsynchronously(
       MessageLoop::current(), callback,
       kMaxHistogramGatheringWaitDuration);
 }
 
 void MetricsService::OnHistogramSynchronizationDone() {
   DCHECK(IsSingleThreaded());
+  // This function should only be called as the callback from an ansynchronous
+  // step.
+  DCHECK(waiting_for_asynchronus_reporting_step_);
 
+  waiting_for_asynchronus_reporting_step_ = false;
+  OnFinalLogInfoCollectionDone();
+}
+
+void MetricsService::OnFinalLogInfoCollectionDone() {
   // If somehow there is a fetch 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(!current_fetch_.get());
   if (current_fetch_.get())
     return;
 
-  // This function should only be called as the callback from an ansynchronous
-  // step.
-  DCHECK(waiting_for_asynchronus_reporting_step_);
-  waiting_for_asynchronus_reporting_step_ = false;
-
   // 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.
   // Similarly, if logs should no longer be uploaded, stop here.
   if (idle_since_last_transmission_ ||
       !recording_active() || !reporting_active()) {
     scheduler_->Stop();
     scheduler_->UploadCancelled();
     return;
   }
 
   MakeStagedLog();
 
   // MakeStagedLog should have prepared log text; if it didn't, skip this
   // upload and hope things work out next time.
   if (log_manager_.staged_log_text().empty()) {
     scheduler_->UploadCancelled();
     return;
   }
 
-  PrepareFetchWithStagedLog();
-
-  if (!current_fetch_.get()) {
-    // Compression failed, and log discarded :-/.
-    log_manager_.DiscardStagedLog();
-    scheduler_->UploadCancelled();
-    // TODO(jar): If compression failed, we should have created a tiny log and
-    // compressed that, so that we can signal that we're losing logs.
-    return;
-  }
-
-  DCHECK(!waiting_for_asynchronus_reporting_step_);
-
-  waiting_for_asynchronus_reporting_step_ = true;
-  current_fetch_->Start();
-
-  HandleIdleSinceLastTransmission(true);
+  SendStagedLog();
 }
 
-
 void MetricsService::MakeStagedLog() {
   if (log_manager_.has_staged_log())
     return;
 
   switch (state_) {
     case INITIALIZED:
     case INIT_TASK_SCHEDULED:  // We should be further along by now.
       DCHECK(false);
       return;
 
     case INIT_TASK_DONE:
       // We need to wait for the initial log to be ready before sending
       // anything, because the server will tell us whether it wants to hear
       // from us.
       PrepareInitialLog();
       DCHECK(state_ == INIT_TASK_DONE);
       log_manager_.LoadPersistedUnsentLogs();
       state_ = INITIAL_LOG_READY;
       break;
 
     case SENDING_OLD_LOGS:
       if (log_manager_.has_unsent_logs()) {
-        log_manager_.StageNextStoredLogForUpload();
+        log_manager_.StageNextLogForUpload();
         break;
       }
       state_ = SENDING_CURRENT_LOGS;
       // Fall through.
 
     case SENDING_CURRENT_LOGS:
       StopRecording();
       StartRecording();
+      log_manager_.StageNextLogForUpload();
       break;
 
     default:
       NOTREACHED();
       return;
   }
 
   DCHECK(log_manager_.has_staged_log());
 }
 
 void MetricsService::PrepareInitialLog() {
   DCHECK(state_ == INIT_TASK_DONE);
 
   MetricsLog* log = new MetricsLog(client_id_, session_id_);
   log->set_hardware_class(hardware_class_);  // Adds to initial log.
   log->RecordEnvironment(plugins_, profile_dictionary_.get());
 
   // Histograms only get written to the current log, so make the new log current
   // before writing them.
   log_manager_.PauseCurrentLog();
-  log_manager_.BeginLoggingWithLog(log);
+  log_manager_.BeginLoggingWithLog(log, MetricsLogManager::INITIAL_LOG);
   RecordCurrentHistograms();
+  log_manager_.FinishCurrentLog();
+  log_manager_.ResumePausedLog();
 
   DCHECK(!log_manager_.has_staged_log());
-  log_manager_.StageCurrentLogForUpload();
-  log_manager_.ResumePausedLog();
+  log_manager_.StageNextLogForUpload();
 }
 
 void MetricsService::StoreUnsentLogs() {
   if (state_ < INITIAL_LOG_READY)
     return;  // We never Recalled the prior unsent logs.
 
   log_manager_.PersistUnsentLogs();
 }
 
+void MetricsService::SendStagedLog() {
+  DCHECK(log_manager_.has_staged_log());
+
+  PrepareFetchWithStagedLog();
+
+  if (!current_fetch_.get()) {
+    // Compression failed, and log discarded :-/.
+    log_manager_.DiscardStagedLog();
+    scheduler_->UploadCancelled();
+    // TODO(jar): If compression failed, we should have created a tiny log and
+    // compressed that, so that we can signal that we're losing logs.
+    return;
+  }
+
+  DCHECK(!waiting_for_asynchronus_reporting_step_);
+
+  waiting_for_asynchronus_reporting_step_ = true;
+  current_fetch_->Start();
+
+  HandleIdleSinceLastTransmission(true);
+}
+
 void MetricsService::PrepareFetchWithStagedLog() {
   DCHECK(!log_manager_.staged_log_text().empty());
   DCHECK(!current_fetch_.get());
 
   current_fetch_.reset(content::URLFetcher::Create(
       GURL(WideToUTF16(server_url_)), content::URLFetcher::POST, this));
   current_fetch_->SetRequestContext(
       g_browser_process->system_request_context());
   current_fetch_->SetUploadData(kMetricsType, log_manager_.staged_log_text());
 }
@@ skipping 494 matching lines @@
   if (local_state) {
     const PrefService::Preference* uma_pref =
         local_state->FindPreference(prefs::kMetricsReportingEnabled);
     if (uma_pref) {
       bool success = uma_pref->GetValue()->GetAsBoolean(&result);
       DCHECK(success);
     }
   }
   return result;
 }