Support using UMA_HISTOGRAM_CUSTOM_ENUMERATION from the renderer.

base/metrics/histogram.h

 // Copyright (c) 2011 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).
 
 // It supports calls to accumulate either time intervals (which are processed
 // as integral number of milliseconds), or arbitrary integral units.
@@ skipping 30 matching lines @@
 #define BASE_METRICS_HISTOGRAM_H_
 #pragma once
 
 #include <list>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/base_export.h"
+#include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/logging.h"
 #include "base/time.h"
 
 class Pickle;
 
 namespace base {
 
 class Lock;
 //------------------------------------------------------------------------------
@@ skipping 414 matching lines @@
   // Convenience methods for serializing/deserializing the histograms.
   // Histograms from Renderer process are serialized and sent to the browser.
   // Browser process reconstructs the histogram from the pickled version
   // accumulates the browser-side shadow copy of histograms (that mirror
   // histograms created in the renderer).
 
   // Serialize the given snapshot of a Histogram into a String. Uses
   // Pickle class to flatten the object.
   static std::string SerializeHistogramInfo(const Histogram& histogram,
                                             const SampleSet& snapshot);
+
   // The following method accepts a list of pickled histograms and
   // builds a histogram and updates shadow copy of histogram data in the
   // browser process.
   static bool DeserializeHistogramInfo(const std::string& histogram_info);
 
   // Check to see if bucket ranges, counts and tallies in the snapshot are
   // consistent with the bucket ranges and checksums in our histogram.  This can
   // produce a false-alarm if a race occurred in the reading of the data during
   // a SnapShot process, but should otherwise be false at all times (unless we
   // have memory over-writes, or DRAM failures).
@@ skipping 28 matching lines @@
   bool HasValidRangeChecksum() const;
 
  protected:
   Histogram(const std::string& name, Sample minimum,
             Sample maximum, size_t bucket_count);
   Histogram(const std::string& name, TimeDelta minimum,
             TimeDelta maximum, size_t bucket_count);
 
   virtual ~Histogram();
 
+  // Serialize the histogram's ranges to |*pickle|, returning true on success.
+  // Most subclasses can leave this no-op implementation, but some will want to
+  // override it, especially if the ranges cannot be re-derived from other
+  // serialized parameters.
+  virtual bool SerializeRanges(Pickle* pickle) const;
+
   // Initialize ranges_ mapping in cached_ranges_.
   void InitializeBucketRange();
 
   // Method to override to skip the display of the i'th bucket if it's empty.
   virtual bool PrintEmptyBucket(size_t index) const;
 
   //----------------------------------------------------------------------------
   // Methods to override to create histogram with different bucket widths.
   //----------------------------------------------------------------------------
   // Find bucket to increment for sample value.
@@ skipping 189 matching lines @@
   virtual ClassType histogram_type() const;
 
   // Helper method for transforming an array of valid enumeration values
   // to the std::vector<int> expected by HISTOGRAM_CUSTOM_ENUMERATION.
   // This function ensures that a guard bucket exists right after any
   // valid sample value (unless the next higher sample is also a valid value),
   // so that invalid samples never fall into the same bucket as valid samples.
   static std::vector<Sample> ArrayToCustomRanges(const Sample* values,
                                                  size_t num_values);
 
+  // Helper for deserializing CustomHistograms.  |*ranges| should already be
+  // correctly sized before this call.  Return true on success.
+  static bool DeserializeRanges(void** iter, const Pickle& pickle,
+                                std::vector<Histogram::Sample>* ranges);
+
+
  protected:
   CustomHistogram(const std::string& name,
                   const std::vector<Sample>& custom_ranges);
 
+  virtual bool SerializeRanges(Pickle* pickle) const OVERRIDE;
+
   // Initialize ranges_ mapping in cached_ranges_.
   void InitializedCustomBucketRange(const std::vector<Sample>& custom_ranges);
   virtual double GetBucketSize(Count current, size_t i) const;
 
   DISALLOW_COPY_AND_ASSIGN(CustomHistogram);
 };
 
 //------------------------------------------------------------------------------
 // StatisticsRecorder handles all histograms in the system.  It provides a
 // general place for histograms to register, and supports a global API for
@@ skipping 112 matching lines @@
   // of our data, and to quickly see if some other CachedRanges instance is
   // possibly Equal() to this instance.
   uint32 range_checksum_;
 
   DISALLOW_COPY_AND_ASSIGN(CachedRanges);
 };
 
 }  // namespace base
 
 #endif  // BASE_METRICS_HISTOGRAM_H_