Have content/ create and destroy its own threads.

chrome/browser/io_thread.cc

 // Copyright (c) 2011 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 "chrome/browser/io_thread.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/bind.h"
@@ skipping 298 matching lines @@
  private:
   IOThread* const io_thread_;  // Weak pointer, owned by BrowserProcess.
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
 
   base::debug::LeakTracker<SystemURLRequestContextGetter> leak_tracker_;
 };
 
 SystemURLRequestContextGetter::SystemURLRequestContextGetter(
     IOThread* io_thread)
     : io_thread_(io_thread),
-      io_message_loop_proxy_(io_thread->message_loop_proxy()) {
+      io_message_loop_proxy_(
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)) {
 }
 
 SystemURLRequestContextGetter::~SystemURLRequestContextGetter() {}
 
 net::URLRequestContext* SystemURLRequestContextGetter::GetURLRequestContext() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(io_thread_->globals()->system_request_context);
 
   return io_thread_->globals()->system_request_context;
 }
@@ skipping 10 matching lines @@
 IOThread::Globals::MediaGlobals::MediaGlobals() {}
 
 IOThread::Globals::MediaGlobals::~MediaGlobals() {}
 
 // |local_state| is passed in explicitly in order to (1) reduce implicit
 // dependencies and (2) make IOThread more flexible for testing.
 IOThread::IOThread(
     PrefService* local_state,
     ChromeNetLog* net_log,
     ExtensionEventRouterForwarder* extension_event_router_forwarder)
-    : content::BrowserProcessSubThread(BrowserThread::IO),
-      net_log_(net_log),
+    : net_log_(net_log),
       extension_event_router_forwarder_(extension_event_router_forwarder),
       globals_(NULL),
       sdch_manager_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   // We call RegisterPrefs() here (instead of inside browser_prefs.cc) to make
   // sure that everything is initialized in the right order.
   RegisterPrefs(local_state);
   auth_schemes_ = local_state->GetString(prefs::kAuthSchemes);
   negotiate_disable_cname_lookup_ = local_state->GetBoolean(
       prefs::kDisableAuthNegotiateCnameLookup);
   negotiate_enable_port_ = local_state->GetBoolean(
       prefs::kEnableAuthNegotiatePort);
   auth_server_whitelist_ = local_state->GetString(prefs::kAuthServerWhitelist);
   auth_delegate_whitelist_ = local_state->GetString(
       prefs::kAuthNegotiateDelegateWhitelist);
   gssapi_library_name_ = local_state->GetString(prefs::kGSSAPILibraryName);
   pref_proxy_config_tracker_.reset(
       ProxyServiceFactory::CreatePrefProxyConfigTracker(local_state));
   ChromeNetworkDelegate::InitializeReferrersEnabled(&system_enable_referrers_,
                                                     local_state);
   ssl_config_service_manager_.reset(
       SSLConfigServiceManager::CreateDefaultManager(local_state));
-  MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&IOThread::InitSystemRequestContext,
-                            weak_factory_.GetWeakPtr()));
+
+  BrowserThread::SetDelegate(BrowserThread::IO, this);
 }
 
 IOThread::~IOThread() {
   if (pref_proxy_config_tracker_.get())
     pref_proxy_config_tracker_->DetachFromPrefService();
-  // We cannot rely on our base class to stop the thread since we want our
-  // CleanUp function to run.
-  Stop();
   DCHECK(!globals_);
 }
 
 IOThread::Globals* IOThread::globals() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return globals_;
 }
 
 ChromeNetLog* IOThread::net_log() {
   return net_log_;
 }
 
 net::URLRequestContextGetter* IOThread::system_url_request_context_getter() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!system_url_request_context_getter_) {
     InitSystemRequestContext();
   }
   return system_url_request_context_getter_;
 }
 
 void IOThread::Init() {
   // Though this thread is called the "IO" thread, it actually just routes
   // messages around; it shouldn't be allowed to perform any blocking disk I/O.
   base::ThreadRestrictions::SetIOAllowed(false);
 
-  content::BrowserProcessSubThread::Init();
-
-  DCHECK_EQ(MessageLoop::TYPE_IO, message_loop()->type());
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
 #if defined(USE_NSS)
   net::SetMessageLoopForOCSP();
 #endif  // defined(USE_NSS)
 
   DCHECK(!globals_);
   globals_ = new Globals;
 
   globals_->media.media_internals.reset(new MediaInternals());
 
@@ skipping 50 matching lines @@
   globals_->proxy_script_fetcher_http_transaction_factory.reset(
       new net::HttpNetworkLayer(network_session));
   globals_->proxy_script_fetcher_ftp_transaction_factory.reset(
       new net::FtpNetworkLayer(globals_->host_resolver.get()));
 
   globals_->proxy_script_fetcher_context =
       ConstructProxyScriptFetcherContext(globals_, net_log_);
 
   sdch_manager_ = new net::SdchManager();
   sdch_manager_->set_sdch_fetcher(new SdchDictionaryFetcher);
+
+  // InitSystemRequestContext turns right around and posts a task back
+  // to the IO thread, so we can't let it run until we know the IO
+  // thread has started.
+  //
+  // Note that since we are at BrowserThread::Init time, the UI thread
+  // is blocked waiting for the thread to start.  Therefore, posting
+  // this task to the main thread's message loop here is guaranteed to
+  // get it onto the message loop while the IOThread object still
+  // exists.  However, the message might not be processed on the UI
+  // thread until after IOThread is gone, so use a weak pointer.
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&IOThread::InitSystemRequestContext,
+                                     weak_factory_.GetWeakPtr()));
+
+  // We constructed the weak pointer on the IO thread but it will be
+  // used on the UI thread.  Call this to avoid a thread checker
+  // error.
+  weak_factory_.DetachFromThread();
 }
 
 void IOThread::CleanUp() {
   delete sdch_manager_;
   sdch_manager_ = NULL;
 
   // Step 1: Kill all things that might be holding onto
   // net::URLRequest/net::URLRequestContexts.
 
 #if defined(USE_NSS)
@@ skipping 20 matching lines @@
 
   system_proxy_config_service_.reset();
 
   delete globals_;
   globals_ = NULL;
 
   // net::URLRequest instances must NOT outlive the IO thread.
   base::debug::LeakTracker<net::URLRequest>::CheckForLeaks();
 
   base::debug::LeakTracker<SystemURLRequestContextGetter>::CheckForLeaks();
-
-  // This will delete the |notification_service_|.  Make sure it's done after
-  // anything else can reference it.
-  content::BrowserProcessSubThread::CleanUp();
 }
 
 // static
 void IOThread::RegisterPrefs(PrefService* local_state) {
   local_state->RegisterStringPref(prefs::kAuthSchemes,
                                   "basic,digest,ntlm,negotiate");
   local_state->RegisterBooleanPref(prefs::kDisableAuthNegotiateCnameLookup,
                                    false);
   local_state->RegisterBooleanPref(prefs::kEnableAuthNegotiatePort, false);
   local_state->RegisterStringPref(prefs::kAuthServerWhitelist, "");
@@ skipping 30 matching lines @@
 }
 
 void IOThread::ClearHostCache() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   net::HostCache* host_cache = globals_->host_resolver->GetHostCache();
   if (host_cache)
     host_cache->clear();
 }
 
+MessageLoop* IOThread::message_loop() const {
+  return BrowserThread::UnsafeGetBrowserThread(
+      BrowserThread::IO)->message_loop();
+}
+
 net::SSLConfigService* IOThread::GetSSLConfigService() {
   return ssl_config_service_manager_->Get();
 }
 
 void IOThread::InitSystemRequestContext() {
   if (system_url_request_context_getter_)
     return;
   // If we're in unit_tests, IOThread may not be run.
   if (!message_loop())
     return;
   ChromeProxyConfigService* proxy_config_service =
       ProxyServiceFactory::CreateProxyConfigService();
   system_proxy_config_service_.reset(proxy_config_service);
   if (pref_proxy_config_tracker_.get()) {
     pref_proxy_config_tracker_->SetChromeProxyConfigService(
         proxy_config_service);
   }
   system_url_request_context_getter_ =
       new SystemURLRequestContextGetter(this);
+  // Safe to post an unretained this pointer, since IOThread is
+  // guaranteed to outlive the IO BrowserThread.
   message_loop()->PostTask(
       FROM_HERE, base::Bind(&IOThread::InitSystemRequestContextOnIOThread,
                             base::Unretained(this)));
 }
 
 void IOThread::InitSystemRequestContextOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!globals_->system_proxy_service.get());
   DCHECK(system_proxy_config_service_.get());
 
@@ skipping 20 matching lines @@
   system_params.network_delegate = globals_->system_network_delegate.get();
   system_params.net_log = net_log_;
   globals_->system_http_transaction_factory.reset(
       new net::HttpNetworkLayer(
           new net::HttpNetworkSession(system_params)));
   globals_->system_ftp_transaction_factory.reset(
       new net::FtpNetworkLayer(globals_->host_resolver.get()));
   globals_->system_request_context =
       ConstructSystemRequestContext(globals_, net_log_);
 }