Log histograms on shutdown when verbose logging is on

base/metrics/statistics_recorder.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.
 
 #include "base/metrics/statistics_recorder.h"
 
 #include "base/at_exit.h"
 #include "base/debug/leak_annotations.h"
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/metrics_hashes.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/values.h"
 
 namespace {
 
 // Initialize histogram statistics gathering system.
 base::LazyInstance<base::StatisticsRecorder>::Leaky g_statistics_recorder_ =
     LAZY_INSTANCE_INITIALIZER;
 
+bool g_vlog_initialized = false;

[Alexei Svitkine (slow), 2016/04/14 20:47:39]

Can this just be a member of the StatisticsRecorder?

+
 bool HistogramNameLesser(const base::HistogramBase* a,
                          const base::HistogramBase* b) {
   return a->histogram_name() < b->histogram_name();
 }
 
 }  // namespace
 
 namespace base {
 
 StatisticsRecorder::HistogramIterator::HistogramIterator(
@@ skipping 256 matching lines @@
     bool include_persistent) {
   return HistogramIterator(histograms_->begin(), include_persistent);
 }
 
 // static
 StatisticsRecorder::HistogramIterator StatisticsRecorder::end() {
   return HistogramIterator(histograms_->end(), true);
 }
 
 // static
+void StatisticsRecorder::InitLogOnShutdown() {
+  if (lock_ == nullptr)
+    return;
+  base::AutoLock auto_lock(*lock_);
+  g_statistics_recorder_.Get().InitLogOnShutdownWithoutLock();
+}
+
+// static
+bool StatisticsRecorder::VLogInitializedForTesting() {
+  return g_vlog_initialized;
+}
+
+// static
 void StatisticsRecorder::GetSnapshot(const std::string& query,
                                      Histograms* snapshot) {
   if (lock_ == NULL)
     return;
   base::AutoLock auto_lock(*lock_);
   if (histograms_ == NULL)
     return;
 
   for (const auto& entry : *histograms_) {
     if (entry.second->histogram_name().find(query) != std::string::npos)
@@ skipping 81 matching lines @@
     // during the termination phase. Since it's a static data member, we will
     // leak one per process, which would be similar to the instance allocated
     // during static initialization and released only on  process termination.
     lock_ = new base::Lock;
   }
   base::AutoLock auto_lock(*lock_);
   histograms_ = new HistogramMap;
   callbacks_ = new CallbackMap;
   ranges_ = new RangesMap;
 
-  if (VLOG_IS_ON(1))
-    AtExitManager::RegisterCallback(&DumpHistogramsToVlog, this);
+  InitLogOnShutdownWithoutLock();
 }
 
 StatisticsRecorder::~StatisticsRecorder() {
   DCHECK(histograms_ && ranges_ && lock_);
 
   // Global clean up.
   Reset();
 }
 
+void StatisticsRecorder::InitLogOnShutdownWithoutLock() {
+  if (!g_vlog_initialized && VLOG_IS_ON(1)) {
+    g_vlog_initialized = true;
+    AtExitManager::RegisterCallback(&DumpHistogramsToVlog, this);
+  }
+}
+
 // static
 void StatisticsRecorder::Reset() {
   // If there's no lock then there is nothing to reset.
   if (!lock_)
     return;
 
   scoped_ptr<HistogramMap> histograms_deleter;
   scoped_ptr<CallbackMap> callbacks_deleter;
   scoped_ptr<RangesMap> ranges_deleter;
   // We don't delete lock_ on purpose to avoid having to properly protect
@@ skipping 21 matching lines @@
 // static
 StatisticsRecorder::HistogramMap* StatisticsRecorder::histograms_ = NULL;
 // static
 StatisticsRecorder::CallbackMap* StatisticsRecorder::callbacks_ = NULL;
 // static
 StatisticsRecorder::RangesMap* StatisticsRecorder::ranges_ = NULL;
 // static
 base::Lock* StatisticsRecorder::lock_ = NULL;
 
 }  // namespace base