Deletes base::MessageLoop::set_thread_name().

content/browser/browser_thread_impl.cc

 // 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 "content/browser/browser_thread_impl.h"
 
 #include <string.h>
 
 #include <string>
 
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
+#include "base/threading/platform_thread.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "build/build_config.h"
 #include "content/public/browser/browser_thread_delegate.h"
 #include "content/public/browser/content_browser_client.h"
 #include "net/disk_cache/simple/simple_backend_impl.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/jni_android.h"
 #endif
 
 namespace content {
 
 namespace {
 
 // Friendly names for the well-known threads.
 static const char* const g_browser_thread_names[BrowserThread::ID_COUNT] = {
   "",  // UI (name assembled in browser_main.cc).
   "Chrome_DBThread",  // DB
   "Chrome_FileThread",  // FILE
   "Chrome_FileUserBlockingThread",  // FILE_USER_BLOCKING
   "Chrome_ProcessLauncherThread",  // PROCESS_LAUNCHER
   "Chrome_CacheThread",  // CACHE
   "Chrome_IOThread",  // IO
 };
 
+static const char* GetThreadName(BrowserThread::ID thread) {
+  if (BrowserThread::UI < thread && thread < BrowserThread::ID_COUNT)
+    return g_browser_thread_names[thread];
+  if (thread == BrowserThread::UI)
+    return "Chrome_UIThread";
+  return "Unknown Thread";
+}
+
 // An implementation of SingleThreadTaskRunner to be used in conjunction
 // with BrowserThread.
 class BrowserThreadTaskRunner : public base::SingleThreadTaskRunner {
  public:
   explicit BrowserThreadTaskRunner(BrowserThread::ID identifier)
       : id_(identifier) {}
 
   // SingleThreadTaskRunner implementation.
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const base::Closure& task,
@@ skipping 60 matching lines @@
 
   const scoped_refptr<base::SequencedWorkerPool> blocking_pool;
 };
 
 base::LazyInstance<BrowserThreadGlobals>::Leaky
     g_globals = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 BrowserThreadImpl::BrowserThreadImpl(ID identifier)
-    : Thread(g_browser_thread_names[identifier]),
-      identifier_(identifier) {
+    : Thread(GetThreadName(identifier)), identifier_(identifier) {
   Initialize();
 }
 
 BrowserThreadImpl::BrowserThreadImpl(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 BrowserThreadImpl::ShutdownThreadPool() {
   // The goal is to make it impossible for chrome 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 269 matching lines @@
 // static
 bool BrowserThread::CurrentlyOn(ID identifier) {
   BrowserThreadGlobals& 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(BrowserThread::ID thread) {
-  if (BrowserThread::UI < thread && thread < BrowserThread::ID_COUNT)
-    return g_browser_thread_names[thread];
-  if (thread == BrowserThread::UI)
-    return "Chrome_UIThread";
-  return "Unknown Thread";
-}
-
 // static
 std::string BrowserThread::GetDCheckCurrentlyOnErrorMessage(ID expected) {
-  const base::MessageLoop* message_loop = base::MessageLoop::current();
-  ID actual_browser_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_browser_thread)) {
-    actual_name = GetThreadName(actual_browser_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 BrowserThread::IsMessageLoopValid(ID identifier) {
@@ skipping 104 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 content