Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/safe_browsing

chrome/browser/safe_browsing/download_protection_service.cc

 // Copyright (c) 2012 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/download_protection_service.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 236 matching lines @@
 
   void CheckDone(SBThreatType threat_type) {
     DownloadProtectionService::DownloadCheckResult result =
         IsDangerous(threat_type) ?
         DownloadProtectionService::DANGEROUS :
         DownloadProtectionService::SAFE;
     UpdateDownloadCheckStats(total_type_);
     if (threat_type != SB_THREAT_TYPE_SAFE) {
       UpdateDownloadCheckStats(dangerous_type_);
       BrowserThread::PostTask(
-          BrowserThread::UI,
-          FROM_HERE,
-          base::Bind(&DownloadUrlSBClient::ReportMalware,
-                     this, threat_type));
+          BrowserThread::UI, FROM_HERE,
+          base::BindOnce(&DownloadUrlSBClient::ReportMalware, this,
+                         threat_type));
     } else if (download_attribution_enabled_) {
         // Identify download referrer chain, which will be used in
         // ClientDownloadRequest.
         BrowserThread::PostTask(
-            BrowserThread::UI,
-            FROM_HERE,
-            base::Bind(&DownloadUrlSBClient::IdentifyReferrerChain,
-                       this));
+            BrowserThread::UI, FROM_HERE,
+            base::BindOnce(&DownloadUrlSBClient::IdentifyReferrerChain, this));
     }
-    BrowserThread::PostTask(BrowserThread::UI,
-                            FROM_HERE,
-                            base::Bind(callback_, result));
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::BindOnce(callback_, result));
   }
 
   void ReportMalware(SBThreatType threat_type) {
     std::string post_data;
     if (!sha256_hash_.empty()) {
       post_data += base::HexEncode(sha256_hash_.data(),
                                    sha256_hash_.size()) + "\n";
     }
     for (size_t i = 0; i < url_chain_.size(); ++i) {
       post_data += url_chain_[i].spec() + "\n";
@@ skipping 202 matching lines @@
   // Start a timeout to cancel the request if it takes too long.
   // This should only be called after we have finished accessing the file.
   void StartTimeout() {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     if (!service_) {
       // Request has already been cancelled.
       return;
     }
     timeout_start_time_ = base::TimeTicks::Now();
     BrowserThread::PostDelayedTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&CheckClientDownloadRequest::Cancel,
-                   weakptr_factory_.GetWeakPtr()),
+        BrowserThread::UI, FROM_HERE,
+        base::BindOnce(&CheckClientDownloadRequest::Cancel,
+                       weakptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(
             service_->download_request_timeout_ms()));
   }
 
   // Canceling a request will cause us to always report the result as UNKNOWN
   // unless a pending request is about to call FinishRequest.
   void Cancel() {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     if (fetcher_.get()) {
       // The DownloadProtectionService is going to release its reference, so we
@@ skipping 146 matching lines @@
     DCHECK(item_ == NULL);
   }
 
   void OnFileFeatureExtractionDone() {
     // This can run in any thread, since it just posts more messages.
 
     // TODO(noelutz): DownloadInfo should also contain the IP address of
     // every URL in the redirect chain.  We also should check whether the
     // download URL is hosted on the internal network.
     BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(&CheckClientDownloadRequest::CheckWhitelists, this));
+        BrowserThread::IO, FROM_HERE,
+        base::BindOnce(&CheckClientDownloadRequest::CheckWhitelists, this));
 
     // We wait until after the file checks finish to start the timeout, as
     // windows can cause permissions errors if the timeout fired while we were
     // checking the file signature and we tried to complete the download.
     BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&CheckClientDownloadRequest::StartTimeout, this));
+        BrowserThread::UI, FROM_HERE,
+        base::BindOnce(&CheckClientDownloadRequest::StartTimeout, this));
   }
 
   void StartExtractFileFeatures() {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(item_);  // Called directly from Start(), item should still exist.
     // Since we do blocking I/O, offload this to a worker thread.
     // The task does not need to block shutdown.
     base::PostTaskWithTraits(
-        FROM_HERE, base::TaskTraits()
-                       .MayBlock()
-                       .WithPriority(base::TaskPriority::BACKGROUND)
-                       .WithShutdownBehavior(
-                           base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
-        base::Bind(&CheckClientDownloadRequest::ExtractFileFeatures, this,
-                   item_->GetFullPath()));
+        FROM_HERE,
+        base::TaskTraits()
+            .MayBlock()
+            .WithPriority(base::TaskPriority::BACKGROUND)
+            .WithShutdownBehavior(
+                base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
+        base::BindOnce(&CheckClientDownloadRequest::ExtractFileFeatures, this,
+                       item_->GetFullPath()));
   }
 
   void ExtractFileFeatures(const base::FilePath& file_path) {
     base::TimeTicks start_time = base::TimeTicks::Now();
     binary_feature_extractor_->CheckSignature(file_path, &signature_info_);
     bool is_signed = (signature_info_.certificate_chain_size() > 0);
     if (is_signed) {
       DVLOG(2) << "Downloaded a signed binary: " << file_path.value();
     } else {
       DVLOG(2) << "Downloaded an unsigned binary: "
@@ skipping 193 matching lines @@
     RecordCountOfWhitelistedDownload(NO_WHITELIST_MATCH);
 
     if (!pingback_enabled_) {
       PostFinishTask(UNKNOWN, REASON_PING_DISABLED);
       return;
     }
 
     // The URLFetcher is owned by the UI thread, so post a message to
     // start the pingback.
     BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&CheckClientDownloadRequest::GetTabRedirects, this));
+        BrowserThread::UI, FROM_HERE,
+        base::BindOnce(&CheckClientDownloadRequest::GetTabRedirects, this));
   }
 
   void GetTabRedirects() {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     if (!service_)
       return;
 
     if (!tab_url_.is_valid()) {
       SendRequest();
       return;
@@ skipping 221 matching lines @@
                             client_download_request_data_);
     request_start_time_ = base::TimeTicks::Now();
     UMA_HISTOGRAM_COUNTS("SBClientDownload.DownloadRequestPayloadSize",
                          client_download_request_data_.size());
     fetcher_->Start();
   }
 
   void PostFinishTask(DownloadCheckResult result,
                       DownloadCheckResultReason reason) {
     BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&CheckClientDownloadRequest::FinishRequest, this, result,
-                   reason));
+        BrowserThread::UI, FROM_HERE,
+        base::BindOnce(&CheckClientDownloadRequest::FinishRequest, this, result,
+                       reason));
   }
 
   void FinishRequest(DownloadCheckResult result,
                      DownloadCheckResultReason reason) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     if (finished_) {
       return;
     }
     finished_ = true;
 
@@ skipping 219 matching lines @@
       Finish(RequestOutcome::UNSUPPORTED_FILE_TYPE, SAFE);
       return;
     }
 
     // In case the request take too long, the check will abort with an UNKNOWN
     // verdict. The weak pointer used for the timeout will be invalidated (and
     // hence would prevent the timeout) if the check completes on time and
     // execution reaches Finish().
     BrowserThread::PostDelayedTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&PPAPIDownloadRequest::OnRequestTimedOut,
-                   weakptr_factory_.GetWeakPtr()),
+        base::BindOnce(&PPAPIDownloadRequest::OnRequestTimedOut,
+                       weakptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(
             service_->download_request_timeout_ms()));
 
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&PPAPIDownloadRequest::CheckWhitelistsOnIOThread,
-                   requestor_url_, database_manager_,
-                   weakptr_factory_.GetWeakPtr()));
+        base::BindOnce(&PPAPIDownloadRequest::CheckWhitelistsOnIOThread,
+                       requestor_url_, database_manager_,
+                       weakptr_factory_.GetWeakPtr()));
   }
 
  private:
   // Whitelist checking needs to the done on the IO thread.
   static void CheckWhitelistsOnIOThread(
       const GURL& requestor_url,
       scoped_refptr<SafeBrowsingDatabaseManager> database_manager,
       base::WeakPtr<PPAPIDownloadRequest> download_request) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     DVLOG(2) << " checking whitelists for requestor URL:" << requestor_url;
 
     bool url_was_whitelisted =
         requestor_url.is_valid() && database_manager &&
         database_manager->MatchDownloadWhitelistUrl(requestor_url);
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&PPAPIDownloadRequest::WhitelistCheckComplete,
-                   download_request, url_was_whitelisted));
+        base::BindOnce(&PPAPIDownloadRequest::WhitelistCheckComplete,
+                       download_request, url_was_whitelisted));
   }
 
   void WhitelistCheckComplete(bool was_on_whitelist) {
     DVLOG(2) << __func__ << " was_on_whitelist:" << was_on_whitelist;
     if (was_on_whitelist) {
       RecordCountOfWhitelistedDownload(URL_WHITELIST);
       // TODO(asanka): Should sample whitelisted downloads based on
       // service_->whitelist_sample_rate(). http://crbug.com/610924
       Finish(RequestOutcome::WHITELIST_HIT, SAFE);
       return;
@@ skipping 316 matching lines @@
 
 void DownloadProtectionService::CheckDownloadUrl(
     content::DownloadItem* item,
     const CheckDownloadCallback& callback) {
   DCHECK(!item->GetUrlChain().empty());
   scoped_refptr<DownloadUrlSBClient> client(
       new DownloadUrlSBClient(item, this, callback, ui_manager_,
                               database_manager_));
   // The client will release itself once it is done.
   BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(&DownloadUrlSBClient::StartCheck, client));
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&DownloadUrlSBClient::StartCheck, client));
 }
 
 bool DownloadProtectionService::IsSupportedDownload(
     const content::DownloadItem& item,
     const base::FilePath& target_path) const {
   DownloadCheckResultReason reason = REASON_MAX;
   ClientDownloadRequest::DownloadType type =
       ClientDownloadRequest::WIN_EXECUTABLE;
   // TODO(nparker): Remove the CRX check here once can support
   // UNKNOWN types properly.  http://crbug.com/581044
@@ skipping 242 matching lines @@
   UMA_HISTOGRAM_COUNTS_100(
       "SafeBrowsing.ReferrerURLChainSize.PPAPIDownloadAttribution",
       out_request->referrer_chain_size());
   UMA_HISTOGRAM_ENUMERATION(
       "SafeBrowsing.ReferrerAttributionResult.PPAPIDownloadAttribution", result,
       SafeBrowsingNavigationObserverManager::ATTRIBUTION_FAILURE_TYPE_MAX);
   out_request->set_download_attribution_finch_enabled(true);
 }
 
 }  // namespace safe_browsing