Add ability to retrieve a thread_name given a thread_id.

base/threading/thread_id_name_manager.cc

Index: base/threading/thread_id_name_manager.cc
diff --git a/base/threading/thread_id_name_manager.cc b/base/threading/thread_id_name_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..477e849602ec9f2fe6ba142926b0cf1cfc1e3055
--- /dev/null
+++ b/base/threading/thread_id_name_manager.cc
@@ -0,0 +1,68 @@
+// 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/threading/thread_id_name_manager.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "base/logging.h"
+#include "base/memory/singleton.h"
+#include "base/string_util.h"
+
+namespace base {
+namespace {
+
+const char* kDefaultName("");
+
+typedef std::map<PlatformThreadId, std::string>::iterator
+    IdToInternedNameIterator;
+typedef std::map<std::string, std::string>::iterator NameToInternedNameIterator;
+}
+
+ThreadIdNameManager::ThreadIdNameManager() {
+  name_to_interned_name_[kDefaultName] = kDefaultName;
+}
+
+ThreadIdNameManager::~ThreadIdNameManager() {
+}
+
+ThreadIdNameManager* ThreadIdNameManager::GetInstance() {
+  return Singleton<ThreadIdNameManager,
+      LeakySingletonTraits<ThreadIdNameManager> >::get();
+}
+
+const char* ThreadIdNameManager::GetDefaultInternedString() {
+  return kDefaultName;
+}
+
+void ThreadIdNameManager::SetNameForId(PlatformThreadId id, const char* name) {
+  std::string str_name(name);
+
+  AutoLock locked(lock_);
+  NameToInternedNameIterator iter = name_to_interned_name_.find(str_name);
+  if (iter == name_to_interned_name_.end())
+    name_to_interned_name_[str_name] = str_name;

[jar (doing other things), 2013/01/24 01:05:14]

I'm a little confused now, as you set values into name_to_interned_name, but you
never read them or use them.

[dsinclair, 2013/01/24 15:13:06]

Bug, I should have used iter->second in the assignment below instead of
str_name. Fixed now.


On 2013/01/24 01:05:14, jar wrote:

+
+  id_to_interned_name_[id] = str_name;

[jar (doing other things), 2013/01/24 01:05:14]

nit: suggest thread_id_to_interned_name

I was confused, as I assumed "id" was the id for the atom we saved away.

[dsinclair, 2013/01/24 15:13:06]

Done.

+}
+
+const char* ThreadIdNameManager::GetNameForId(PlatformThreadId id) {

[jar (doing other things), 2013/01/24 01:05:14]

nit: Clearer might be GetNameForThread(...), or possibly even GetName(...) since
the caller would prefix it with a ThreadIdNameManager

[dsinclair, 2013/01/24 15:13:06]

Done.

+  AutoLock locked(lock_);
+  IdToInternedNameIterator iter = id_to_interned_name_.find(id);
+  DCHECK(iter != id_to_interned_name_.end());
+  return iter->second.c_str();

[jar (doing other things), 2013/01/24 01:05:14]

This sort of return tends to suggest that the string is very long lived.  Care
must be taken that the caller knows that the  char* will go away :-/.  ...
unless you decide to leak.

[dsinclair, 2013/01/24 15:13:06]

This should be long lived as it will continue to live in the name ->
interned_name hash even after the id -> name mapping is removed.


On 2013/01/24 01:05:14, jar wrote:

+}
+
+void ThreadIdNameManager::RemoveNameForId(PlatformThreadId id) {
+  if (id == kInvalidThreadId)
+    return;
+
+  AutoLock locked(lock_);
+  IdToInternedNameIterator iter = id_to_interned_name_.find(id);
+  DCHECK((iter != id_to_interned_name_.end()));
+  id_to_interned_name_.erase(iter);
+}
+
+}  // namespace base