Deletes base::MessageLoop::set_thread_name().

base/message_loop/message_loop.cc

 // Copyright 2013 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/message_loop/message_loop.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_pump_default.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/run_loop.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
+#include "base/threading/thread_id_name_manager.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/tracked_objects.h"
 #include "build/build_config.h"
 
 #if defined(OS_MACOSX)
 #include "base/message_loop/message_pump_mac.h"
 #endif
@@ skipping 357 matching lines @@
       pending_high_res_tasks_(0),
       in_high_res_mode_(false),
 #endif
       nestable_tasks_allowed_(true),
       pump_factory_(pump_factory),
       message_histogram_(NULL),
       run_loop_(NULL),
       incoming_task_queue_(new internal::IncomingTaskQueue(this)),
       unbound_task_runner_(
           new internal::MessageLoopTaskRunner(incoming_task_queue_)),
-      task_runner_(unbound_task_runner_) {
+      task_runner_(unbound_task_runner_),
+      thread_id_(kInvalidThreadId) {
   // If type is TYPE_CUSTOM non-null pump_factory must be given.
   DCHECK(type_ != TYPE_CUSTOM || !pump_factory_.is_null());
 }
 
 void MessageLoop::BindToCurrentThread() {
   DCHECK(!pump_);
   if (!pump_factory_.is_null())
     pump_ = pump_factory_.Run();
   else
     pump_ = CreateMessagePumpForType(type_);
 
   DCHECK(!current()) << "should only have one message loop per thread";
   lazy_tls_ptr.Pointer()->Set(this);
 
   incoming_task_queue_->StartScheduling();
   unbound_task_runner_->BindToCurrentThread();
   unbound_task_runner_ = nullptr;
+  subtle::Release_Store(&thread_id_, PlatformThread::CurrentId());
   SetThreadTaskRunnerHandle();
 }
 
+std::string MessageLoop::GetThreadName() const {
+  return ThreadIdNameManager::GetInstance()->GetName(
+      subtle::Release_Load(&thread_id_));

[gab, 2016/06/03 15:31:17]

I don't think you need to use an Atomic32. Instead you can initialize
|thread_id_| to |PlatformThread::kInvalidThreadId| and here do:

if (thread_id_ == PlatformThread::kInvalidThreadId) {
  // |thread_id_| should already have been initialized but this thread might not
have received the update yet.
  subtle::MemoryBarrier();
  DCHECK_NE(PlatformThread::kInvalidThreadId, thread_id_);
}
return ThreadIdNameManager::GetInstance()->GetName(thread_id_);

[alokp, 2016/06/03 16:34:56]

Used subtle::MemoryBarrier() in the new patch. I did not add the DCHECK_NE
because I think it is possible that this function is called before
BindToCurrentThread is executed. No?

May be I should add a WARNING that message loop is not bound to any thread yet.
WDYT?

[gab, 2016/06/07 00:30:59]

I think it's reasonable to document in the header that this API is only valid 
when the MessageLoop is running (and BindToCurrentThread is called before the
loop runs [1]). In which case the DCHECK makes sense.

The only place where this is not called from MessageLoop::current() is for
tracing logging when that thread is hung (and thus clearly running).

[1] https://cs.chromium.org/chromium/src/base/threading/thread.cc?rcl=0&l=233

[alokp, 2016/06/10 22:12:59]

Done.

+}
+
 void MessageLoop::SetTaskRunner(
     scoped_refptr<SingleThreadTaskRunner> task_runner) {
   DCHECK_EQ(this, current());
   DCHECK(task_runner->BelongsToCurrentThread());
   DCHECK(!unbound_task_runner_);
   task_runner_ = std::move(task_runner);
   SetThreadTaskRunnerHandle();
 }
 
 void MessageLoop::SetThreadTaskRunnerHandle() {
@@ skipping 118 matching lines @@
 }
 
 //------------------------------------------------------------------------------
 // Method and data for histogramming events and actions taken by each instance
 // on each thread.
 
 void MessageLoop::StartHistogrammer() {
 #if !defined(OS_NACL)  // NaCl build has no metrics code.
   if (enable_histogrammer_ && !message_histogram_
       && StatisticsRecorder::IsActive()) {
-    DCHECK(!thread_name_.empty());
+    std::string thread_name = GetThreadName();
+    DCHECK(!thread_name.empty());
     message_histogram_ = LinearHistogram::FactoryGetWithRangeDescription(
-        "MsgLoop:" + thread_name_,
-        kLeastNonZeroMessageId, kMaxMessageId,
+        "MsgLoop:" + thread_name, kLeastNonZeroMessageId, kMaxMessageId,
         kNumberOfDistinctMessagesDisplayed,
-        HistogramBase::kHexRangePrintingFlag,
-        event_descriptions_);
+        HistogramBase::kHexRangePrintingFlag, event_descriptions_);
   }
 #endif
 }
 
 void MessageLoop::HistogramEvent(int event) {
 #if !defined(OS_NACL)
   if (message_histogram_)
     message_histogram_->Add(event);
 #endif
 }
@@ skipping 166 matching lines @@
       persistent,
       mode,
       controller,
       delegate);
 }
 #endif
 
 #endif  // !defined(OS_NACL_SFI)
 
 }  // namespace base