Convert safe_browsing_service_browsertest.cc to base::Bind.

chrome/browser/safe_browsing/safe_browsing_service_browsertest.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.
 //
 // This test creates a safebrowsing service using test safebrowsing database
 // and a test protocol manager. It is used to test logics in safebrowsing
 // service.
 
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/scoped_temp_dir.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/client_side_detection_service.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
@@ skipping 192 matching lines @@
   // database and safebrowsing service issues a get hash request to backends.
   // We return a result from the prefilled full_hashes_ hash_map to simulate
   // server's response. At the same time, latency is added to simulate real
   // life network issues.
   virtual void GetFullHash(SafeBrowsingService::SafeBrowsingCheck* check,
                            const std::vector<SBPrefix>& prefixes) {
     // When we get a valid response, always cache the result.
     bool cancache = true;
     BrowserThread::PostDelayedTask(
         BrowserThread::IO, FROM_HERE,
-        NewRunnableMethod(
-            sb_service_, &SafeBrowsingService::HandleGetHashResults,
-            check, full_hashes_, cancache),
+        base::Bind(&SafeBrowsingService::HandleGetHashResults,
+                   sb_service_, check, full_hashes_, cancache),
         delay_ms_);
   }
 
   // Prepare the GetFullHash results for the next request.
   void SetGetFullHashResponse(const SBFullHashResult& full_hash_result) {
     full_hashes_.clear();
     full_hashes_.push_back(full_hash_result);
   }
 
   void IntroduceDelay(int64 ms) {
@@ skipping 49 matching lines @@
 }
 
 namespace {
 
 void QuitUIThread() {
   MessageLoopForUI::current()->Quit();
 }
 
 void QuitFromIOThread() {
   BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE, NewRunnableFunction(&QuitUIThread));
+      BrowserThread::UI, FROM_HERE, base::Bind(&QuitUIThread));
 }
 
 }  // namespace
 
 // Tests the safe browsing blocking page in a browser.
 class SafeBrowsingServiceTest : public InProcessBrowserTest {
  public:
   SafeBrowsingServiceTest() {
   }
 
@@ skipping 111 matching lines @@
     sb_service->RefreshState();
   }
 
  protected:
   StrictMock<MockObserver> observer_;
 
   // Waits for pending tasks on the IO thread to complete. This is useful
   // to wait for the SafeBrowsingService to finish loading/stopping.
   void WaitForIOThread() {
     BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE, NewRunnableFunction(&QuitFromIOThread));
+        BrowserThread::IO, FROM_HERE, base::Bind(&QuitFromIOThread));
     ui_test_utils::RunMessageLoop();  // Will stop from |QuitUIThread|.
   }
 
  private:
   TestSafeBrowsingDatabaseFactory db_factory_;
   TestSBProtocolManagerFactory pm_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServiceTest);
 };
 
@@ skipping 83 matching lines @@
                                           safe_browsing_service()) {
   }
 
   int GetResult() {
     return result_;
   }
 
   void CheckDownloadUrl(const std::vector<GURL>& url_chain) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        NewRunnableMethod(this,
-                          &TestSBClient::CheckDownloadUrlOnIOThread,
-                          url_chain));
+        base::Bind(&TestSBClient::CheckDownloadUrlOnIOThread,
+                   this, url_chain));
     ui_test_utils::RunMessageLoop();  // Will stop in OnDownloadUrlCheckResult.
   }
 
   void CheckDownloadHash(const std::string& full_hash) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        NewRunnableMethod(this,
-                          &TestSBClient::CheckDownloadHashOnIOThread,
-                          full_hash));
+        base::Bind(&TestSBClient::CheckDownloadHashOnIOThread,
+                   this, full_hash));
     ui_test_utils::RunMessageLoop();  // Will stop in OnDownloadHashCheckResult.
   }
 
  private:
   void CheckDownloadUrlOnIOThread(const std::vector<GURL>& url_chain) {
     safe_browsing_service_->CheckDownloadUrl(url_chain, this);
   }
 
   void CheckDownloadHashOnIOThread(const std::string& full_hash) {
     safe_browsing_service_->CheckDownloadHash(full_hash, this);
   }
 
   // Called when the result of checking a download URL is known.
   void OnDownloadUrlCheckResult(const std::vector<GURL>& url_chain,
                                 SafeBrowsingService::UrlCheckResult result) {
     result_ = result;
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-      NewRunnableMethod(this, &TestSBClient::DownloadCheckDone));
+                            base::Bind(&TestSBClient::DownloadCheckDone, this));
   }
 
   // Called when the result of checking a download hash is known.
   void OnDownloadHashCheckResult(const std::string& hash,
                                  SafeBrowsingService::UrlCheckResult result) {
     result_ = result;
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-      NewRunnableMethod(this, &TestSBClient::DownloadCheckDone));
+                            base::Bind(&TestSBClient::DownloadCheckDone, this));
   }
 
   void DownloadCheckDone() {
     MessageLoopForUI::current()->Quit();
   }
 
   SafeBrowsingService::UrlCheckResult result_;
   SafeBrowsingService* safe_browsing_service_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSBClient);
@@ skipping 188 matching lines @@
 
   // Delete the Profile. SBS stops again.
   pref_service2 = NULL;
   profile2.reset();
   WaitForIOThread();
   EXPECT_FALSE(sb_service->enabled());
   EXPECT_FALSE(csd_service->enabled());
 }
 
 }  // namespace