Persist setup metrics and have Chrome report them during UMA upload.

base/metrics/histogram_persistence.cc

 // Copyright (c) 2015 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/histogram_persistence.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
@@ skipping 32 matching lines @@
   // Could not allocate histogram memory due to unknown error.
   CREATE_HISTOGRAM_ALLOCATOR_ERROR,
 
   // Histogram was of unknown type.
   CREATE_HISTOGRAM_UNKNOWN_TYPE,
 
   // Always keep this at the end.
   CREATE_HISTOGRAM_MAX
 };
 
+// Name of histogram for storing results of local operations.
+const char kResultHistogram[] = "UMA.CreatePersistentHistogram.Result";
+
 // Type identifiers used when storing in persistent memory so they can be
 // identified during extraction; the first 4 bytes of the SHA1 of the name
 // is used as a unique integer. A "version number" is added to the base
 // so that, if the structure of that object changes, stored older versions
 // will be safely ignored.
 enum : uint32_t {
   kTypeIdHistogram   = 0xF1645910 + 1,  // SHA1(Histogram) v1
   kTypeIdRangesArray = 0xBCEA225A + 1,  // SHA1(RangesArray) v1
   kTypeIdCountsArray = 0x53215530 + 1,  // SHA1(CountsArray) v1
 };
@@ skipping 79 matching lines @@
           base::subtle::Acquire_Load(&atomic_histogram_pointer)));
   if (!histogram_pointer) {
     // It's possible for multiple threads to make it here in parallel but
     // they'll always return the same result as there is a mutex in the Get.
     // The purpose of the "initialized" variable is just to ensure that
     // the same thread doesn't recurse which is also why it doesn't have
     // to be atomic.
     static bool initialized = false;
     if (!initialized) {
       initialized = true;
+      if (g_allocator) {
+        DLOG(WARNING) << "Creating the results-histogram inside persistent"
+                      << " memory can cause future allocations to crash if"
+                      << " that memory is ever released (for testing).";
+      }
+
       histogram_pointer = LinearHistogram::FactoryGet(
-          "UMA.CreatePersistentHistogram.Result",
-          1, CREATE_HISTOGRAM_MAX, CREATE_HISTOGRAM_MAX + 1,
+          kResultHistogram, 1, CREATE_HISTOGRAM_MAX, CREATE_HISTOGRAM_MAX + 1,
           HistogramBase::kUmaTargetedHistogramFlag);
       base::subtle::Release_Store(
           &atomic_histogram_pointer,
           reinterpret_cast<base::subtle::AtomicWord>(histogram_pointer));
     }
   }
   return histogram_pointer;
 }
 
 // Record the result of a histogram creation.
 void RecordCreateHistogramResult(CreateHistogramResultType result) {
   HistogramBase* result_histogram = GetCreateHistogramResultHistogram();
   if (result_histogram)
     result_histogram->Add(result);
 }
 
 void SetPersistentHistogramMemoryAllocator(
     PersistentMemoryAllocator* allocator) {
   // Releasing or changing an allocator is extremely dangerous because it
   // likely has histograms stored within it. If the backing memory is also
   // also released, future accesses to those histograms will seg-fault.
-  // It's not a fatal CHECK() because tests do this knowing that all
-  // such persistent histograms have already been forgotten.
-  if (g_allocator) {
-    LOG(WARNING) << "Active PersistentMemoryAllocator has been released."
-                 << " Some existing histogram pointers may be invalid.";
-    delete g_allocator;
-  }
+  CHECK(!g_allocator);
   g_allocator = allocator;
 }
 
 PersistentMemoryAllocator* GetPersistentHistogramMemoryAllocator() {
   return g_allocator;
 }
 
-PersistentMemoryAllocator* ReleasePersistentHistogramMemoryAllocator() {
+PersistentMemoryAllocator*
+ReleasePersistentHistogramMemoryAllocatorForTesting() {
   PersistentMemoryAllocator* allocator = g_allocator;
+  if (!allocator)
+    return nullptr;
+
+  // Before releasing the memory, it's necessary to have the Statistics
+  // Recorder forget about the histograms contained within otherwise some
+  // operations will try to access it.
+  PersistentMemoryAllocator::Iterator iter;
+  PersistentMemoryAllocator::Reference ref;
+  uint32_t type_id;
+  allocator->CreateIterator(&iter);
+  while ((ref = allocator->GetNextIterable(&iter, &type_id)) != 0) {
+    if (type_id == kTypeIdHistogram) {
+      PersistentHistogramData* histogram_data =
+          allocator->GetAsObject<PersistentHistogramData>(
+              ref, kTypeIdHistogram);
+      DCHECK(histogram_data);
+      std::string name(histogram_data->name);
+      StatisticsRecorder::ForgetHistogramForTesting(name);
+      DLOG(WARNING) << "Dropped persistent histogram \"" << name << "\"";
+
+      // Fix by calling GetCreateHistogramResultHistogram() before setting
+      // the (temporary) persistent memory allocator.
+      DCHECK_NE(kResultHistogram, name);
+    }
+  }
+
   g_allocator = nullptr;
   return allocator;
 };
 
 HistogramBase* CreatePersistentHistogram(
     PersistentMemoryAllocator* allocator,
     PersistentHistogramData* histogram_data_ptr) {
   if (!histogram_data_ptr) {
     RecordCreateHistogramResult(CREATE_HISTOGRAM_INVALID_METADATA_POINTER);
     NOTREACHED();
@@ skipping 235 matching lines @@
   }
   RecordCreateHistogramResult(result);
   NOTREACHED() << "error=" << result;
 
   return nullptr;
 }
 
 void ImportPersistentHistograms() {
   // The lock protects against concurrent access to the iterator and is created
   // in a thread-safe manner when needed.
-  static base::LazyInstance<base::Lock> lock = LAZY_INSTANCE_INITIALIZER;
+  static base::LazyInstance<base::Lock>::Leaky lock = LAZY_INSTANCE_INITIALIZER;
 
   if (g_allocator) {
     base::AutoLock auto_lock(lock.Get());
 
     // Each call resumes from where it last left off so need persistant
     // iterator. This class has a constructor so even the definition has
     // to be protected by the lock in order to be thread-safe.
     static PersistentMemoryAllocator::Iterator iter;
     if (iter.is_clear())
       g_allocator->CreateIterator(&iter);
 
     for (;;) {

[grt (UTC plus 2), 2016/02/15 15:42:39]

fyi for the future: "while (true)" is more common for infloops in src/chrome.

[bcwhite, 2016/02/15 19:22:10]

Done.

       HistogramBase* histogram = GetNextPersistentHistogram(g_allocator, &iter);
       if (!histogram)
         break;
       StatisticsRecorder::RegisterOrDeleteDuplicate(histogram);
     }
   }
 }
 
 }  // namespace base