Integrate Crashpad UMA

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 @@
                                          StringPiece name);
 
   // Create a global allocator using an internal block of memory of the
   // specified |size| taken from the heap.
   static void CreateWithLocalMemory(size_t size, uint64_t id, StringPiece name);
 
 #if !defined(OS_NACL)
   // Create a global allocator by memory-mapping a |file|. If the file does
   // not exist, it will be created with the specified |size|. If the file does
   // exist, the allocator will use and add to its contents, ignoring the passed
-  // size in favor of the existing size.
-  static void CreateWithFile(const FilePath& file_path,
+  // size in favor of the existing size. Returns whether the global allocator
+  // was set.
+  static bool CreateWithFile(const FilePath& file_path,
                              size_t size,
                              uint64_t id,
                              StringPiece name);
+
+  // Creates a new file at |active_path|. If it already exists, it will first be
+  // moved to |base_path|. In all cases, any old file at |base_path| will be
+  // removed. The file will be created using the given size, id, and name.
+  // Returns whether the global allocator was set.
+  static bool CreateWithActiveFile(const FilePath& base_path,
+                                   const FilePath& active_path,
+                                   size_t size,
+                                   uint64_t id,
+                                   StringPiece name);
+
+  // Uses ConstructBaseActivePairFilePaths() to build a pair of file names which
+  // are then used for CreateWithActiveFile().

[bcwhite, 2016/09/14 21:11:29]

Note that |name| will be used for both the internal name of the allocator and
the name of the file within |dir|.

[scottmg, 2016/09/14 22:12:30]

Done.

+  static bool CreateWithActiveFileInDir(const FilePath& dir,
+                                        size_t size,
+                                        uint64_t id,
+                                        StringPiece name);
+
+  // Constructs a pair of names in |dir| based on name that can be used for a
+  // base + active persistent memory mapped location for CreateWithActiveFile().
+  static void ConstructBaseActivePairFilePaths(const FilePath& dir,

[bcwhite, 2016/09/14 21:11:30]

How about shortening this method to just ContructFilePaths so it can be used
even when a pair isn't needed (by passing nullptr for the second FilePath)? 
Then it could be used for getting the path passed to CreateWithFile().

Also, it's worth noting that |name| will be the file name and though it's
commonly the same as the name of the persistent memory block, it doesn't have to
be.

[scottmg, 2016/09/14 22:12:31]

Done.

+                                               StringPiece name,
+                                               FilePath* out_base_path,
+                                               FilePath* out_active_path);
 #endif
 
   // Create a global allocator using a block of shared |memory| of the
   // specified |size|. The allocator takes ownership of the shared memory
   // and releases it upon destruction, though the memory will continue to
   // live if other processes have access to it.
   static void CreateWithSharedMemory(std::unique_ptr<SharedMemory> memory,
                                      size_t size,
                                      uint64_t id,
                                      StringPiece name);
@@ skipping 30 matching lines @@
   // Retrieves a previously set pathname to which the contents of this allocator
   // are to be saved.
   const FilePath& GetPersistentLocation() const;
 
   // 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();
 
+  // If there is a global metrics file being updated on disk, mark it to be
+  // deleted when the process exits. A normal shutdown is almost complete so

[bcwhite, 2016/09/14 21:11:30]

Comment needs updating for its new location.  A shutdown being almost complete
is a likely use but not strictly necessary.

[scottmg, 2016/09/14 22:12:31]

Done.

+  // there is no benefit in keeping a file with no new data to be processed
+  // during the next startup sequence. Deleting the file during shutdown adds an
+  // extra disk-access or two to shutdown but eliminates the unnecessary
+  // processing of the contents during startup only to find nothing.
+  void DeletePersistentLocation();
+
  private:
   friend class StatisticsRecorder;
 
   // 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_