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 15 matching lines @@
 // Friendly names for the well-known threads.
 const char* const g_web_thread_names[WebThread::ID_COUNT] = {
     "Web_UIThread",                // UI
     "Web_DBThread",                // DB
     "Web_FileThread",              // FILE
     "Web_FileUserBlockingThread",  // FILE_USER_BLOCKING
     "Web_CacheThread",             // CACHE
     "Web_IOThread",                // IO
 };
 
+static const char* GetThreadName(WebThread::ID thread) {
+  if (WebThread::UI <= thread && thread < WebThread::ID_COUNT)
+    return g_web_thread_names[thread];
+  return "Unknown Thread";
+}
+
 // An implementation of SingleThreadTaskRunner to be used in conjunction
 // with WebThread.
 class WebThreadTaskRunner : public base::SingleThreadTaskRunner {
  public:
   explicit WebThreadTaskRunner(WebThread::ID identifier) : id_(identifier) {}
 
   // SingleThreadTaskRunner implementation.
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const base::Closure& task,
                        base::TimeDelta delay) override {
@@ skipping 57 matching lines @@
 
   const scoped_refptr<base::SequencedWorkerPool> blocking_pool;
 };
 
 base::LazyInstance<WebThreadGlobals>::Leaky g_globals =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 WebThreadImpl::WebThreadImpl(ID identifier)
-    : Thread(g_web_thread_names[identifier]), identifier_(identifier) {
+    : Thread(GetThreadName(identifier)), identifier_(identifier) {
   Initialize();
 }
 
 WebThreadImpl::WebThreadImpl(ID identifier, base::MessageLoop* message_loop)
-    : Thread(message_loop->thread_name()), identifier_(identifier) {
+    : Thread(GetThreadName(identifier)), identifier_(identifier) {
   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 235 matching lines @@
   // http://crbug.com/63678
   base::ThreadRestrictions::ScopedAllowSingleton allow_singleton;
   WebThreadGlobals& globals = g_globals.Get();
   base::AutoLock lock(globals.lock);
   DCHECK(identifier >= 0 && identifier < ID_COUNT);
   return globals.threads[identifier] &&
          globals.threads[identifier]->message_loop() ==
              base::MessageLoop::current();
 }
 
-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