Merge subprocess metrics into global StatisticsRecorder.

base/metrics/persistent_histogram_allocator.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_histogram_allocator.h"
 
 #include <memory>
 
 #include "base/files/important_file_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/persistent_sample_map.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/metrics/statistics_recorder.h"
+#include "base/pickle.h"
 #include "base/synchronization/lock.h"
 
 // TODO(bcwhite): Order these methods to match the header file. The current
 // order is only temporary in order to aid review of the transition from
 // a non-class implementation.
 
 namespace base {
 
 namespace {
 
@@ skipping 447 matching lines @@
   // be marked as "iterable" in order to be found by other processes.
   if (registered)
     memory_allocator_->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
     memory_allocator_->SetType(ref, 0);
 }
 
+void PersistentHistogramAllocator::MergeHistogramToStatisticsRecorder(
+    HistogramBase* histogram) {
+  // This should never be called on the global histogram allocator as objects
+  // created there are already within the global statistics recorder.
+  DCHECK_NE(g_allocator, this);
+  DCHECK(histogram);
+
+  HistogramBase* existing =
+      StatisticsRecorder::FindHistogram(histogram->histogram_name());
+  if (!existing) {
+    // Adding the passed histogram to the SR would cause a problem if the
+    // allocator that holds it eventually goes away. Instead, create a new
+    // one from a serialized version and then add the data to it. Future
+    // merges won't need to do this step since FindHistogram() will locate
+    // the one created here.
+    base::Pickle pickle;
+    if (!histogram->SerializeInfo(&pickle)) {
+      // Pickling should never fail but if it does, no real harm is done.
+      // The data won't be merged but it also won't be recorded as merged
+      // so a future try, if successful, will get what was missed. If it
+      // continues to fail, some metric data will be lost but that is
+      // better than crashing.
+      NOTREACHED();
+      return;
+    }
+
+    PickleIterator iter(pickle);
+    existing = DeserializeHistogramInfo(&iter);
+    if (!existing) {
+      // Un-pickling should similarly never fail.
+      NOTREACHED();
+      return;
+    }
+
+    // Make sure there is no "serialization" flag set.
+    DCHECK_EQ(0,
+              existing->flags() & HistogramBase::kIPCSerializationSourceFlag);
+
+    // Record the newly created histogram in the SR.
+    existing = StatisticsRecorder::RegisterOrDeleteDuplicate(existing);
+  }
+
+  // Merge the delta from the passed object to the one in the SR.
+  existing->AddSamples(*histogram->SnapshotDelta());
+}
+
 PersistentSampleMapRecords* PersistentHistogramAllocator::UseSampleMapRecords(
     uint64_t id,
     const void* user) {
   return sparse_histogram_data_manager_.UseSampleMapRecords(id, user);
 }
 
 std::unique_ptr<HistogramBase> PersistentHistogramAllocator::AllocateHistogram(
     HistogramType histogram_type,
     const std::string& name,
     int minimum,
@@ skipping 262 matching lines @@
   while (true) {
     std::unique_ptr<HistogramBase> histogram =
         import_iterator_.GetNextWithIgnore(record_to_ignore);
     if (!histogram)
       break;
     StatisticsRecorder::RegisterOrDeleteDuplicate(histogram.release());
   }
 }
 
 }  // namespace base