Persist setup metrics and have Chrome report them during UMA upload.

base/metrics/histogram_snapshot_manager.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.
 
 #include "base/metrics/histogram_snapshot_manager.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_flattener.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/stl_util.h"
 
 namespace {
-// A flag to indicate that a new inconsistency has been added to the set.
-// It is used to know if the value needs to be sent upstream and cleared after.
-const int kNewInconsistency = (int)0x80000000;
+const int kNewInconsistency = static_cast<int>(0x80000000);
 }  // namespace
 
 namespace base {
 
 HistogramSnapshotManager::HistogramSnapshotManager(
     HistogramFlattener* histogram_flattener)
     : preparing_deltas_(false),
       histogram_flattener_(histogram_flattener) {
   DCHECK(histogram_flattener_);
 }
 
 HistogramSnapshotManager::~HistogramSnapshotManager() {
 }
 
 void HistogramSnapshotManager::StartDeltas() {
   // Ensure that start/finish calls do not get nested.
   DCHECK(!preparing_deltas_);
   preparing_deltas_ = true;
 
+  DCHECK(owned_histograms_.empty());
+
 #ifdef DEBUG
-  for (const auto& iter : known_histograms) {
     CHECK(!iter->second.histogram);
     CHECK(!iter->second.accumulated_samples);
     CHECK(!(iter->second.inconsistencies & kNewInconsistency));
   }
 #endif
 }
 
 void HistogramSnapshotManager::PrepareDelta(HistogramBase* histogram) {
-  PrepareSamples(histogram, histogram->SnapshotDelta());
+  PrepareSamples(histogram, histogram->SnapshotDelta(), false);
+}
+
+void HistogramSnapshotManager::PrepareDeltaTakingOwnership(
+    scoped_ptr<HistogramBase> histogram) {
+  // Snapshot must be done before releasing the pointer.
+  scoped_ptr<HistogramSamples> samples = histogram->SnapshotDelta();
+  PrepareSamples(histogram.release(), std::move(samples), true);
 }
 
 void HistogramSnapshotManager::PrepareOnce(const HistogramBase* histogram) {
-  PrepareSamples(histogram, histogram->SnapshotSamples());
+  PrepareSamples(histogram, histogram->SnapshotSamples(), false);
+}
+
+void HistogramSnapshotManager::PrepareOnceTakingOwnership(
+    scoped_ptr<const HistogramBase> histogram) {
+  // Snapshot must be done before releasing the pointer.
+  scoped_ptr<HistogramSamples> samples = histogram->SnapshotSamples();
+  PrepareSamples(histogram.release(), std::move(samples), true);
 }
 
 void HistogramSnapshotManager::FinishDeltas() {
   DCHECK(preparing_deltas_);
 
   // Iterate over all known histograms to see what should be recorded.
-  for (auto& iter : known_histograms_) {
-    SampleInfo* sample_info = &iter.second;
+  for (auto& hash_and_info : known_histograms_) {
+    SampleInfo* sample_info = &hash_and_info.second;
 
     // First, record any histograms in which corruption was detected.
     if (sample_info->inconsistencies & kNewInconsistency) {
       sample_info->inconsistencies &= ~kNewInconsistency;
       histogram_flattener_->UniqueInconsistencyDetected(
           static_cast<HistogramBase::Inconsistency>(
               sample_info->inconsistencies));
     }
 
     // Second, record actual accumulated deltas.
     if (sample_info->accumulated_samples) {
       // TODO(bcwhite): Investigate using redundant_count() below to avoid
       // additional pass through all the samples to calculate real total.
       if (sample_info->accumulated_samples->TotalCount() > 0) {
         histogram_flattener_->RecordDelta(*sample_info->histogram,
                                           *sample_info->accumulated_samples);
       }
       delete sample_info->accumulated_samples;
       sample_info->accumulated_samples = nullptr;
     }
 
     // The Histogram pointer must be cleared at this point because the owner
     // is only required to keep it alive until FinishDeltas() completes.
     sample_info->histogram = nullptr;
   }
 
+  owned_histograms_.clear();
   preparing_deltas_ = false;
 }
 
 void HistogramSnapshotManager::PrepareSamples(
     const HistogramBase* histogram,
-    scoped_ptr<HistogramSamples> samples) {
+    scoped_ptr<HistogramSamples> samples,
+    bool take_ownership) {
   DCHECK(histogram_flattener_);
+  scoped_ptr<const HistogramBase> owned_histogram;
 
   // Get information known about this histogram.
   SampleInfo* sample_info = &known_histograms_[histogram->name_hash()];
   if (sample_info->histogram) {
     DCHECK_EQ(sample_info->histogram->histogram_name(),
               histogram->histogram_name()) << "hash collision";
+    // Passed histogram won't be needed past end of this method so store
+    // it in a scoped_ptr that will release it when returning.
+    if (take_ownership)
+      owned_histogram.reset(histogram);
   } else {
     // First time this histogram has been seen; datafill.
     sample_info->histogram = histogram;
+    // The histogram data will be needed up until "finished" so store
+    // in member vector for releasing when that is done.
+    if (take_ownership)
+      owned_histograms_.push_back(make_scoped_ptr(histogram));
   }
 
   // Crash if we detect that our histograms have been overwritten.  This may be
   // a fair distance from the memory smasher, but we hope to correlate these
   // crashes with other events, such as plugins, or usage patterns, etc.
   int corruption = histogram->FindCorruption(*samples);
   if (HistogramBase::BUCKET_ORDER_ERROR & corruption) {
     // The checksum should have caught this, so crash separately if it didn't.
     CHECK_NE(0, HistogramBase::RANGE_CHECKSUM_ERROR & corruption);
     CHECK(false);  // Crash for the bucket order corruption.
@@ skipping 37 matching lines @@
 
   histogram_flattener_->InconsistencyDetectedInLoggedCount(discrepancy);
   if (discrepancy > Histogram::kCommonRaceBasedCountMismatch) {
     // Fix logged_samples.
     logged_samples->Subtract(*logged_samples);
     logged_samples->Add(new_snapshot);
   }
 }
 
 }  // namespace base