Fourth patch in getting rid of caching MessageLoop pointers.

chrome/browser/safe_browsing/safe_browsing_service.cc

 // Copyright (c) 2009 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/safe_browsing/safe_browsing_service.h"
 
 #include "base/command_line.h"
 #include "base/histogram.h"
 #include "base/logging.h"
@@ skipping 13 matching lines @@
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/url_constants.h"
 #include "net/base/registry_controlled_domain.h"
 
 using base::Time;
 using base::TimeDelta;
 
 SafeBrowsingService::SafeBrowsingService()
-    : io_loop_(NULL),
-      database_(NULL),
+    : database_(NULL),
       protocol_manager_(NULL),
       enabled_(false),
       resetting_(false),
       database_loaded_(false),
       update_in_progress_(false) {
 }
 
 SafeBrowsingService::~SafeBrowsingService() {
 }
 
 // Only called on the UI thread.
-void SafeBrowsingService::Initialize(MessageLoop* io_loop) {
-  io_loop_ = io_loop;
-
+void SafeBrowsingService::Initialize() {
   // Get the profile's preference for SafeBrowsing.
   FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   Profile* profile = profile_manager->GetDefaultProfile(user_data_dir);
   PrefService* pref_service = profile->GetPrefs();
   if (pref_service->GetBoolean(prefs::kSafeBrowsingEnabled))
     Start();
 }
 
 // Start up SafeBrowsing objects. This can be called at browser start, or when
 // the user checks the "Enable SafeBrowsing" option in the Advanced options UI.
 void SafeBrowsingService::Start() {
   DCHECK(!safe_browsing_thread_.get());
   safe_browsing_thread_.reset(new base::Thread("Chrome_SafeBrowsingThread"));
   if (!safe_browsing_thread_->Start())
     return;
 
   // Retrieve client MAC keys.
   PrefService* local_state = g_browser_process->local_state();
   std::string client_key, wrapped_key;
   if (local_state) {
     client_key =
       WideToASCII(local_state->GetString(prefs::kSafeBrowsingClientKey));
     wrapped_key =
       WideToASCII(local_state->GetString(prefs::kSafeBrowsingWrappedKey));
   }
 
-  io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SafeBrowsingService::OnIOInitialize, MessageLoop::current(),
-      client_key, wrapped_key));
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(
+          this, &SafeBrowsingService::OnIOInitialize, client_key, wrapped_key));
 
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &SafeBrowsingService::OnDBInitialize));
 }
 
 void SafeBrowsingService::ShutDown() {
-  io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SafeBrowsingService::OnIOShutdown));
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(this, &SafeBrowsingService::OnIOShutdown));
 }
 
-void SafeBrowsingService::OnIOInitialize(MessageLoop* notify_loop,
-                                         const std::string& client_key,
+void SafeBrowsingService::OnIOInitialize(const std::string& client_key,
                                          const std::string& wrapped_key) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   enabled_ = true;
   protocol_manager_ = new SafeBrowsingProtocolManager(this,
-                                                      notify_loop,
                                                       client_key,
                                                       wrapped_key);
   // We want to initialize the protocol manager only after the database has
   // loaded, which we'll receive asynchronously (DatabaseLoadComplete). If
   // database_loaded_ isn't true, we'll wait for that notification to do the
   // init.
   if (database_loaded_)
     protocol_manager_->Initialize();
 }
 
 void SafeBrowsingService::OnDBInitialize() {
   DCHECK(MessageLoop::current() == safe_browsing_thread_->message_loop());
   GetDatabase();
 }
 
 void SafeBrowsingService::OnIOShutdown() {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   if (!enabled_)
     return;
 
   enabled_ = false;
   resetting_ = false;
 
   // This cancels all in-flight GetHash requests.
   delete protocol_manager_;
   protocol_manager_ = NULL;
 
@@ skipping 34 matching lines @@
   else
     ShutDown();
 }
 
 bool SafeBrowsingService::CanCheckUrl(const GURL& url) const {
   return url.SchemeIs(chrome::kHttpScheme) ||
          url.SchemeIs(chrome::kHttpsScheme);
 }
 
 bool SafeBrowsingService::CheckUrl(const GURL& url, Client* client) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   if (!enabled_ || !database_)
     return true;
 
   if (resetting_ || !database_loaded_) {
     QueuedCheck check;
     check.client = client;
     check.url = url;
     queued_checks_.push_back(check);
     return false;
   }
@@ skipping 15 matching lines @@
   // ResourceDispatcherHost event handler which can't pause there.
   SafeBrowsingCheck* check = new SafeBrowsingCheck();
   check->url = url;
   check->client = client;
   check->result = URL_SAFE;
   check->need_get_hash = full_hits.empty();
   check->prefix_hits.swap(prefix_hits);
   check->full_hits.swap(full_hits);
   checks_.insert(check);
 
-  io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SafeBrowsingService::OnCheckDone, check));
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(this, &SafeBrowsingService::OnCheckDone, check));
 
   return false;
 }
 
 void SafeBrowsingService::DisplayBlockingPage(const GURL& url,
                                               ResourceType::Type resource_type,
                                               UrlCheckResult result,
                                               Client* client,
                                               MessageLoop* ui_loop,
                                               int render_process_host_id,
@@ skipping 54 matching lines @@
   PrefService* prefs = g_browser_process->local_state();
   DCHECK(prefs);
   if (prefs && prefs->GetBoolean(prefs::kMetricsReportingEnabled) &&
       resource.resource_type != ResourceType::MAIN_FRAME &&
       resource.threat_type == SafeBrowsingService::URL_MALWARE) {
     GURL page_url = wc->GetURL();
     GURL referrer_url;
     NavigationEntry* entry = wc->controller().GetActiveEntry();
     if (entry)
       referrer_url = entry->referrer();
-    io_loop_->PostTask(FROM_HERE,
+    ChromeThread::PostTask(
+        ChromeThread::IO, FROM_HERE,
         NewRunnableMethod(this,
                           &SafeBrowsingService::ReportMalware,
                           resource.url,
                           page_url,
                           referrer_url));
   }
 
   SafeBrowsingBlockingPage::ShowBlockingPage(this, resource);
 }
 
 void SafeBrowsingService::CancelCheck(Client* client) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   for (CurrentChecks::iterator i = checks_.begin(); i != checks_.end(); ++i) {
     if ((*i)->client == client)
       (*i)->client = NULL;
   }
 
   // Scan the queued clients store. Clients may be here if they requested a URL
   // check before the database has finished loading or resetting.
   if (!database_loaded_ || resetting_) {
     std::deque<QueuedCheck>::iterator it = queued_checks_.begin();
     for (; it != queued_checks_.end(); ++it) {
       if (it->client == client)
         it->client = NULL;
     }
   }
 }
 
 void SafeBrowsingService::OnCheckDone(SafeBrowsingCheck* check) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   // If we've been shutdown during the database lookup, this check will already
   // have been deleted (in OnIOShutdown).
   if (!enabled_ || checks_.find(check) == checks_.end())
     return;
 
   if (check->client && check->need_get_hash) {
     // We have a partial match so we need to query Google for the full hash.
     // Clean up will happen in HandleGetHashResults.
 
@@ skipping 37 matching lines @@
   DCHECK(result);
   path = path.Append(chrome::kSafeBrowsingFilename);
 
   Time before = Time::Now();
   SafeBrowsingDatabase* database = SafeBrowsingDatabase::Create();
   Callback0::Type* chunk_callback =
       NewCallback(this, &SafeBrowsingService::ChunkInserted);
   database->Init(path, chunk_callback);
   database_ = database;
 
-  io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SafeBrowsingService::DatabaseLoadComplete));
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(this, &SafeBrowsingService::DatabaseLoadComplete));
 
   TimeDelta open_time = Time::Now() - before;
   SB_DLOG(INFO) << "SafeBrowsing database open took " <<
       open_time.InMilliseconds() << " ms.";
 
   return database_;
 }
 
 // Public API called only on the IO thread.
 // The SafeBrowsingProtocolManager has received the full hash results for
@@ skipping 56 matching lines @@
 
     // Let the client continue handling the original request.
     check->client->OnUrlCheckResult(check->url, result);
   }
 
   checks_.erase(check);
   delete check;
 }
 
 void SafeBrowsingService::UpdateStarted() {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   DCHECK(enabled_);
   DCHECK(!update_in_progress_);
   update_in_progress_ = true;
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &SafeBrowsingService::GetAllChunksFromDatabase));
 }
 
 void SafeBrowsingService::UpdateFinished(bool update_succeeded) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   DCHECK(enabled_);
   if (update_in_progress_) {
     update_in_progress_ = false;
     safe_browsing_thread_->message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(this,
                           &SafeBrowsingService::DatabaseUpdateFinished,
                           update_succeeded));
   }
 }
 
@@ skipping 34 matching lines @@
                                        const std::string& wrapped_key) {
   PrefService* prefs = g_browser_process->local_state();
   if (prefs) {
     prefs->SetString(prefs::kSafeBrowsingClientKey, ASCIIToWide(client_key));
     prefs->SetString(prefs::kSafeBrowsingWrappedKey, ASCIIToWide(wrapped_key));
   }
 }
 
 void SafeBrowsingService::ChunkInserted() {
   DCHECK(MessageLoop::current() == safe_browsing_thread_->message_loop());
-  io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SafeBrowsingService::OnChunkInserted));
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(this, &SafeBrowsingService::OnChunkInserted));
 }
 
 void SafeBrowsingService::OnChunkInserted() {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   if (enabled_)
     protocol_manager_->OnChunkInserted();
 }
 
 void SafeBrowsingService::DatabaseLoadComplete() {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   if (!enabled_)
     return;
 
   database_loaded_ = true;
 
   if (protocol_manager_)
     protocol_manager_->Initialize();
 
   // If we have any queued requests, we can now check them.
   if (!resetting_)
     RunQueuedClients();
 }
 
 // static
 void SafeBrowsingService::RegisterPrefs(PrefService* prefs) {
   prefs->RegisterStringPref(prefs::kSafeBrowsingClientKey, L"");
   prefs->RegisterStringPref(prefs::kSafeBrowsingWrappedKey, L"");
 }
 
 void SafeBrowsingService::ResetDatabase() {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   resetting_ = true;
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &SafeBrowsingService::OnResetDatabase));
 }
 
 void SafeBrowsingService::OnResetDatabase() {
   DCHECK(MessageLoop::current() == safe_browsing_thread_->message_loop());
   GetDatabase()->ResetDatabase();
-  io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SafeBrowsingService::OnResetComplete));
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(this, &SafeBrowsingService::OnResetComplete));
 }
 
 void SafeBrowsingService::OnResetComplete() {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   if (enabled_) {
     resetting_ = false;
     database_loaded_ = true;
     RunQueuedClients();
   }
 }
 
 void SafeBrowsingService::HandleChunk(const std::string& list,
                                       std::deque<SBChunk>* chunks) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   DCHECK(enabled_);
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &SafeBrowsingService::HandleChunkForDatabase, list, chunks));
 }
 
 void SafeBrowsingService::HandleChunkForDatabase(
     const std::string& list_name,
     std::deque<SBChunk>* chunks) {
   DCHECK(MessageLoop::current() == safe_browsing_thread_->message_loop());
 
   GetDatabase()->InsertChunks(list_name, chunks);
 }
 
 void SafeBrowsingService::HandleChunkDelete(
     std::vector<SBChunkDelete>* chunk_deletes) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   DCHECK(enabled_);
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &SafeBrowsingService::DeleteChunks, chunk_deletes));
 }
 
 void SafeBrowsingService::DeleteChunks(
     std::vector<SBChunkDelete>* chunk_deletes) {
   DCHECK(MessageLoop::current() == safe_browsing_thread_->message_loop());
 
   GetDatabase()->DeleteChunks(chunk_deletes);
 }
 
 // Database worker function.
 void SafeBrowsingService::GetAllChunksFromDatabase() {
   DCHECK(MessageLoop::current() == safe_browsing_thread_->message_loop());
   bool database_error = true;
   std::vector<SBListChunkRanges> lists;
   if (GetDatabase()) {
     if (GetDatabase()->UpdateStarted()) {
       GetDatabase()->GetListsInfo(&lists);
       database_error = false;
     } else {
       GetDatabase()->UpdateFinished(false);
     }
   }
 
-  io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SafeBrowsingService::OnGetAllChunksFromDatabase, lists,
-      database_error));
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(
+          this, &SafeBrowsingService::OnGetAllChunksFromDatabase, lists,
+          database_error));
 }
 
 // Called on the io thread with the results of all chunks.
 void SafeBrowsingService::OnGetAllChunksFromDatabase(
     const std::vector<SBListChunkRanges>& lists, bool database_error) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   if (enabled_)
     protocol_manager_->OnGetChunksComplete(lists, database_error);
 }
 
 SafeBrowsingService::UrlCheckResult SafeBrowsingService::GetResultFromListname(
     const std::string& list_name) {
   if (safe_browsing_util::IsPhishingList(list_name)) {
     return URL_PHISHING;
   }
 
@@ skipping 10 matching lines @@
 }
 
 void SafeBrowsingService::CacheHashResults(
   const std::vector<SBPrefix>& prefixes,
   const std::vector<SBFullHashResult>& full_hashes) {
   DCHECK(MessageLoop::current() == safe_browsing_thread_->message_loop());
   GetDatabase()->CacheHashResults(prefixes, full_hashes);
 }
 
 void SafeBrowsingService::RunQueuedClients() {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   HISTOGRAM_COUNTS("SB.QueueDepth", queued_checks_.size());
   while (!queued_checks_.empty()) {
     QueuedCheck check = queued_checks_.front();
     HISTOGRAM_TIMES("SB.QueueDelay", Time::Now() - check.start);
     CheckUrl(check.url, check.client);
     queued_checks_.pop_front();
   }
 }
 
 void SafeBrowsingService::ReportMalware(const GURL& malware_url,
                                         const GURL& page_url,
                                         const GURL& referrer_url) {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   if (!enabled_ || !database_)
     return;
 
   // Check if 'page_url' is already blacklisted (exists in our cache). Only
   // report if it's not there.
   std::string list;
   std::vector<SBPrefix> prefix_hits;
   std::vector<SBFullHashResult> full_hits;
   database_->ContainsUrl(page_url, &list, &prefix_hits, &full_hits,
                          protocol_manager_->last_update());
 
   if (full_hits.empty())
     protocol_manager_->ReportMalware(malware_url, page_url, referrer_url);
 }