Remove std::string histogram name from HistogramBase object.

base/metrics/sparse_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.
 
 #include "base/metrics/sparse_histogram.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/metrics_hashes.h"
@@ skipping 27 matching lines @@
       tentative_histogram = allocator->AllocateHistogram(
           SPARSE_HISTOGRAM, name, 0, 0, nullptr, flags, &histogram_ref);
     }
 
     // Handle the case where no persistent allocator is present or the
     // persistent allocation fails (perhaps because it is full).
     if (!tentative_histogram) {
       DCHECK(!histogram_ref);  // Should never have been set.
       DCHECK(!allocator);      // Shouldn't have failed.
       flags &= ~HistogramBase::kIsPersistent;
-      tentative_histogram.reset(new SparseHistogram(name));
+      tentative_histogram.reset(new SparseHistogram(GetPermanentName(name)));
       tentative_histogram->SetFlags(flags);
     }
 
     // Register this histogram with the StatisticsRecorder. Keep a copy of
     // the pointer value to tell later whether the locally created histogram
     // was registered or deleted. The type is "void" because it could point
     // to released memory after the following line.
     const void* tentative_histogram_ptr = tentative_histogram.get();
     histogram = StatisticsRecorder::RegisterOrDeleteDuplicate(
         tentative_histogram.release());
 
     // Persistent histograms need some follow-up processing.
     if (histogram_ref) {
       allocator->FinalizeHistogram(histogram_ref,
                                    histogram == tentative_histogram_ptr);
     }
 
     ReportHistogramActivity(*histogram, HISTOGRAM_CREATED);
   } else {
     ReportHistogramActivity(*histogram, HISTOGRAM_LOOKUP);
   }
 
   CHECK_EQ(SPARSE_HISTOGRAM, histogram->GetHistogramType());
   return histogram;
 }
 
 // static
 std::unique_ptr<HistogramBase> SparseHistogram::PersistentCreate(
     PersistentHistogramAllocator* allocator,
-    const std::string& name,
+    const char* name,
     HistogramSamples::Metadata* meta,
     HistogramSamples::Metadata* logged_meta) {
   return WrapUnique(
       new SparseHistogram(allocator, name, meta, logged_meta));
 }
 
 SparseHistogram::~SparseHistogram() {}
 
 uint64_t SparseHistogram::name_hash() const {
   return unlogged_samples_->id();
@@ skipping 77 matching lines @@
 }
 
 void SparseHistogram::WriteAscii(std::string* output) const {
   WriteAsciiImpl(true, "\n", output);
 }
 
 bool SparseHistogram::SerializeInfoImpl(Pickle* pickle) const {
   return pickle->WriteString(histogram_name()) && pickle->WriteInt(flags());
 }
 
-SparseHistogram::SparseHistogram(const std::string& name)
+SparseHistogram::SparseHistogram(const char* name)
     : HistogramBase(name),
       unlogged_samples_(new SampleMap(HashMetricName(name))),
       logged_samples_(new SampleMap(unlogged_samples_->id())) {}
 
 SparseHistogram::SparseHistogram(PersistentHistogramAllocator* allocator,
-                                 const std::string& name,
+                                 const char* name,
                                  HistogramSamples::Metadata* meta,
                                  HistogramSamples::Metadata* logged_meta)
     : HistogramBase(name),
       // While other histogram types maintain a static vector of values with
       // sufficient space for both "active" and "logged" samples, with each
       // SampleVector being given the appropriate half, sparse histograms
       // have no such initial allocation. Each sample has its own record
       // attached to a single PersistentSampleMap by a common 64-bit identifier.
       // Since a sparse histogram has two sample maps (active and logged),
       // there must be two sets of sample records with diffent IDs. The
@@ skipping 77 matching lines @@
     if (graph_it)
       WriteAsciiBucketGraph(count, largest_count, output);
     WriteAsciiBucketValue(count, scaled_total_count, output);
     output->append(newline);
     it->Next();
   }
 }
 
 void SparseHistogram::WriteAsciiHeader(const Count total_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(),
                 total_count);
   if (flags())
     StringAppendF(output, " (flags = 0x%x)", flags());
 }
 
 }  // namespace base