Optimize memory use of registered histograms.

base/metrics/statistics_recorder.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/statistics_recorder.h"
 
 #include "base/at_exit.h"
 #include "base/debug/leak_annotations.h"
 #include "base/json/string_escape.h"
 #include "base/logging.h"
@@ skipping 39 matching lines @@
   }
 
   HistogramBase* histogram_to_delete = NULL;
   HistogramBase* histogram_to_return = NULL;
   {
     base::AutoLock auto_lock(*lock_);
     if (histograms_ == NULL) {
       histogram_to_return = histogram;
     } else {
       const std::string& name = histogram->histogram_name();
-      HistogramMap::iterator it = histograms_->find(name);
+      HistogramMap::iterator it = histograms_->find(HistogramNameRef(name));
       if (histograms_->end() == it) {
-        (*histograms_)[name] = histogram;
+        (*histograms_)[HistogramNameRef(name)] = histogram;
         ANNOTATE_LEAKING_OBJECT_PTR(histogram);  // see crbug.com/79322
         histogram_to_return = histogram;
       } else if (histogram == it->second) {
         // The histogram was registered before.
         histogram_to_return = histogram;
       } else {
         // We already have one histogram with this name.
         histogram_to_return = it->second;
         histogram_to_delete = histogram;
       }
@@ skipping 110 matching lines @@
 
 // static
 void StatisticsRecorder::GetHistograms(Histograms* output) {
   if (lock_ == NULL)
     return;
   base::AutoLock auto_lock(*lock_);
   if (histograms_ == NULL)
     return;
 
   for (const auto& entry : *histograms_) {
-    DCHECK_EQ(entry.first, entry.second->histogram_name());
+    DCHECK_EQ(entry.first.name_, entry.second->histogram_name());
     output->push_back(entry.second);
   }
 }
 
 // static
 void StatisticsRecorder::GetBucketRanges(
     std::vector<const BucketRanges*>* output) {
   if (lock_ == NULL)
     return;
   base::AutoLock auto_lock(*lock_);
   if (ranges_ == NULL)
     return;
 
   for (const auto& entry : *ranges_) {
     for (const auto& range_entry : *entry.second) {
       output->push_back(range_entry);
     }
   }
 }
 
 // static
 HistogramBase* StatisticsRecorder::FindHistogram(const std::string& name) {
   if (lock_ == NULL)
     return NULL;
   base::AutoLock auto_lock(*lock_);
   if (histograms_ == NULL)
     return NULL;
 
-  HistogramMap::iterator it = histograms_->find(name);
+  HistogramMap::iterator it = histograms_->find(HistogramNameRef(name));
   if (histograms_->end() == it)
     return NULL;
   return it->second;
 }
 
 // private static
 void StatisticsRecorder::GetSnapshot(const std::string& query,
                                      Histograms* snapshot) {
   if (lock_ == NULL)
     return;
   base::AutoLock auto_lock(*lock_);
   if (histograms_ == NULL)
     return;
 
   for (const auto& entry : *histograms_) {
-    if (entry.first.find(query) != std::string::npos)
+    if (entry.first.name_.find(query) != std::string::npos)
       snapshot->push_back(entry.second);
   }
 }
 
 // This singleton instance should be started during the single threaded portion
 // of main(), and hence it is not thread safe.  It initializes globals to
 // provide support for all future calls.
 StatisticsRecorder::StatisticsRecorder() {
   DCHECK(!histograms_);
   if (lock_ == NULL) {
@@ skipping 40 matching lines @@
 
 
 // static
 StatisticsRecorder::HistogramMap* StatisticsRecorder::histograms_ = NULL;
 // static
 StatisticsRecorder::RangesMap* StatisticsRecorder::ranges_ = NULL;
 // static
 base::Lock* StatisticsRecorder::lock_ = NULL;
 
 }  // namespace base