Revert 111695 - Have content/ create and destroy its own threads.

chrome/browser/browser_process_impl.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/browser_process_impl.h"
 
 #include <map>
 #include <set>
 #include <vector>
 
@@ skipping 50 matching lines @@
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_l10n_util.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/json_pref_store.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/switch_utils.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/installer/util/google_update_constants.h"
-#include "content/browser/browser_child_process_host.h"
+#include "content/browser/browser_process_sub_thread.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/download/download_file_manager.h"
 #include "content/browser/download/download_status_updater.h"
 #include "content/browser/download/mhtml_generation_manager.h"
 #include "content/browser/download/save_file_manager.h"
 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
 #include "content/browser/net/browser_online_state_observer.h"
 #include "content/browser/plugin_service.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 35 matching lines @@
 // Linux. We have a timeout here because we're unable to run the UI messageloop
 // and there's some deadlock risk. Our only option is to exit anyway.
 static const int kEndSessionTimeoutSeconds = 10;
 #endif
 
 using content::BrowserThread;
 
 BrowserProcessImpl::BrowserProcessImpl(const CommandLine& command_line)
     : created_resource_dispatcher_host_(false),
       created_metrics_service_(false),
+      created_io_thread_(false),
+      created_file_thread_(false),
+      created_db_thread_(false),
+      created_process_launcher_thread_(false),
+      created_cache_thread_(false),
       created_watchdog_thread_(false),
+#if defined(OS_CHROMEOS)
+      created_web_socket_proxy_thread_(false),
+#endif
       created_profile_manager_(false),
       created_local_state_(false),
       created_icon_manager_(false),
       created_sidebar_manager_(false),
       created_browser_policy_connector_(false),
       created_notification_ui_manager_(false),
       created_safe_browsing_service_(false),
       module_ref_count_(0),
       did_start_(false),
       checked_for_new_frames_(false),
@@ skipping 12 matching lines @@
       chrome::kExtensionScheme);
 
   extension_event_router_forwarder_ = new ExtensionEventRouterForwarder;
 
   ExtensionTabIdMap::GetInstance()->Init();
 
   online_state_observer_.reset(new BrowserOnlineStateObserver);
 }
 
 BrowserProcessImpl::~BrowserProcessImpl() {
-  // See StartTearDown and PreStopThread functions below, this is where
-  // most destruction happens so that it can be interleaved with threads
-  // going away.
+#if defined(OS_CHROMEOS)
+  if (web_socket_proxy_thread_.get())
+    chromeos::WebSocketProxyController::Shutdown();
+  web_socket_proxy_thread_.reset();
+#endif
 
-  // Wait for the pending print jobs to finish.
-  print_job_manager_->OnQuit();
-  print_job_manager_.reset();
-
-  tracked_objects::ThreadData::EnsureCleanupWasCalled(4);
-
-  g_browser_process = NULL;
-}
-
-void BrowserProcessImpl::StartTearDown() {
   // Delete the AutomationProviderList before NotificationService,
   // since it may try to unregister notifications
   // Both NotificationService and AutomationProvider are singleton instances in
   // the BrowserProcess. Since AutomationProvider may have some active
   // notification observers, it is essential that it gets destroyed before the
   // NotificationService. NotificationService won't be destroyed until after
   // this destructor is run.
   automation_provider_list_.reset();
 
   // We need to shutdown the SdchDictionaryFetcher as it regularly holds
@@ skipping 48 matching lines @@
   browser_policy_connector_.reset();
 
   // Destroying the GpuProcessHostUIShims on the UI thread posts a task to
   // delete related objects on the GPU thread. This must be done before
   // stopping the GPU thread. The GPU thread will close IPC channels to renderer
   // processes so this has to happen before stopping the IO thread.
   GpuProcessHostUIShim::DestroyAll();
 
   // Stop the watchdog thread before stopping other threads.
   watchdog_thread_.reset();
-}
 
-void BrowserProcessImpl::PreStartThread(BrowserThread::ID thread_id) {
-  switch (thread_id) {
-    case BrowserThread::IO:
-      CreateIOThreadState();
-      break;
+  // Need to stop io_thread_ before resource_dispatcher_host_, since
+  // io_thread_ may still deref ResourceDispatcherHost and handle resource
+  // request before going away.
+  io_thread_.reset();
 
-    default:
-      break;
+  // The IO thread was the only user of this thread.
+  cache_thread_.reset();
+
+  // Stop the process launcher thread after the IO thread, in case the IO thread
+  // posted a task to terminate a process on the process launcher thread.
+  process_launcher_thread_.reset();
+
+  // Clean up state that lives on the file_thread_ before it goes away.
+  if (resource_dispatcher_host_.get()) {
+    resource_dispatcher_host()->download_file_manager()->Shutdown();
+    resource_dispatcher_host()->save_file_manager()->Shutdown();
   }
-}
 
-void BrowserProcessImpl::PostStartThread(BrowserThread::ID thread_id) {
-}
+  // Need to stop the file_thread_ here to force it to process messages in its
+  // message loop from the previous call to shutdown the DownloadFileManager,
+  // SaveFileManager and SessionService.
+  file_thread_.reset();
 
-void BrowserProcessImpl::PreStopThread(BrowserThread::ID thread_id) {
-  switch (thread_id) {
-#if defined(OS_CHROMEOS)
-    case BrowserThread::WEB_SOCKET_PROXY:
-      chromeos::WebSocketProxyController::Shutdown();
-      break;
-#endif
-    case BrowserThread::FILE:
-      // Clean up state that lives on or uses the file_thread_ before
-      // it goes away.
-      if (resource_dispatcher_host_.get()) {
-        resource_dispatcher_host()->download_file_manager()->Shutdown();
-        resource_dispatcher_host()->save_file_manager()->Shutdown();
-      }
-      break;
-    case BrowserThread::WEBKIT:
-      // Need to destroy ResourceDispatcherHost before PluginService
-      // and SafeBrowsingService, since it caches a pointer to
-      // it. This also causes the webkit thread to terminate (which is
-      // still the responsibility of the embedder, not of the content
-      // framework).
-      resource_dispatcher_host_.reset();
-      break;
-    default:
-      break;
-  }
-}
+  // With the file_thread_ flushed, we can release any icon resources.
+  icon_manager_.reset();
 
-void BrowserProcessImpl::PostStopThread(BrowserThread::ID thread_id) {
-  switch (thread_id) {
-    case BrowserThread::FILE:
-      // With the file_thread_ flushed, we can release any icon resources.
-      icon_manager_.reset();
-      break;
-    case BrowserThread::IO:
-      // Reset associated state right after actual thread is stopped,
-      // as io_thread_.global_ cleanup happens in CleanUp on the IO
-      // thread, i.e. as the thread exits its message loop.
-      io_thread_.reset();
-      break;
-    default:
-      break;
-  }
+  // Need to destroy ResourceDispatcherHost before PluginService and
+  // SafeBrowsingService, since it caches a pointer to it. This also
+  // causes the webkit thread to terminate.
+  resource_dispatcher_host_.reset();
+
+  // Wait for the pending print jobs to finish.
+  print_job_manager_->OnQuit();
+  print_job_manager_.reset();
+
+  // Destroy TabCloseableStateWatcher before NotificationService since the
+  // former registers for notifications.
+  tab_closeable_state_watcher_.reset();
+
+  tracked_objects::ThreadData::EnsureCleanupWasCalled(4);
+
+  g_browser_process = NULL;
 }
 
 #if defined(OS_WIN)
 // Send a QuitTask to the given MessageLoop when the (file) thread has processed
 // our (other) recent requests (to save preferences).
 // Change the boolean so that the receiving thread will know that we did indeed
 // send the QuitTask that terminated the message loop.
 static void PostQuit(MessageLoop* message_loop) {
   g_end_session_file_thread_has_completed = true;
   message_loop->PostTask(FROM_HERE, new MessageLoop::QuitTask());
@@ skipping 93 matching lines @@
 
 MetricsService* BrowserProcessImpl::metrics_service() {
   DCHECK(CalledOnValidThread());
   if (!created_metrics_service_)
     CreateMetricsService();
   return metrics_service_.get();
 }
 
 IOThread* BrowserProcessImpl::io_thread() {
   DCHECK(CalledOnValidThread());
-  DCHECK(io_thread_.get());
+  if (!created_io_thread_)
+    CreateIOThread();
   return io_thread_.get();
 }
 
 base::Thread* BrowserProcessImpl::file_thread() {
   DCHECK(CalledOnValidThread());
-  return BrowserThread::UnsafeGetBrowserThread(BrowserThread::FILE);
+  if (!created_file_thread_)
+    CreateFileThread();
+  return file_thread_.get();
 }
 
 base::Thread* BrowserProcessImpl::db_thread() {
   DCHECK(CalledOnValidThread());
-  return BrowserThread::UnsafeGetBrowserThread(BrowserThread::DB);
+  if (!created_db_thread_)
+    CreateDBThread();
+  return db_thread_.get();
 }
 
 base::Thread* BrowserProcessImpl::process_launcher_thread() {
   DCHECK(CalledOnValidThread());
-  return BrowserThread::UnsafeGetBrowserThread(BrowserThread::PROCESS_LAUNCHER);
+  if (!created_process_launcher_thread_)
+    CreateProcessLauncherThread();
+  return process_launcher_thread_.get();
 }
 
 base::Thread* BrowserProcessImpl::cache_thread() {
   DCHECK(CalledOnValidThread());
-  return BrowserThread::UnsafeGetBrowserThread(BrowserThread::CACHE);
+  if (!created_cache_thread_)
+    CreateCacheThread();
+  return cache_thread_.get();
 }
 
 WatchDogThread* BrowserProcessImpl::watchdog_thread() {
   DCHECK(CalledOnValidThread());
   if (!created_watchdog_thread_)
     CreateWatchdogThread();
   DCHECK(watchdog_thread_.get() != NULL);
   return watchdog_thread_.get();
 }
 
 #if defined(OS_CHROMEOS)
 base::Thread* BrowserProcessImpl::web_socket_proxy_thread() {
   DCHECK(CalledOnValidThread());
-  return BrowserThread::UnsafeGetBrowserThread(BrowserThread::WEB_SOCKET_PROXY);
+  if (!created_web_socket_proxy_thread_)
+    CreateWebSocketProxyThread();
+  DCHECK(web_socket_proxy_thread_.get() != NULL);
+  return web_socket_proxy_thread_.get();
 }
 #endif
 
 ProfileManager* BrowserProcessImpl::profile_manager() {
   DCHECK(CalledOnValidThread());
   if (!created_profile_manager_)
     CreateProfileManager();
   return profile_manager_.get();
 }
 
@@ skipping 179 matching lines @@
 
 safe_browsing::ClientSideDetectionService*
     BrowserProcessImpl::safe_browsing_detection_service() {
   DCHECK(CalledOnValidThread());
   if (safe_browsing_service())
     return safe_browsing_service()->safe_browsing_detection_service();
   return NULL;
 }
 
 bool BrowserProcessImpl::plugin_finder_disabled() const {
-  if (plugin_finder_disabled_pref_.get())
-    return plugin_finder_disabled_pref_->GetValue();
-  else
-    return false;
+  return *plugin_finder_disabled_pref_;
 }
 
 void BrowserProcessImpl::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_PREF_CHANGED) {
     std::string* pref = content::Details<std::string>(details).ptr();
     if (*pref == prefs::kDefaultBrowserSettingEnabled) {
       ApplyDefaultBrowserPolicy();
     } else if (*pref == prefs::kDisabledSchemes) {
@@ skipping 94 matching lines @@
   ApplyAllowCrossOriginAuthPromptPolicy();
 }
 
 void BrowserProcessImpl::CreateMetricsService() {
   DCHECK(!created_metrics_service_ && metrics_service_.get() == NULL);
   created_metrics_service_ = true;
 
   metrics_service_.reset(new MetricsService);
 }
 
-void BrowserProcessImpl::CreateIOThreadState() {
-  // Prior to any processing happening on the io thread, we create the
-  // plugin service as it is predominantly used from the io thread,
-  // but must be created on the main thread. The service ctor is
-  // inexpensive and does not invoke the io_thread() accessor.
+void BrowserProcessImpl::CreateIOThread() {
+  DCHECK(!created_io_thread_ && io_thread_.get() == NULL);
+  created_io_thread_ = true;
+
+  // Prior to starting the io thread, we create the plugin service as
+  // it is predominantly used from the io thread, but must be created
+  // on the main thread. The service ctor is inexpensive and does not
+  // invoke the io_thread() accessor.
   PluginService* plugin_service = PluginService::GetInstance();
   plugin_service->Init();
   plugin_service->set_filter(ChromePluginServiceFilter::GetInstance());
   plugin_service->StartWatchingPlugins();
 
   // Register the internal Flash if available.
   FilePath path;
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableInternalFlash) &&
       PathService::Get(chrome::FILE_FLASH_PLUGIN, &path)) {
     plugin_service->AddExtraPluginPath(path);
   }
 
 #if defined(OS_POSIX)
   // Also find plugins in a user-specific plugins dir,
   // e.g. ~/.config/chromium/Plugins.
   FilePath user_data_dir;
   if (PathService::Get(chrome::DIR_USER_DATA, &user_data_dir)) {
     plugin_service->AddExtraPluginPath(user_data_dir.Append("Plugins"));
   }
 #endif
 
   scoped_ptr<IOThread> thread(new IOThread(
       local_state(), net_log_.get(), extension_event_router_forwarder_.get()));
+  base::Thread::Options options;
+  options.message_loop_type = MessageLoop::TYPE_IO;
+  if (!thread->StartWithOptions(options))
+    return;
   io_thread_.swap(thread);
 }
 
+void BrowserProcessImpl::CreateFileThread() {
+  DCHECK(!created_file_thread_ && file_thread_.get() == NULL);
+  created_file_thread_ = true;
+
+  scoped_ptr<base::Thread> thread(
+      new content::BrowserProcessSubThread(BrowserThread::FILE));
+  base::Thread::Options options;
+#if defined(OS_WIN)
+  // On Windows, the FILE thread needs to be have a UI message loop which pumps
+  // messages in such a way that Google Update can communicate back to us.
+  options.message_loop_type = MessageLoop::TYPE_UI;
+#else
+  options.message_loop_type = MessageLoop::TYPE_IO;
+#endif
+  if (!thread->StartWithOptions(options))
+    return;
+  file_thread_.swap(thread);
+}
+
+#if defined(OS_CHROMEOS)
+void BrowserProcessImpl::CreateWebSocketProxyThread() {
+  DCHECK(!created_web_socket_proxy_thread_);
+  DCHECK(web_socket_proxy_thread_.get() == NULL);
+  created_web_socket_proxy_thread_ = true;
+
+  scoped_ptr<base::Thread> thread(
+      new content::BrowserProcessSubThread(BrowserThread::WEB_SOCKET_PROXY));
+  base::Thread::Options options;
+  options.message_loop_type = MessageLoop::TYPE_IO;
+  if (!thread->StartWithOptions(options))
+    return;
+  web_socket_proxy_thread_.swap(thread);
+}
+#endif
+
+void BrowserProcessImpl::CreateDBThread() {
+  DCHECK(!created_db_thread_ && db_thread_.get() == NULL);
+  created_db_thread_ = true;
+
+  scoped_ptr<base::Thread> thread(
+      new content::BrowserProcessSubThread(BrowserThread::DB));
+  if (!thread->Start())
+    return;
+  db_thread_.swap(thread);
+}
+
+void BrowserProcessImpl::CreateProcessLauncherThread() {
+  DCHECK(!created_process_launcher_thread_ && !process_launcher_thread_.get());
+  created_process_launcher_thread_ = true;
+
+  scoped_ptr<base::Thread> thread(
+      new content::BrowserProcessSubThread(BrowserThread::PROCESS_LAUNCHER));
+  if (!thread->Start())
+    return;
+  process_launcher_thread_.swap(thread);
+}
+
+void BrowserProcessImpl::CreateCacheThread() {
+  DCHECK(!created_cache_thread_ && !cache_thread_.get());
+  created_cache_thread_ = true;
+
+  scoped_ptr<base::Thread> thread(
+      new content::DeprecatedBrowserThread(BrowserThread::CACHE));
+  base::Thread::Options options;
+  options.message_loop_type = MessageLoop::TYPE_IO;
+  if (!thread->StartWithOptions(options))
+    return;
+  cache_thread_.swap(thread);
+}
+
 void BrowserProcessImpl::CreateWatchdogThread() {
   DCHECK(!created_watchdog_thread_ && watchdog_thread_.get() == NULL);
   created_watchdog_thread_ = true;
 
   scoped_ptr<WatchDogThread> thread(new WatchDogThread());
   if (!thread->Start())
     return;
   watchdog_thread_.swap(thread);
 }
 
@@ skipping 25 matching lines @@
   // Initialize the notification for the default browser setting policy.
   local_state_->RegisterBooleanPref(prefs::kDefaultBrowserSettingEnabled,
                                     false);
   if (local_state_->IsManagedPreference(prefs::kDefaultBrowserSettingEnabled))
     ApplyDefaultBrowserPolicy();
   pref_change_registrar_.Add(prefs::kDefaultBrowserSettingEnabled, this);
 
   // Initialize the preference for the plugin finder policy.
   // This preference is only needed on the IO thread so make it available there.
   local_state_->RegisterBooleanPref(prefs::kDisablePluginFinder, false);
-  plugin_finder_disabled_pref_.reset(new BooleanPrefMember);
-  plugin_finder_disabled_pref_->Init(prefs::kDisablePluginFinder,
+  plugin_finder_disabled_pref_.Init(prefs::kDisablePluginFinder,
                                    local_state_.get(), NULL);
-  plugin_finder_disabled_pref_->MoveToThread(BrowserThread::IO);
+  plugin_finder_disabled_pref_.MoveToThread(BrowserThread::IO);
 
   // Another policy that needs to be defined before the net subsystem is
   // initialized is MaxConnectionsPerProxy so we do it here.
   local_state_->RegisterIntegerPref(prefs::kMaxConnectionsPerProxy,
                                     net::kDefaultMaxSocketsPerProxyServer);
   int max_per_proxy = local_state_->GetInteger(prefs::kMaxConnectionsPerProxy);
   net::ClientSocketPoolManager::set_max_sockets_per_proxy_server(
       std::max(std::min(max_per_proxy, 99),
                net::ClientSocketPoolManager::max_sockets_per_group()));
 
@@ skipping 150 matching lines @@
 }
 
 void BrowserProcessImpl::OnAutoupdateTimer() {
   if (CanAutorestartForUpdate()) {
     DLOG(WARNING) << "Detected update.  Restarting browser.";
     RestartBackgroundInstance();
   }
 }
 
 #endif  // (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)