Support negative sample values in PersistentHistogramMap.

base/metrics/persistent_sample_map.cc

 // 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.
 
 #include "base/metrics/persistent_sample_map.h"
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/persistent_histogram_allocator.h"
 #include "base/stl_util.h"
@@ skipping 113 matching lines @@
   // Have to override "const" to make sure all samples have been loaded before
   // being able to know what value to return.
   Count* count_pointer =
       const_cast<PersistentSampleMap*>(this)->GetSampleCountStorage(value);
   return count_pointer ? *count_pointer : 0;
 }
 
 Count PersistentSampleMap::TotalCount() const {
   // Have to override "const" in order to make sure all samples have been
   // loaded before trying to iterate over the map.
-  const_cast<PersistentSampleMap*>(this)->ImportSamples(kAllSamples);
+  const_cast<PersistentSampleMap*>(this)->ImportSamples(-1, true);
 
   Count count = 0;
   for (const auto& entry : sample_counts_) {
     count += *entry.second;
   }
   return count;
 }
 
 std::unique_ptr<SampleCountIterator> PersistentSampleMap::Iterator() const {
   // Have to override "const" in order to make sure all samples have been
   // loaded before trying to iterate over the map.
-  const_cast<PersistentSampleMap*>(this)->ImportSamples(kAllSamples);
+  const_cast<PersistentSampleMap*>(this)->ImportSamples(-1, true);
   return WrapUnique(new PersistentSampleMapIterator(sample_counts_));
 }
 
 // static
 PersistentMemoryAllocator::Reference
 PersistentSampleMap::GetNextPersistentRecord(
     PersistentMemoryAllocator::Iterator& iterator,
     uint64_t* sample_map_id) {
   PersistentMemoryAllocator::Reference ref =
       iterator.GetNextOfType(kTypeIdSampleRecord);
@@ skipping 40 matching lines @@
     if (min + 1 != max)
       return false;  // SparseHistogram only supports bucket with size 1.
 
     *GetOrCreateSampleCountStorage(min) +=
         (op == HistogramSamples::ADD) ? count : -count;
   }
   return true;
 }
 
 Count* PersistentSampleMap::GetSampleCountStorage(Sample value) {
-  DCHECK_LE(0, value);
-
   // If |value| is already in the map, just return that.
   auto it = sample_counts_.find(value);
   if (it != sample_counts_.end())
     return it->second;
 
   // Import any new samples from persistent memory looking for the value.
-  return ImportSamples(value);
+  return ImportSamples(value, false);
 }
 
 Count* PersistentSampleMap::GetOrCreateSampleCountStorage(Sample value) {
   // Get any existing count storage.
   Count* count_pointer = GetSampleCountStorage(value);
   if (count_pointer)
     return count_pointer;
 
   // Create a new record in persistent memory for the value.
   PersistentMemoryAllocator::Reference ref = records_->CreateNew(value);
   if (!ref) {
     // If a new record could not be created then the underlying allocator is
     // full or corrupt. Instead, allocate the counter from the heap. This
     // sample will not be persistent, will not be shared, and will leak...
     // but it's better than crashing.
     count_pointer = new Count(0);
     sample_counts_[value] = count_pointer;
     return count_pointer;
   }
 
   // A race condition between two independent processes (i.e. two independent
   // histogram objects sharing the same sample data) could cause two of the
   // above records to be created. The allocator, however, forces a strict
   // ordering on iterable objects so use the import method to actually add the
   // just-created record. This ensures that all PersistentSampleMap objects
   // will always use the same record, whichever was first made iterable.
   // Thread-safety within a process where multiple threads use the same
   // histogram object is delegated to the controlling histogram object which,
   // for sparse histograms, is a lock object.
-  count_pointer = ImportSamples(value);
+  count_pointer = ImportSamples(value, false);
   DCHECK(count_pointer);
   return count_pointer;
 }
 
-Count* PersistentSampleMap::ImportSamples(Sample until_value) {
+Count* PersistentSampleMap::ImportSamples(Sample until_value,
+                                          bool import_everything) {
+  Count* found_count = nullptr;
   PersistentMemoryAllocator::Reference ref;
   while ((ref = records_->GetNext()) != 0) {
     SampleRecord* record =
         records_->GetAsObject<SampleRecord>(ref, kTypeIdSampleRecord);
     if (!record)
       continue;
 
     DCHECK_EQ(id(), record->id);
 
     // Check if the record's value is already known.
     if (!ContainsKey(sample_counts_, record->value)) {
-      // No: Add it to map of known values if the value is valid.
-      if (record->value >= 0)
-        sample_counts_[record->value] = &record->count;
+      // No: Add it to map of known values.
+      sample_counts_[record->value] = &record->count;
     } else {
       // Yes: Ignore it; it's a duplicate caused by a race condition -- see
       // code & comment in GetOrCreateSampleCountStorage() for details.
       // Check that nothing ever operated on the duplicate record.
       DCHECK_EQ(0, record->count);
     }
 
-    // Stop if it's the value being searched for.
-    if (record->value == until_value)
-      return &record->count;
+    // Check if it's the value being searched for and, if so, keep a pointer
+    // to return later. Stop here unless everything is being imported.
+    // Because race conditions can cause multiple records for a single value,
+    // be sure to return the first one found.
+    if (record->value == until_value) {
+      if (!found_count)
+        found_count = &record->count;
+      if (!import_everything)
+        break;
+    }
   }
 
-  return nullptr;
+  return found_count;
 }
 
 }  // namespace base