Third patch in getting rid of caching MessageLoop pointers and always using C...

chrome/browser/profile.cc

 // Copyright (c) 2006-2008 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/profile.h"
 
 #include "app/theme_provider.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/browser_list.h"
-#include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_theme_provider.h"
+#include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/download/download_manager.h"
 #include "chrome/browser/extensions/extension_devtools_manager.h"
 #include "chrome/browser/extensions/extension_message_service.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/extensions/user_script_master.h"
 #include "chrome/browser/favicon_service.h"
 #include "chrome/browser/strict_transport_security_persister.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/in_process_webkit/webkit_context.h"
@@ skipping 97 matching lines @@
 
 // A pointer to the request context for the default profile.  See comments on
 // Profile::GetDefaultRequestContext.
 URLRequestContextGetter* Profile::default_request_context_;
 
 static void CleanupRequestContext(ChromeURLRequestContextGetter* context) {
   if (context) {
     context->CleanupOnUIThread();
 
     // Clean up request context on IO thread.
-    g_browser_process->io_thread()->message_loop()->ReleaseSoon(FROM_HERE,
-                                                                context);
+    ChromeThread::ReleaseSoon(ChromeThread::IO, FROM_HERE, context);
   }
 }
 
 // static
 const ProfileId Profile::InvalidProfileId = static_cast<ProfileId>(0);
 
 // static
 void Profile::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kSearchSuggestEnabled, true);
   prefs->RegisterBooleanPref(prefs::kSessionExitedCleanly, true);
@@ skipping 541 matching lines @@
     // Tell UserScriptMaser to watch this extension's directory for changes so
     // you can live edit content scripts during development.
     user_script_master_->AddWatchedPath(path);
   }
 }
 
 void ProfileImpl::InitWebResources() {
   if (web_resource_service_)
     return;  // Already initialized.
 
-  web_resource_service_ = new WebResourceService(
-      this,
-      g_browser_process->file_thread()->message_loop());
-
+  web_resource_service_ = new WebResourceService(this);
   web_resource_service_->StartAfterDelay();
 }
 
 ProfileImpl::~ProfileImpl() {
   tab_restore_service_ = NULL;
 
   StopCreateSessionServiceTimer();
   // TemplateURLModel schedules a task on the WebDataService from its
   // destructor. Delete it first to ensure the task gets scheduled before we
   // shut down the database.
@@ skipping 95 matching lines @@
   off_the_record_profile_.reset();
 }
 
 Profile* ProfileImpl::GetOriginalProfile() {
   return this;
 }
 
 VisitedLinkMaster* ProfileImpl::GetVisitedLinkMaster() {
   if (!visited_link_master_.get()) {
     scoped_ptr<VisitedLinkMaster> visited_links(
-      new VisitedLinkMaster(g_browser_process->file_thread(),
-                            visited_link_event_listener_.get(), this));
+      new VisitedLinkMaster(visited_link_event_listener_.get(), this));
     if (!visited_links->Init())
       return NULL;
     visited_link_master_.swap(visited_links);
   }
 
   return visited_link_master_.get();
 }
 
 ExtensionsService* ProfileImpl::GetExtensionsService() {
   return extensions_service_.get();
@@ skipping 21 matching lines @@
 
   DCHECK(ssl_host_state_->CalledOnValidThread());
   return ssl_host_state_.get();
 }
 
 net::StrictTransportSecurityState*
     ProfileImpl::GetStrictTransportSecurityState() {
   if (!strict_transport_security_state_.get()) {
     strict_transport_security_state_ = new net::StrictTransportSecurityState();
     strict_transport_security_persister_ = new StrictTransportSecurityPersister(
-        strict_transport_security_state_.get(),
-        g_browser_process->file_thread(), path_);
+        strict_transport_security_state_.get(), path_);
   }
 
   return strict_transport_security_state_.get();
 }
 
 PrefService* ProfileImpl::GetPrefs() {
   if (!prefs_.get()) {
-    prefs_.reset(new PrefService(GetPrefFilePath(),
-                                 g_browser_process->file_thread()));
+    prefs_.reset(new PrefService(GetPrefFilePath()));
 
     // The Profile class and ProfileManager class may read some prefs so
     // register known prefs as soon as possible.
     Profile::RegisterUserPrefs(prefs_.get());
     ProfileManager::RegisterUserPrefs(prefs_.get());
 #if defined(OS_CHROMEOS)
     // Register Touchpad prefs here instead of in browser_prefs because these
     // prefs are used in the constructor of ProfileImpl which happens before
     // browser_prefs' RegisterAllPrefs is called.
     chromeos::Preferences::RegisterUserPrefs(prefs_.get());
@@ skipping 380 matching lines @@
     spellchecker_->EnableAutoSpellCorrect(
         prefs->GetBoolean(prefs::kEnableAutoSpellCorrect));
 
     NotifySpellCheckerChanged();
   } else {
     DeleteSpellCheckerImpl(true);
   }
 }
 
 void ProfileImpl::NotifySpellCheckerChanged() {
-  // The I/O thread may be NULL during testing.
-  base::Thread* io_thread = g_browser_process->io_thread();
-  if (io_thread) {  // Notify resource message filters.
-    SpellcheckerReinitializedDetails scoped_spellchecker;
-    scoped_spellchecker.spellchecker = spellchecker_;
-    io_thread->message_loop()->PostTask(FROM_HERE,
-        new NotifySpellcheckerChangeTask(this, scoped_spellchecker));
-  }
+  SpellcheckerReinitializedDetails scoped_spellchecker;
+  scoped_spellchecker.spellchecker = spellchecker_;
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      new NotifySpellcheckerChangeTask(this, scoped_spellchecker));
 }
 
 void ProfileImpl::DeleteSpellCheckerImpl(bool notify) {
-  if (spellchecker_) {
-    // The spellchecker must be deleted on the I/O thread.
-    // The I/O thread may be NULL during testing.
-    base::Thread* io_thread = g_browser_process->io_thread();
-    if (io_thread)
-      io_thread->message_loop()->ReleaseSoon(FROM_HERE, spellchecker_);
-    else  //  during testing, we don't have an I/O thread
-      spellchecker_->Release();
+  if (!spellchecker_)
+    return;
 
-    spellchecker_ = NULL;
+  // The spellchecker must be deleted on the I/O thread.
+  ChromeThread::ReleaseSoon(ChromeThread::IO, FROM_HERE, spellchecker_);
+  spellchecker_ = NULL;
 
-    if (notify)
-      NotifySpellCheckerChanged();
-  }
+  if (notify)
+    NotifySpellCheckerChanged();
 }
 
 SpellChecker* ProfileImpl::GetSpellChecker() {
   if (!spellchecker_) {
     // This is where spellchecker gets initialized. Note that this is being
     // initialized in the ui_thread. However, this is not a problem as long as
     // it is *used* in the io thread.
     // TODO(sidchat): One day, change everything so that spellchecker gets
     // initialized in the IO thread itself.
     ReinitializeSpellChecker();
@@ skipping 63 matching lines @@
     return sync_service_.get();
   }
 #endif
   return NULL;
 }
 
 void ProfileImpl::InitSyncService() {
   sync_service_.reset(new ProfileSyncService(this));
   sync_service_->Initialize();
 }