Add ownership-transfer to histogram management calls.

base/metrics/histogram.cc

 // Copyright (c) 2012 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.
 
 // Histogram is an object that aggregates statistics, and can summarize them in
 // various forms, including ASCII graphical, HTML, and numerically (as a
 // vector of numbers corresponding to each of the aggregating buckets).
 // See header file for details and examples.
 
 #include "base/metrics/histogram.h"
@@ skipping 138 matching lines @@
 HistogramBase* Histogram::Factory::Build() {
   // Import histograms from known persistent storage. Histograms could have
   // been added by other processes and they must be fetched and recognized
   // locally in order to be found by FindHistograms() below. If the persistent
   // memory segment is not shared between processes, this call does nothing.
   ImportPersistentHistograms();
 
   HistogramBase* histogram = StatisticsRecorder::FindHistogram(name_);
   if (!histogram) {
     // To avoid racy destruction at shutdown, the following will be leaked.
-    const BucketRanges* created_ranges = CreateRanges();
+    scoped_ptr<const BucketRanges> created_ranges(CreateRanges());
     const BucketRanges* registered_ranges =
-        StatisticsRecorder::RegisterOrDeleteDuplicateRanges(created_ranges);
+        StatisticsRecorder::RegisterOrDeleteDuplicateRanges(
+            std::move(created_ranges));
 
     // In most cases, the bucket-count, minimum, and maximum values are known
     // when the code is written and so are passed in explicitly. In other
     // cases (such as with a CustomHistogram), they are calculated dynamically
     // at run-time. In the latter case, those ctor parameters are zero and
     // the results extracted from the result of CreateRanges().
     if (bucket_count_ == 0) {
       bucket_count_ = static_cast<uint32_t>(registered_ranges->bucket_count());
       minimum_ = registered_ranges->range(1);
       maximum_ = registered_ranges->range(bucket_count_ - 1);
     }
 
     // Try to create the histogram using a "persistent" allocator. As of
     // 2015-01-14, the availability of such is controlled by a base::Feature
     // that is off by default. If the allocator doesn't exist or if
     // allocating from it fails, code below will allocate the histogram from
     // the process heap.
     PersistentMemoryAllocator::Reference histogram_ref = 0;
-    HistogramBase* tentative_histogram = nullptr;
+    scoped_ptr<HistogramBase> tentative_histogram;
     PersistentMemoryAllocator* allocator =
         GetPersistentHistogramMemoryAllocator();
     if (allocator) {
       flags_ |= HistogramBase::kIsPersistent;
       tentative_histogram = AllocatePersistentHistogram(
           allocator,
           histogram_type_,
           name_,
           minimum_,
           maximum_,
           registered_ranges,
           flags_,
           &histogram_ref);
     }
 
     // Handle the case where no persistent allocator is present or the
     // persistent allocation fails (perhaps because it is full).
     if (!tentative_histogram) {
       DCHECK(!histogram_ref);  // Should never have been set.
       DCHECK(!allocator);  // Shouldn't have failed.
       flags_ &= ~HistogramBase::kIsPersistent;
-      tentative_histogram = HeapAlloc(registered_ranges);
+      tentative_histogram.reset(HeapAlloc(registered_ranges));
     }
 
-    FillHistogram(tentative_histogram);
-    histogram =
-        StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
+    FillHistogram(tentative_histogram.get());
+    const void* allocated_histogram = tentative_histogram.get();
+    histogram = StatisticsRecorder::RegisterOrDeleteDuplicate(
+        std::move(tentative_histogram));
 
     // Persistent histograms need some follow-up processing.
     if (histogram_ref) {
       FinalizePersistentHistogram(histogram_ref,
-                                  histogram == tentative_histogram);
+                                  histogram == allocated_histogram);
     }
   }
 
   DCHECK_EQ(histogram_type_, histogram->GetHistogramType());
   if (bucket_count_ != 0 &&
       !histogram->HasConstructionArguments(minimum_, maximum_, bucket_count_)) {
     // The construction arguments do not match the existing histogram.  This can
     // come about if an extension updates in the middle of a chrome run and has
     // changed one of them, or simply by bad code within Chrome itself.  We
     // return NULL here with the expectation that bad code in Chrome will crash
@@ skipping 932 matching lines @@
     Sample sample = custom_ranges[i];
     if (sample < 0 || sample > HistogramBase::kSampleType_MAX - 1)
       return false;
     if (sample != 0)
       has_valid_range = true;
   }
   return has_valid_range;
 }
 
 }  // namespace base