Deletes base::MessageLoop::set_thread_name().

ios/web/web_thread_impl.cc

 // Copyright 2014 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 "ios/web/web_thread_impl.h"
 
 #include <string>
 
 #include "base/atomicops.h"
 #include "base/bind.h"
@@ skipping 97 matching lines @@
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 WebThreadImpl::WebThreadImpl(ID identifier)
     : Thread(g_web_thread_names[identifier]), identifier_(identifier) {
   Initialize();
 }
 
 WebThreadImpl::WebThreadImpl(ID identifier, base::MessageLoop* message_loop)
-    : Thread(message_loop->thread_name()), identifier_(identifier) {
+    : Thread(message_loop->GetThreadName()), identifier_(identifier) {

[gab, 2016/06/13 18:57:35]

Is |message_loop| already running at this point?

[alokp, 2016/06/14 12:31:22]

Good catch. This constructor seems to be used in unittests only:
https://cs.chromium.org/chromium/src/ios/web/test/test_web_thread_bundle.cc?q...

I am going to change it to use the same pattern used in BrowserThreadImpl.

   set_message_loop(message_loop);
   Initialize();
 }
 
 // static
 void WebThreadImpl::ShutdownThreadPool() {
   // The goal is to make it impossible to 'infinite loop' during shutdown,
   // but to reasonably expect that all BLOCKING_SHUTDOWN tasks queued during
   // shutdown get run. There's nothing particularly scientific about the
   // number chosen.
@@ skipping 243 matching lines @@
 }
 
 static const char* GetThreadName(WebThread::ID thread) {
   if (WebThread::UI <= thread && thread < WebThread::ID_COUNT)
     return g_web_thread_names[thread];
   return "Unknown Thread";
 }
 
 // static
 std::string WebThread::GetDCheckCurrentlyOnErrorMessage(ID expected) {
-  const base::MessageLoop* message_loop = base::MessageLoop::current();
-  ID actual_web_thread;
-  const char* actual_name = "Unknown Thread";
-  if (message_loop && !message_loop->thread_name().empty()) {
-    actual_name = message_loop->thread_name().c_str();
-  } else if (GetCurrentThreadIdentifier(&actual_web_thread)) {
-    actual_name = GetThreadName(actual_web_thread);
-  }
+  std::string actual_name = base::PlatformThread::GetName();
+  if (actual_name.empty())
+    actual_name = "Unknown Thread";
+
   std::string result = "Must be called on ";
   result += GetThreadName(expected);
   result += "; actually called on ";
   result += actual_name;
   result += ".";
   return result;
 }
 
 // static
 bool WebThread::IsMessageLoopValid(ID identifier) {
@@ skipping 100 matching lines @@
   AtomicWord* storage =
       reinterpret_cast<AtomicWord*>(&globals.thread_delegates[identifier]);
   AtomicWord old_pointer = base::subtle::NoBarrier_AtomicExchange(
       storage, reinterpret_cast<AtomicWord>(delegate));
 
   // This catches registration when previously registered.
   DCHECK(!delegate || !old_pointer);
 }
 
 }  // namespace web