Create 'errors' histogram for failures.

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>
@@ skipping 268 matching lines @@
   bool IsReadonly() { return readonly_; }
 
   // Create internal histograms for tracking memory use and allocation sizes
   // for allocator of |name| (which can simply be the result of Name()). This
   // is done seperately from construction for situations such as when the
   // histograms will be backed by memory provided by this very allocator.
   //
   // IMPORTANT: Callers must update tools/metrics/histograms/histograms.xml
   // with the following histograms:
   //    UMA.PersistentAllocator.name.Allocs
+  //    UMA.PersistentAllocator.name.Errors
   //    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;
@@ skipping 303 matching lines @@
   // Get the actual data within a block associated with a specific reference.
   const volatile void* GetBlockData(Reference ref, uint32_t type_id,
                                     uint32_t size) const;
   volatile void* GetBlockData(Reference ref, uint32_t type_id,
                               uint32_t size) {
       return const_cast<volatile void*>(
           const_cast<const PersistentMemoryAllocator*>(this)->GetBlockData(
               ref, type_id, size));
   }
 
-  const bool readonly_;              // Indicates access to read-only memory.
-  std::atomic<bool> corrupt_;        // Local version of "corrupted" flag.
+  // Record an error in the internal histogram.
+  void RecordError(int error) const;
+
+  const bool readonly_;                // Indicates access to read-only memory.
+  mutable std::atomic<bool> corrupt_;  // Local version of "corrupted" flag.
 
   HistogramBase* allocs_histogram_;  // Histogram recording allocs.
   HistogramBase* used_histogram_;    // Histogram recording used space.
+  HistogramBase* errors_histogram_;  // Histogram recording errors.
 
   friend class PersistentMemoryAllocatorTest;
   FRIEND_TEST_ALL_PREFIXES(PersistentMemoryAllocatorTest, AllocateAndIterate);
   DISALLOW_COPY_AND_ASSIGN(PersistentMemoryAllocator);
 };
 
 
 // This allocator uses a local memory block it allocates from the general
 // heap. It is generally used when some kind of "death rattle" handler will
 // save the contents to persistent storage during process shutdown. It is
@@ skipping 70 matching lines @@
  private:
   std::unique_ptr<MemoryMappedFile> mapped_file_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePersistentMemoryAllocator);
 };
 #endif  // !defined(OS_NACL)
 
 }  // namespace base
 
 #endif  // BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_