Split a MetricsLogStore object out of MetricsLogManager.

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 240 matching lines @@
   registry->RegisterListPref(prefs::kMetricsInitialLogs);
   registry->RegisterListPref(prefs::kMetricsOngoingLogs);
 
   registry->RegisterInt64Pref(prefs::kUninstallLaunchCount, 0);
   registry->RegisterInt64Pref(prefs::kUninstallMetricsUptimeSec, 0);
 }
 
 MetricsService::MetricsService(MetricsStateManager* state_manager,
                                MetricsServiceClient* client,
                                PrefService* local_state)
-    : log_manager_(local_state, kUploadLogAvoidRetransmitSize),
+    : log_store_(local_state, kUploadLogAvoidRetransmitSize),
       histogram_snapshot_manager_(this),
       state_manager_(state_manager),
       client_(client),
       local_state_(local_state),
       clean_exit_beacon_(client->GetRegistryBackupKey(), local_state),
       recording_state_(UNSET),
       reporting_active_(false),
       test_mode_active_(false),
       state_(INITIALIZED),
       log_upload_in_progress_(false),
@@ skipping 241 matching lines @@
   StabilityMetricsProvider(local_state_)
       .RecordBreakpadHasDebugger(has_debugger);
 }
 
 void MetricsService::ClearSavedStabilityMetrics() {
   for (auto& provider : metrics_providers_)
     provider->ClearSavedStabilityMetrics();
 }
 
 void MetricsService::PushExternalLog(const std::string& log) {
-  log_manager_.StoreLog(log, MetricsLog::ONGOING_LOG);
+  log_store_.StoreLog(log, MetricsLog::ONGOING_LOG);
 }
 
 void MetricsService::UpdateMetricsUsagePrefs(const std::string& service_name,
                                              int message_size,
                                              bool is_cellular) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (data_use_tracker_) {
     data_use_tracker_->UpdateMetricsUsagePrefs(service_name,
                                                message_size,
                                                is_cellular);
@@ skipping 14 matching lines @@
 
   bool version_changed = false;
   EnvironmentRecorder recorder(local_state_);
   int64_t previous_buildtime = recorder.GetLastBuildtime();
   std::string previous_version = recorder.GetLastVersion();
   if (previous_buildtime != buildtime || previous_version != version) {
     recorder.SetBuildtimeAndVersion(buildtime, version);
     version_changed = true;
   }
 
-  log_manager_.LoadPersistedUnsentLogs();
+  log_store_.LoadPersistedUnsentLogs();
 
   session_id_ = local_state_->GetInteger(prefs::kMetricsSessionID);
 
   StabilityMetricsProvider provider(local_state_);
   if (!clean_exit_beacon_.exited_cleanly()) {
     provider.LogCrash();
     // Reset flag, and wait until we call LogNeedForCleanShutdown() before
     // monitoring.
     clean_exit_beacon_.WriteBeaconValue(true);
     ExecutionPhaseManager manager(local_state_);
@@ skipping 166 matching lines @@
   RecordCurrentEnvironment(current_log);
   base::TimeDelta incremental_uptime;
   base::TimeDelta uptime;
   GetUptimes(local_state_, &incremental_uptime, &uptime);
   current_log->RecordStabilityMetrics(metrics_providers_, incremental_uptime,
                                       uptime);
 
   current_log->RecordGeneralMetrics(metrics_providers_);
   RecordCurrentHistograms();
   DVLOG(1) << "Generated an ongoing log.";
-  log_manager_.FinishCurrentLog();
+  log_manager_.FinishCurrentLog(&log_store_);
 }
 
 void MetricsService::PushPendingLogsToPersistentStorage() {
   if (state_ < SENDING_LOGS)
     return;  // We didn't and still don't have time to get plugin list etc.
 
   CloseCurrentLog();
-  log_manager_.PersistUnsentLogs();
+  log_store_.PersistUnsentLogs();
 }
 
 //------------------------------------------------------------------------------
 // Transmission of logs methods
 
 void MetricsService::StartSchedulerIfNecessary() {
   // Never schedule cutting or uploading of logs in test mode.
   if (test_mode_active_)
     return;
 
@@ skipping 30 matching lines @@
       rotation_scheduler_->RotationFinished();
     } else {
       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()) {
+  if (state_ == SENDING_LOGS && log_store_.has_unsent_logs()) {
     if (upload_scheduler_) {
       upload_scheduler_->Start();
       rotation_scheduler_->RotationFinished();
     } else {
       SendNextLog();
     }
   } else {
     // There are no logs left to send, so start creating a new one.
     client_->CollectFinalMetricsForLog(
         base::Bind(&MetricsService::OnFinalLogInfoCollectionDone,
@@ skipping 46 matching lines @@
     DCHECK_EQ(SENDING_LOGS, state_);
   if (!reporting_active()) {
     if (upload_scheduler_) {
       upload_scheduler_->StopAndUploadCancelled();
     } else {
       scheduler_->Stop();
       scheduler_->UploadCancelled();
     }
     return;
   }
-  if (!log_manager_.has_unsent_logs()) {
+  if (!log_store_.has_unsent_logs()) {
     // Should only get here if serializing the log failed somehow.
     if (upload_scheduler_) {
       upload_scheduler_->Stop();
       // Reset backoff interval
       upload_scheduler_->UploadFinished(true);
     } else {
       // Just tell the scheduler it was uploaded and wait for the next log
       // interval.
-      scheduler_->UploadFinished(true, log_manager_.has_unsent_logs());
+      scheduler_->UploadFinished(true, log_store_.has_unsent_logs());
     }
     return;
   }
-  if (!log_manager_.has_staged_log())
-    log_manager_.StageNextLogForUpload();
+  if (!log_store_.has_staged_log())
+    log_store_.StageNextLog();
 
   // Proceed to stage the log for upload if log size satisfies cellular log
   // upload constrains.
   bool upload_canceled = false;
   bool is_cellular_logic = client_->IsUMACellularUploadLogicEnabled();
   if (is_cellular_logic && data_use_tracker_ &&
       !data_use_tracker_->ShouldUploadLogOnCellular(
-          log_manager_.staged_log_hash().size())) {
+          log_store_.staged_log_hash().size())) {
     if (upload_scheduler_) {
       upload_scheduler_->UploadOverDataUsageCap();
     } else {
       scheduler_->UploadCancelled();
     }
     upload_canceled = true;
   } else {
     SendStagedLog();
   }
   if (is_cellular_logic) {
@@ skipping 37 matching lines @@
   // Note: Some stability providers may record stability stats via histograms,
   //       so this call has to be after BeginLoggingWithLog().
   log_manager_.current_log()->RecordStabilityMetrics(
       metrics_providers_, base::TimeDelta(), base::TimeDelta());
   RecordCurrentStabilityHistograms();
 
   // Note: RecordGeneralMetrics() intentionally not called since this log is for
   //       stability stats from a previous session only.
 
   DVLOG(1) << "Generated an stability log.";
-  log_manager_.FinishCurrentLog();
+  log_manager_.FinishCurrentLog(&log_store_);
   log_manager_.ResumePausedLog();
 
   // Store unsent logs, including the stability log that was just saved, so
   // that they're not lost in case of a crash before upload time.
-  log_manager_.PersistUnsentLogs();
+  log_store_.PersistUnsentLogs();
 
   return true;
 }
 
 void MetricsService::PrepareInitialMetricsLog() {
   DCHECK_EQ(INIT_TASK_DONE, state_);
 
   RecordCurrentEnvironment(initial_metrics_log_.get());
   base::TimeDelta incremental_uptime;
   base::TimeDelta uptime;
   GetUptimes(local_state_, &incremental_uptime, &uptime);
 
   // Histograms only get written to the current log, so make the new log current
   // before writing them.
   log_manager_.PauseCurrentLog();
   log_manager_.BeginLoggingWithLog(std::move(initial_metrics_log_));
 
   // Note: Some stability providers may record stability stats via histograms,
   //       so this call has to be after BeginLoggingWithLog().
   MetricsLog* current_log = log_manager_.current_log();
   current_log->RecordStabilityMetrics(metrics_providers_, base::TimeDelta(),
                                       base::TimeDelta());
   current_log->RecordGeneralMetrics(metrics_providers_);
   RecordCurrentHistograms();
 
   DVLOG(1) << "Generated an initial log.";
-  log_manager_.FinishCurrentLog();
+  log_manager_.FinishCurrentLog(&log_store_);
   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();
+  log_store_.PersistUnsentLogs();
 
   state_ = SENDING_LOGS;
 }
 
 void MetricsService::SendStagedLog() {
-  DCHECK(log_manager_.has_staged_log());
-  if (!log_manager_.has_staged_log())
+  DCHECK(log_store_.has_staged_log());
+  if (!log_store_.has_staged_log())
     return;
 
   DCHECK(!log_upload_in_progress_);
   log_upload_in_progress_ = true;
 
   if (!log_uploader_) {
     log_uploader_ = client_->CreateUploader(
         client_->GetMetricsServerUrl(),
         metrics::kDefaultMetricsMimeType,
         base::Bind(&MetricsService::OnLogUploadComplete,
                    self_ptr_factory_.GetWeakPtr()));
   }
-  const std::string hash =
-      base::HexEncode(log_manager_.staged_log_hash().data(),
-                      log_manager_.staged_log_hash().size());
-  log_uploader_->UploadLog(log_manager_.staged_log(), hash);
+  const std::string hash = base::HexEncode(log_store_.staged_log_hash().data(),
+                                           log_store_.staged_log_hash().size());
+  log_uploader_->UploadLog(log_store_.staged_log(), hash);
 
   if (!upload_scheduler_)
     HandleIdleSinceLastTransmission(true);
 }
 
 
 void MetricsService::OnLogUploadComplete(int response_code) {
   DVLOG(1) << "OnLogUploadComplete:" << response_code;
   if (!upload_scheduler_)
     DCHECK_EQ(SENDING_LOGS, state_);
   DCHECK(log_upload_in_progress_);
   log_upload_in_progress_ = false;
 
   // Log a histogram to track response success vs. failure rates.
   UMA_HISTOGRAM_ENUMERATION("UMA.UploadResponseStatus.Protobuf",
                             ResponseCodeToStatus(response_code),
                             NUM_RESPONSE_STATUSES);
 
   bool upload_succeeded = response_code == 200;
 
   // Provide boolean for error recovery (allow us to ignore response_code).
   bool discard_log = false;
-  const size_t log_size = log_manager_.staged_log().length();
+  const size_t log_size = log_store_.staged_log().length();
   if (upload_succeeded) {
     UMA_HISTOGRAM_COUNTS_10000("UMA.LogSize.OnSuccess", log_size / 1024);
   } else if (log_size > kUploadLogAvoidRetransmitSize) {
     UMA_HISTOGRAM_COUNTS("UMA.Large Rejected Log was Discarded",
                          static_cast<int>(log_size));
     discard_log = true;
   } else if (response_code == 400) {
     // Bad syntax.  Retransmission won't work.
     discard_log = true;
   }
 
   if (upload_succeeded || discard_log) {
-    log_manager_.DiscardStagedLog();
+    log_store_.DiscardStagedLog();
     // Store the updated list to disk now that the removed log is uploaded.
-    log_manager_.PersistUnsentLogs();
+    log_store_.PersistUnsentLogs();
   }
 
   // Error 400 indicates a problem with the log, not with the server, so
   // don't consider that a sign that the server is in trouble.
   bool server_is_healthy = upload_succeeded || response_code == 400;
   if (upload_scheduler_) {
-    if (!log_manager_.has_unsent_logs()) {
+    if (!log_store_.has_unsent_logs()) {
       DVLOG(1) << "Stopping upload_scheduler_";
       upload_scheduler_->Stop();
     }
     upload_scheduler_->UploadFinished(server_is_healthy);
   } else {
-    scheduler_->UploadFinished(server_is_healthy,
-                               log_manager_.has_unsent_logs());
+    scheduler_->UploadFinished(server_is_healthy, log_store_.has_unsent_logs());
   }
 }
 
 void MetricsService::IncrementLongPrefsValue(const char* path) {
   int64_t value = local_state_->GetInt64(path);
   local_state_->SetInt64(path, value + 1);
 }
 
 bool MetricsService::UmaMetricsProperlyShutdown() {
   CHECK(clean_shutdown_status_ == CLEANLY_SHUTDOWN ||
@@ skipping 138 matching lines @@
   // Redundant setting to assure that we always reset this value at shutdown
   // (and that we don't use some alternate path, and not call LogCleanShutdown).
   clean_shutdown_status_ = CLEANLY_SHUTDOWN;
   client_->OnLogCleanShutdown();
   clean_exit_beacon_.WriteBeaconValue(true);
   SetExecutionPhase(ExecutionPhase::SHUTDOWN_COMPLETE, local_state_);
   StabilityMetricsProvider(local_state_).MarkSessionEndCompleted(end_completed);
 }
 
 }  // namespace metrics