Use strings for keys in the histogram map.

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 <memory>
 
 #include "base/at_exit.h"
 #include "base/debug/leak_annotations.h"
@@ skipping 95 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();
-      const uint64_t name_hash = histogram->name_hash();
-      DCHECK_NE(0U, name_hash);
-      HistogramMap::iterator it = histograms_->find(name_hash);
+      HistogramMap::iterator it = histograms_->find(name);
       if (histograms_->end() == it) {
-        (*histograms_)[name_hash] = histogram;
+        // The StringKey references the name within |histogram| rather than
+        // making a copy.
+        (*histograms_)[name] = histogram;
         ANNOTATE_LEAKING_OBJECT_PTR(histogram);  // see crbug.com/79322
         // If there are callbacks for this histogram, we set the kCallbackExists
         // flag.
         auto callback_iterator = callbacks_->find(name);
         if (callback_iterator != callbacks_->end()) {
           if (!callback_iterator->second.is_null())
             histogram->SetFlags(HistogramBase::kCallbackExists);
           else
             histogram->ClearFlags(HistogramBase::kCallbackExists);
         }
@@ skipping 123 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->name_hash());
     output->push_back(entry.second);
   }
 }
 
 // static
 void StatisticsRecorder::GetBucketRanges(
     std::vector<const BucketRanges*>* output) {
   if (lock_ == NULL)
     return;
   base::AutoLock auto_lock(*lock_);
@@ skipping 16 matching lines @@
     return NULL;
 
   // Import histograms from known persistent storage. Histograms could have
   // been added by other processes and they must be fetched and recognized
   // locally. If the persistent memory segment is not shared between processes,
   // this call does nothing.
   GlobalHistogramAllocator* allocator = GlobalHistogramAllocator::Get();
   if (allocator)
     allocator->ImportHistogramsToStatisticsRecorder();
 
-  HistogramMap::iterator it = histograms_->find(HashMetricName(name));
+  HistogramMap::iterator it = histograms_->find(name);
   if (histograms_->end() == it)
     return NULL;
-  DCHECK_EQ(name, it->second->histogram_name()) << "hash collision";
   return it->second;
 }
 
 // static
 StatisticsRecorder::HistogramIterator StatisticsRecorder::begin(
     bool include_persistent) {
   return HistogramIterator(histograms_->begin(), include_persistent);
 }
 
 // static
@@ skipping 24 matching lines @@
   if (lock_ == NULL)
     return false;
   base::AutoLock auto_lock(*lock_);
   if (histograms_ == NULL)
     return false;
 
   if (ContainsKey(*callbacks_, name))
     return false;
   callbacks_->insert(std::make_pair(name, cb));
 
-  auto it = histograms_->find(HashMetricName(name));
-  if (it != histograms_->end()) {
-    DCHECK_EQ(name, it->second->histogram_name()) << "hash collision";
+  auto it = histograms_->find(name);
+  if (it != histograms_->end())
     it->second->SetFlags(HistogramBase::kCallbackExists);
-  }
 
   return true;
 }
 
 // static
 void StatisticsRecorder::ClearCallback(const std::string& name) {
   if (lock_ == NULL)
     return;
   base::AutoLock auto_lock(*lock_);
   if (histograms_ == NULL)
     return;
 
   callbacks_->erase(name);
 
   // We also clear the flag from the histogram (if it exists).
-  auto it = histograms_->find(HashMetricName(name));
-  if (it != histograms_->end()) {
-    DCHECK_EQ(name, it->second->histogram_name()) << "hash collision";
+  auto it = histograms_->find(name);
+  if (it != histograms_->end())
     it->second->ClearFlags(HistogramBase::kCallbackExists);
-  }
 }
 
 // static
 StatisticsRecorder::OnSampleCallback StatisticsRecorder::FindCallback(
     const std::string& name) {
   if (lock_ == NULL)
     return OnSampleCallback();
   base::AutoLock auto_lock(*lock_);
   if (histograms_ == NULL)
     return OnSampleCallback();
@@ skipping 16 matching lines @@
 
 // static
 void StatisticsRecorder::ResetForTesting() {
   // Just call the private version that is used also by the destructor.
   Reset();
 }
 
 // static
 void StatisticsRecorder::ForgetHistogramForTesting(base::StringPiece name) {
   if (histograms_)
-    histograms_->erase(HashMetricName(name.as_string()));
+    histograms_->erase(name);
 }
 
 // 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) {
     // This will leak on purpose. It's the only way to make sure we won't race
     // against the static uninitialization of the module while one of our
@@ skipping 46 matching lines @@
 // static
 StatisticsRecorder::HistogramMap* StatisticsRecorder::histograms_ = NULL;
 // static
 StatisticsRecorder::CallbackMap* StatisticsRecorder::callbacks_ = NULL;
 // static
 StatisticsRecorder::RangesMap* StatisticsRecorder::ranges_ = NULL;
 // static
 base::Lock* StatisticsRecorder::lock_ = NULL;
 
 }  // namespace base