Revert of Ensure BrowserThread::CurrentlyOn is correct through MessageLoop teardown

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>
 
@@ skipping 88 matching lines @@
 base::LazyInstance<BrowserThreadTaskRunners>::Leaky g_task_runners =
     LAZY_INSTANCE_INITIALIZER;
 
 struct BrowserThreadGlobals {
   BrowserThreadGlobals()
       : blocking_pool(
             new base::SequencedWorkerPool(3,
                                           "BrowserBlocking",
                                           base::TaskPriority::USER_VISIBLE)) {
     memset(threads, 0, BrowserThread::ID_COUNT * sizeof(threads[0]));
-    memset(thread_ids, 0, BrowserThread::ID_COUNT * sizeof(thread_ids[0]));
     memset(thread_delegates, 0,
            BrowserThread::ID_COUNT * sizeof(thread_delegates[0]));
   }
 
-  // This lock protects |threads| and |thread_ids|. Do not read or modify those
-  // arrays without holding this lock. Do not block while holding this lock.
+  // This lock protects |threads|. Do not read or modify that array
+  // without holding this lock. Do not block while holding this lock.
   base::Lock lock;
 
-  // This array is protected by |lock|. IDs in this array are populated as soon
-  // as their respective thread is started and are never reset.
-  base::PlatformThreadId thread_ids[BrowserThread::ID_COUNT];
-
   // This array is protected by |lock|. The threads are not owned by this
   // array. Typically, the threads are owned on the UI thread by
   // BrowserMainLoop. BrowserThreadImpl objects remove themselves from this
   // array upon destruction.
   BrowserThreadImpl* threads[BrowserThread::ID_COUNT];
 
   // Only atomic operations are used on this array. The delegates are not owned
   // by this array, rather by whoever calls BrowserThread::SetDelegate.
   BrowserThreadDelegate* thread_delegates[BrowserThread::ID_COUNT];
 
   const scoped_refptr<base::SequencedWorkerPool> blocking_pool;
 };
 
 base::LazyInstance<BrowserThreadGlobals>::Leaky
     g_globals = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 BrowserThreadImpl::BrowserThreadImpl(ID identifier)
     : Thread(GetThreadName(identifier)), identifier_(identifier) {
   Initialize();
-
-  // Unit tests may create multiple TestBrowserThreadBundles, causing the same
-  // BrowserThread ID to be reinitialized. We explicitly clear the thread ID
-  // here so Start() can sanity check.
-  BrowserThreadGlobals& globals = g_globals.Get();
-  base::AutoLock lock(globals.lock);
-  globals.thread_ids[identifier] = base::kInvalidThreadId;
 }
 
 BrowserThreadImpl::BrowserThreadImpl(ID identifier,
                                      base::MessageLoop* message_loop)
     : Thread(GetThreadName(identifier)), identifier_(identifier) {
   set_message_loop(message_loop);
   Initialize();
-
-  // If constructed with an explicit message loop, this is a fake BrowserThread
-  // which runs on the current thread.
-  BrowserThreadGlobals& globals = g_globals.Get();
-  base::AutoLock lock(globals.lock);
-  globals.thread_ids[identifier] = base::PlatformThread::CurrentId();
 }
 
 // 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.
   const int kMaxNewShutdownBlockingTasks = 1000;
   BrowserThreadGlobals& globals = g_globals.Get();
@@ skipping 155 matching lines @@
   globals.threads[identifier_] = nullptr;
 #ifndef NDEBUG
   // Double check that the threads are ordered correctly in the enumeration.
   for (int i = identifier_ + 1; i < ID_COUNT; ++i) {
     DCHECK(!globals.threads[i]) <<
         "Threads must be listed in the reverse order that they die";
   }
 #endif
 }
 
-bool BrowserThreadImpl::Start() {
-  return StartWithOptions(base::Thread::Options());
-}
-
 bool BrowserThreadImpl::StartWithOptions(const Options& options) {
   // The global thread table needs to be locked while a new thread is
   // starting, as the new thread can asynchronously start touching the
   // table (and other thread's message_loop).
   BrowserThreadGlobals& globals = g_globals.Get();
   base::AutoLock lock(globals.lock);
-  DCHECK_EQ(globals.thread_ids[identifier_], base::kInvalidThreadId);
-  bool result = Thread::StartWithOptions(options);
-  globals.thread_ids[identifier_] = GetThreadId();
-  return result;
+  return Thread::StartWithOptions(options);
 }
 
-bool BrowserThreadImpl::StartAndWaitForTesting() {
-  if (!Start())
-    return false;
-  WaitUntilThreadStarted();
-  return true;
-}
 // static
 bool BrowserThreadImpl::PostTaskHelper(
     BrowserThread::ID identifier,
     const tracked_objects::Location& from_here,
     const base::Closure& task,
     base::TimeDelta delay,
     bool nestable) {
   DCHECK_GE(identifier, 0);
   DCHECK_LT(identifier, ID_COUNT);
   // Optimization: to avoid unnecessary locks, we listed the ID enumeration in
@@ skipping 79 matching lines @@
   DCHECK_LT(identifier, ID_COUNT);
   return globals.threads[identifier] != nullptr;
 }
 
 // static
 bool BrowserThread::CurrentlyOn(ID identifier) {
   BrowserThreadGlobals& globals = g_globals.Get();
   base::AutoLock lock(globals.lock);
   DCHECK_GE(identifier, 0);
   DCHECK_LT(identifier, ID_COUNT);
-  return base::PlatformThread::CurrentId() == globals.thread_ids[identifier];
+  return globals.threads[identifier] &&
+         globals.threads[identifier]->message_loop() ==
+             base::MessageLoop::current();
 }
 
 // static
 std::string BrowserThread::GetDCheckCurrentlyOnErrorMessage(ID expected) {
   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);
@@ skipping 112 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