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 35 matching lines @@
   // Histogram was of unknown type.
   CREATE_HISTOGRAM_UNKNOWN_TYPE,
 
   // Instance has detected a corrupt allocator (recorded only once).
   CREATE_HISTOGRAM_ALLOCATOR_NEWLY_CORRUPT,
 
   // 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 86 matching lines @@
     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.
@@ skipping 29 matching lines @@
   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);
       StatisticsRecorder::ForgetHistogramForTesting(histogram_data->name);
+
+      // If a test breaks here then a memory region containing a histogram
+      // actively used by this code is being released back to the test.
+      // If that memory segment were to be deleted, future calls to create
+      // persistent histograms would crash. To avoid this, have the test call
+      // the method GetCreateHistogramResultHistogram() *before* setting the
+      // (temporary) memory allocator via SetPersistentMemoryAllocator() so
+      // that the histogram is instead allocated from the process heap.
+      DCHECK_NE(kResultHistogram, histogram_data->name);
     }
   }
 
   g_allocator = nullptr;
   return allocator;
 };
 
 HistogramBase* CreatePersistentHistogram(
     PersistentMemoryAllocator* allocator,
     PersistentHistogramData* histogram_data_ptr) {
@@ skipping 250 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 (;;) {
+    while (true) {
       HistogramBase* histogram = GetNextPersistentHistogram(g_allocator, &iter);
       if (!histogram)
         break;
       StatisticsRecorder::RegisterOrDeleteDuplicate(histogram);
     }
   }
 }
 
 }  // namespace base