Remove std::string histogram name from HistogramBase object.

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 75 matching lines @@
     if (!histograms_) {
       histogram_to_return = histogram;
 
       // As per crbug.com/79322 the histograms are intentionally leaked, so we
       // need to annotate them. Because ANNOTATE_LEAKING_OBJECT_PTR may be used
       // only once for an object, the duplicates should not be annotated.
       // Callers are responsible for not calling RegisterOrDeleteDuplicate(ptr)
       // twice |if (!histograms_)|.
       ANNOTATE_LEAKING_OBJECT_PTR(histogram);  // see crbug.com/79322
     } else {
-      const std::string& name = histogram->histogram_name();
-      HistogramMap::iterator it = histograms_->find(name);
+      const char* name = histogram->histogram_name();
+      StringPiece name_piece = name;
+      HistogramMap::iterator it = histograms_->find(name_piece);
       if (histograms_->end() == it) {
         // The StringKey references the name within |histogram| rather than
         // making a copy.
-        (*histograms_)[name] = histogram;
+        (*histograms_)[name_piece] = 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);
         }
         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.
-        DCHECK_EQ(histogram->histogram_name(),
-                  it->second->histogram_name()) << "hash collision";
+        DCHECK_EQ(StringPiece(histogram->histogram_name()),
+                  StringPiece(it->second->histogram_name()))
+            << "hash collision";
         histogram_to_return = it->second;
         histogram_to_delete = histogram;
       }
     }
   }
   delete histogram_to_delete;
   return histogram_to_return;
 }
 
 // static
@@ skipping 192 matching lines @@
                                      Histograms* snapshot) {
   // This must be called *before* the lock is acquired below because it will
   // call back into this object to register histograms. Those called methods
   // will acquire the lock at that time.
   ImportGlobalPersistentHistograms();
 
   base::AutoLock auto_lock(lock_.Get());
   if (!histograms_)
     return;
 
+  // Need a c-string query for comparisons against c-string histogram name.
+  const char* query_string = query.c_str();
+
   for (const auto& entry : *histograms_) {
-    if (entry.second->histogram_name().find(query) != std::string::npos)
+    if (strstr(entry.second->histogram_name(), query_string) != nullptr)
       snapshot->push_back(entry.second);
   }
 }
 
 // static
 bool StatisticsRecorder::SetCallback(
     const std::string& name,
     const StatisticsRecorder::OnSampleCallback& cb) {
   DCHECK(!cb.is_null());
   base::AutoLock auto_lock(lock_.Get());
@@ skipping 185 matching lines @@
 StatisticsRecorder::CallbackMap* StatisticsRecorder::callbacks_ = nullptr;
 // static
 StatisticsRecorder::RangesMap* StatisticsRecorder::ranges_ = nullptr;
 // static
 StatisticsRecorder::HistogramProviders* StatisticsRecorder::providers_;
 // static
 base::LazyInstance<base::Lock>::Leaky StatisticsRecorder::lock_ =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace base