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 371 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();

[Ilya Sherman, 2016/04/26 20:01:24]

Looking at the uses, it looks like you could replace this method with a
GetName() method, which would get the allocator name even if it's disabled.  I
think that would be a less confusing API.  Heck, the name of the global
allocator could just be a static constant exported by this class, rather than
something passed to the constructor.

[bcwhite, 2016/04/26 21:04:26]

The name can't be a constant here because the name changes depending on what
it's global for:  BrowserMetrics, SetupMetrics, RendererMetrics, etc.

I looked at GetName() but that seems odd since there is already a non-static
Name() method that returns the same thing.  It would also muddy the distinction
between normal/static.  Normal methods go into the object while static methods
manage the singleton's connection to global activity.

Part of the reason of creating the GlobalHistogramManager derived class was to
move Import() away from being a static method that acted on the global object.

I also think GetEvenIfDisabled() works better for the future because when it
stops being an experiment, the only change necessary will be to replace calls to
it with calls to Get().

+
   // 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_