Change TrackManager::GetOrCreate* to std::string_view

src/OrbitGl/TrackManager.cpp

@@ -488,28 +488,31 @@ GpuTrack* TrackManager::GetOrCreateGpuTrack(uint64_t timeline_hash) {
   return track.get();
 }
 
-VariableTrack* TrackManager::GetOrCreateVariableTrack(std::string name) {
+VariableTrack* TrackManager::GetOrCreateVariableTrack(std::string_view name) {
   std::lock_guard<std::recursive_mutex> lock(mutex_);
-  std::shared_ptr<VariableTrack> track = variable_tracks_[name];
-  if (track == nullptr) {
-    track = std::make_shared<VariableTrack>(track_container_, timeline_info_, viewport_, layout_,
-                                            name, module_manager_, capture_data_);
-    variable_tracks_[name] = track;
-    AddTrack(track);
-  }
+
+  auto existing_track = variable_tracks_.find(name);
+  if (existing_track != variable_tracks_.end()) return existing_track->second.get();
+
+  auto track = std::make_shared<VariableTrack>(track_container_, timeline_info_, viewport_, layout_,
+                                               std::string{name}, module_manager_, capture_data_);
+  variable_tracks_.emplace(name, track);
+  AddTrack(track);
   return track.get();
 }
 
-AsyncTrack* TrackManager::GetOrCreateAsyncTrack(std::string name) {
+AsyncTrack* TrackManager::GetOrCreateAsyncTrack(std::string_view name) {
   std::lock_guard<std::recursive_mutex> lock(mutex_);
-  std::shared_ptr<AsyncTrack> track = async_tracks_[name];
-  if (track == nullptr) {
-    auto [unused, timer_data] = capture_data_->CreateTimerData();
-    track = std::make_shared<AsyncTrack>(track_container_, timeline_info_, viewport_, layout_, name,
-                                         app_, module_manager_, capture_data_, timer_data);
-    async_tracks_[name] = track;
-    AddTrack(track);
-  }
+
+  auto existing_track = async_tracks_.find(name);
+  if (existing_track != async_tracks_.end()) return existing_track->second.get();
+
+  auto [unused, timer_data] = capture_data_->CreateTimerData();
+  auto track = std::make_shared<AsyncTrack>(track_container_, timeline_info_, viewport_, layout_,
+                                            std::string{name}, app_, module_manager_, capture_data_,
+                                            timer_data);
+  async_tracks_.emplace(name, track);
+  AddTrack(track);
   return track.get();
 }
 

src/OrbitGl/include/OrbitGl/TrackManager.h

@@ -10,6 +10,7 @@
 #include <stdlib.h>
 
 #include <cstdint>
+#include <functional>
 #include <map>
 #include <memory>
 #include <mutex>
@@ -71,8 +72,8 @@ class TrackManager {
   ThreadTrack* GetOrCreateThreadTrack(uint32_t tid);
   [[nodiscard]] std::optional<ThreadTrack*> GetThreadTrack(uint32_t tid) const;
   GpuTrack* GetOrCreateGpuTrack(uint64_t timeline_hash);
-  VariableTrack* GetOrCreateVariableTrack(std::string name);
-  AsyncTrack* GetOrCreateAsyncTrack(std::string name);
+  VariableTrack* GetOrCreateVariableTrack(std::string_view name);
+  AsyncTrack* GetOrCreateAsyncTrack(std::string_view name);
   FrameTrack* GetOrCreateFrameTrack(uint64_t function_id);
   [[nodiscard]] SystemMemoryTrack* GetSystemMemoryTrack() const {
     return system_memory_track_.get();
@@ -115,8 +116,8 @@ class TrackManager {
 
   std::vector<std::shared_ptr<Track>> all_tracks_;
   absl::flat_hash_map<uint32_t, std::shared_ptr<ThreadTrack>> thread_tracks_;
-  std::map<std::string, std::shared_ptr<AsyncTrack>> async_tracks_;
-  std::map<std::string, std::shared_ptr<VariableTrack>> variable_tracks_;
+  std::map<std::string, std::shared_ptr<AsyncTrack>, std::less<>> async_tracks_;
+  std::map<std::string, std::shared_ptr<VariableTrack>, std::less<>> variable_tracks_;
   // Mapping from timeline to GPU tracks. Timeline name is used for stable ordering. In particular
   // we want the marker tracks next to their queue track. E.g. "gfx" and "gfx_markers" should appear
   // next to each other.