Delay PersistentHistogramAllocator creation until it's known to be used.

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 376 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);
 
-  // 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.
+  // Gets a pointer to the global histogram allocator. Returns null if none
+  // exists.
   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 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.
+  // the current allocator completely. 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.
+  // Creates a new global histogram allocator.
   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_