Remove ScopedVector in //component/metrics

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 305 matching lines @@
     upload_scheduler_.reset(new MetricsUploadScheduler(send_next_log_callback));
   } else {
     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_))));
   }
 
-  for (MetricsProvider* provider : metrics_providers_)
+  for (auto& provider : metrics_providers_)
     provider->Init();
 }
 
 void MetricsService::Start() {
   HandleIdleSinceLastTransmission(false);
   EnableRecording();
   EnableReporting();
 }
 
 void MetricsService::StartRecordingForTests() {
@@ skipping 40 matching lines @@
 
   if (recording_state_ == ACTIVE)
     return;
   recording_state_ = ACTIVE;
 
   state_manager_->ForceClientIdCreation();
   client_->SetMetricsClientId(state_manager_->client_id());
   if (!log_manager_.current_log())
     OpenNewLog();
 
-  for (MetricsProvider* provider : metrics_providers_)
+  for (auto& provider : metrics_providers_)
     provider->OnRecordingEnabled();
 
   base::RemoveActionCallback(action_callback_);
   action_callback_ = base::Bind(&MetricsService::OnUserAction,
                                 base::Unretained(this));
   base::AddActionCallback(action_callback_);
 }
 
 void MetricsService::DisableRecording() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (recording_state_ == INACTIVE)
     return;
   recording_state_ = INACTIVE;
 
   base::RemoveActionCallback(action_callback_);
 
-  for (MetricsProvider* provider : metrics_providers_)
+  for (auto& provider : metrics_providers_)
     provider->OnRecordingDisabled();
 
   PushPendingLogsToPersistentStorage();
 }
 
 bool MetricsService::recording_active() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return recording_state_ == ACTIVE;
 }
 
@@ skipping 53 matching lines @@
     rotation_scheduler_->Stop();
     upload_scheduler_->Stop();
   } else {
     scheduler_->Stop();
   }
 
   MarkAppCleanShutdownAndCommit(&clean_exit_beacon_, local_state_);
 
   // Give providers a chance to persist histograms as part of being
   // backgrounded.
-  for (MetricsProvider* provider : metrics_providers_)
+  for (auto& provider : metrics_providers_)
     provider->OnAppEnterBackground();
 
   // At this point, there's no way of knowing when the process will be
   // killed, so this has to be treated similar to a shutdown, closing and
   // persisting all logs. Unlinke a shutdown, the state is primed to be ready
   // to continue logging and uploading if the process does return.
   if (recording_active() && state_ >= SENDING_LOGS) {
     PushPendingLogsToPersistentStorage();
     // Persisting logs closes the current log, so start recording a new log
     // immediately to capture any background work that might be done before the
@@ skipping 29 matching lines @@
 }
 
 void MetricsService::RecordBreakpadHasDebugger(bool has_debugger) {
   if (!has_debugger)
     IncrementPrefValue(prefs::kStabilityDebuggerNotPresent);
   else
     IncrementPrefValue(prefs::kStabilityDebuggerPresent);
 }
 
 void MetricsService::ClearSavedStabilityMetrics() {
-  for (MetricsProvider* provider : metrics_providers_)
+  for (auto& provider : metrics_providers_)
     provider->ClearSavedStabilityMetrics();
 
   // Reset the prefs that are managed by MetricsService/MetricsLog directly.
   local_state_->SetInteger(prefs::kStabilityBreakpadRegistrationSuccess, 0);
   local_state_->SetInteger(prefs::kStabilityBreakpadRegistrationFail, 0);
   local_state_->SetInteger(prefs::kStabilityCrashCount, 0);
   local_state_->SetInteger(prefs::kStabilityDebuggerPresent, 0);
   local_state_->SetInteger(prefs::kStabilityDebuggerNotPresent, 0);
   local_state_->SetInteger(prefs::kStabilityIncompleteSessionEndCount, 0);
   local_state_->SetInteger(prefs::kStabilityLaunchCount, 0);
@@ skipping 167 matching lines @@
   const int64_t incremental_time_secs = incremental_uptime->InSeconds();
   if (incremental_time_secs > 0) {
     int64_t metrics_uptime = pref->GetInt64(prefs::kUninstallMetricsUptimeSec);
     metrics_uptime += incremental_time_secs;
     pref->SetInt64(prefs::kUninstallMetricsUptimeSec, metrics_uptime);
   }
 }
 
 void MetricsService::NotifyOnDidCreateMetricsLog() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  for (MetricsProvider* provider : metrics_providers_)
+  for (auto& provider : metrics_providers_)
     provider->OnDidCreateMetricsLog();
 }
 
 
 //------------------------------------------------------------------------------
 // Recording control methods
 
 void MetricsService::OpenNewLog() {
   DCHECK(!log_manager_.current_log());
 
@@ skipping 40 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 = log_manager_.current_log();
   DCHECK(current_log);
   RecordCurrentEnvironment(current_log);
   base::TimeDelta incremental_uptime;
   base::TimeDelta uptime;
   GetUptimes(local_state_, &incremental_uptime, &uptime);
-  current_log->RecordStabilityMetrics(metrics_providers_.get(),
-                                      incremental_uptime, uptime);
+  current_log->RecordStabilityMetrics(metrics_providers_, incremental_uptime,
+                                      uptime);
 
-  current_log->RecordGeneralMetrics(metrics_providers_.get());
+  current_log->RecordGeneralMetrics(metrics_providers_);
   RecordCurrentHistograms();
   DVLOG(1) << "Generated an ongoing log.";
   log_manager_.FinishCurrentLog();
 }
 
 void MetricsService::PushPendingLogsToPersistentStorage() {
   if (state_ < SENDING_LOGS)
     return;  // We didn't and still don't have time to get plugin list etc.
 
   CloseCurrentLog();
@@ skipping 153 matching lines @@
                           upload_canceled);
   }
 }
 
 bool MetricsService::ProvidersHaveInitialStabilityMetrics() {
   // Check whether any metrics provider has initial stability metrics.
   // All providers are queried (rather than stopping after the first "true"
   // response) in case they do any kind of setup work in preparation for
   // the later call to RecordInitialHistogramSnapshots().
   bool has_stability_metrics = false;
-  for (MetricsProvider* provider : metrics_providers_)
+  for (auto& provider : metrics_providers_)
     has_stability_metrics |= provider->HasInitialStabilityMetrics();
 
   return has_stability_metrics;
 }
 
 bool MetricsService::PrepareInitialStabilityLog(
     const std::string& prefs_previous_version) {
   DCHECK_EQ(INITIALIZED, state_);
 
   std::unique_ptr<MetricsLog> initial_stability_log(
       CreateLog(MetricsLog::INITIAL_STABILITY_LOG));
 
   // Do not call NotifyOnDidCreateMetricsLog here because the stability
   // log describes stats from the _previous_ session.
   std::string system_profile_app_version;
   if (!initial_stability_log->LoadSavedEnvironmentFromPrefs(
           &system_profile_app_version)) {
     return false;
   }
   if (system_profile_app_version != prefs_previous_version)
     IncrementPrefValue(prefs::kStabilityVersionMismatchCount);
 
   log_manager_.PauseCurrentLog();
   log_manager_.BeginLoggingWithLog(std::move(initial_stability_log));
 
   // 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_.get(), base::TimeDelta(), base::TimeDelta());
+      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_.ResumePausedLog();
 
   // Store unsent logs, including the stability log that was just saved, so
@@ skipping 12 matching lines @@
   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_.get(),
-                                      base::TimeDelta(), base::TimeDelta());
-  current_log->RecordGeneralMetrics(metrics_providers_.get());
+  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_.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();
 
@@ skipping 186 matching lines @@
     MetricsLog::LogType log_type) {
   return base::MakeUnique<MetricsLog>(state_manager_->client_id(), session_id_,
                                       log_type, client_, local_state_);
 }
 
 void MetricsService::RecordCurrentEnvironment(MetricsLog* log) {
   DCHECK(client_);
   std::vector<variations::ActiveGroupId> synthetic_trials;
   GetSyntheticFieldTrialsOlderThan(log->creation_time(), &synthetic_trials);
   std::string serialized_environment = log->RecordEnvironment(
-      metrics_providers_.get(), synthetic_trials, GetInstallDate(),
+      metrics_providers_, synthetic_trials, GetInstallDate(),
       GetMetricsReportingEnabledDate());
   client_->OnEnvironmentUpdate(&serialized_environment);
 }
 
 void MetricsService::RecordCurrentHistograms() {
   DCHECK(log_manager_.current_log());
   SCOPED_UMA_HISTOGRAM_TIMER("UMA.MetricsService.RecordCurrentHistograms.Time");
 
   // "true" to the begin() call indicates that StatisticsRecorder should include
   // histograms held in persistent storage.
   histogram_snapshot_manager_.PrepareDeltas(
       base::StatisticsRecorder::begin(true), base::StatisticsRecorder::end(),
       base::Histogram::kNoFlags, base::Histogram::kUmaTargetedHistogramFlag);
-  for (MetricsProvider* provider : metrics_providers_)
+  for (auto& provider : metrics_providers_)
     provider->RecordHistogramSnapshots(&histogram_snapshot_manager_);
 }
 
 void MetricsService::RecordCurrentStabilityHistograms() {
   DCHECK(log_manager_.current_log());
   // "true" indicates that StatisticsRecorder should include histograms in
   // persistent storage.
   histogram_snapshot_manager_.PrepareDeltas(
       base::StatisticsRecorder::begin(true), base::StatisticsRecorder::end(),
       base::Histogram::kNoFlags, base::Histogram::kUmaStabilityHistogramFlag);
-  for (MetricsProvider* provider : metrics_providers_)
+  for (auto& provider : metrics_providers_)
     provider->RecordInitialHistogramSnapshots(&histogram_snapshot_manager_);
 }
 
 void MetricsService::LogCleanShutdown(bool end_completed) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // 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_);
   local_state_->SetBoolean(prefs::kStabilitySessionEndCompleted, end_completed);
 }
 
 }  // namespace metrics