[base] Apply BindOnceRewriter in //chrome/browser/android

This change applies the BindOnceRewriter in //chrome/browser/android.
This rewriter replaces calls to base::Bind and base::BindRepeating with
calls to base::BindOnce, in case the result is immediately assigned to a
base::OnceCallback. Given that base::RepeatingCallback is implicitly
convertible to base::OnceCallback, there is no change in functionality.

Steps:
  1. run_tool.py --tool base_bind_rewriters \
                 --tool-arg='--rewriter=bind_to_bind_once'
  2. git cl format

This CL was uploaded by git cl split.

R=twellington@chromium.org

Bug: 714018
Change-Id: Ib7bc83521f16b2ce741ff1ddc3e8b42aa9d1099f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2132149Reviewed-by: David Trainor <dtrainor@chromium.org>
Commit-Queue: Jan Wilken Dörrie <jdoerrie@chromium.org>
Cr-Commit-Position: refs/heads/master@{#760406}

chrome/browser/android/bookmarks/partner_bookmarks_reader.cc

@@ -267,10 +267,10 @@ void PartnerBookmarksReader::GetFaviconFromCacheOrServer(
     FaviconFetchedCallback callback) {
   GetLargeIconService()->GetLargeIconRawBitmapOrFallbackStyleForPageUrl(
       page_url, kPartnerBookmarksMinimumFaviconSizePx, desired_favicon_size_px,
-      base::Bind(&PartnerBookmarksReader::OnGetFaviconFromCacheFinished,
-                 base::Unretained(this), page_url,
-                 base::Passed(std::move(callback)), fallback_to_server,
-                 from_server, desired_favicon_size_px),
+      base::BindOnce(&PartnerBookmarksReader::OnGetFaviconFromCacheFinished,
+                     base::Unretained(this), page_url,
+                     base::Passed(std::move(callback)), fallback_to_server,
+                     from_server, desired_favicon_size_px),
       &favicon_task_tracker_);
 }
 
@@ -324,9 +324,10 @@ void PartnerBookmarksReader::OnGetFaviconFromCacheFinished(
       ->GetLargeIconOrFallbackStyleFromGoogleServerSkippingLocalCache(
           page_url, false /* may_page_url_be_private */,
           false /* should_trim_page_url_path */, traffic_annotation,
-          base::Bind(&PartnerBookmarksReader::OnGetFaviconFromServerFinished,
-                     base::Unretained(this), page_url, desired_favicon_size_px,
-                     base::Passed(std::move(callback))));
+          base::BindOnce(
+              &PartnerBookmarksReader::OnGetFaviconFromServerFinished,
+              base::Unretained(this), page_url, desired_favicon_size_px,
+              base::Passed(std::move(callback))));
 }
 
 void PartnerBookmarksReader::OnGetFaviconFromServerFinished(

chrome/browser/android/ntp/ntp_snippets_bridge.cc

@@ -199,8 +199,8 @@ void NTPSnippetsBridge::FetchSuggestionImage(
   content_suggestions_service_->FetchSuggestionImage(
       ContentSuggestion::ID(Category::FromIDValue(j_category_id),
                             ConvertJavaStringToUTF8(env, id_within_category)),
-      base::Bind(&NTPSnippetsBridge::OnImageFetched,
-                 weak_ptr_factory_.GetWeakPtr(), callback));
+      base::BindOnce(&NTPSnippetsBridge::OnImageFetched,
+                     weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void NTPSnippetsBridge::FetchSuggestionFavicon(
@@ -216,8 +216,8 @@ void NTPSnippetsBridge::FetchSuggestionFavicon(
       ContentSuggestion::ID(Category::FromIDValue(j_category_id),
                             ConvertJavaStringToUTF8(env, id_within_category)),
       j_minimum_size_px, j_desired_size_px,
-      base::Bind(&NTPSnippetsBridge::OnImageFetched,
-                 weak_ptr_factory_.GetWeakPtr(), callback));
+      base::BindOnce(&NTPSnippetsBridge::OnImageFetched,
+                     weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void NTPSnippetsBridge::Fetch(
@@ -238,9 +238,9 @@ void NTPSnippetsBridge::Fetch(
       category,
       std::set<std::string>(known_suggestion_ids.begin(),
                             known_suggestion_ids.end()),
-      base::Bind(&NTPSnippetsBridge::OnSuggestionsFetched,
-                 weak_ptr_factory_.GetWeakPtr(), success_callback,
-                 failure_callback, category));
+      base::BindOnce(&NTPSnippetsBridge::OnSuggestionsFetched,
+                     weak_ptr_factory_.GetWeakPtr(), success_callback,
+                     failure_callback, category));
 }
 
 void NTPSnippetsBridge::ReloadSuggestions(JNIEnv* env,

chrome/browser/android/oom_intervention/oom_intervention_tab_helper.cc

@@ -319,9 +319,9 @@ void OomInterventionTabHelper::OnNearOomDetected() {
   DCHECK(!renderer_detection_timer_.IsRunning());
   renderer_detection_timer_.Start(
       FROM_HERE, kRendererHighMemoryUsageDetectionWindow,
-      base::BindRepeating(&OomInterventionTabHelper::
-                              OnDetectionWindowElapsedWithoutHighMemoryUsage,
-                          weak_ptr_factory_.GetWeakPtr()));
+      base::BindOnce(&OomInterventionTabHelper::
+                         OnDetectionWindowElapsedWithoutHighMemoryUsage,
+                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void OomInterventionTabHelper::

chrome/browser/android/preferences/website_preference_bridge.cc

@@ -747,8 +747,8 @@ static void JNI_WebsitePreferenceBridge_FetchLocalStorageInfo(
   auto local_storage_helper =
       base::MakeRefCounted<browsing_data::LocalStorageHelper>(profile);
   local_storage_helper->StartFetching(
-      base::Bind(&OnLocalStorageModelInfoLoaded, profile, fetch_important,
-                 ScopedJavaGlobalRef<jobject>(java_callback)));
+      base::BindOnce(&OnLocalStorageModelInfoLoaded, profile, fetch_important,
+                     ScopedJavaGlobalRef<jobject>(java_callback)));
 }
 
 static void JNI_WebsitePreferenceBridge_FetchStorageInfo(

chrome/browser/android/vr/gvr_scheduler_delegate.cc

@@ -545,8 +545,8 @@ void GvrSchedulerDelegate::SubmitDrawnFrame(FrameType frame_type,
   }
   if (fence) {
     webxr_delayed_gvr_submit_.Reset(
-        base::BindRepeating(&GvrSchedulerDelegate::DrawFrameSubmitWhenReady,
-                            base::Unretained(this)));
+        base::BindOnce(&GvrSchedulerDelegate::DrawFrameSubmitWhenReady,
+                       base::Unretained(this)));
     task_runner()->PostTask(
         FROM_HERE, base::BindOnce(webxr_delayed_gvr_submit_.callback(),
                                   frame_type, head_pose, std::move(fence)));
@@ -574,8 +574,8 @@ void GvrSchedulerDelegate::DrawFrameSubmitWhenReady(
     }
     if (!fence->HasCompleted()) {
       webxr_delayed_gvr_submit_.Reset(
-          base::BindRepeating(&GvrSchedulerDelegate::DrawFrameSubmitWhenReady,
-                              base::Unretained(this)));
+          base::BindOnce(&GvrSchedulerDelegate::DrawFrameSubmitWhenReady,
+                         base::Unretained(this)));
       if (use_polling) {
         // Poll the fence status at a short interval. This burns some CPU, but
         // avoids excessive waiting on devices which don't handle timeouts

chrome/browser/android/vr/test/run_all_unittests.cc

@@ -11,6 +11,5 @@ int main(int argc, char** argv) {
 
   return base::LaunchUnitTests(
       argc, argv,
-      base::BindRepeating(&vr::ArTestSuite::Run,
-                          base::Unretained(&test_suite)));
+      base::BindOnce(&vr::ArTestSuite::Run, base::Unretained(&test_suite)));
 }

chrome/browser/android/vr/vr_gl_thread.cc

@@ -485,46 +485,45 @@ void VrGLThread::UpdateWebInputIndices(int selection_start,
                                        int composition_end) {
   task_runner()->PostTask(
       FROM_HERE,
-      base::BindRepeating(&BrowserUiInterface::UpdateWebInputIndices,
-                          weak_browser_ui_, selection_start, selection_end,
-                          composition_start, composition_end));
+      base::BindOnce(&BrowserUiInterface::UpdateWebInputIndices,
+                     weak_browser_ui_, selection_start, selection_end,
+                     composition_start, composition_end));
 }
 
 void VrGLThread::OnSwapContents(int new_content_id) {
-  task_runner()->PostTask(
-      FROM_HERE, base::BindRepeating(&BrowserUiInterface::OnSwapContents,
-                                     weak_browser_ui_, new_content_id));
+  task_runner()->PostTask(FROM_HERE,
+                          base::BindOnce(&BrowserUiInterface::OnSwapContents,
+                                         weak_browser_ui_, new_content_id));
 }
 
 void VrGLThread::SetDialogLocation(float x, float y) {
-  task_runner()->PostTask(
-      FROM_HERE, base::BindRepeating(&BrowserUiInterface::SetDialogLocation,
-                                     weak_browser_ui_, x, y));
+  task_runner()->PostTask(FROM_HERE,
+                          base::BindOnce(&BrowserUiInterface::SetDialogLocation,
+                                         weak_browser_ui_, x, y));
 }
 
 void VrGLThread::SetDialogFloating(bool floating) {
-  task_runner()->PostTask(
-      FROM_HERE, base::BindRepeating(&BrowserUiInterface::SetDialogFloating,
-                                     weak_browser_ui_, floating));
+  task_runner()->PostTask(FROM_HERE,
+                          base::BindOnce(&BrowserUiInterface::SetDialogFloating,
+                                         weak_browser_ui_, floating));
 }
 
 void VrGLThread::ShowPlatformToast(const base::string16& text) {
-  task_runner()->PostTask(
-      FROM_HERE, base::BindRepeating(&BrowserUiInterface::ShowPlatformToast,
-                                     weak_browser_ui_, text));
+  task_runner()->PostTask(FROM_HERE,
+                          base::BindOnce(&BrowserUiInterface::ShowPlatformToast,
+                                         weak_browser_ui_, text));
 }
 
 void VrGLThread::CancelPlatformToast() {
   task_runner()->PostTask(
-      FROM_HERE, base::BindRepeating(&BrowserUiInterface::CancelPlatformToast,
-                                     weak_browser_ui_));
+      FROM_HERE, base::BindOnce(&BrowserUiInterface::CancelPlatformToast,
+                                weak_browser_ui_));
 }
 
 void VrGLThread::OnContentBoundsChanged(int width, int height) {
   task_runner()->PostTask(
-      FROM_HERE,
-      base::BindRepeating(&BrowserUiInterface::OnContentBoundsChanged,
-                          weak_browser_ui_, width, height));
+      FROM_HERE, base::BindOnce(&BrowserUiInterface::OnContentBoundsChanged,
+                                weak_browser_ui_, width, height));
 }
 
 void VrGLThread::PerformKeyboardInputForTesting(

chrome/browser/android/vr/vr_shell.cc

@@ -177,8 +177,8 @@ VrShell::VrShell(JNIEnv* env,
   if (!can_load_new_assets_) {
     waiting_for_assets_component_timer_.Start(
         FROM_HERE, kAssetsComponentWaitDelay,
-        base::BindRepeating(&VrShell::OnAssetsComponentWaitTimeout,
-                            weak_ptr_factory_.GetWeakPtr()));
+        base::BindOnce(&VrShell::OnAssetsComponentWaitTimeout,
+                       weak_ptr_factory_.GetWeakPtr()));
   }
 
   AssetsLoader::GetInstance()->SetOnComponentReadyCallback(base::BindRepeating(
@@ -954,7 +954,7 @@ void VrShell::PollCapturingState() {
     }
   }
 
-  geolocation_config_->IsHighAccuracyLocationBeingCaptured(base::BindRepeating(
+  geolocation_config_->IsHighAccuracyLocationBeingCaptured(base::BindOnce(
       [](VrShell* shell, BrowserUiInterface* ui,
          CapturingStateModel* active_capturing,
          CapturingStateModel* background_capturing,

chrome/browser/android/webapk/webapk_icon_hasher.cc

@@ -125,8 +125,8 @@ WebApkIconHasher::WebApkIconHasher(
 
   download_timeout_timer_.Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(timeout_ms),
-      base::Bind(&WebApkIconHasher::OnDownloadTimedOut,
-                 base::Unretained(this)));
+      base::BindOnce(&WebApkIconHasher::OnDownloadTimedOut,
+                     base::Unretained(this)));
 
   auto resource_request = std::make_unique<network::ResourceRequest>();
   resource_request->trusted_params = network::ResourceRequest::TrustedParams();

chrome/browser/android/webapk/webapk_install_service.cc

@@ -55,9 +55,9 @@ void WebApkInstallService::InstallAsync(content::WebContents* web_contents,
   auto observer = std::make_unique<LifetimeObserver>(web_contents);
   WebApkInstaller::InstallAsync(
       browser_context_, shortcut_info, primary_icon, is_primary_icon_maskable,
-      base::Bind(&WebApkInstallService::OnFinishedInstall,
-                 weak_ptr_factory_.GetWeakPtr(), base::Passed(&observer),
-                 shortcut_info, primary_icon, is_primary_icon_maskable));
+      base::BindOnce(&WebApkInstallService::OnFinishedInstall,
+                     weak_ptr_factory_.GetWeakPtr(), base::Passed(&observer),
+                     shortcut_info, primary_icon, is_primary_icon_maskable));
 }
 
 void WebApkInstallService::UpdateAsync(

chrome/browser/android/webapk/webapk_installer.cc

@@ -702,8 +702,8 @@ void WebApkInstaller::SendRequest(
 
   timer_.Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(webapk_server_timeout_ms_),
-      base::Bind(&WebApkInstaller::OnResult, weak_ptr_factory_.GetWeakPtr(),
-                 WebApkInstallResult::FAILURE));
+      base::BindOnce(&WebApkInstaller::OnResult, weak_ptr_factory_.GetWeakPtr(),
+                     WebApkInstallResult::FAILURE));
 
   auto request = std::make_unique<network::ResourceRequest>();
   request->url = server_url_;

chrome/browser/android/webapk/webapk_update_data_fetcher.cc

@@ -175,8 +175,8 @@ void WebApkUpdateDataFetcher::OnDidGetInstallableData(
           ->GetURLLoaderFactoryForBrowserProcess()
           .get(),
       url::Origin::Create(last_fetched_url_), urls,
-      base::Bind(&WebApkUpdateDataFetcher::OnGotIconMurmur2Hashes,
-                 weak_ptr_factory_.GetWeakPtr()));
+      base::BindOnce(&WebApkUpdateDataFetcher::OnGotIconMurmur2Hashes,
+                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void WebApkUpdateDataFetcher::OnGotIconMurmur2Hashes(

chrome/browser/android/webapk/webapk_update_manager.cc

@@ -224,5 +224,5 @@ static void JNI_WebApkUpdateManager_UpdateWebApkFromFile(
       ConvertJavaStringToUTF8(env, java_update_request_path);
   WebApkInstallService::Get(profile)->UpdateAsync(
       base::FilePath(update_request_path),
-      base::Bind(&OnUpdated, callback_ref));
+      base::BindOnce(&OnUpdated, callback_ref));
 }

chrome/browser/android/webapps/add_to_homescreen_data_fetcher.cc

@@ -134,7 +134,7 @@ AddToHomescreenDataFetcher::AddToHomescreenDataFetcher(
   // Bind the InterfacePtr into the callback so that it's kept alive until
   // there's either a connection error or a response.
   auto* web_app_info_proxy = chrome_render_frame.get();
-  web_app_info_proxy->GetWebApplicationInfo(base::Bind(
+  web_app_info_proxy->GetWebApplicationInfo(base::BindOnce(
       &AddToHomescreenDataFetcher::OnDidGetWebApplicationInfo,
       weak_ptr_factory_.GetWeakPtr(), base::Passed(&chrome_render_frame)));
 }
@@ -188,8 +188,8 @@ void AddToHomescreenDataFetcher::OnDidGetWebApplicationInfo(
   // worst, a dynamically-generated launcher icon.
   data_timeout_timer_.Start(
       FROM_HERE, data_timeout_ms_,
-      base::Bind(&AddToHomescreenDataFetcher::OnDataTimedout,
-                 weak_ptr_factory_.GetWeakPtr()));
+      base::BindOnce(&AddToHomescreenDataFetcher::OnDataTimedout,
+                     weak_ptr_factory_.GetWeakPtr()));
   start_time_ = base::TimeTicks::Now();
 
   installable_manager_->GetData(
@@ -316,8 +316,8 @@ void AddToHomescreenDataFetcher::FetchFavicon() {
       ShortcutHelper::GetIdealHomescreenIconSizeInPx() - 1;
   favicon_service->GetLargestRawFaviconForPageURL(
       shortcut_info_.url, icon_types, threshold_to_get_any_largest_icon,
-      base::Bind(&AddToHomescreenDataFetcher::OnFaviconFetched,
-                 weak_ptr_factory_.GetWeakPtr()),
+      base::BindOnce(&AddToHomescreenDataFetcher::OnFaviconFetched,
+                     weak_ptr_factory_.GetWeakPtr()),
       &favicon_task_tracker_);
 }