Explicitly make BrowserThread::SetDelegate specific to the IO thread.

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 81 matching lines @@
           new BrowserThreadTaskRunner(static_cast<BrowserThread::ID>(i));
     }
   }
 
   scoped_refptr<base::SingleThreadTaskRunner> proxies[BrowserThread::ID_COUNT];
 };
 
 base::LazyInstance<BrowserThreadTaskRunners>::Leaky g_task_runners =
     LAZY_INSTANCE_INITIALIZER;
 
+using BrowserThreadDelegateAtomicPtr = base::subtle::AtomicWord;
+
 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.
   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];
+  // Only atomic operations are used on this pointer. The delegate isn't owned
+  // by BrowserThreadGlobals, rather by whoever calls
+  // BrowserThread::SetIOThreadDelegate.
+  BrowserThreadDelegateAtomicPtr io_thread_delegate = 0;
 
   const scoped_refptr<base::SequencedWorkerPool> blocking_pool;
 };
 
 base::LazyInstance<BrowserThreadGlobals>::Leaky
     g_globals = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 BrowserThreadImpl::BrowserThreadImpl(ID identifier)
@@ skipping 37 matching lines @@
   // We don't want to create a pool if none exists.
   if (g_globals == nullptr)
     return;
   g_globals.Get().blocking_pool->FlushForTesting();
   disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
 }
 
 void BrowserThreadImpl::Init() {
   BrowserThreadGlobals& globals = g_globals.Get();
 
-  if (BrowserThread::CurrentlyOn(BrowserThread::DB) ||
-      BrowserThread::CurrentlyOn(BrowserThread::FILE) ||
-      BrowserThread::CurrentlyOn(BrowserThread::FILE_USER_BLOCKING) ||
-      BrowserThread::CurrentlyOn(BrowserThread::PROCESS_LAUNCHER) ||
-      BrowserThread::CurrentlyOn(BrowserThread::CACHE)) {
+  if (identifier_ == BrowserThread::DB ||
+      identifier_ == BrowserThread::FILE ||
+      identifier_ == BrowserThread::FILE_USER_BLOCKING ||
+      identifier_ == BrowserThread::PROCESS_LAUNCHER ||
+      identifier_ == BrowserThread::CACHE) {
     base::MessageLoop* message_loop = base::MessageLoop::current();
     message_loop->DisallowNesting();
     message_loop->DisallowTaskObservers();
   }
 
-  using base::subtle::AtomicWord;
-  AtomicWord* storage =
-      reinterpret_cast<AtomicWord*>(&globals.thread_delegates[identifier_]);
-  AtomicWord stored_pointer = base::subtle::NoBarrier_Load(storage);
-  BrowserThreadDelegate* delegate =
-      reinterpret_cast<BrowserThreadDelegate*>(stored_pointer);
-  if (delegate)
-    delegate->Init();
+  if (identifier_ == BrowserThread::IO) {
+    BrowserThreadDelegateAtomicPtr delegate =
+        base::subtle::NoBarrier_Load(&globals.io_thread_delegate);
+    if (delegate)
+      reinterpret_cast<BrowserThreadDelegate*>(delegate)->Init();
+  }
 }
 
 // We disable optimizations for this block of functions so the compiler doesn't
 // merge them all together.
 MSVC_DISABLE_OPTIMIZE()
 MSVC_PUSH_DISABLE_WARNING(4748)
 
 NOINLINE void BrowserThreadImpl::UIThreadRun(base::RunLoop* run_loop) {
   volatile int line_number = __LINE__;
   Thread::Run(run_loop);
@@ skipping 76 matching lines @@
   }
 
   // |identifier_| must be set to a valid enum value in the constructor, so it
   // should be impossible to reach here.
   CHECK(false);
 }
 
 void BrowserThreadImpl::CleanUp() {
   BrowserThreadGlobals& globals = g_globals.Get();
 
-  using base::subtle::AtomicWord;
-  AtomicWord* storage =
-      reinterpret_cast<AtomicWord*>(&globals.thread_delegates[identifier_]);
-  AtomicWord stored_pointer = base::subtle::NoBarrier_Load(storage);
-  BrowserThreadDelegate* delegate =
-      reinterpret_cast<BrowserThreadDelegate*>(stored_pointer);
-
-  if (delegate)
-    delegate->CleanUp();
+  if (identifier_ == BrowserThread::IO) {
+    BrowserThreadDelegateAtomicPtr delegate =
+        base::subtle::NoBarrier_Load(&globals.io_thread_delegate);
+    if (delegate)
+      reinterpret_cast<BrowserThreadDelegate*>(delegate)->CleanUp();
+  }
 
   // PostTaskHelper() accesses the message loop while holding this lock.
   // However, the message loop will soon be destructed without any locking. So
   // to prevent a race with accessing the message loop in PostTaskHelper(),
   // remove this thread from the global array now.
   base::AutoLock lock(globals.lock);
   globals.threads[identifier_] = nullptr;
 }
 
 void BrowserThreadImpl::Initialize() {
@@ skipping 243 matching lines @@
 
   return false;
 }
 
 // static
 scoped_refptr<base::SingleThreadTaskRunner>
 BrowserThread::GetTaskRunnerForThread(ID identifier) {
   return g_task_runners.Get().proxies[identifier];
 }
 
-void BrowserThread::SetDelegate(ID identifier,
-                                BrowserThreadDelegate* delegate) {
-  using base::subtle::AtomicWord;
+// static
+void BrowserThread::SetIOThreadDelegate(BrowserThreadDelegate* delegate) {
   BrowserThreadGlobals& globals = g_globals.Get();
-  AtomicWord* storage = reinterpret_cast<AtomicWord*>(
-      &globals.thread_delegates[identifier]);
-  AtomicWord old_pointer = base::subtle::NoBarrier_AtomicExchange(
-      storage, reinterpret_cast<AtomicWord>(delegate));
+  BrowserThreadDelegateAtomicPtr old_delegate =
+      base::subtle::NoBarrier_AtomicExchange(
+          &globals.io_thread_delegate,
+          reinterpret_cast<BrowserThreadDelegateAtomicPtr>(delegate));
 
   // This catches registration when previously registered.
-  DCHECK(!delegate || !old_pointer);
+  DCHECK(!delegate || !old_delegate);
 }
 
 }  // namespace content