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

base/metrics/persistent_memory_allocator.h

 // Copyright (c) 2015 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_PERSISTENT_MEMORY_ALLOCATOR_H_
 #define BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
 
 #include <stdint.h>
 
 #include <atomic>
 #include <memory>
 
 #include "base/atomicops.h"
 #include "base/base_export.h"
+#include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/strings/string_piece.h"
 
 namespace base {
 
 class HistogramBase;
 class MemoryMappedFile;
 class SharedMemory;
 
@@ skipping 94 matching lines @@
   };
 
   enum : Reference {
     kReferenceNull = 0  // A common "null" reference value.
   };
 
   enum : uint32_t {
     kTypeIdAny = 0  // Match any type-id inside GetAsObject().
   };
 
+  // This is the standard file extension (suitable for being passed to the
+  // AddExtension() method of base::FilePath) for dumps of persistent memory.
+  static const base::FilePath::CharType kFileExtension[];
+
   // The allocator operates on any arbitrary block of memory. Creation and
   // persisting or sharing of that block with another process is the
   // responsibility of the caller. The allocator needs to know only the
   // block's |base| address, the total |size| of the block, and any internal
   // |page| size (zero if not paged) across which allocations should not span.
   // The |id| is an arbitrary value the caller can use to identify a
   // particular memory segment. It will only be loaded during the initial
   // creation of the segment and can be checked by the caller for consistency.
   // The |name|, if provided, is used to distinguish histograms for this
   // allocator. Only the primary owner of the segment should define this value;
@@ skipping 45 matching lines @@
   // with the following histograms:
   //    UMA.PersistentAllocator.name.Allocs
   //    UMA.PersistentAllocator.name.UsedPct
   void CreateTrackingHistograms(base::StringPiece name);
 
   // Direct access to underlying memory segment. If the segment is shared
   // across threads or processes, reading data through these values does
   // not guarantee consistency. Use with care. Do not write.
   const void* data() const { return const_cast<const char*>(mem_base_); }
   size_t length() const { return mem_size_; }
+  size_t size() const { return mem_size_; }
   size_t used() const;
 
   // Get an object referenced by a |ref|. For safety reasons, the |type_id|
   // code and size-of(|T|) are compared to ensure the reference is valid
   // and cannot return an object outside of the memory segment. A |type_id| of
   // kTypeIdAny (zero) will match any though the size is still checked. NULL is
   // returned if any problem is detected, such as corrupted storage or incorrect
   // parameters. Callers MUST check that the returned value is not-null EVERY
   // TIME before accessing it or risk crashing! Once dereferenced, the pointer
   // is safe to reuse forever.
@@ skipping 194 matching lines @@
 
  private:
   std::unique_ptr<MemoryMappedFile> mapped_file_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePersistentMemoryAllocator);
 };
 
 }  // namespace base
 
 #endif  // BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_