// 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).

//直方图是汇总统计信息的对象，可以将它们汇总

//各种形式，包括ASCII图形，HTML和数字（如

//每个聚合桶对应的数字向量）。

#include "base/histogram.h"

#include <math.h>

#include <string>

#include "base/logging.h"

#include "base/pickle.h"

#include "base/string_util.h"

#include "base/pickle.h"

    bool Serialize(Pickle* pickle) const;

    bool Deserialize(void** iter, const Pickle& pickle);

class Pickle;

class Histogram {

 public:

//----------------------------------------------------------------------------

  // Statistic values, developed over the life of the histogram.

  class SampleSet {

   public:

    explicit SampleSet();

    // Adjust size of counts_ for use with given histogram.

    void Resize(const Histogram& histogram);

    void CheckSize(const Histogram& histogram) const;

    // Accessor for histogram to make routine additions.

    void Accumulate(Sample value, Count count, size_t index);

    // Accessor methods.

    Count counts(size_t i) const { return counts_[i]; }

    Count TotalCount() const;

    int64 sum() const { return sum_; }

    int64 square_sum() const { return square_sum_; }

    // Arithmetic manipulation of corresponding elements of the set.

    void Add(const SampleSet& other);

    void Subtract(const SampleSet& other);

    bool Serialize(Pickle* pickle) const;

    bool Deserialize(void** iter, const Pickle& pickle);

   protected:

    // Actual histogram data is stored in buckets, showing the count of values

    // that fit into each bucket.

    Counts counts_;

    // Save simple stats locally.  Note that this MIGHT get done in base class

    // without shared memory at some point.

    int64 sum_;         // sum of samples.

    int64 square_sum_;  // sum of squares of samples.

  };

  //----------------------------------------------------------------------------

  Histogram(const char* name, Sample minimum,

            Sample maximum, size_t bucket_count);

  Histogram(const char* name, base::TimeDelta minimum,

            base::TimeDelta maximum, size_t bucket_count);

  virtual ~Histogram();

  void Add(int value);

  // Accept a TimeDelta to increment.

  void AddTime(base::TimeDelta time) {

    Add(static_cast<int>(time.InMilliseconds()));

  }

  void AddSampleSet(const SampleSet& sample);

  // The following methods provide graphical histogram displays.

  void WriteHTMLGraph(std::string* output) const;

  void WriteAscii(bool graph_it, const std::string& newline,

                  std::string* output) const;

  // Support generic flagging of Histograms.

  // 0x1 Currently used to mark this histogram to be recorded by UMA..

  // 0x8000 means print ranges in hex.

  void SetFlags(int flags) { flags_ |= flags; }

  void ClearFlags(int flags) { flags_ &= ~flags; }

  int flags() const { return flags_; }

  virtual BucketLayout histogram_type() const { return EXPONENTIAL; }

  // 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);

  //----------------------------------------------------------------------------

  // Accessors for serialization and testing.

  //----------------------------------------------------------------------------

  const std::string histogram_name() const { return histogram_name_; }

  Sample declared_min() const { return declared_min_; }

  Sample declared_max() const { return declared_max_; }

  virtual Sample ranges(size_t i) const { return ranges_[i];}

  virtual size_t bucket_count() const { return bucket_count_; }

  // Snapshot the current complete set of sample data.

  // Override with atomic/locked snapshot if needed.

  virtual void SnapshotSample(SampleSet* sample) const;

  // ...

}

// Check for basic syntax and use.

TEST(HistogramTest, StartupShutdownTest) {

  // Try basic construction

  Histogram histogram("TestHistogram", , , );

  Histogram histogram1("Test1Histogram", , , );

  LinearHistogram linear_histogram("TestLinearHistogram", , , );

  LinearHistogram linear_histogram1("Test1LinearHistogram", , , );

  // Use standard macros (but with fixed samples)

  HISTOGRAM_TIMES("Test2Histogram", TimeDelta::FromDays());

  HISTOGRAM_COUNTS("Test3Histogram", );

  DHISTOGRAM_TIMES("Test4Histogram", TimeDelta::FromDays());

  DHISTOGRAM_COUNTS("Test5Histogram", );

  ASSET_HISTOGRAM_COUNTS("Test6Histogram", );

  // Try to construct samples.

  Histogram::SampleSet sample1;

  Histogram::SampleSet sample2;

  // Use copy constructor of SampleSet

  sample1 = sample2;

  Histogram::SampleSet sample3(sample1);

  // Finally test a statistics recorder, without really using it.

  StatisticsRecorder recorder;

}