Support "shared" histograms between processes.

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 115 matching lines @@
 
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/metrics/histogram_persistence.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 92 matching lines @@
 
   int probability;
   // In case specified sampling rate is invalid.
   if (!base::StringToInt(probability_str, &probability))
     return true;
   return base::RandInt(1, 100) <= probability;
 }
 
 }  // namespace
 
+MetricsService::PersistentHistogramIterator::PersistentHistogramIterator(
+    AllocatorSet& allocators,
+    AllocatorSet::iterator pos)
+    : allocators_(allocators),
+      allocator_iter_(pos) {
+  if (pos != allocators_.end()) {
+    (*allocator_iter_)->CreateIterator(&histogram_iter_);
+    // Have to call ++ to advance iterator to the first persistent histogram.
+    operator++();
+  }
+}
+
+MetricsService::PersistentHistogramIterator&
+MetricsService::PersistentHistogramIterator::operator++() {
+  if (allocator_iter_ != allocators_.end()) {
+    for (;;) {
+      base::HistogramBase* h = base::GetNextPersistentHistogram(
+          *allocator_iter_, &histogram_iter_);
+      if (h) {
+        current_histogram_ = new HistogramPointer(h);
+        break;
+      }
+      allocator_iter_++;
+      if (allocator_iter_ == allocators_.end()) {
+        histogram_iter_.clear();  // Clear so it matches end() iterator.
+        current_histogram_ = nullptr;
+        break;
+      }
+      (*allocator_iter_)->CreateIterator(&histogram_iter_);
+    }
+  }
+  return *this;
+}
+
 // static
 MetricsService::ShutdownCleanliness MetricsService::clean_shutdown_status_ =
     MetricsService::CLEANLY_SHUTDOWN;
 
 MetricsService::ExecutionPhase MetricsService::execution_phase_ =
     MetricsService::UNINITIALIZED_PHASE;
 
 // static
 void MetricsService::RegisterPrefs(PrefRegistrySimple* registry) {
   DCHECK(IsSingleThreaded());
@@ skipping 276 matching lines @@
                            UNINITIALIZED_PHASE);
   local_state_->SetInteger(prefs::kStabilityIncompleteSessionEndCount, 0);
   local_state_->SetInteger(prefs::kStabilityLaunchCount, 0);
   local_state_->SetBoolean(prefs::kStabilitySessionEndCompleted, true);
 }
 
 void MetricsService::PushExternalLog(const std::string& log) {
   log_manager_.StoreLog(log, MetricsLog::ONGOING_LOG);
 }
 
+void MetricsService::AddPersistentMemorySegment(
+    base::PersistentMemoryAllocator* allocator) {
+  DCHECK(allocators_.find(allocator) == allocators_.end());
+  allocators_.insert(allocator);
+}
+
+void MetricsService::RemovePersistentMemorySegment(
+    base::PersistentMemoryAllocator* allocator) {
+  DCHECK(allocators_.find(allocator) != allocators_.end());
+  allocators_.erase(allocator);
+}
+
 //------------------------------------------------------------------------------
 // private methods
 //------------------------------------------------------------------------------
 
 
 //------------------------------------------------------------------------------
 // Initialization methods
 
 void MetricsService::InitializeMetricsState() {
   const int64_t buildtime = MetricsLog::GetBuildTime();
@@ skipping 179 matching lines @@
 
   // TODO(jar): Integrate bounds on log recording more consistently, so that we
   // can stop recording logs that are too big much sooner.
   if (log_manager_.current_log()->num_events() > kEventLimit) {
     UMA_HISTOGRAM_COUNTS("UMA.Discarded Log Events",
                          log_manager_.current_log()->num_events());
     log_manager_.DiscardCurrentLog();
     OpenNewLog();  // Start trivial log to hold our histograms.
   }
 
+  base::PersistentMemoryAllocator* allocator =
+      base::GetPersistentHistogramMemoryAllocator();
+  if (allocator)
+    allocator->UpdateStaticHistograms();
+
   // 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);
@@ skipping 340 matching lines @@
 void MetricsService::RecordCurrentEnvironment(MetricsLog* log) {
   std::vector<variations::ActiveGroupId> synthetic_trials;
   GetSyntheticFieldTrialsOlderThan(log->creation_time(), &synthetic_trials);
   log->RecordEnvironment(metrics_providers_.get(), synthetic_trials,
                          GetInstallDate(), GetMetricsReportingEnabledDate());
 }
 
 void MetricsService::RecordCurrentHistograms() {
   DCHECK(log_manager_.current_log());
   histogram_snapshot_manager_.PrepareDeltas(
+      base::StatisticsRecorder::begin(true), base::StatisticsRecorder::end(),
+      base::Histogram::kNoFlags, base::Histogram::kUmaTargetedHistogramFlag);
+  histogram_snapshot_manager_.PrepareDeltas(
+      persistent_begin(), persistent_end(),
       base::Histogram::kNoFlags, base::Histogram::kUmaTargetedHistogramFlag);
 }
 
 void MetricsService::RecordCurrentStabilityHistograms() {
   DCHECK(log_manager_.current_log());
   histogram_snapshot_manager_.PrepareDeltas(
+      base::StatisticsRecorder::begin(true), base::StatisticsRecorder::end(),
       base::Histogram::kNoFlags, base::Histogram::kUmaStabilityHistogramFlag);
 }
 
 void MetricsService::LogCleanShutdown() {
   // 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;
 
   clean_exit_beacon_.WriteBeaconValue(true);
   RecordCurrentState(local_state_);
@@ skipping 18 matching lines @@
   pref->SetInt64(prefs::kStabilityLastTimestampSec,
                  base::Time::Now().ToTimeT());
 }
 
 void MetricsService::SkipAndDiscardUpload() {
   log_manager_.DiscardStagedLog();
   scheduler_->UploadCancelled();
   log_upload_in_progress_ = false;
 }
 
+MetricsService::PersistentHistogramIterator MetricsService::persistent_begin() {
+  return PersistentHistogramIterator(allocators_, allocators_.begin());
+}
+
+MetricsService::PersistentHistogramIterator MetricsService::persistent_end() {
+  return PersistentHistogramIterator(allocators_, allocators_.end());
+}
+
 }  // namespace metrics