Some easy NewRunnableMethod conversions in safe_browsing.

chrome/browser/safe_browsing/safe_browsing_service.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/safe_browsing/safe_browsing_service.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/metrics/metrics_service.h"
 #include "chrome/browser/prefs/pref_change_registrar.h"
@@ skipping 102 matching lines @@
 }
 
 SafeBrowsingService::UnsafeResource::~UnsafeResource() {}
 
 SafeBrowsingService::SafeBrowsingCheck::SafeBrowsingCheck()
     : full_hash(NULL),
       client(NULL),
       need_get_hash(false),
       result(SAFE),
       is_download(false),
-      timeout_task(NULL) {
+      timeout_factory_(NULL) {
 }
 
 SafeBrowsingService::SafeBrowsingCheck::~SafeBrowsingCheck() {}
 
 void SafeBrowsingService::Client::OnSafeBrowsingResult(
     const SafeBrowsingCheck& check) {
   if (!check.urls.empty()) {
 
     DCHECK(!check.full_hash.get());
     if (!check.is_download) {
@@ skipping 107 matching lines @@
   if (!enabled_ || !enable_download_protection_)
     return true;
 
   // We need to check the database for url prefix, and later may fetch the url
   // from the safebrowsing backends. These need to be asynchronous.
   SafeBrowsingCheck* check = new SafeBrowsingCheck();
   check->urls = url_chain;
   StartDownloadCheck(
       check,
       client,
-      NewRunnableMethod(this,
-                        &SafeBrowsingService::CheckDownloadUrlOnSBThread,
-                        check),
+      base::Bind(&SafeBrowsingService::CheckDownloadUrlOnSBThread, this, check),
       download_urlcheck_timeout_ms_);
   return false;
 }
 
 bool SafeBrowsingService::CheckDownloadHash(const std::string& full_hash,
                                             Client* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!full_hash.empty());
   if (!enabled_ || !enable_download_protection_ || full_hash.empty())
     return true;
 
   // We need to check the database for url prefix, and later may fetch the url
   // from the safebrowsing backends. These need to be asynchronous.
   SafeBrowsingCheck* check = new SafeBrowsingCheck();
   check->full_hash.reset(new SBFullHash);
   safe_browsing_util::StringToSBFullHash(full_hash, check->full_hash.get());
   StartDownloadCheck(
       check,
       client,
-      NewRunnableMethod(this,
-                        &SafeBrowsingService::CheckDownloadHashOnSBThread,
-                        check),
+      base::Bind(&SafeBrowsingService::CheckDownloadHashOnSBThread,this, check),
       download_hashcheck_timeout_ms_);
   return false;
 }
 
 bool SafeBrowsingService::MatchCsdWhitelistUrl(const GURL& url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!enabled_ || !enable_csd_whitelist_ || !MakeDatabaseAvailable()) {
     // There is something funky going on here -- for example, perhaps the user
     // has not restarted since enabling metrics reporting, so we haven't
     // enabled the csd whitelist yet.  Just to be safe we return true in this
@@ skipping 50 matching lines @@
   check->client = client;
   check->result = SAFE;
   check->is_download = false;
   check->need_get_hash = full_hits.empty();
   check->prefix_hits.swap(prefix_hits);
   check->full_hits.swap(full_hits);
   checks_.insert(check);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(this, &SafeBrowsingService::OnCheckDone, check));
+      base::Bind(&SafeBrowsingService::OnCheckDone, this, check));
 
   return false;
 }
 
 void SafeBrowsingService::CancelCheck(Client* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   for (CurrentChecks::iterator i = checks_.begin(); i != checks_.end(); ++i) {
     // We can't delete matching checks here because the db thread has a copy of
     // the pointer.  Instead, we simply NULL out the client, and when the db
     // thread calls us back, we'll clean up the check.
@@ skipping 30 matching lines @@
   resource.redirect_urls = redirect_urls;
   resource.is_subresource = is_subresource;
   resource.threat_type= result;
   resource.client = client;
   resource.render_process_host_id = render_process_host_id;
   resource.render_view_id = render_view_id;
 
   // The blocking page must be created from the UI thread.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableMethod(
-          this, &SafeBrowsingService::DoDisplayBlockingPage, resource));
+      base::Bind(&SafeBrowsingService::DoDisplayBlockingPage, this, resource));
 }
 
 void SafeBrowsingService::HandleGetHashResults(
     SafeBrowsingCheck* check,
     const std::vector<SBFullHashResult>& full_hashes,
     bool can_cache) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!enabled_)
     return;
@@ skipping 13 matching lines @@
   if (can_cache && MakeDatabaseAvailable()) {
     // Cache the GetHash results in memory:
     database_->CacheHashResults(prefixes, full_hashes);
   }
 }
 
 void SafeBrowsingService::HandleChunk(const std::string& list,
                                       SBChunkList* chunks) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(enabled_);
-  safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SafeBrowsingService::HandleChunkForDatabase, list, chunks));
+  safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, base::Bind(
+      &SafeBrowsingService::HandleChunkForDatabase, this, list, chunks));
 }
 
 void SafeBrowsingService::HandleChunkDelete(
     std::vector<SBChunkDelete>* chunk_deletes) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(enabled_);
-  safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SafeBrowsingService::DeleteChunks, chunk_deletes));
+  safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, base::Bind(
+      &SafeBrowsingService::DeleteChunks, this, chunk_deletes));
 }
 
 void SafeBrowsingService::UpdateStarted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(enabled_);
   DCHECK(!update_in_progress_);
   update_in_progress_ = true;
-  safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SafeBrowsingService::GetAllChunksFromDatabase));
+  safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, base::Bind(
+      &SafeBrowsingService::GetAllChunksFromDatabase, this));
 }
 
 void SafeBrowsingService::UpdateFinished(bool update_succeeded) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::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));
+      base::Bind(&SafeBrowsingService::DatabaseUpdateFinished,
+                 this, update_succeeded));
   }
 }
 
 bool SafeBrowsingService::IsUpdateInProgress() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return update_in_progress_;
 }
 
 void SafeBrowsingService::OnBlockingPageDone(
     const std::vector<UnsafeResource>& resources,
     bool proceed) {
   for (std::vector<UnsafeResource>::const_iterator iter = resources.begin();
        iter != resources.end(); ++iter) {
     const UnsafeResource& resource = *iter;
     NotifyClientBlockingComplete(resource.client, proceed);
 
     if (proceed) {
       BrowserThread::PostTask(
           BrowserThread::UI,
           FROM_HERE,
-          NewRunnableMethod(this,
-                            &SafeBrowsingService::UpdateWhitelist,
-                            resource));
+          base::Bind(&SafeBrowsingService::UpdateWhitelist, this, resource));
     }
   }
 }
 
 void SafeBrowsingService::OnNewMacKeys(const std::string& client_key,
                                        const std::string& wrapped_key) {
   PrefService* prefs = g_browser_process->local_state();
   if (prefs) {
     prefs->SetString(prefs::kSafeBrowsingClientKey, client_key);
     prefs->SetString(prefs::kSafeBrowsingWrappedKey, wrapped_key);
   }
 }
 
 // static
 void SafeBrowsingService::RegisterPrefs(PrefService* prefs) {
   prefs->RegisterStringPref(prefs::kSafeBrowsingClientKey, "");
   prefs->RegisterStringPref(prefs::kSafeBrowsingWrappedKey, "");
 }
 
 void SafeBrowsingService::ResetDatabase() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(enabled_);
-  safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SafeBrowsingService::OnResetDatabase));
+  safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, base::Bind(
+      &SafeBrowsingService::OnResetDatabase, this));
 }
 
 void SafeBrowsingService::LogPauseDelay(base::TimeDelta time) {
   UMA_HISTOGRAM_LONG_TIMES("SB2.Delay", time);
 }
 
 void SafeBrowsingService::OnIOInitialize(
     const std::string& client_key,
     const std::string& wrapped_key,
     net::URLRequestContextGetter* request_context_getter) {
@@ skipping 100 matching lines @@
   // Delete pending checks, calling back any clients with 'SAFE'.  We have
   // to do this after the db thread returns because methods on it can have
   // copies of these pointers, so deleting them might lead to accessing garbage.
   for (CurrentChecks::iterator it = checks_.begin();
        it != checks_.end(); ++it) {
     SafeBrowsingCheck* check = *it;
     if (check->client) {
       check->result = SAFE;
       check->client->OnSafeBrowsingResult(*check);
     }
-    if (check->timeout_task)
-      check->timeout_task->Cancel();
   }
   STLDeleteElements(&checks_);
 
   gethash_requests_.clear();
 }
 
 bool SafeBrowsingService::DatabaseAvailable() const {
   base::AutoLock lock(database_lock_);
   return !closing_database_ && (database_ != NULL);
 }
 
 bool SafeBrowsingService::MakeDatabaseAvailable() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(enabled_);
   if (DatabaseAvailable())
     return true;
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &SafeBrowsingService::GetDatabase));
+      base::IgnoreReturn<SafeBrowsingDatabase*>(
+          base::Bind(&SafeBrowsingService::GetDatabase, this)));
   return false;
 }
 
 void SafeBrowsingService::CloseDatabase() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Cases to avoid:
   //  * If |closing_database_| is true, continuing will queue up a second
   //    request, |closing_database_| will be reset after handling the first
   //    request, and if any functions on the db thread recreate the database, we
@@ skipping 10 matching lines @@
   //    would lead to an infinite loop in DatabaseLoadComplete(), and even if it
   //    didn't, it would be pointless since we'd just want to recreate.
   //
   // The first two cases above are handled by checking DatabaseAvailable().
   if (!DatabaseAvailable() || !queued_checks_.empty())
     return;
 
   closing_database_ = true;
   if (safe_browsing_thread_.get()) {
     safe_browsing_thread_->message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &SafeBrowsingService::OnCloseDatabase));
+        base::Bind(&SafeBrowsingService::OnCloseDatabase, this));
   }
 }
 
 SafeBrowsingDatabase* SafeBrowsingService::GetDatabase() {
   DCHECK_EQ(MessageLoop::current(), safe_browsing_thread_->message_loop());
   if (database_)
     return database_;
 
   FilePath path;
   bool result = PathService::Get(chrome::DIR_USER_DATA, &path);
@@ skipping 10 matching lines @@
   database->Init(path);
   {
     // Acquiring the lock here guarantees correct ordering between the writes to
     // the new database object above, and the setting of |databse_| below.
     base::AutoLock lock(database_lock_);
     database_ = database;
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(this, &SafeBrowsingService::DatabaseLoadComplete));
+      base::Bind(&SafeBrowsingService::DatabaseLoadComplete, this));
 
   UMA_HISTOGRAM_TIMES("SB2.DatabaseOpen", base::TimeTicks::Now() - before);
   return database_;
 }
 
 void SafeBrowsingService::OnCheckDone(SafeBrowsingCheck* check) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!enabled_)
     return;
@@ skipping 45 matching lines @@
   database_update_in_progress_ = true;
   GetDatabase();  // This guarantees that |database_| is non-NULL.
   if (database_->UpdateStarted(&lists)) {
     database_error = false;
   } else {
     database_->UpdateFinished(false);
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(
-          this, &SafeBrowsingService::OnGetAllChunksFromDatabase, lists,
-          database_error));
+      base::Bind(&SafeBrowsingService::OnGetAllChunksFromDatabase,
+                 this, lists, database_error));
 }
 
 void SafeBrowsingService::OnGetAllChunksFromDatabase(
     const std::vector<SBListChunkRanges>& lists, bool database_error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (enabled_)
     protocol_manager_->OnGetChunksComplete(lists, database_error);
 }
 
 void SafeBrowsingService::OnChunkInserted() {
@@ skipping 34 matching lines @@
 
 void SafeBrowsingService::HandleChunkForDatabase(
     const std::string& list_name, SBChunkList* chunks) {
   DCHECK_EQ(MessageLoop::current(), safe_browsing_thread_->message_loop());
   if (chunks) {
     GetDatabase()->InsertChunks(list_name, *chunks);
     delete chunks;
   }
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(this, &SafeBrowsingService::OnChunkInserted));
+      base::Bind(&SafeBrowsingService::OnChunkInserted, this));
 }
 
 void SafeBrowsingService::DeleteChunks(
     std::vector<SBChunkDelete>* chunk_deletes) {
   DCHECK_EQ(MessageLoop::current(), safe_browsing_thread_->message_loop());
   if (chunk_deletes) {
     GetDatabase()->DeleteChunks(*chunk_deletes);
     delete chunk_deletes;
   }
 }
@@ skipping 66 matching lines @@
 #endif
 
   // TODO(noelutz): remove this boolean variable since it should always be true
   // if SafeBrowsing is enabled.  Unfortunately, we have no test data for this
   // list right now.  This means that we need to be able to disable this list
   // for the SafeBrowsing test to pass.
   enable_download_whitelist_ = enable_csd_whitelist_;
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(
-          this, &SafeBrowsingService::OnIOInitialize, client_key, wrapped_key,
-          request_context_getter));
+      base::Bind(&SafeBrowsingService::OnIOInitialize,
+                 this, client_key, wrapped_key, request_context_getter));
 }
 
 void SafeBrowsingService::Stop() {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(this, &SafeBrowsingService::OnIOShutdown));
+      base::Bind(&SafeBrowsingService::OnIOShutdown, this));
 }
 
 void SafeBrowsingService::OnCloseDatabase() {
   DCHECK_EQ(MessageLoop::current(), safe_browsing_thread_->message_loop());
   DCHECK(closing_database_);
 
   // Because |closing_database_| is true, nothing on the IO thread will be
   // accessing the database, so it's safe to delete and then NULL the pointer.
   delete database_;
   database_ = NULL;
@@ skipping 73 matching lines @@
 }
 
 void SafeBrowsingService::DoDisplayBlockingPage(
     const UnsafeResource& resource) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Check if the user has already ignored our warning for this render_view
   // and domain.
   if (IsWhitelisted(resource)) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        NewRunnableMethod(this,
-                          &SafeBrowsingService::NotifyClientBlockingComplete,
-                          resource.client, true));
+        base::Bind(&SafeBrowsingService::NotifyClientBlockingComplete,
+                   this, resource.client, true));
     return;
   }
 
   // The tab might have been closed.
   TabContents* tab_contents =
       tab_util::GetTabContentsByID(resource.render_process_host_id,
                                    resource.render_view_id);
 
   if (!tab_contents) {
     // The tab is gone and we did not have a chance at showing the interstitial.
     // Just act as if "Don't Proceed" were chosen.
     std::vector<UnsafeResource> resources;
     resources.push_back(resource);
     BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(
-          this, &SafeBrowsingService::OnBlockingPageDone, resources, false));
+      base::Bind(&SafeBrowsingService::OnBlockingPageDone,
+                 this, resources, false));
     return;
   }
 
   if (resource.threat_type != SafeBrowsingService::SAFE &&
       CanReportStats()) {
     GURL page_url = tab_contents->GetURL();
     GURL referrer_url;
     NavigationEntry* entry = tab_contents->controller().GetActiveEntry();
     if (entry)
       referrer_url = entry->referrer();
@@ skipping 89 matching lines @@
 void SafeBrowsingService::CheckDownloadHashOnSBThread(
     SafeBrowsingCheck* check) {
   DCHECK_EQ(MessageLoop::current(), safe_browsing_thread_->message_loop());
   DCHECK(enable_download_protection_);
 
   if (!database_->ContainsDownloadHashPrefix(check->full_hash->prefix)) {
     // Good, we don't have hash for this url prefix.
     check->result = SAFE;
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        NewRunnableMethod(this,
-                          &SafeBrowsingService::CheckDownloadHashDone,
-                          check));
+        base::Bind(&SafeBrowsingService::CheckDownloadHashDone, this, check));
     return;
   }
 
   check->need_get_hash = true;
   check->prefix_hits.push_back(check->full_hash->prefix);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(this, &SafeBrowsingService::OnCheckDone, check));
+      base::Bind(&SafeBrowsingService::OnCheckDone, this, check));
 }
 
 void SafeBrowsingService::CheckDownloadUrlOnSBThread(SafeBrowsingCheck* check) {
   DCHECK_EQ(MessageLoop::current(), safe_browsing_thread_->message_loop());
   DCHECK(enable_download_protection_);
 
   std::vector<SBPrefix> prefix_hits;
 
   if (!database_->ContainsDownloadUrl(check->urls, &prefix_hits)) {
     // Good, we don't have hash for this url prefix.
     check->result = SAFE;
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        NewRunnableMethod(this,
-                          &SafeBrowsingService::CheckDownloadUrlDone,
-                          check));
+        base::Bind(&SafeBrowsingService::CheckDownloadUrlDone, this, check));
     return;
   }
 
   check->need_get_hash = true;
   check->prefix_hits.clear();
   check->prefix_hits = prefix_hits;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      NewRunnableMethod(this, &SafeBrowsingService::OnCheckDone, check));
+      base::Bind(&SafeBrowsingService::OnCheckDone, this, check));
 }
 
 void SafeBrowsingService::TimeoutCallback(SafeBrowsingCheck* check) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(check);
 
   if (!enabled_)
     return;
 
   DCHECK(checks_.find(check) != checks_.end());
   DCHECK_EQ(check->result, SAFE);
   if (check->client) {
     check->client->OnSafeBrowsingResult(*check);
     check->client = NULL;
   }
-  check->timeout_task = NULL;
 }
 
 void SafeBrowsingService::CheckDownloadUrlDone(SafeBrowsingCheck* check) {
   DCHECK(enable_download_protection_);
   SafeBrowsingCheckDone(check);
 }
 
 void SafeBrowsingService::CheckDownloadHashDone(SafeBrowsingCheck* check) {
   DCHECK(enable_download_protection_);
   SafeBrowsingCheckDone(check);
 }
 
 void SafeBrowsingService::SafeBrowsingCheckDone(SafeBrowsingCheck* check) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(check);
 
   if (!enabled_)
     return;
 
   VLOG(1) << "SafeBrowsingCheckDone: " << check->result;
   DCHECK(checks_.find(check) != checks_.end());
   if (check->client)
     check->client->OnSafeBrowsingResult(*check);
-  if (check->timeout_task)
-    check->timeout_task->Cancel();
   checks_.erase(check);
   delete check;
 }
 
 void SafeBrowsingService::StartDownloadCheck(SafeBrowsingCheck* check,
                                              Client* client,
-                                             CancelableTask* task,
+                                             const base::Closure& task,
                                              int64 timeout_ms) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   check->client = client;
   check->result = SAFE;
   check->is_download = true;
-  check->timeout_task =
-      NewRunnableMethod(this, &SafeBrowsingService::TimeoutCallback, check);
+  check->timeout_factory_.reset(
+      new base::WeakPtrFactory<SafeBrowsingService>(this));
   checks_.insert(check);
 
   safe_browsing_thread_->message_loop()->PostTask(FROM_HERE, task);
 
-  MessageLoop::current()->PostDelayedTask(
-      FROM_HERE, check->timeout_task, timeout_ms);
+  MessageLoop::current()->PostDelayedTask(FROM_HERE,
+      base::Bind(&SafeBrowsingService::TimeoutCallback,
+                 check->timeout_factory_->GetWeakPtr(), check),
+      timeout_ms);
 }
 
 void SafeBrowsingService::UpdateWhitelist(const UnsafeResource& resource) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Whitelist this domain and warning type for the given tab.
   WhiteListedEntry entry;
   entry.render_process_host_id = resource.render_process_host_id;
   entry.render_view_id = resource.render_view_id;
   entry.domain = net::RegistryControlledDomainService::GetDomainAndRegistry(
       resource.url);
@@ skipping 97 matching lines @@
     Stop();
 
   if (csd_service_.get())
     csd_service_->SetEnabledAndRefreshState(enable);
   if (download_service_.get()) {
     download_service_->SetEnabled(
         enable && CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableImprovedDownloadProtection));
   }
 }