Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/{i,l,m,n,p,r}*

chrome/browser/loader/chrome_resource_dispatcher_host_delegate.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/loader/chrome_resource_dispatcher_host_delegate.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 379 matching lines @@
 
 ChromeResourceDispatcherHostDelegate::ChromeResourceDispatcherHostDelegate()
     : download_request_limiter_(g_browser_process->download_request_limiter()),
       safe_browsing_(g_browser_process->safe_browsing_service())
 #if BUILDFLAG(ENABLE_EXTENSIONS)
       , user_script_listener_(new extensions::UserScriptListener())
 #endif
       {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(content::ServiceWorkerContext::AddExcludedHeadersForFetchEvent,
-                 variations::GetVariationHeaderNames()));
+      base::BindOnce(
+          content::ServiceWorkerContext::AddExcludedHeadersForFetchEvent,
+          variations::GetVariationHeaderNames()));
 }
 
 ChromeResourceDispatcherHostDelegate::~ChromeResourceDispatcherHostDelegate() {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   CHECK(stream_target_info_.empty());
 #endif
 }
 
 bool ChromeResourceDispatcherHostDelegate::ShouldBeginRequest(
     const std::string& method,
@@ skipping 97 matching lines @@
     net::URLRequest* request,
     content::ResourceContext* resource_context,
     bool is_content_initiated,
     bool must_download,
     bool is_new_request,
     std::vector<std::unique_ptr<content::ResourceThrottle>>* throttles) {
   const content::ResourceRequestInfo* info =
         content::ResourceRequestInfo::ForRequest(request);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&NotifyDownloadInitiatedOnUI,
-      info->GetWebContentsGetterForRequest()));
+      base::BindOnce(&NotifyDownloadInitiatedOnUI,
+                     info->GetWebContentsGetterForRequest()));
 
   // If it's from the web, we don't trust it, so we push the throttle on.
   if (is_content_initiated) {
     throttles->push_back(base::MakeUnique<DownloadResourceThrottle>(
         download_request_limiter_, info->GetWebContentsGetterForRequest(),
         request->url(), request->method()));
   }
 
   // If this isn't a new request, the standard resource throttles have already
   // been added, so no need to add them again.
@@ skipping 61 matching lines @@
   // Main frame external protocols are handled by
   // InterceptNavigationResourceThrottle.
   if (info->IsMainFrame())
     return false;
 #endif  // defined(ANDROID)
 
   const bool is_whitelisted =
       url_state == policy::URLBlacklist::URLBlacklistState::URL_IN_WHITELIST;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&LaunchURL, url, info->GetWebContentsGetterForRequest(),
-                 info->GetPageTransition(), info->HasUserGesture(),
-                 is_whitelisted));
+      base::BindOnce(&LaunchURL, url, info->GetWebContentsGetterForRequest(),
+                     info->GetPageTransition(), info->HasUserGesture(),
+                     is_whitelisted));
   return true;
 }
 
 void ChromeResourceDispatcherHostDelegate::AppendStandardResourceThrottles(
     net::URLRequest* request,
     content::ResourceContext* resource_context,
     ResourceType resource_type,
     std::vector<std::unique_ptr<content::ResourceThrottle>>* throttles) {
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
 
@@ skipping 115 matching lines @@
     net::URLRequest* request,
     std::unique_ptr<content::StreamInfo> stream) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
   std::map<net::URLRequest*, StreamTargetInfo>::iterator ix =
       stream_target_info_.find(request);
   CHECK(ix != stream_target_info_.end());
   bool embedded = info->GetResourceType() != content::RESOURCE_TYPE_MAIN_FRAME;
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
-      base::Bind(&SendExecuteMimeTypeHandlerEvent, base::Passed(&stream),
-                 request->GetExpectedContentSize(), ix->second.extension_id,
-                 ix->second.view_id, embedded, info->GetFrameTreeNodeId(),
-                 info->GetChildID(), info->GetRenderFrameID()));
+      base::BindOnce(&SendExecuteMimeTypeHandlerEvent, base::Passed(&stream),
+                     request->GetExpectedContentSize(), ix->second.extension_id,
+                     ix->second.view_id, embedded, info->GetFrameTreeNodeId(),
+                     info->GetChildID(), info->GetRenderFrameID()));
   stream_target_info_.erase(request);
 #endif
 }
 
 void ChromeResourceDispatcherHostDelegate::OnResponseStarted(
     net::URLRequest* request,
     content::ResourceContext* resource_context,
     content::ResourceResponse* response) {
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
@@ skipping 69 matching lines @@
   data_reduction_proxy::DataReductionProxyData* data =
       data_reduction_proxy::DataReductionProxyData::GetData(*url_request);
   bool used_data_reduction_proxy = data && data->used_data_reduction_proxy();
   int64_t original_content_length =
       used_data_reduction_proxy
           ? data_reduction_proxy::util::CalculateEffectiveOCL(*url_request)
           : url_request->GetRawBodyBytes();
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&NotifyUIThreadOfRequestComplete,
-                 info->GetWebContentsGetterForRequest(), url_request->url(),
-                 info->GetGlobalRequestID(), info->GetResourceType(),
-                 url_request->was_cached(), used_data_reduction_proxy,
-                 net_error, url_request->GetTotalReceivedBytes(),
-                 url_request->GetRawBodyBytes(), original_content_length,
-                 url_request->creation_time(),
-                 base::TimeTicks::Now() - url_request->creation_time()));
+      base::BindOnce(&NotifyUIThreadOfRequestComplete,
+                     info->GetWebContentsGetterForRequest(), url_request->url(),
+                     info->GetGlobalRequestID(), info->GetResourceType(),
+                     url_request->was_cached(), used_data_reduction_proxy,
+                     net_error, url_request->GetTotalReceivedBytes(),
+                     url_request->GetRawBodyBytes(), original_content_length,
+                     url_request->creation_time(),
+                     base::TimeTicks::Now() - url_request->creation_time()));
 }
 
 content::PreviewsState ChromeResourceDispatcherHostDelegate::GetPreviewsState(
     const net::URLRequest& url_request,
     content::ResourceContext* resource_context) {
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
   data_reduction_proxy::DataReductionProxyIOData* data_reduction_proxy_io_data =
       io_data->data_reduction_proxy_io_data();
 
   content::PreviewsState previews_state = content::PREVIEWS_UNSPECIFIED;
@@ skipping 49 matching lines @@
   return ProfileIOData::FromResourceContext(resource_context)->
       CreateClientCertStore();
 }
 
 // Record RAPPOR for aborted main frame loads. Separate into a fast and
 // slow bucket because a shocking number of aborts happen under 100ms.
 void ChromeResourceDispatcherHostDelegate::OnAbortedFrameLoad(
     const GURL& url,
     base::TimeDelta request_loading_time) {
   if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
-      BrowserThread::PostTask(
-          BrowserThread::UI, FROM_HERE,
-          base::Bind(&ChromeResourceDispatcherHostDelegate::OnAbortedFrameLoad,
-                    base::Unretained(this), url, request_loading_time));
-      return;
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::BindOnce(
+            &ChromeResourceDispatcherHostDelegate::OnAbortedFrameLoad,
+            base::Unretained(this), url, request_loading_time));
+    return;
   }
 
   std::string metric_name = (request_loading_time.InMilliseconds() < 100 ?
       "Net.ErrAborted.Fast" : "Net.ErrAborted.Slow");
   rappor::SampleDomainAndRegistryFromGURL(
       g_browser_process->rappor_service(), metric_name, url);
 }