Remove std::string histogram name from HistogramBase object.

base/metrics/histogram.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.
 
 // 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).
 // See header file for details and examples.
 
 #include "base/metrics/histogram.h"
@@ skipping 119 matching lines @@
   virtual BucketRanges* CreateRanges() {
     BucketRanges* ranges = new BucketRanges(bucket_count_ + 1);
     Histogram::InitializeBucketRanges(minimum_, maximum_, ranges);
     base::debug::Alias(&ranges);  // TODO(bcwhite): Remove after crbug/586622.
     return ranges;
   }
 
   // Allocate the correct Histogram object off the heap (in case persistent
   // memory is not available).
   virtual std::unique_ptr<HistogramBase> HeapAlloc(const BucketRanges* ranges) {
-    return WrapUnique(new Histogram(name_, minimum_, maximum_, ranges));
+    return WrapUnique(
+        new Histogram(GetPermanentName(name_), minimum_, maximum_, ranges));
   }
 
   // Perform any required datafill on the just-created histogram.  If
   // overridden, be sure to call the "super" version -- this method may not
   // always remain empty.
   virtual void FillHistogram(HistogramBase* histogram) {}
 
   // These values are protected (instead of private) because they need to
   // be accessible to methods of sub-classes in order to avoid passing
   // unnecessary parameters everywhere.
@@ skipping 129 matching lines @@
 HistogramBase* Histogram::FactoryTimeGet(const char* name,
                                          TimeDelta minimum,
                                          TimeDelta maximum,
                                          uint32_t bucket_count,
                                          int32_t flags) {
   return FactoryTimeGet(std::string(name), minimum, maximum, bucket_count,
                         flags);
 }
 
 std::unique_ptr<HistogramBase> Histogram::PersistentCreate(
-    const std::string& name,
+    const char* name,
     Sample minimum,
     Sample maximum,
     const BucketRanges* ranges,
     const DelayedPersistentAllocation& counts,
     const DelayedPersistentAllocation& logged_counts,
     HistogramSamples::Metadata* meta,
     HistogramSamples::Metadata* logged_meta) {
   return WrapUnique(new Histogram(name, minimum, maximum, ranges, counts,
                                   logged_counts, meta, logged_meta));
 }
@@ skipping 90 matching lines @@
 
 Sample Histogram::ranges(uint32_t i) const {
   return bucket_ranges()->range(i);
 }
 
 uint32_t Histogram::bucket_count() const {
   return static_cast<uint32_t>(bucket_ranges()->bucket_count());
 }
 
 // static
-bool Histogram::InspectConstructionArguments(const std::string& name,
+bool Histogram::InspectConstructionArguments(StringPiece name,
                                              Sample* minimum,
                                              Sample* maximum,
                                              uint32_t* bucket_count) {
   // Defensive code for backward compatibility.
   if (*minimum < 1) {
     DVLOG(1) << "Histogram: " << name << " has bad minimum: " << *minimum;
     *minimum = 1;
   }
   if (*maximum >= kSampleType_MAX) {
     DVLOG(1) << "Histogram: " << name << " has bad maximum: " << *maximum;
@@ skipping 165 matching lines @@
     bad_fields |= 1 << kFlagsField;
   if (dummy_ != kDummyValue)
     bad_fields |= 1 << kDummyField;
 
   const bool is_valid = (bad_fields & ~(1 << kFlagsField)) == 0;
   if (is_valid || !crash_if_invalid)
     return is_valid;
 
   // Abort if a problem is found (except "flags", which could legally be zero).
   const std::string debug_string = base::StringPrintf(
-      "%s/%" PRIu32 "#%d", histogram_name().c_str(), bad_fields, identifier);
+      "%s/%" PRIu32 "#%d", histogram_name(), bad_fields, identifier);
 #if !defined(OS_NACL)
   // Temporary for https://crbug.com/736675.
   base::debug::ScopedCrashKey crash_key("bad_histogram", debug_string);
 #endif
   // CHECK(false) << debug_string;
   debug::Alias(&bad_fields);
   return false;
 }
 
 bool Histogram::SerializeInfoImpl(Pickle* pickle) const {
   DCHECK(bucket_ranges()->HasValidChecksum());
   return pickle->WriteString(histogram_name()) &&
       pickle->WriteInt(flags()) &&
       pickle->WriteInt(declared_min()) &&
       pickle->WriteInt(declared_max()) &&
       pickle->WriteUInt32(bucket_count()) &&
       pickle->WriteUInt32(bucket_ranges()->checksum());
 }
 
 // TODO(bcwhite): Remove minimum/maximum parameters from here and call chain.
-Histogram::Histogram(const std::string& name,
+Histogram::Histogram(const char* name,
                      Sample minimum,
                      Sample maximum,
                      const BucketRanges* ranges)
     : HistogramBase(name), dummy_(kDummyValue) {
   // TODO(bcwhite): Make this a DCHECK once crbug/734049 is resolved.
   CHECK(ranges) << name << ": " << minimum << "-" << maximum;
   unlogged_samples_.reset(new SampleVector(HashMetricName(name), ranges));
   logged_samples_.reset(new SampleVector(unlogged_samples_->id(), ranges));
 }
 
-Histogram::Histogram(const std::string& name,
+Histogram::Histogram(const char* name,
                      Sample minimum,
                      Sample maximum,
                      const BucketRanges* ranges,
                      const DelayedPersistentAllocation& counts,
                      const DelayedPersistentAllocation& logged_counts,
                      HistogramSamples::Metadata* meta,
                      HistogramSamples::Metadata* logged_meta)
     : HistogramBase(name), dummy_(kDummyValue) {
   // TODO(bcwhite): Make this a DCHECK once crbug/734049 is resolved.
   CHECK(ranges) << name << ": " << minimum << "-" << maximum;
@@ skipping 150 matching lines @@
     double current_size = GetBucketSize(samples.GetCountAtIndex(i), i);
     if (current_size > max)
       max = current_size;
   }
   return max;
 }
 
 void Histogram::WriteAsciiHeader(const SampleVectorBase& samples,
                                  Count sample_count,
                                  std::string* output) const {
-  StringAppendF(output,
-                "Histogram: %s recorded %d samples",
-                histogram_name().c_str(),
+  StringAppendF(output, "Histogram: %s recorded %d samples", histogram_name(),
                 sample_count);
   if (sample_count == 0) {
     DCHECK_EQ(samples.sum(), 0);
   } else {
     double mean = static_cast<float>(samples.sum()) / sample_count;
     StringAppendF(output, ", mean = %.1f", mean);
   }
   if (flags())
     StringAppendF(output, " (flags = 0x%x)", flags());
 }
@@ skipping 60 matching lines @@
  protected:
   BucketRanges* CreateRanges() override {
     BucketRanges* ranges = new BucketRanges(bucket_count_ + 1);
     LinearHistogram::InitializeBucketRanges(minimum_, maximum_, ranges);
     base::debug::Alias(&ranges);  // TODO(bcwhite): Remove after crbug/586622.
     return ranges;
   }
 
   std::unique_ptr<HistogramBase> HeapAlloc(
       const BucketRanges* ranges) override {
-    return WrapUnique(new LinearHistogram(name_, minimum_, maximum_, ranges));
+    return WrapUnique(new LinearHistogram(GetPermanentName(name_), minimum_,
+                                          maximum_, ranges));
   }
 
   void FillHistogram(HistogramBase* base_histogram) override {
     Histogram::Factory::FillHistogram(base_histogram);
     LinearHistogram* histogram = static_cast<LinearHistogram*>(base_histogram);
     // Set range descriptions.
     if (descriptions_) {
       for (int i = 0; descriptions_[i].description; ++i) {
         histogram->bucket_description_[descriptions_[i].sample] =
             descriptions_[i].description;
       }
     }
   }
 
  private:
   const DescriptionPair* descriptions_;
 
   DISALLOW_COPY_AND_ASSIGN(Factory);
 };
 
 LinearHistogram::~LinearHistogram() {}
 
 HistogramBase* LinearHistogram::FactoryGet(const std::string& name,
                                            Sample minimum,
                                            Sample maximum,
                                            uint32_t bucket_count,
                                            int32_t flags) {
-  return FactoryGetWithRangeDescription(name, minimum, maximum, bucket_count,
-                                        flags, nullptr);
+  return FactoryGetWithRangeDescription(
+      name, minimum, maximum, bucket_count, flags, NULL);
 }
 
 HistogramBase* LinearHistogram::FactoryTimeGet(const std::string& name,
                                                TimeDelta minimum,
                                                TimeDelta maximum,
                                                uint32_t bucket_count,
                                                int32_t flags) {
   return FactoryGet(name, static_cast<Sample>(minimum.InMilliseconds()),
                     static_cast<Sample>(maximum.InMilliseconds()), bucket_count,
                     flags);
@@ skipping 10 matching lines @@
 HistogramBase* LinearHistogram::FactoryTimeGet(const char* name,
                                                TimeDelta minimum,
                                                TimeDelta maximum,
                                                uint32_t bucket_count,
                                                int32_t flags) {
   return FactoryTimeGet(std::string(name),  minimum, maximum, bucket_count,
                         flags);
 }
 
 std::unique_ptr<HistogramBase> LinearHistogram::PersistentCreate(
-    const std::string& name,
+    const char* name,
     Sample minimum,
     Sample maximum,
     const BucketRanges* ranges,
     const DelayedPersistentAllocation& counts,
     const DelayedPersistentAllocation& logged_counts,
     HistogramSamples::Metadata* meta,
     HistogramSamples::Metadata* logged_meta) {
   return WrapUnique(new LinearHistogram(name, minimum, maximum, ranges, counts,
                                         logged_counts, meta, logged_meta));
 }
@@ skipping 10 matching lines @@
   DCHECK(valid_arguments);
 
   return Factory(name, minimum, maximum, bucket_count, flags, descriptions)
       .Build();
 }
 
 HistogramType LinearHistogram::GetHistogramType() const {
   return LINEAR_HISTOGRAM;
 }
 
-LinearHistogram::LinearHistogram(const std::string& name,
+LinearHistogram::LinearHistogram(const char* name,
                                  Sample minimum,
                                  Sample maximum,
                                  const BucketRanges* ranges)
-    : Histogram(name, minimum, maximum, ranges) {
-}
+    : Histogram(name, minimum, maximum, ranges) {}
 
 LinearHistogram::LinearHistogram(
-    const std::string& name,
+    const char* name,
     Sample minimum,
     Sample maximum,
     const BucketRanges* ranges,
     const DelayedPersistentAllocation& counts,
     const DelayedPersistentAllocation& logged_counts,
     HistogramSamples::Metadata* meta,
     HistogramSamples::Metadata* logged_meta)
     : Histogram(name,
                 minimum,
                 maximum,
@@ skipping 79 matching lines @@
  protected:
   BucketRanges* CreateRanges() override {
     BucketRanges* ranges = new BucketRanges(3 + 1);
     LinearHistogram::InitializeBucketRanges(1, 2, ranges);
     base::debug::Alias(&ranges);  // TODO(bcwhite): Remove after crbug/586622.
     return ranges;
   }
 
   std::unique_ptr<HistogramBase> HeapAlloc(
       const BucketRanges* ranges) override {
-    return WrapUnique(new BooleanHistogram(name_, ranges));
+    return WrapUnique(new BooleanHistogram(GetPermanentName(name_), ranges));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Factory);
 };
 
 HistogramBase* BooleanHistogram::FactoryGet(const std::string& name,
                                             int32_t flags) {
   return Factory(name, flags).Build();
 }
 
 HistogramBase* BooleanHistogram::FactoryGet(const char* name, int32_t flags) {
   return FactoryGet(std::string(name), flags);
 }
 
 std::unique_ptr<HistogramBase> BooleanHistogram::PersistentCreate(
-    const std::string& name,
+    const char* name,
     const BucketRanges* ranges,
     const DelayedPersistentAllocation& counts,
     const DelayedPersistentAllocation& logged_counts,
     HistogramSamples::Metadata* meta,
     HistogramSamples::Metadata* logged_meta) {
   return WrapUnique(new BooleanHistogram(name, ranges, counts, logged_counts,
                                          meta, logged_meta));
 }
 
 HistogramType BooleanHistogram::GetHistogramType() const {
   return BOOLEAN_HISTOGRAM;
 }
 
-BooleanHistogram::BooleanHistogram(const std::string& name,
-                                   const BucketRanges* ranges)
+BooleanHistogram::BooleanHistogram(const char* name, const BucketRanges* ranges)
     : LinearHistogram(name, 1, 2, ranges) {}
 
 BooleanHistogram::BooleanHistogram(
-    const std::string& name,
+    const char* name,
     const BucketRanges* ranges,
     const DelayedPersistentAllocation& counts,
     const DelayedPersistentAllocation& logged_counts,
     HistogramSamples::Metadata* meta,
     HistogramSamples::Metadata* logged_meta)
     : LinearHistogram(name,
                       1,
                       2,
                       ranges,
                       counts,
@@ skipping 51 matching lines @@
     BucketRanges* bucket_ranges = new BucketRanges(ranges.size());
     for (uint32_t i = 0; i < ranges.size(); i++) {
       bucket_ranges->set_range(i, ranges[i]);
     }
     bucket_ranges->ResetChecksum();
     return bucket_ranges;
   }
 
   std::unique_ptr<HistogramBase> HeapAlloc(
       const BucketRanges* ranges) override {
-    return WrapUnique(new CustomHistogram(name_, ranges));
+    return WrapUnique(new CustomHistogram(GetPermanentName(name_), ranges));
   }
 
  private:
   const std::vector<Sample>* custom_ranges_;
 
   DISALLOW_COPY_AND_ASSIGN(Factory);
 };
 
 HistogramBase* CustomHistogram::FactoryGet(
     const std::string& name,
     const std::vector<Sample>& custom_ranges,
     int32_t flags) {
   CHECK(ValidateCustomRanges(custom_ranges));
 
   return Factory(name, &custom_ranges, flags).Build();
 }
 
 HistogramBase* CustomHistogram::FactoryGet(
     const char* name,
     const std::vector<Sample>& custom_ranges,
     int32_t flags) {
   return FactoryGet(std::string(name), custom_ranges, flags);
 }
 
 std::unique_ptr<HistogramBase> CustomHistogram::PersistentCreate(
-    const std::string& name,
+    const char* name,
     const BucketRanges* ranges,
     const DelayedPersistentAllocation& counts,
     const DelayedPersistentAllocation& logged_counts,
     HistogramSamples::Metadata* meta,
     HistogramSamples::Metadata* logged_meta) {
   return WrapUnique(new CustomHistogram(name, ranges, counts, logged_counts,
                                         meta, logged_meta));
 }
 
 HistogramType CustomHistogram::GetHistogramType() const {
   return CUSTOM_HISTOGRAM;
 }
 
 // static
 std::vector<Sample> CustomHistogram::ArrayToCustomRanges(
     const Sample* values, uint32_t num_values) {
   std::vector<Sample> all_values;
   for (uint32_t i = 0; i < num_values; ++i) {
     Sample value = values[i];
     all_values.push_back(value);
 
     // Ensure that a guard bucket is added. If we end up with duplicate
     // values, FactoryGet will take care of removing them.
     all_values.push_back(value + 1);
   }
   return all_values;
 }
 
-CustomHistogram::CustomHistogram(const std::string& name,
-                                 const BucketRanges* ranges)
+CustomHistogram::CustomHistogram(const char* name, const BucketRanges* ranges)
     : Histogram(name,
                 ranges->range(1),
                 ranges->range(ranges->bucket_count() - 1),
                 ranges) {}
 
 CustomHistogram::CustomHistogram(
-    const std::string& name,
+    const char* name,
     const BucketRanges* ranges,
     const DelayedPersistentAllocation& counts,
     const DelayedPersistentAllocation& logged_counts,
     HistogramSamples::Metadata* meta,
     HistogramSamples::Metadata* logged_meta)
     : Histogram(name,
                 ranges->range(1),
                 ranges->range(ranges->bucket_count() - 1),
                 ranges,
                 counts,
@@ skipping 62 matching lines @@
     Sample sample = custom_ranges[i];
     if (sample < 0 || sample > HistogramBase::kSampleType_MAX - 1)
       return false;
     if (sample != 0)
       has_valid_range = true;
   }
   return has_valid_range;
 }
 
 }  // namespace base