Instrumentation to debug actions memory leak.

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 230 matching lines @@
 }
 
 void MetricsService::InitializeMetricsRecordingState() {
   reporting_service_.Initialize();
   InitializeMetricsState();
 
   base::Closure upload_callback =
       base::Bind(&MetricsService::StartScheduledUpload,
                  self_ptr_factory_.GetWeakPtr());
 
+  UMA_HISTOGRAM_BOOLEAN("UMA.Dbg.InitiateRecording", true);
   rotation_scheduler_.reset(new MetricsRotationScheduler(
       upload_callback,
       // MetricsServiceClient outlives MetricsService, and
       // MetricsRotationScheduler is tied to the lifetime of |this|.
       base::Bind(&MetricsServiceClient::GetStandardUploadInterval,
                  base::Unretained(client_))));
 
   for (auto& provider : metrics_providers_)
     provider->Init();
 }
 
 void MetricsService::Start() {
+  UMA_HISTOGRAM_BOOLEAN("UMA.Dbg.MetricsService.Start", true);
   HandleIdleSinceLastTransmission(false);
   EnableRecording();
   EnableReporting();
 }
 
 void MetricsService::StartRecordingForTests() {
   test_mode_active_ = true;
   EnableRecording();
   DisableReporting();
 }
 
 void MetricsService::Stop() {
   HandleIdleSinceLastTransmission(false);
   DisableReporting();
   DisableRecording();
 }
 
 void MetricsService::EnableReporting() {
   if (reporting_service_.reporting_active())
     return;
+  UMA_HISTOGRAM_BOOLEAN("UMA.Dbg.EnableReporting", true);
   reporting_service_.EnableReporting();
   StartSchedulerIfNecessary();
 }
 
 void MetricsService::DisableReporting() {
   reporting_service_.DisableReporting();
 }
 
 std::string MetricsService::GetClientId() {
   return state_manager_->client_id();
 }
 
 int64_t MetricsService::GetInstallDate() {
   return local_state_->GetInt64(prefs::kInstallDate);
 }
 
 int64_t MetricsService::GetMetricsReportingEnabledDate() {
   return local_state_->GetInt64(prefs::kMetricsReportingEnabledTimestamp);
 }
 
 bool MetricsService::WasLastShutdownClean() const {
   return clean_exit_beacon_.exited_cleanly();
 }
 
 void MetricsService::EnableRecording() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (recording_state_ == ACTIVE)
     return;
+  UMA_HISTOGRAM_BOOLEAN("UMA.Dbg.EnableRecording", true);
   recording_state_ = ACTIVE;
 
   state_manager_->ForceClientIdCreation();
   client_->SetMetricsClientId(state_manager_->client_id());
   if (!log_manager_.current_log())
     OpenNewLog();
 
   for (auto& provider : metrics_providers_)
     provider->OnRecordingEnabled();
 
@@ skipping 285 matching lines @@
   for (auto& provider : metrics_providers_)
     provider->OnDidCreateMetricsLog();
 }
 
 
 //------------------------------------------------------------------------------
 // Recording control methods
 
 void MetricsService::OpenNewLog() {
   DCHECK(!log_manager_.current_log());
+  UMA_HISTOGRAM_BOOLEAN("UMA.Dbg.OpenNewLog", true);
 
   log_manager_.BeginLoggingWithLog(CreateLog(MetricsLog::ONGOING_LOG));
   NotifyOnDidCreateMetricsLog();
   if (state_ == INITIALIZED) {
     // We only need to schedule that run once.
     state_ = INIT_TASK_SCHEDULED;
 
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&MetricsService::StartInitTask,
                               self_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromSeconds(kInitializationDelaySeconds));
 
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&MetricsService::PrepareProviderMetricsTask,
                    self_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromSeconds(2 * kInitializationDelaySeconds));
   }
 }
 
 void MetricsService::StartInitTask() {
   client_->InitializeSystemProfileMetrics(
       base::Bind(&MetricsService::FinishedInitTask,
                  self_ptr_factory_.GetWeakPtr()));
 }
 
 void MetricsService::CloseCurrentLog() {
   if (!log_manager_.current_log())
     return;
+  UMA_HISTOGRAM_BOOLEAN("UMA.Dbg.CloseCurrentLog", true);
 
   // If a persistent allocator is in use, update its internal histograms (such
   // as how much memory is being used) before reporting.
   base::PersistentHistogramAllocator* allocator =
       base::GlobalHistogramAllocator::Get();
   if (allocator)
     allocator->UpdateTrackingHistograms();
 
   // Put incremental data (histogram deltas, and realtime stats deltas) at the
   // end of all log transmissions (initial log handles this separately).
@@ skipping 141 matching lines @@
 
   // 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_store()->PersistUnsentLogs();
 
   return true;
 }
 
 void MetricsService::PrepareInitialMetricsLog() {
   DCHECK_EQ(INIT_TASK_DONE, state_);
+  UMA_HISTOGRAM_BOOLEAN("UMA.Dbg.PrepareInitialMetricsLog", true);
 
   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_));
@@ skipping 196 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