Add ownership-transfer to histogram management calls.

base/metrics/histogram_persistence.cc

 // 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.
 
 #include "base/metrics/histogram_persistence.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
@@ skipping 210 matching lines @@
       // (temporary) memory allocator via SetPersistentMemoryAllocator() so
       // that the histogram is instead allocated from the process heap.
       DCHECK_NE(kResultHistogram, histogram_data->name);
     }
   }
 
   g_allocator = nullptr;
   return allocator;
 };
 
-HistogramBase* CreatePersistentHistogram(
+scoped_ptr<HistogramBase> CreatePersistentHistogram(
     PersistentMemoryAllocator* allocator,
     PersistentHistogramData* histogram_data_ptr) {
   if (!histogram_data_ptr) {
     RecordCreateHistogramResult(CREATE_HISTOGRAM_INVALID_METADATA_POINTER);
     NOTREACHED();
     return nullptr;
   }
 
   // Copy the histogram_data to local storage because anything in persistent
   // memory cannot be trusted as it could be changed at any moment by a
   // malicious actor that shares access. The contents of histogram_data are
   // validated below; the local copy is to ensure that the contents cannot
   // be externally changed between validation and use.
   PersistentHistogramData histogram_data = *histogram_data_ptr;
 
   HistogramBase::Sample* ranges_data =
       allocator->GetAsObject<HistogramBase::Sample>(histogram_data.ranges_ref,
                                                     kTypeIdRangesArray);
   if (!ranges_data || histogram_data.bucket_count < 2 ||
       histogram_data.bucket_count + 1 >
           std::numeric_limits<uint32_t>::max() /
               sizeof(HistogramBase::Sample) ||
       allocator->GetAllocSize(histogram_data.ranges_ref) <
           (histogram_data.bucket_count + 1) * sizeof(HistogramBase::Sample)) {
     RecordCreateHistogramResult(CREATE_HISTOGRAM_INVALID_RANGES_ARRAY);
     NOTREACHED();
     return nullptr;
   }
-  // To avoid racy destruction at shutdown, the following will be leaked.
-  const BucketRanges* ranges = CreateRangesFromData(
+
+  scoped_ptr<const BucketRanges> created_ranges(CreateRangesFromData(
       ranges_data,
       histogram_data.ranges_checksum,
-      histogram_data.bucket_count + 1);
-  if (!ranges) {
+      histogram_data.bucket_count + 1));
+  if (!created_ranges) {
     RecordCreateHistogramResult(CREATE_HISTOGRAM_INVALID_RANGES_ARRAY);
     NOTREACHED();
     return nullptr;
   }
-  ranges = StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
+  const BucketRanges* ranges =
+      StatisticsRecorder::RegisterOrDeleteDuplicateRanges(
+          std::move(created_ranges));
 
   HistogramBase::AtomicCount* counts_data =
       allocator->GetAsObject<HistogramBase::AtomicCount>(
           histogram_data.counts_ref, kTypeIdCountsArray);
   size_t counts_bytes =
       CalculateRequiredCountsBytes(histogram_data.bucket_count);
   if (!counts_data || !counts_bytes ||
       allocator->GetAllocSize(histogram_data.counts_ref) < counts_bytes) {
     RecordCreateHistogramResult(CREATE_HISTOGRAM_INVALID_COUNTS_ARRAY);
     NOTREACHED();
     return nullptr;
   }
 
   // After the main "counts" array is a second array using for storing what
   // was previously logged. This is used to calculate the "delta" during
   // snapshot operations.
   HistogramBase::AtomicCount* logged_data =
       counts_data + histogram_data.bucket_count;
 
   std::string name(histogram_data_ptr->name);
-  HistogramBase* histogram = nullptr;
+  scoped_ptr<HistogramBase> histogram;
   switch (histogram_data.histogram_type) {
     case HISTOGRAM:
-      histogram = Histogram::PersistentGet(
+      histogram.reset(Histogram::PersistentGet(
           name,
           histogram_data.minimum,
           histogram_data.maximum,
           ranges,
           counts_data,
           logged_data,
           histogram_data.bucket_count,
           &histogram_data_ptr->samples_metadata,
-          &histogram_data_ptr->logged_metadata);
+          &histogram_data_ptr->logged_metadata));
       DCHECK(histogram);
       break;
     case LINEAR_HISTOGRAM:
-      histogram = LinearHistogram::PersistentGet(
+      histogram.reset(LinearHistogram::PersistentGet(
           name,
           histogram_data.minimum,
           histogram_data.maximum,
           ranges,
           counts_data,
           logged_data,
           histogram_data.bucket_count,
           &histogram_data_ptr->samples_metadata,
-          &histogram_data_ptr->logged_metadata);
+          &histogram_data_ptr->logged_metadata));
       DCHECK(histogram);
       break;
     case BOOLEAN_HISTOGRAM:
-      histogram = BooleanHistogram::PersistentGet(
+      histogram.reset(BooleanHistogram::PersistentGet(
           name,
           ranges,
           counts_data,
           logged_data,
           &histogram_data_ptr->samples_metadata,
-          &histogram_data_ptr->logged_metadata);
+          &histogram_data_ptr->logged_metadata));
       DCHECK(histogram);
       break;
     case CUSTOM_HISTOGRAM:
-      histogram = CustomHistogram::PersistentGet(
+      histogram.reset(CustomHistogram::PersistentGet(
           name,
           ranges,
           counts_data,
           logged_data,
           histogram_data.bucket_count,
           &histogram_data_ptr->samples_metadata,
-          &histogram_data_ptr->logged_metadata);
+          &histogram_data_ptr->logged_metadata));
       DCHECK(histogram);
       break;
     default:
       NOTREACHED();
   }
 
   if (histogram) {
     DCHECK_EQ(histogram_data.histogram_type, histogram->GetHistogramType());
     histogram->SetFlags(histogram_data.flags);
     RecordCreateHistogramResult(CREATE_HISTOGRAM_SUCCESS);
   } else {
     RecordCreateHistogramResult(CREATE_HISTOGRAM_UNKNOWN_TYPE);
   }
 
   return histogram;
 }
 
-HistogramBase* GetPersistentHistogram(
+scoped_ptr<HistogramBase> GetPersistentHistogram(
     PersistentMemoryAllocator* allocator,
     int32_t ref) {
   // Unfortunately, the above "pickle" methods cannot be used as part of the
   // persistance because the deserialization methods always create local
   // count data (these must referenced the persistent counts) and always add
   // it to the local list of known histograms (these may be simple references
   // to histograms in other processes).
   PersistentHistogramData* histogram_data =
       allocator->GetAsObject<PersistentHistogramData>(ref, kTypeIdHistogram);
   size_t length = allocator->GetAllocSize(ref);
   if (!histogram_data ||
       reinterpret_cast<char*>(histogram_data)[length - 1] != '\0') {
     RecordCreateHistogramResult(CREATE_HISTOGRAM_INVALID_METADATA);
     NOTREACHED();
     return nullptr;
   }
   return CreatePersistentHistogram(allocator, histogram_data);
 }
 
-HistogramBase* GetNextPersistentHistogram(
+scoped_ptr<HistogramBase> GetNextPersistentHistogram(
     PersistentMemoryAllocator* allocator,
     PersistentMemoryAllocator::Iterator* iter) {
   PersistentMemoryAllocator::Reference ref;
   uint32_t type_id;
   while ((ref = allocator->GetNextIterable(iter, &type_id)) != 0) {
     if (type_id == kTypeIdHistogram)
       return GetPersistentHistogram(allocator, ref);
   }
   return nullptr;
 }
 
 void FinalizePersistentHistogram(PersistentMemoryAllocator::Reference ref,
                                  bool registered) {
   // If the created persistent histogram was registered then it needs to
   // be marked as "iterable" in order to be found by other processes.
   if (registered)
     GetPersistentHistogramMemoryAllocator()->MakeIterable(ref);
   // If it wasn't registered then a race condition must have caused
   // two to be created. The allocator does not support releasing the
   // acquired memory so just change the type to be empty.
   else
     GetPersistentHistogramMemoryAllocator()->SetType(ref, 0);
 }
 
-HistogramBase* AllocatePersistentHistogram(
+scoped_ptr<HistogramBase> AllocatePersistentHistogram(
     PersistentMemoryAllocator* allocator,
     HistogramType histogram_type,
     const std::string& name,
     int minimum,
     int maximum,
     const BucketRanges* bucket_ranges,
     int32_t flags,
     PersistentMemoryAllocator::Reference* ref_ptr) {
   if (!allocator)
     return nullptr;
@@ skipping 47 matching lines @@
     histogram_data->bucket_count = static_cast<uint32_t>(bucket_count);
     histogram_data->ranges_ref = ranges_ref;
     histogram_data->ranges_checksum = bucket_ranges->checksum();
     histogram_data->counts_ref = counts_ref;
 
     // Create the histogram using resources in persistent memory. This ends up
     // resolving the "ref" values stored in histogram_data instad of just
     // using what is already known above but avoids duplicating the switch
     // statement here and serves as a double-check that everything is
     // correct before commiting the new histogram to persistent space.
-    HistogramBase* histogram =
-        CreatePersistentHistogram(allocator, histogram_data);
+    scoped_ptr<HistogramBase> histogram(
+        CreatePersistentHistogram(allocator, histogram_data));
     DCHECK(histogram);
     if (ref_ptr != nullptr)
       *ref_ptr = histogram_ref;
     return histogram;
   }
 
   CreateHistogramResultType result;
   if (allocator->IsCorrupt()) {
     RecordCreateHistogramResult(CREATE_HISTOGRAM_ALLOCATOR_NEWLY_CORRUPT);
     result = CREATE_HISTOGRAM_ALLOCATOR_CORRUPT;
@@ skipping 17 matching lines @@
     base::AutoLock auto_lock(lock.Get());
 
     // Each call resumes from where it last left off so need persistant
     // iterator. This class has a constructor so even the definition has
     // to be protected by the lock in order to be thread-safe.
     static PersistentMemoryAllocator::Iterator iter;
     if (iter.is_clear())
       g_allocator->CreateIterator(&iter);
 
     while (true) {
-      HistogramBase* histogram = GetNextPersistentHistogram(g_allocator, &iter);
+      scoped_ptr<HistogramBase> histogram(
+          GetNextPersistentHistogram(g_allocator, &iter));
       if (!histogram)
         break;
-      StatisticsRecorder::RegisterOrDeleteDuplicate(histogram);
+      StatisticsRecorder::RegisterOrDeleteDuplicate(std::move(histogram));
     }
   }
 }
 
 }  // namespace base