Fix StatisticsRecorder to handle re-entry during tests.

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"
@@ skipping 351 matching lines @@
   base::AutoLock auto_lock(*lock_);
   if (histograms_ == NULL)
     return OnSampleCallback();
 
   auto callback_iterator = callbacks_->find(name);
   return callback_iterator != callbacks_->end() ? callback_iterator->second
                                                 : OnSampleCallback();
 }
 
 // static
-void StatisticsRecorder::ResetForTesting() {
-  // Just call the private version that is used also by the destructor.
-  Reset();
-}
-
-// static
 void StatisticsRecorder::ForgetHistogramForTesting(base::StringPiece name) {
   if (histograms_)
     histograms_->erase(HashMetricName(name.as_string()));
 }
 
 // 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() {
-  DCHECK(!histograms_);
   if (lock_ == NULL) {
     // This will leak on purpose. It's the only way to make sure we won't race
     // against the static uninitialization of the module while one of our
     // static methods relying on the lock get called at an inappropriate time
     // 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_);
+
+  existing_histograms_.reset(histograms_);
+  existing_callbacks_.reset(callbacks_);
+  existing_ranges_.reset(ranges_);
+
   histograms_ = new HistogramMap;
   callbacks_ = new CallbackMap;
   ranges_ = new RangesMap;
 
   if (VLOG_IS_ON(1))
     AtExitManager::RegisterCallback(&DumpHistogramsToVlog, this);
 }
 
 StatisticsRecorder::~StatisticsRecorder() {
   DCHECK(histograms_ && ranges_ && lock_);
 
-  // Global clean up.
+  // Clean out what this object created and then restore what existed before.
   Reset();
+  base::AutoLock auto_lock(*lock_);
+  histograms_ = existing_histograms_.release();
+  callbacks_ = existing_callbacks_.release();
+  ranges_ = existing_ranges_.release();
 }
 
 // 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;
@@ skipping 23 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