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

chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.cc

 // Copyright 2016 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/browsing_data/chrome_browsing_data_remover_delegate.h"
 
 #include <set>
 #include <string>
 #include <utility>
 
@@ skipping 467 matching lines @@
     // Need to clear the host cache and accumulated speculative data, as it also
     // reveals some history. We have no mechanism to track when these items were
     // created, so we'll not honor the time range.
     // TODO(msramek): We can use the plugin filter here because plugins, same
     // as the hostname resolution cache, key their entries by hostname. Rename
     // BuildPluginFilter() to something more general to reflect this use.
     if (g_browser_process->io_thread()) {
       clear_hostname_resolution_cache_.Start();
       BrowserThread::PostTaskAndReply(
           BrowserThread::IO, FROM_HERE,
-          base::Bind(&ClearHostnameResolutionCacheOnIOThread,
-                     g_browser_process->io_thread(),
-                     filter_builder.BuildPluginFilter()),
+          base::BindOnce(&ClearHostnameResolutionCacheOnIOThread,
+                         g_browser_process->io_thread(),
+                         filter_builder.BuildPluginFilter()),
           clear_hostname_resolution_cache_.GetCompletionCallback());
     }
     if (profile_->GetNetworkPredictor()) {
       // TODO(dmurph): Support all backends with filter (crbug.com/113621).
       clear_network_predictor_.Start();
       BrowserThread::PostTaskAndReply(
           BrowserThread::IO, FROM_HERE,
-          base::Bind(&ClearNetworkPredictorOnIOThread,
-                     profile_->GetNetworkPredictor()),
+          base::BindOnce(&ClearNetworkPredictorOnIOThread,
+                         profile_->GetNetworkPredictor()),
           clear_network_predictor_.GetCompletionCallback());
       profile_->GetNetworkPredictor()->ClearPrefsOnUIThread();
     }
 
     // As part of history deletion we also delete the auto-generated keywords.
     TemplateURLService* keywords_model =
         TemplateURLServiceFactory::GetForProfile(profile_);
 
     if (keywords_model && !keywords_model->loaded()) {
       // TODO(msramek): Store filters from the currently executed task on the
@@ skipping 49 matching lines @@
     scoped_refptr<autofill::AutofillWebDataService> web_data_service =
         WebDataServiceFactory::GetAutofillWebDataForProfile(
             profile_, ServiceAccessType::EXPLICIT_ACCESS);
     if (web_data_service.get()) {
       clear_autofill_origin_urls_.Start();
       web_data_service->RemoveOriginURLsModifiedBetween(
           delete_begin_, delete_end_);
       // The above calls are done on the UI thread but do their work on the DB
       // thread. So wait for it.
       BrowserThread::PostTaskAndReply(
-          BrowserThread::DB, FROM_HERE, base::Bind(&base::DoNothing),
+          BrowserThread::DB, FROM_HERE, base::BindOnce(&base::DoNothing),
           clear_autofill_origin_urls_.GetCompletionCallback());
 
       autofill::PersonalDataManager* data_manager =
           autofill::PersonalDataManagerFactory::GetForProfile(profile_);
       if (data_manager)
         data_manager->Refresh();
     }
 
 #if BUILDFLAG(ENABLE_WEBRTC)
     clear_webrtc_logs_.Start();
     BrowserThread::PostTaskAndReply(
         BrowserThread::FILE, FROM_HERE,
-        base::Bind(
+        base::BindOnce(
             &WebRtcLogUtil::DeleteOldAndRecentWebRtcLogFiles,
             WebRtcLogList::GetWebRtcLogDirectoryForProfile(profile_->GetPath()),
             delete_begin_),
         clear_webrtc_logs_.GetCompletionCallback());
 #endif
 
 #if defined(OS_ANDROID)
     precache::PrecacheManager* precache_manager =
         precache::PrecacheManagerFactory::GetForBrowserContext(profile_);
     // |precache_manager| could be nullptr if the profile is off the record.
@@ skipping 75 matching lines @@
     if (delete_begin_ == base::Time()) {
       safe_browsing::SafeBrowsingService* sb_service =
           g_browser_process->safe_browsing_service();
       if (sb_service) {
         scoped_refptr<net::URLRequestContextGetter> sb_context =
             sb_service->url_request_context();
         ++clear_cookies_count_;
         if (filter_builder.IsEmptyBlacklist()) {
           BrowserThread::PostTask(
               BrowserThread::IO, FROM_HERE,
-              base::Bind(
+              base::BindOnce(
                   &ClearCookiesOnIOThread, delete_begin_, delete_end_,
                   base::RetainedRef(std::move(sb_context)),
-                  UIThreadTrampoline(
-                      base::Bind(
-                          &ChromeBrowsingDataRemoverDelegate::OnClearedCookies,
-                          weak_ptr_factory_.GetWeakPtr()))));
+                  UIThreadTrampoline(base::Bind(
+                      &ChromeBrowsingDataRemoverDelegate::OnClearedCookies,
+                      weak_ptr_factory_.GetWeakPtr()))));
         } else {
           BrowserThread::PostTask(
               BrowserThread::IO, FROM_HERE,
-              base::Bind(
+              base::BindOnce(
                   &ClearCookiesWithPredicateOnIOThread, delete_begin_,
                   delete_end_, filter_builder.BuildCookieFilter(),
                   base::RetainedRef(std::move(sb_context)),
-                  UIThreadTrampoline(
-                      base::Bind(
-                          &ChromeBrowsingDataRemoverDelegate::OnClearedCookies,
-                          weak_ptr_factory_.GetWeakPtr()))));
+                  UIThreadTrampoline(base::Bind(
+                      &ChromeBrowsingDataRemoverDelegate::OnClearedCookies,
+                      weak_ptr_factory_.GetWeakPtr()))));
         }
       }
     }
 
     MediaDeviceIDSalt::Reset(profile_->GetPrefs());
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // DATA_TYPE_DURABLE_PERMISSION
   if (remove_mask & DATA_TYPE_DURABLE_PERMISSION) {
@@ skipping 37 matching lines @@
           filter, delete_begin_, delete_end_,
           clear_passwords_.GetCompletionCallback());
     }
 
     scoped_refptr<net::URLRequestContextGetter> request_context =
         BrowserContext::GetDefaultStoragePartition(profile_)
             ->GetURLRequestContext();
     clear_http_auth_cache_.Start();
     BrowserThread::PostTaskAndReply(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&ClearHttpAuthCacheOnIOThread, std::move(request_context),
-                   delete_begin_),
+        base::BindOnce(&ClearHttpAuthCacheOnIOThread,
+                       std::move(request_context), delete_begin_),
         clear_http_auth_cache_.GetCompletionCallback());
   }
 
   if (remove_mask & BrowsingDataRemover::DATA_TYPE_COOKIES) {
     password_manager::PasswordStore* password_store =
         PasswordStoreFactory::GetForProfile(profile_,
                                             ServiceAccessType::EXPLICIT_ACCESS)
             .get();
 
     if (password_store) {
@@ skipping 26 matching lines @@
             profile_, ServiceAccessType::EXPLICIT_ACCESS);
 
     if (web_data_service.get()) {
       clear_form_.Start();
       web_data_service->RemoveFormElementsAddedBetween(delete_begin_,
           delete_end_);
       web_data_service->RemoveAutofillDataModifiedBetween(
           delete_begin_, delete_end_);
       // The above calls are done on the UI thread but do their work on the DB
       // thread. So wait for it.
-      BrowserThread::PostTaskAndReply(
-          BrowserThread::DB, FROM_HERE, base::Bind(&base::DoNothing),
-          clear_form_.GetCompletionCallback());
+      BrowserThread::PostTaskAndReply(BrowserThread::DB, FROM_HERE,
+                                      base::BindOnce(&base::DoNothing),
+                                      clear_form_.GetCompletionCallback());
 
       autofill::PersonalDataManager* data_manager =
           autofill::PersonalDataManagerFactory::GetForProfile(profile_);
       if (data_manager)
         data_manager->Refresh();
     }
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // DATA_TYPE_CACHE
   if (remove_mask & BrowsingDataRemover::DATA_TYPE_CACHE) {
     // Tell the renderers to clear their cache.
     // TODO(crbug.com/668114): Renderer cache is a platform concept, and should
     // live in BrowsingDataRemoverImpl. However, WebCacheManager itself is
     // a component with dependency on content/browser. Untangle these
     // dependencies or reimplement the relevant part of WebCacheManager
     // in content/browser.
     web_cache::WebCacheManager::GetInstance()->ClearCache();
 
 #if !defined(DISABLE_NACL)
     clear_nacl_cache_.Start();
 
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&ClearNaClCacheOnIOThread,
-                   UIThreadTrampoline(
-                       clear_nacl_cache_.GetCompletionCallback())));
+        base::BindOnce(
+            &ClearNaClCacheOnIOThread,
+            UIThreadTrampoline(clear_nacl_cache_.GetCompletionCallback())));
 
     clear_pnacl_cache_.Start();
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(
+        base::BindOnce(
             &ClearPnaclCacheOnIOThread, delete_begin_, delete_end_,
             UIThreadTrampoline(clear_pnacl_cache_.GetCompletionCallback())));
 #endif
 
     // The PrerenderManager may have a page actively being prerendered, which
     // is essentially a preemptively cached page.
     prerender::PrerenderManager* prerender_manager =
         prerender::PrerenderManagerFactory::GetForBrowserContext(profile_);
     if (prerender_manager) {
       prerender_manager->ClearData(
@@ skipping 288 matching lines @@
 }
 
 void ChromeBrowsingDataRemoverDelegate::
 OnDeauthorizeFlashContentLicensesCompleted(
     uint32_t request_id,
     bool /* success */) {
   DCHECK_EQ(request_id, deauthorize_flash_content_licenses_request_id_);
   clear_flash_content_licenses_.GetCompletionCallback().Run();
 }
 #endif