Bug 1366294 - Part 2 - Cleanup Chromium Histogram code. r=chutten
authorGeorg Fritzsche <georg.fritzsche@googlemail.com>
Tue, 06 Jun 2017 16:48:11 +0700
changeset 419302 d51abac894b8a31090e66c82f462781b0059716e
parent 419301 51f2cc05efdea472ec78f2c93aae9491a910559c
child 419303 9332d032c50d84f91412ca359a1e9e655d05c15e
push id7566
push usermtabara@mozilla.com
push dateWed, 02 Aug 2017 08:25:16 +0000
treeherdermozilla-beta@86913f512c3c [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerschutten
bugs1366294
milestone56.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1366294 - Part 2 - Cleanup Chromium Histogram code. r=chutten - A histogram name identifies a set of histogram instances, for which storage and lookup will be handled in TelemetryHistogram.cpp. So we remove the names from histogram code. - Various unused macros in the header are removed. - Remaining traces of StatisticsRecorder are removed from the Histogram class code. - Some unused methods are dropped that were about printing histograms to ASCII etc. MozReview-Commit-ID: BF2rLSpKOJ8
ipc/chromium/src/base/histogram.cc
ipc/chromium/src/base/histogram.h
--- a/ipc/chromium/src/base/histogram.cc
+++ b/ipc/chromium/src/base/histogram.cc
@@ -76,52 +76,42 @@ 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L, 0
 0x2d02ef8dL,
 };
 
 typedef Histogram::Count Count;
 
 // static
 const size_t Histogram::kBucketCount_MAX = 16384u;
 
-Histogram* Histogram::FactoryGet(const std::string& name,
-                                 Sample minimum,
+Histogram* Histogram::FactoryGet(Sample minimum,
                                  Sample maximum,
                                  size_t bucket_count,
                                  Flags flags) {
   Histogram* histogram(NULL);
 
   // Defensive code.
   if (minimum < 1)
     minimum = 1;
   if (maximum > kSampleType_MAX - 1)
     maximum = kSampleType_MAX - 1;
 
-  if (!StatisticsRecorder::FindHistogram(name, &histogram)) {
-    // Extra variable is not needed... but this keeps this section basically
-    // identical to other derived classes in this file (and compiler will
-    // optimize away the extra variable.
-    Histogram* tentative_histogram =
-        new Histogram(name, minimum, maximum, bucket_count);
-    tentative_histogram->InitializeBucketRange();
-    tentative_histogram->SetFlags(flags);
-    histogram =
-        StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
-  }
+  histogram = new Histogram(minimum, maximum, bucket_count);
+  histogram->InitializeBucketRange();
+  histogram->SetFlags(flags);
 
   DCHECK_EQ(HISTOGRAM, histogram->histogram_type());
   DCHECK(histogram->HasConstructorArguments(minimum, maximum, bucket_count));
   return histogram;
 }
 
-Histogram* Histogram::FactoryTimeGet(const std::string& name,
-                                     TimeDelta minimum,
+Histogram* Histogram::FactoryTimeGet(TimeDelta minimum,
                                      TimeDelta maximum,
                                      size_t bucket_count,
                                      Flags flags) {
-  return FactoryGet(name, minimum.InMilliseconds(), maximum.InMilliseconds(),
+  return FactoryGet(minimum.InMilliseconds(), maximum.InMilliseconds(),
                     bucket_count, flags);
 }
 
 void Histogram::Add(int value) {
   if (value > kSampleType_MAX - 1)
     value = kSampleType_MAX - 1;
   if (value < 0)
     value = 0;
@@ -155,90 +145,16 @@ void Histogram::Clear() {
   ss.Resize(*this);
   sample_ = ss;
 }
 
 void Histogram::SetRangeDescriptions(const DescriptionPair descriptions[]) {
   DCHECK(false);
 }
 
-// The following methods provide a graphical histogram display.
-void Histogram::WriteHTMLGraph(std::string* output) const {
-  // TBD(jar) Write a nice HTML bar chart, with divs an mouse-overs etc.
-  output->append("<PRE>");
-  WriteAscii(true, "<br>", output);
-  output->append("</PRE>");
-}
-
-void Histogram::WriteAscii(bool graph_it, const std::string& newline,
-                           std::string* output) const {
-  // Get local (stack) copies of all effectively volatile class data so that we
-  // are consistent across our output activities.
-  SampleSet snapshot;
-  SnapshotSample(&snapshot);
-
-  Count sample_count = snapshot.TotalCount();
-
-  WriteAsciiHeader(snapshot, sample_count, output);
-  output->append(newline);
-
-  // Prepare to normalize graphical rendering of bucket contents.
-  double max_size = 0;
-  if (graph_it)
-    max_size = GetPeakBucketSize(snapshot);
-
-  // Calculate space needed to print bucket range numbers.  Leave room to print
-  // nearly the largest bucket range without sliding over the histogram.
-  size_t largest_non_empty_bucket = bucket_count() - 1;
-  while (0 == snapshot.counts(largest_non_empty_bucket)) {
-    if (0 == largest_non_empty_bucket)
-      break;  // All buckets are empty.
-    --largest_non_empty_bucket;
-  }
-
-  // Calculate largest print width needed for any of our bucket range displays.
-  size_t print_width = 1;
-  for (size_t i = 0; i < bucket_count(); ++i) {
-    if (snapshot.counts(i)) {
-      size_t width = GetAsciiBucketRange(i).size() + 1;
-      if (width > print_width)
-        print_width = width;
-    }
-  }
-
-  int64_t remaining = sample_count;
-  int64_t past = 0;
-  // Output the actual histogram graph.
-  for (size_t i = 0; i < bucket_count(); ++i) {
-    Count current = snapshot.counts(i);
-    if (!current && !PrintEmptyBucket(i))
-      continue;
-    remaining -= current;
-    std::string range = GetAsciiBucketRange(i);
-    output->append(range);
-    for (size_t j = 0; range.size() + j < print_width + 1; ++j)
-      output->push_back(' ');
-    if (0 == current &&
-        i < bucket_count() - 1 && 0 == snapshot.counts(i + 1)) {
-      while (i < bucket_count() - 1 && 0 == snapshot.counts(i + 1))
-        ++i;
-      output->append("... ");
-      output->append(newline);
-      continue;  // No reason to plot emptiness.
-    }
-    double current_size = GetBucketSize(current, i);
-    if (graph_it)
-      WriteAsciiBucketGraph(current_size, max_size, output);
-    WriteAsciiBucketContext(past, current, remaining, i, output);
-    output->append(newline);
-    past += current;
-  }
-  DCHECK_EQ(sample_count, past);
-}
-
 //------------------------------------------------------------------------------
 // Methods for the validating a sample and a related histogram.
 //------------------------------------------------------------------------------
 
 Histogram::Inconsistencies
 Histogram::FindCorruption(const SampleSet& snapshot) const
 {
   int inconsistencies = NO_INCONSISTENCIES;
@@ -265,22 +181,20 @@ Histogram::FindCorruption(const SampleSe
     // we'll catch a redundant count that doesn't match the sample count.  We
     // allow for a certain amount of slop before flagging this as an
     // inconsistency.  Even with an inconsistency, we'll snapshot it again (for
     // UMA in about a half hour, so we'll eventually get the data, if it was
     // not the result of a corruption.  If histograms show that 1 is "too tight"
     // then we may try to use 2 or 3 for this slop value.
     const int kCommonRaceBasedCountMismatch = 1;
     if (delta > 0) {
-      UMA_HISTOGRAM_COUNTS("Histogram.InconsistentCountHigh", delta);
       if (delta > kCommonRaceBasedCountMismatch)
         inconsistencies |= COUNT_HIGH_ERROR;
     } else {
       DCHECK_GT(0, delta);
-      UMA_HISTOGRAM_COUNTS("Histogram.InconsistentCountLow", -delta);
       if (-delta > kCommonRaceBasedCountMismatch)
         inconsistencies |= COUNT_LOW_ERROR;
     }
   }
   return static_cast<Inconsistencies>(inconsistencies);
 }
 
 Histogram::ClassType Histogram::histogram_type() const {
@@ -332,51 +246,41 @@ size_t Histogram::SizeOfIncludingThis(mo
 size_t
 Histogram::SampleSet::SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf)
 {
   // We're not allowed to do deep dives into STL data structures.  This
   // is as close as we can get to measuring this array.
   return aMallocSizeOf(&counts_[0]);
 }
 
-Histogram::Histogram(const std::string& name, Sample minimum,
-                     Sample maximum, size_t bucket_count)
+Histogram::Histogram(Sample minimum, Sample maximum, size_t bucket_count)
   : sample_(),
-    histogram_name_(name),
     declared_min_(minimum),
     declared_max_(maximum),
     bucket_count_(bucket_count),
     flags_(kNoFlags),
     ranges_(bucket_count + 1, 0),
     range_checksum_(0),
     recording_enabled_(true) {
   Initialize();
 }
 
-Histogram::Histogram(const std::string& name, TimeDelta minimum,
-                     TimeDelta maximum, size_t bucket_count)
+Histogram::Histogram(TimeDelta minimum, TimeDelta maximum, size_t bucket_count)
   : sample_(),
-    histogram_name_(name),
     declared_min_(static_cast<int> (minimum.InMilliseconds())),
     declared_max_(static_cast<int> (maximum.InMilliseconds())),
     bucket_count_(bucket_count),
     flags_(kNoFlags),
     ranges_(bucket_count + 1, 0),
     range_checksum_(0),
     recording_enabled_(true) {
   Initialize();
 }
 
 Histogram::~Histogram() {
-  if (StatisticsRecorder::dump_on_exit()) {
-    std::string output;
-    WriteAscii(true, "\n", &output);
-    CHROMIUM_LOG(INFO) << output;
-  }
-
   // Just to make sure most derived class did this properly...
   DCHECK(ValidateBucketRanges());
 }
 
 // Calculate what range of values are held in each bucket.
 // We have to be careful that we don't pick a ratio between starting points in
 // consecutive buckets that is sooo small, that the integer bounds are the same
 // (effectively making one bucket get no values).  We need to avoid:
@@ -555,67 +459,16 @@ double Histogram::GetPeakBucketSize(cons
     double current_size
         = GetBucketSize(snapshot.counts(i), i);
     if (current_size > max)
       max = current_size;
   }
   return max;
 }
 
-void Histogram::WriteAsciiHeader(const SampleSet& snapshot,
-                                 Count sample_count,
-                                 std::string* output) const {
-  StringAppendF(output,
-                "Histogram: %s recorded %d samples",
-                histogram_name().c_str(),
-                sample_count);
-  int64_t snapshot_sum = snapshot.sum();
-  if (0 == sample_count) {
-    DCHECK_EQ(snapshot_sum, 0);
-  } else {
-    double average = static_cast<float>(snapshot_sum) / sample_count;
-
-    StringAppendF(output, ", average = %.1f", average);
-  }
-  if (flags_ & ~kHexRangePrintingFlag)
-    StringAppendF(output, " (flags = 0x%x)", flags_ & ~kHexRangePrintingFlag);
-}
-
-void Histogram::WriteAsciiBucketContext(const int64_t past,
-                                        const Count current,
-                                        const int64_t remaining,
-                                        const size_t i,
-                                        std::string* output) const {
-  double scaled_sum = (past + current + remaining) / 100.0;
-  WriteAsciiBucketValue(current, scaled_sum, output);
-  if (0 < i) {
-    double percentage = past / scaled_sum;
-    StringAppendF(output, " {%3.1f%%}", percentage);
-  }
-}
-
-void Histogram::WriteAsciiBucketValue(Count current, double scaled_sum,
-                                      std::string* output) const {
-  StringAppendF(output, " (%d = %3.1f%%)", current, current/scaled_sum);
-}
-
-void Histogram::WriteAsciiBucketGraph(double current_size, double max_size,
-                                      std::string* output) const {
-  const int k_line_length = 72;  // Maximal horizontal width of graph.
-  int x_count = static_cast<int>(k_line_length * (current_size / max_size)
-                                 + 0.5);
-  int x_remainder = k_line_length - x_count;
-
-  while (0 < x_count--)
-    output->append("-");
-  output->append("O");
-  while (0 < x_remainder--)
-    output->append(" ");
-}
-
 //------------------------------------------------------------------------------
 // Methods for the Histogram::SampleSet class
 //------------------------------------------------------------------------------
 
 Histogram::SampleSet::SampleSet()
     : counts_(),
       sum_(0),
       redundant_count_(0) {
@@ -660,48 +513,43 @@ void Histogram::SampleSet::Add(const Sam
 //------------------------------------------------------------------------------
 // LinearHistogram: This histogram uses a traditional set of evenly spaced
 // buckets.
 //------------------------------------------------------------------------------
 
 LinearHistogram::~LinearHistogram() {
 }
 
-Histogram* LinearHistogram::FactoryGet(const std::string& name,
-                                       Sample minimum,
+Histogram* LinearHistogram::FactoryGet(Sample minimum,
                                        Sample maximum,
                                        size_t bucket_count,
                                        Flags flags) {
   Histogram* histogram(NULL);
 
   if (minimum < 1)
     minimum = 1;
   if (maximum > kSampleType_MAX - 1)
     maximum = kSampleType_MAX - 1;
 
-  if (!StatisticsRecorder::FindHistogram(name, &histogram)) {
-    LinearHistogram* tentative_histogram =
-        new LinearHistogram(name, minimum, maximum, bucket_count);
-    tentative_histogram->InitializeBucketRange();
-    tentative_histogram->SetFlags(flags);
-    histogram =
-        StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
-  }
+  LinearHistogram* linear_histogram =
+        new LinearHistogram(minimum, maximum, bucket_count);
+  linear_histogram->InitializeBucketRange();
+  linear_histogram->SetFlags(flags);
+  histogram = linear_histogram;
 
   DCHECK_EQ(LINEAR_HISTOGRAM, histogram->histogram_type());
   DCHECK(histogram->HasConstructorArguments(minimum, maximum, bucket_count));
   return histogram;
 }
 
-Histogram* LinearHistogram::FactoryTimeGet(const std::string& name,
-                                           TimeDelta minimum,
+Histogram* LinearHistogram::FactoryTimeGet(TimeDelta minimum,
                                            TimeDelta maximum,
                                            size_t bucket_count,
                                            Flags flags) {
-  return FactoryGet(name, minimum.InMilliseconds(), maximum.InMilliseconds(),
+  return FactoryGet(minimum.InMilliseconds(), maximum.InMilliseconds(),
                     bucket_count, flags);
 }
 
 Histogram::ClassType LinearHistogram::histogram_type() const {
   return LINEAR_HISTOGRAM;
 }
 
 void LinearHistogram::Accumulate(Sample value, Count count, size_t index) {
@@ -710,28 +558,26 @@ void LinearHistogram::Accumulate(Sample 
 
 void LinearHistogram::SetRangeDescriptions(
     const DescriptionPair descriptions[]) {
   for (int i =0; descriptions[i].description; ++i) {
     bucket_description_[descriptions[i].sample] = descriptions[i].description;
   }
 }
 
-LinearHistogram::LinearHistogram(const std::string& name,
-                                 Sample minimum,
+LinearHistogram::LinearHistogram(Sample minimum,
                                  Sample maximum,
                                  size_t bucket_count)
-    : Histogram(name, minimum >= 1 ? minimum : 1, maximum, bucket_count) {
+    : Histogram(minimum >= 1 ? minimum : 1, maximum, bucket_count) {
 }
 
-LinearHistogram::LinearHistogram(const std::string& name,
-                                 TimeDelta minimum,
+LinearHistogram::LinearHistogram(TimeDelta minimum,
                                  TimeDelta maximum,
                                  size_t bucket_count)
-    : Histogram(name, minimum >= TimeDelta::FromMilliseconds(1) ?
+    : Histogram(minimum >= TimeDelta::FromMilliseconds(1) ?
                                  minimum : TimeDelta::FromMilliseconds(1),
                 maximum, bucket_count) {
 }
 
 void LinearHistogram::InitializeBucketRange() {
   DCHECK_GT(declared_min(), 0);  // 0 is the underflow bucket here.
   double min = declared_min();
   double max = declared_max();
@@ -764,74 +610,69 @@ bool LinearHistogram::PrintEmptyBucket(s
   return bucket_description_.find(ranges(index)) == bucket_description_.end();
 }
 
 
 //------------------------------------------------------------------------------
 // This section provides implementation for BooleanHistogram.
 //------------------------------------------------------------------------------
 
-Histogram* BooleanHistogram::FactoryGet(const std::string& name, Flags flags) {
+Histogram* BooleanHistogram::FactoryGet(Flags flags) {
   Histogram* histogram(NULL);
 
-  if (!StatisticsRecorder::FindHistogram(name, &histogram)) {
-    BooleanHistogram* tentative_histogram = new BooleanHistogram(name);
-    tentative_histogram->InitializeBucketRange();
-    tentative_histogram->SetFlags(flags);
-    histogram =
-        StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
-  }
+  BooleanHistogram* tentative_histogram = new BooleanHistogram();
+  tentative_histogram->InitializeBucketRange();
+  tentative_histogram->SetFlags(flags);
+  histogram = tentative_histogram;
 
   DCHECK_EQ(BOOLEAN_HISTOGRAM, histogram->histogram_type());
   return histogram;
 }
 
 Histogram::ClassType BooleanHistogram::histogram_type() const {
   return BOOLEAN_HISTOGRAM;
 }
 
 void BooleanHistogram::AddBoolean(bool value) {
   Add(value ? 1 : 0);
 }
 
-BooleanHistogram::BooleanHistogram(const std::string& name)
-    : LinearHistogram(name, 1, 2, 3) {
+BooleanHistogram::BooleanHistogram()
+    : LinearHistogram(1, 2, 3) {
 }
 
 void
 BooleanHistogram::Accumulate(Sample value, Count count, size_t index)
 {
   // Callers will have computed index based on the non-booleanified value.
   // So we need to adjust the index manually.
   LinearHistogram::Accumulate(!!value, count, value ? 1 : 0);
 }
 
 //------------------------------------------------------------------------------
 // FlagHistogram:
 //------------------------------------------------------------------------------
 
 Histogram *
-FlagHistogram::FactoryGet(const std::string &name, Flags flags)
+FlagHistogram::FactoryGet(Flags flags)
 {
   Histogram *h(nullptr);
 
-  if (!StatisticsRecorder::FindHistogram(name, &h)) {
-    FlagHistogram *fh = new FlagHistogram(name);
-    fh->InitializeBucketRange();
-    fh->SetFlags(flags);
-    size_t zero_index = fh->BucketIndex(0);
-    fh->LinearHistogram::Accumulate(0, 1, zero_index);
-    h = StatisticsRecorder::RegisterOrDeleteDuplicate(fh);
-  }
+  FlagHistogram *fh = new FlagHistogram();
+  fh->InitializeBucketRange();
+  fh->SetFlags(flags);
+  size_t zero_index = fh->BucketIndex(0);
+  fh->LinearHistogram::Accumulate(0, 1, zero_index);
+  h = fh;
 
   return h;
 }
 
-FlagHistogram::FlagHistogram(const std::string &name)
-  : BooleanHistogram(name), mSwitched(false) {
+FlagHistogram::FlagHistogram()
+  : BooleanHistogram(), mSwitched(false) {
 }
 
 Histogram::ClassType
 FlagHistogram::histogram_type() const
 {
   return FLAG_HISTOGRAM;
 }
 
@@ -884,32 +725,30 @@ FlagHistogram::Clear() {
   LinearHistogram::Accumulate(0, 1, zero_index);
 }
 
 //------------------------------------------------------------------------------
 // CountHistogram:
 //------------------------------------------------------------------------------
 
 Histogram *
-CountHistogram::FactoryGet(const std::string &name, Flags flags)
+CountHistogram::FactoryGet(Flags flags)
 {
   Histogram *h(nullptr);
 
-  if (!StatisticsRecorder::FindHistogram(name, &h)) {
-    CountHistogram *fh = new CountHistogram(name);
-    fh->InitializeBucketRange();
-    fh->SetFlags(flags);
-    h = StatisticsRecorder::RegisterOrDeleteDuplicate(fh);
-  }
+  CountHistogram *fh = new CountHistogram();
+  fh->InitializeBucketRange();
+  fh->SetFlags(flags);
+  h = fh;
 
   return h;
 }
 
-CountHistogram::CountHistogram(const std::string &name)
-  : LinearHistogram(name, 1, 2, 3) {
+CountHistogram::CountHistogram()
+  : LinearHistogram(1, 2, 3) {
 }
 
 Histogram::ClassType
 CountHistogram::histogram_type() const
 {
   return COUNT_HISTOGRAM;
 }
 
@@ -937,55 +776,50 @@ CountHistogram::AddSampleSet(const Sampl
   }
 }
 
 
 //------------------------------------------------------------------------------
 // CustomHistogram:
 //------------------------------------------------------------------------------
 
-Histogram* CustomHistogram::FactoryGet(const std::string& name,
-                                       const std::vector<Sample>& custom_ranges,
+Histogram* CustomHistogram::FactoryGet(const std::vector<Sample>& custom_ranges,
                                        Flags flags) {
   Histogram* histogram(NULL);
 
   // Remove the duplicates in the custom ranges array.
   std::vector<int> ranges = custom_ranges;
   ranges.push_back(0);  // Ensure we have a zero value.
   std::sort(ranges.begin(), ranges.end());
   ranges.erase(std::unique(ranges.begin(), ranges.end()), ranges.end());
   if (ranges.size() <= 1) {
     DCHECK(false);
     // Note that we pushed a 0 in above, so for defensive code....
     ranges.push_back(1);  // Put in some data so we can index to [1].
   }
 
   DCHECK_LT(ranges.back(), kSampleType_MAX);
 
-  if (!StatisticsRecorder::FindHistogram(name, &histogram)) {
-    CustomHistogram* tentative_histogram = new CustomHistogram(name, ranges);
-    tentative_histogram->InitializedCustomBucketRange(ranges);
-    tentative_histogram->SetFlags(flags);
-    histogram =
-        StatisticsRecorder::RegisterOrDeleteDuplicate(tentative_histogram);
-  }
+  CustomHistogram* custom_histogram = new CustomHistogram(ranges);
+  custom_histogram->InitializedCustomBucketRange(ranges);
+  custom_histogram->SetFlags(flags);
+  histogram = custom_histogram;
 
   DCHECK_EQ(histogram->histogram_type(), CUSTOM_HISTOGRAM);
   DCHECK(histogram->HasConstructorArguments(ranges[1], ranges.back(),
                                             ranges.size()));
   return histogram;
 }
 
 Histogram::ClassType CustomHistogram::histogram_type() const {
   return CUSTOM_HISTOGRAM;
 }
 
-CustomHistogram::CustomHistogram(const std::string& name,
-                                 const std::vector<Sample>& custom_ranges)
-    : Histogram(name, custom_ranges[1], custom_ranges.back(),
+CustomHistogram::CustomHistogram(const std::vector<Sample>& custom_ranges)
+    : Histogram(custom_ranges[1], custom_ranges.back(),
                 custom_ranges.size()) {
   DCHECK_GT(custom_ranges.size(), 1u);
   DCHECK_EQ(custom_ranges[0], 0);
 }
 
 void CustomHistogram::InitializedCustomBucketRange(
     const std::vector<Sample>& custom_ranges) {
   DCHECK_GT(custom_ranges.size(), 1u);
--- a/ipc/chromium/src/base/histogram.h
+++ b/ipc/chromium/src/base/histogram.h
@@ -51,216 +51,16 @@
 #include <vector>
 
 #include "base/time.h"
 #include "base/lock.h"
 
 namespace base {
 
 //------------------------------------------------------------------------------
-// Provide easy general purpose histogram in a macro, just like stats counters.
-// The first four macros use 50 buckets.
-
-#define HISTOGRAM_TIMES(name, sample) HISTOGRAM_CUSTOM_TIMES( \
-    name, sample, base::TimeDelta::FromMilliseconds(1), \
-    base::TimeDelta::FromSeconds(10), 50)
-
-#define HISTOGRAM_COUNTS(name, sample) HISTOGRAM_CUSTOM_COUNTS( \
-    name, sample, 1, 1000000, 50)
-
-#define HISTOGRAM_COUNTS_100(name, sample) HISTOGRAM_CUSTOM_COUNTS( \
-    name, sample, 1, 100, 50)
-
-#define HISTOGRAM_COUNTS_10000(name, sample) HISTOGRAM_CUSTOM_COUNTS( \
-    name, sample, 1, 10000, 50)
-
-#define HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count) do { \
-    static base::Histogram* counter(NULL); \
-    if (!counter) \
-      counter = base::Histogram::FactoryGet(name, min, max, bucket_count, \
-                                            base::Histogram::kNoFlags); \
-    DCHECK_EQ(name, counter->histogram_name()); \
-    counter->Add(sample); \
-  } while (0)
-
-#define HISTOGRAM_PERCENTAGE(name, under_one_hundred) \
-    HISTOGRAM_ENUMERATION(name, under_one_hundred, 101)
-
-// For folks that need real specific times, use this to select a precise range
-// of times you want plotted, and the number of buckets you want used.
-#define HISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) do { \
-    static base::Histogram* counter(NULL); \
-    if (!counter) \
-      counter = base::Histogram::FactoryTimeGet(name, min, max, bucket_count, \
-                                                base::Histogram::kNoFlags); \
-    DCHECK_EQ(name, counter->histogram_name()); \
-    counter->AddTime(sample); \
-  } while (0)
-
-// DO NOT USE THIS.  It is being phased out, in favor of HISTOGRAM_CUSTOM_TIMES.
-#define HISTOGRAM_CLIPPED_TIMES(name, sample, min, max, bucket_count) do { \
-    static base::Histogram* counter(NULL); \
-    if (!counter) \
-      counter = base::Histogram::FactoryTimeGet(name, min, max, bucket_count, \
-                                                base::Histogram::kNoFlags); \
-    DCHECK_EQ(name, counter->histogram_name()); \
-    if ((sample) < (max)) counter->AddTime(sample); \
-  } while (0)
-
-// Support histograming of an enumerated value.  The samples should always be
-// less than boundary_value.
-
-#define HISTOGRAM_ENUMERATION(name, sample, boundary_value) do { \
-    static base::Histogram* counter(NULL); \
-    if (!counter) \
-      counter = base::LinearHistogram::FactoryGet(name, 1, boundary_value, \
-          boundary_value + 1, base::Histogram::kNoFlags); \
-    DCHECK_EQ(name, counter->histogram_name()); \
-    counter->Add(sample); \
-  } while (0)
-
-#define HISTOGRAM_CUSTOM_ENUMERATION(name, sample, custom_ranges) do { \
-    static base::Histogram* counter(NULL); \
-    if (!counter) \
-      counter = base::CustomHistogram::FactoryGet(name, custom_ranges, \
-                                                  base::Histogram::kNoFlags); \
-    DCHECK_EQ(name, counter->histogram_name()); \
-    counter->Add(sample); \
-  } while (0)
-
-
-//------------------------------------------------------------------------------
-// Define Debug vs non-debug flavors of macros.
-#ifndef NDEBUG
-
-#define DHISTOGRAM_TIMES(name, sample) HISTOGRAM_TIMES(name, sample)
-#define DHISTOGRAM_COUNTS(name, sample) HISTOGRAM_COUNTS(name, sample)
-#define DHISTOGRAM_PERCENTAGE(name, under_one_hundred) HISTOGRAM_PERCENTAGE(\
-    name, under_one_hundred)
-#define DHISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) \
-    HISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count)
-#define DHISTOGRAM_CLIPPED_TIMES(name, sample, min, max, bucket_count) \
-    HISTOGRAM_CLIPPED_TIMES(name, sample, min, max, bucket_count)
-#define DHISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count) \
-    HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count)
-#define DHISTOGRAM_ENUMERATION(name, sample, boundary_value) \
-    HISTOGRAM_ENUMERATION(name, sample, boundary_value)
-#define DHISTOGRAM_CUSTOM_ENUMERATION(name, sample, custom_ranges) \
-    HISTOGRAM_CUSTOM_ENUMERATION(name, sample, custom_ranges)
-
-#else  // NDEBUG
-
-#define DHISTOGRAM_TIMES(name, sample) do {} while (0)
-#define DHISTOGRAM_COUNTS(name, sample) do {} while (0)
-#define DHISTOGRAM_PERCENTAGE(name, under_one_hundred) do {} while (0)
-#define DHISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) \
-    do {} while (0)
-#define DHISTOGRAM_CLIPPED_TIMES(name, sample, min, max, bucket_count) \
-    do {} while (0)
-#define DHISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count) \
-    do {} while (0)
-#define DHISTOGRAM_ENUMERATION(name, sample, boundary_value) do {} while (0)
-#define DHISTOGRAM_CUSTOM_ENUMERATION(name, sample, custom_ranges) \
-    do {} while (0)
-
-#endif  // NDEBUG
-
-//------------------------------------------------------------------------------
-// The following macros provide typical usage scenarios for callers that wish
-// to record histogram data, and have the data submitted/uploaded via UMA.
-// Not all systems support such UMA, but if they do, the following macros
-// should work with the service.
-
-#define UMA_HISTOGRAM_TIMES(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES( \
-    name, sample, base::TimeDelta::FromMilliseconds(1), \
-    base::TimeDelta::FromSeconds(10), 50)
-
-#define UMA_HISTOGRAM_MEDIUM_TIMES(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES( \
-    name, sample, base::TimeDelta::FromMilliseconds(10), \
-    base::TimeDelta::FromMinutes(3), 50)
-
-// Use this macro when times can routinely be much longer than 10 seconds.
-#define UMA_HISTOGRAM_LONG_TIMES(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES( \
-    name, sample, base::TimeDelta::FromMilliseconds(1), \
-    base::TimeDelta::FromHours(1), 50)
-
-#define UMA_HISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) do { \
-    static base::Histogram* counter(NULL); \
-    if (!counter) \
-      counter = base::Histogram::FactoryTimeGet(name, min, max, bucket_count, \
-            base::Histogram::kUmaTargetedHistogramFlag); \
-    DCHECK_EQ(name, counter->histogram_name()); \
-    counter->AddTime(sample); \
-  } while (0)
-
-// DO NOT USE THIS.  It is being phased out, in favor of HISTOGRAM_CUSTOM_TIMES.
-#define UMA_HISTOGRAM_CLIPPED_TIMES(name, sample, min, max, bucket_count) do { \
-    static base::Histogram* counter(NULL); \
-    if (!counter) \
-      counter = base::Histogram::FactoryTimeGet(name, min, max, bucket_count, \
-           base::Histogram::kUmaTargetedHistogramFlag); \
-    DCHECK_EQ(name, counter->histogram_name()); \
-    if ((sample) < (max)) counter->AddTime(sample); \
-  } while (0)
-
-#define UMA_HISTOGRAM_COUNTS(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS( \
-    name, sample, 1, 1000000, 50)
-
-#define UMA_HISTOGRAM_COUNTS_100(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS( \
-    name, sample, 1, 100, 50)
-
-#define UMA_HISTOGRAM_COUNTS_10000(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS( \
-    name, sample, 1, 10000, 50)
-
-#define UMA_HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count) do { \
-    static base::Histogram* counter(NULL); \
-    if (!counter) \
-      counter = base::Histogram::FactoryGet(name, min, max, bucket_count, \
-          base::Histogram::kUmaTargetedHistogramFlag); \
-    DCHECK_EQ(name, counter->histogram_name()); \
-    counter->Add(sample); \
-  } while (0)
-
-#define UMA_HISTOGRAM_MEMORY_KB(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS( \
-    name, sample, 1000, 500000, 50)
-
-#define UMA_HISTOGRAM_MEMORY_MB(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS( \
-    name, sample, 1, 1000, 50)
-
-#define UMA_HISTOGRAM_PERCENTAGE(name, under_one_hundred) \
-    UMA_HISTOGRAM_ENUMERATION(name, under_one_hundred, 101)
-
-#define UMA_HISTOGRAM_BOOLEAN(name, sample) do { \
-    static base::Histogram* counter(NULL); \
-    if (!counter) \
-      counter = base::BooleanHistogram::FactoryGet(name, \
-          base::Histogram::kUmaTargetedHistogramFlag); \
-    DCHECK_EQ(name, counter->histogram_name()); \
-    counter->AddBoolean(sample); \
-  } while (0)
-
-#define UMA_HISTOGRAM_ENUMERATION(name, sample, boundary_value) do { \
-    static base::Histogram* counter(NULL); \
-    if (!counter) \
-      counter = base::LinearHistogram::FactoryGet(name, 1, boundary_value, \
-          boundary_value + 1, base::Histogram::kUmaTargetedHistogramFlag); \
-    DCHECK_EQ(name, counter->histogram_name()); \
-    counter->Add(sample); \
-  } while (0)
-
-#define UMA_HISTOGRAM_CUSTOM_ENUMERATION(name, sample, custom_ranges) do { \
-    static base::Histogram* counter(NULL); \
-    if (!counter) \
-      counter = base::CustomHistogram::FactoryGet(name, custom_ranges, \
-          base::Histogram::kUmaTargetedHistogramFlag); \
-    DCHECK_EQ(name, counter->histogram_name()); \
-    counter->Add(sample); \
-  } while (0)
-
-//------------------------------------------------------------------------------
 
 class BooleanHistogram;
 class CustomHistogram;
 class Histogram;
 class LinearHistogram;
 
 class Histogram {
  public:
@@ -368,23 +168,21 @@ class Histogram {
     // and also the snapshotting code may asynchronously get a mismatch (though
     // generally either race based mismatch cause is VERY rare).
     int64_t redundant_count_;
   };
 
   //----------------------------------------------------------------------------
   // minimum should start from 1. 0 is invalid as a minimum. 0 is an implicit
   // default underflow bucket.
-  static Histogram* FactoryGet(const std::string& name,
-                               Sample minimum,
+  static Histogram* FactoryGet(Sample minimum,
                                Sample maximum,
                                size_t bucket_count,
                                Flags flags);
-  static Histogram* FactoryTimeGet(const std::string& name,
-                                   base::TimeDelta minimum,
+  static Histogram* FactoryTimeGet(base::TimeDelta minimum,
                                    base::TimeDelta maximum,
                                    size_t bucket_count,
                                    Flags flags);
 
   void Add(int value);
   void Subtract(int value);
 
   // TODO: Currently recording_enabled_ is not used by any Histogram class, but
@@ -403,21 +201,16 @@ class Histogram {
 
   virtual void AddSampleSet(const SampleSet& sample);
 
   virtual void Clear();
 
   // This method is an interface, used only by LinearHistogram.
   virtual void SetRangeDescriptions(const DescriptionPair descriptions[]);
 
-  // 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(Flags flags) { flags_ = static_cast<Flags> (flags_ | flags); }
   void ClearFlags(Flags flags) { flags_ = static_cast<Flags>(flags_ & ~flags); }
   int flags() const { return flags_; }
 
   // Check to see if bucket ranges, counts and tallies in the snapshot are
@@ -426,17 +219,16 @@ class Histogram {
   // a SnapShot process, but should otherwise be false at all times (unless we
   // have memory over-writes, or DRAM failures).
   virtual Inconsistencies FindCorruption(const SampleSet& snapshot) const;
 
   //----------------------------------------------------------------------------
   // Accessors for factory constuction, serialization and testing.
   //----------------------------------------------------------------------------
   virtual ClassType histogram_type() const;
-  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;
   uint32_t range_checksum() const { return range_checksum_; }
   virtual size_t bucket_count() const;
 
   // Do a safe atomic snapshot of sample data.  The caller is assumed to
   // have exclusive access to the destination, |*sample|, and no locking
@@ -448,20 +240,18 @@ class Histogram {
 
   virtual bool HasConstructorTimeDeltaArguments(TimeDelta minimum,
                                                 TimeDelta maximum,
                                                 size_t bucket_count);
   // Return true iff the range_checksum_ matches current ranges_ vector.
   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);
+  Histogram(Sample minimum, Sample maximum, size_t bucket_count);
+  Histogram(TimeDelta minimum, TimeDelta maximum, size_t bucket_count);
 
   virtual ~Histogram();
 
   // Initialize ranges_ mapping.
   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;
@@ -511,44 +301,22 @@ class Histogram {
   static uint32_t Crc32(uint32_t sum, Sample range);
 
   //----------------------------------------------------------------------------
   // Helpers for emitting Ascii graphic.  Each method appends data to output.
 
   // Find out how large the (graphically) the largest bucket will appear to be.
   double GetPeakBucketSize(const SampleSet& snapshot) const;
 
-  // Write a common header message describing this histogram.
-  void WriteAsciiHeader(const SampleSet& snapshot,
-                        Count sample_count, std::string* output) const;
-
-  // Write information about previous, current, and next buckets.
-  // Information such as cumulative percentage, etc.
-  void WriteAsciiBucketContext(const int64_t past, const Count current,
-                               const int64_t remaining, const size_t i,
-                               std::string* output) const;
-
-  // Write textual description of the bucket contents (relative to histogram).
-  // Output is the count in the buckets, as well as the percentage.
-  void WriteAsciiBucketValue(Count current, double scaled_sum,
-                             std::string* output) const;
-
-  // Produce actual graph (set of blank vs non blank char's) for a bucket.
-  void WriteAsciiBucketGraph(double current_size, double max_size,
-                             std::string* output) const;
-
   //----------------------------------------------------------------------------
   // Table for generating Crc32 values.
   static const uint32_t kCrcTable[256];
   //----------------------------------------------------------------------------
   // Invariant values set at/near construction time
 
-  // ASCII version of original name given to the constructor.  All identically
-  // named instances will be coalesced cross-project.
-  const std::string histogram_name_;
   Sample declared_min_;  // Less than this goes into counts_[0]
   Sample declared_max_;  // Over this goes into counts_[bucket_count_ - 1].
   size_t bucket_count_;  // Dimension of counts_[].
 
   // Flag the histogram for recording by UMA via metric_services.h.
   Flags flags_;
 
   // For each index, show the least value that can be stored in the
@@ -573,42 +341,38 @@ class Histogram {
 // LinearHistogram is a more traditional histogram, with evenly spaced
 // buckets.
 class LinearHistogram : public Histogram {
  public:
   virtual ~LinearHistogram();
 
   /* minimum should start from 1. 0 is as minimum is invalid. 0 is an implicit
      default underflow bucket. */
-  static Histogram* FactoryGet(const std::string& name,
-                               Sample minimum,
+  static Histogram* FactoryGet(Sample minimum,
                                Sample maximum,
                                size_t bucket_count,
                                Flags flags);
-  static Histogram* FactoryTimeGet(const std::string& name,
-                                   TimeDelta minimum,
+  static Histogram* FactoryTimeGet(TimeDelta minimum,
                                    TimeDelta maximum,
                                    size_t bucket_count,
                                    Flags flags);
 
   // Overridden from Histogram:
   virtual ClassType histogram_type() const;
 
   virtual void Accumulate(Sample value, Count count, size_t index);
 
   // Store a list of number/text values for use in rendering the histogram.
   // The last element in the array has a null in its "description" slot.
   virtual void SetRangeDescriptions(const DescriptionPair descriptions[]);
 
  protected:
-  LinearHistogram(const std::string& name, Sample minimum,
-                  Sample maximum, size_t bucket_count);
+  LinearHistogram(Sample minimum, Sample maximum, size_t bucket_count);
 
-  LinearHistogram(const std::string& name, TimeDelta minimum,
-                  TimeDelta maximum, size_t bucket_count);
+  LinearHistogram(TimeDelta minimum, TimeDelta maximum, size_t bucket_count);
 
   // Initialize ranges_ mapping.
   void InitializeBucketRange();
   virtual double GetBucketSize(Count current, size_t i) const;
 
   // If we have a description for a bucket, then return that.  Otherwise
   // let parent class provide a (numeric) description.
   virtual const std::string GetAsciiBucketRange(size_t i) const;
@@ -627,87 +391,85 @@ class LinearHistogram : public Histogram
   DISALLOW_COPY_AND_ASSIGN(LinearHistogram);
 };
 
 //------------------------------------------------------------------------------
 
 // BooleanHistogram is a histogram for booleans.
 class BooleanHistogram : public LinearHistogram {
  public:
-  static Histogram* FactoryGet(const std::string& name, Flags flags);
+  static Histogram* FactoryGet(Flags flags);
 
   virtual ClassType histogram_type() const;
 
   virtual void AddBoolean(bool value);
 
   virtual void Accumulate(Sample value, Count count, size_t index);
 
  protected:
-  explicit BooleanHistogram(const std::string& name);
+  explicit BooleanHistogram();
 
   DISALLOW_COPY_AND_ASSIGN(BooleanHistogram);
 };
 
 //------------------------------------------------------------------------------
 
 // FlagHistogram is like boolean histogram, but only allows a single off/on value.
 class FlagHistogram : public BooleanHistogram
 {
 public:
-  static Histogram *FactoryGet(const std::string &name, Flags flags);
+  static Histogram *FactoryGet(Flags flags);
 
   virtual ClassType histogram_type() const;
 
   virtual void Accumulate(Sample value, Count count, size_t index);
 
   virtual void AddSampleSet(const SampleSet& sample);
 
   virtual void Clear();
 
 private:
-  explicit FlagHistogram(const std::string &name);
+  explicit FlagHistogram();
   bool mSwitched;
 
   DISALLOW_COPY_AND_ASSIGN(FlagHistogram);
 };
 
 // CountHistogram only allows a single monotic counter value.
 class CountHistogram : public LinearHistogram
 {
 public:
-  static Histogram *FactoryGet(const std::string &name, Flags flags);
+  static Histogram *FactoryGet(Flags flags);
 
   virtual ClassType histogram_type() const;
 
   virtual void Accumulate(Sample value, Count count, size_t index);
 
   virtual void AddSampleSet(const SampleSet& sample);
 
 private:
-  explicit CountHistogram(const std::string &name);
+  explicit CountHistogram();
 
   DISALLOW_COPY_AND_ASSIGN(CountHistogram);
 };
 
 //------------------------------------------------------------------------------
 
 // CustomHistogram is a histogram for a set of custom integers.
 class CustomHistogram : public Histogram {
  public:
 
-  static Histogram* FactoryGet(const std::string& name,
-                               const std::vector<Sample>& custom_ranges,
+  static Histogram* FactoryGet(const std::vector<Sample>& custom_ranges,
                                Flags flags);
 
   // Overridden from Histogram:
   virtual ClassType histogram_type() const;
 
  protected:
-  CustomHistogram(const std::string& name,
-                  const std::vector<Sample>& custom_ranges);
+  CustomHistogram(const std::vector<Sample>& custom_ranges);
 
   // Initialize ranges_ mapping.
   void InitializedCustomBucketRange(const std::vector<Sample>& custom_ranges);
   virtual double GetBucketSize(Count current, size_t i) const;
 
   DISALLOW_COPY_AND_ASSIGN(CustomHistogram);
 };