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

base/metrics/persistent_histogram_allocator.h

 // 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.
 
 #ifndef BASE_METRICS_HISTOGRAM_PERSISTENCE_H_
 #define BASE_METRICS_HISTOGRAM_PERSISTENCE_H_
 
 #include <map>
 #include <memory>
 
@@ skipping 375 matching lines @@
                                            size_t size);
 
   // Sets a GlobalHistogramAllocator for globally storing histograms in
   // a space that can be persisted or shared between processes. There is only
   // ever one allocator for all such histograms created by a single process.
   // This takes ownership of the object and should be called as soon as
   // possible during startup to capture as many histograms as possible and
   // while operating single-threaded so there are no race-conditions.
   static void Set(std::unique_ptr<GlobalHistogramAllocator> allocator);
 
-  // Gets a pointer to the global histogram allocator.
+  // Enables the global persistent allocator. Existing histograms will not be
+  // affected; only newly created ones will go into the allocator.
+  static void Enable();
+
+  // Disables the global persistent allocator. Existing histograms will not be
+  // affected; newly created histograms will be allocated from the heap.
+  static void Disable();
+
+  // Gets a pointer to an enabled global histogram allocator. If a global
+  // allocator exists but is disabled, this will return null.
   static GlobalHistogramAllocator* Get();
 
+  // Gets a pointer to a global histogram allocator if one exists, even if
+  // that allocator is disabled.
+  static GlobalHistogramAllocator* GetEvenIfDisabled();
+
   // This access to the persistent allocator is only for testing; it extracts
-  // the current allocator completely. This allows easy creation of histograms
-  // within persistent memory segments which can then be extracted and used
-  // in other ways.
+  // the current allocator completely regardless whether it is enabled or not.
+  // This allows easy creation of histograms within persistent memory segments
+  // which can then be extracted and used in other ways.
   static std::unique_ptr<GlobalHistogramAllocator> ReleaseForTesting();
 
+  // Stores a pathname to which the contents of this allocator should be saved
+  // in order to persist the data for a later use.
+  void SetPersistentLocation(const FilePath& location);
+
+  // Writes the internal data to a previously set location. This is generally
+  // called when a process is exiting from a section of code that may not know
+  // the filesystem. The data is written in an atomic manner. The return value
+  // indicates success.
+  bool WriteToPersistentLocation();
+
  private:
   friend class StatisticsRecorder;
 
+  // Creates a new global histogram allocator. It will be enabled by default.
   explicit GlobalHistogramAllocator(
       std::unique_ptr<PersistentMemoryAllocator> memory);
 
   // Import new histograms from the global histogram allocator. It's possible
   // for other processes to create histograms in the active memory segment;
   // this adds those to the internal list of known histograms to avoid creating
   // duplicates that would have to be merged during reporting. Every call to
   // this method resumes from the last entry it saw; it costs nothing if
   // nothing new has been added.
   void ImportHistogramsToStatisticsRecorder();
 
   // Import always continues from where it left off, making use of a single
   // iterator to continue the work.
   Iterator import_iterator_;
 
+  // The location to which the data should be persisted.
+  FilePath persistent_location_;
+
   DISALLOW_COPY_AND_ASSIGN(GlobalHistogramAllocator);
 };
 
 }  // namespace base
 
 #endif  // BASE_METRICS_HISTOGRAM_PERSISTENCE_H_