Support saving browser metrics to disk and reading them during next run.

base/metrics/persistent_histogram_allocator.cc

 // Copyright 2016 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/persistent_histogram_allocator.h"
 
 #include <memory>
 
+#include "base/files/important_file_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/persistent_sample_map.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/synchronization/lock.h"
@@ skipping 678 matching lines @@
     // the method GetCreateHistogramResultHistogram() *before* setting
     // the (temporary) memory allocator via SetGlobalAllocator() so that
     // histogram is instead allocated from the process heap.
     DCHECK_NE(kResultHistogram, histogram_data->name);
   }
 
   g_allocator = nullptr;
   return WrapUnique(histogram_allocator);
 };
 
+void GlobalHistogramAllocator::SetPersistentLocation(const FilePath& location) {
+  persistent_location_ = location;
+}
+
+bool GlobalHistogramAllocator::WriteToPersistentLocation() {
+#if defined(OS_NACL)
+  // NACL doesn't support file operations, including ImportantFileWriter.
+  NOTREACHED();
+  return false;
+#else
+  // Stop if no destination is set, perhaps because it has not been enabled.
+  if (persistent_location_.empty())

[Ilya Sherman, 2016/04/20 17:10:33]

I'd still prefer the location to be guaranteed to be set, and to track
enabled/disabled state explicitly.

(I don't actually see a way for the location to be unset, except in case of an
error.  If this is really intended to be error-handling code, then please update
the comment.  And, we should think carefully about what might cause that error
to come up, and whether we're willing to live with simply dropping metrics in
that case.  It certainly seems oddly asymmetric to log an error below, but not
to log one here, if this is error-handling code.)

[bcwhite, 2016/04/22 15:18:04]

Enable/Disable: Done.
It can't be unset (at least by existing code) but there may be paths where it
never gets set at all.  I don't think a log message is necessary but I don't
mind adding one.

+    return false;
+
+  StringPiece contents(static_cast<const char*>(data()), used());
+  if (!ImportantFileWriter::WriteFileAtomically(persistent_location_,
+                                                contents)) {
+    LOG(ERROR) << "Could not write persistent histograms to file: "
+               << persistent_location_.value();
+    return false;
+  }
+
+  return true;
+#endif
+}
+
 GlobalHistogramAllocator::GlobalHistogramAllocator(
     std::unique_ptr<PersistentMemoryAllocator> memory)
     : PersistentHistogramAllocator(std::move(memory)),
       import_iterator_(this) {}
 
 void GlobalHistogramAllocator::ImportHistogramsToStatisticsRecorder() {
   // Skip the import if it's the histogram that was last created. Should a
   // race condition cause the "last created" to be overwritten before it
   // is recognized here then the histogram will be created and be ignored
   // when it is detected as a duplicate by the statistics-recorder. This
   // simple check reduces the time of creating persistent histograms by
   // about 40%.
   Reference record_to_ignore = last_created();
 
   // There is no lock on this because the iterator is lock-free while still
   // guaranteed to only return each entry only once. The StatisticsRecorder
   // has its own lock so the Register operation is safe.
   while (true) {
     std::unique_ptr<HistogramBase> histogram =
         import_iterator_.GetNextWithIgnore(record_to_ignore);
     if (!histogram)
       break;
     StatisticsRecorder::RegisterOrDeleteDuplicate(histogram.release());
   }
 }
 
 }  // namespace base