Merge histograms from providers into StatisticsRecorder for display.

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 <memory>
 
 #include "base/at_exit.h"
 #include "base/debug/leak_annotations.h"
@@ skipping 69 matching lines @@
 StatisticsRecorder::~StatisticsRecorder() {
   DCHECK(histograms_);
   DCHECK(ranges_);
 
   // Clean out what this object created and then restore what existed before.
   Reset();
   base::AutoLock auto_lock(lock_.Get());
   histograms_ = existing_histograms_.release();
   callbacks_ = existing_callbacks_.release();
   ranges_ = existing_ranges_.release();
+  providers_ = existing_providers_.release();
 }
 
 // static
 void StatisticsRecorder::Initialize() {
   // Tests sometimes create local StatisticsRecorders in order to provide a
   // contained environment of histograms that can be later discarded. If a
   // true global instance gets created in this environment then it will
   // eventually get disconnected when the local instance destructs and
   // restores the previous state, resulting in no StatisticsRecorder at all.
   // The global lazy instance, however, will remain valid thus ensuring that
   // another never gets installed via this method. If a |histograms_| map
   // exists then assume the StatisticsRecorder is already "initialized".
   if (histograms_)
     return;
 
   // Ensure that an instance of the StatisticsRecorder object is created.
   g_statistics_recorder_.Get();
 }
 
 // static
 bool StatisticsRecorder::IsActive() {
   base::AutoLock auto_lock(lock_.Get());
   return histograms_ != nullptr;
 }
 
 // static
+void StatisticsRecorder::RegisterHistogramProvider(
+    const WeakPtr<HistogramProvider>& provider) {
+  providers_->push_back(provider);
+}
+
+// static
 HistogramBase* StatisticsRecorder::RegisterOrDeleteDuplicate(
     HistogramBase* histogram) {
   HistogramBase* histogram_to_delete = nullptr;
   HistogramBase* histogram_to_return = nullptr;
   {
     base::AutoLock auto_lock(lock_.Get());
     if (!histograms_) {
       histogram_to_return = histogram;
 
       // As per crbug.com/79322 the histograms are intentionally leaked, so we
@@ skipping 174 matching lines @@
   if (!histograms_)
     return nullptr;
 
   HistogramMap::iterator it = histograms_->find(name);
   if (histograms_->end() == it)
     return nullptr;
   return it->second;
 }
 
 // static
+void StatisticsRecorder::ImportProvidedHistograms() {

[Alexei Svitkine (slow), 2017/01/27 16:22:03]

Can you add a thread check here?

[bcwhite, 2017/01/27 18:05:31]

Not sure if I can because base/ doesn't generally know about specific threads.

The providers, though, have thread-checkers that will break if not called on the
UI thread.

[Alexei Svitkine (slow), 2017/01/27 18:06:57]

Can you add base::ThreadChecker as a member and use
DCHECK(thread_checker_.CalledOnValidThread()) ?

[bcwhite, 2017/01/27 18:12:57]

These are static methods so there's no object to hold the thread_checker_.  A
static one could be created like the other static objects are, but I don't think
it's worth the complication.

+  if (!providers_)
+    return;
+
+  // Merge histogram data from each provider in turn.
+  for (const WeakPtr<HistogramProvider>& provider : *providers_) {
+    if (provider)

[Alexei Svitkine (slow), 2017/01/27 16:22:03]

Nit: Maybe add a comment here to mention this is check is because the weak
pointer may have been invalidated.

[bcwhite, 2017/01/27 18:05:31]

Done.

+      provider->MergeHistogramDeltas();
+  }
+}
+
+// static
 StatisticsRecorder::HistogramIterator StatisticsRecorder::begin(
     bool include_persistent) {
   DCHECK(histograms_);
   ImportGlobalPersistentHistograms();
 
   HistogramMap::iterator iter_begin;
   {
     base::AutoLock auto_lock(lock_.Get());
     iter_begin = histograms_->begin();
   }
@@ skipping 19 matching lines @@
   g_statistics_recorder_.Get().InitLogOnShutdownWithoutLock();
 }
 
 // static
 void StatisticsRecorder::GetSnapshot(const std::string& query,
                                      Histograms* snapshot) {
   base::AutoLock auto_lock(lock_.Get());
   if (!histograms_)
     return;
 
+  ImportGlobalPersistentHistograms();
+
   for (const auto& entry : *histograms_) {
     if (entry.second->histogram_name().find(query) != std::string::npos)
       snapshot->push_back(entry.second);
   }
 }
 
 // static
 bool StatisticsRecorder::SetCallback(
     const std::string& name,
     const StatisticsRecorder::OnSampleCallback& cb) {
@@ skipping 92 matching lines @@
 
 // This singleton instance should be started during the single threaded portion
 // of main(), and hence it is not thread safe.  It initializes globals to
 // provide support for all future calls.
 StatisticsRecorder::StatisticsRecorder() {
   base::AutoLock auto_lock(lock_.Get());
 
   existing_histograms_.reset(histograms_);
   existing_callbacks_.reset(callbacks_);
   existing_ranges_.reset(ranges_);
+  existing_providers_.reset(providers_);
 
   histograms_ = new HistogramMap;
   callbacks_ = new CallbackMap;
   ranges_ = new RangesMap;
+  providers_ = new HistogramProviders;
 
   InitLogOnShutdownWithoutLock();
 }
 
 void StatisticsRecorder::InitLogOnShutdownWithoutLock() {
   if (!vlog_initialized_ && VLOG_IS_ON(1)) {
     vlog_initialized_ = true;
     AtExitManager::RegisterCallback(&DumpHistogramsToVlog, this);
   }
 }
 
 // static
 void StatisticsRecorder::Reset() {
 
   std::unique_ptr<HistogramMap> histograms_deleter;
   std::unique_ptr<CallbackMap> callbacks_deleter;
   std::unique_ptr<RangesMap> ranges_deleter;
+  std::unique_ptr<HistogramProviders> providers_deleter;
   {
     base::AutoLock auto_lock(lock_.Get());
     histograms_deleter.reset(histograms_);
     callbacks_deleter.reset(callbacks_);
     ranges_deleter.reset(ranges_);
+    providers_deleter.reset(providers_);
     histograms_ = nullptr;
     callbacks_ = nullptr;
     ranges_ = nullptr;
+    providers_ = nullptr;
   }
   // We are going to leak the histograms and the ranges.
 }
 
 // static
 void StatisticsRecorder::DumpHistogramsToVlog(void* instance) {
   std::string output;
   StatisticsRecorder::WriteGraph(std::string(), &output);
   VLOG(1) << output;
 }
 
 
 // static
 StatisticsRecorder::HistogramMap* StatisticsRecorder::histograms_ = nullptr;
 // static
 StatisticsRecorder::CallbackMap* StatisticsRecorder::callbacks_ = nullptr;
 // static
 StatisticsRecorder::RangesMap* StatisticsRecorder::ranges_ = nullptr;
 // static
+StatisticsRecorder::HistogramProviders* StatisticsRecorder::providers_;
+// static
 base::LazyInstance<base::Lock>::Leaky StatisticsRecorder::lock_ =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace base