Move away from using base::{Bind,Callback,Closure}()

base::{Bind,Callback,Closure}() have been deprecatedfor a while now,
are finally gone on Chromium 92, so it would be good to migrate all
current instances in the code (and stop introducing new ones) to the
Once/Repeating variants instead to easy further rebases.

This patch changes ALL instances of those old definitions and move
to using the Once variants whenever possible (as they are preferred)
and Repeating variants in every other case.

Last, this patch also makes some changes in brave_rewards_api.{h,cc}
to use weak pointers instead of base::Unretained() when binding
callbacks, for extra safety (and consistency with existing code).

[1] https://chromium-review.googlesource.com/c/chromium/src/+/2867526

Resolves brave/brave-browser#15855

browser/binance/android/binance_native_worker.cc

@@ -104,7 +104,7 @@ BinanceNativeWorker::GetOAuthClientUrl(JNIEnv* env) {
 
 void BinanceNativeWorker::GetAccessToken(JNIEnv* env) {
   if (binance_service_) {
-    binance_service_->GetAccessToken(base::Bind(
+    binance_service_->GetAccessToken(base::BindOnce(
         &BinanceNativeWorker::OnGetAccessToken, weak_factory_.GetWeakPtr()));
   }
 }
@@ -139,8 +139,8 @@ void BinanceNativeWorker::OnGetAccessToken(bool success) {
 void BinanceNativeWorker::GetAccountBalances(JNIEnv* env) {
   if (binance_service_) {
     binance_service_->GetAccountBalances(
-        base::Bind(&BinanceNativeWorker::OnGetAccountBalances,
-                   weak_factory_.GetWeakPtr()));
+        base::BindOnce(&BinanceNativeWorker::OnGetAccountBalances,
+                       weak_factory_.GetWeakPtr()));
   }
 }
 
@@ -164,8 +164,8 @@ void BinanceNativeWorker::GetConvertQuote(
         base::android::ConvertJavaStringToUTF8(env, from),
         base::android::ConvertJavaStringToUTF8(env, to),
         base::android::ConvertJavaStringToUTF8(env, amount),
-        base::Bind(&BinanceNativeWorker::OnGetConvertQuote,
-                   weak_factory_.GetWeakPtr()));
+        base::BindOnce(&BinanceNativeWorker::OnGetConvertQuote,
+                       weak_factory_.GetWeakPtr()));
   }
 }
 
@@ -184,7 +184,7 @@ void BinanceNativeWorker::OnGetConvertQuote(const std::string& quote_id,
 
 void BinanceNativeWorker::GetCoinNetworks(JNIEnv* env) {
   if (binance_service_) {
-    binance_service_->GetCoinNetworks(base::Bind(
+    binance_service_->GetCoinNetworks(base::BindOnce(
         &BinanceNativeWorker::OnGetCoinNetworks, weak_factory_.GetWeakPtr()));
   }
 }
@@ -206,8 +206,8 @@ void BinanceNativeWorker::GetDepositInfo(
     binance_service_->GetDepositInfo(
         base::android::ConvertJavaStringToUTF8(env, symbol),
         base::android::ConvertJavaStringToUTF8(env, ticker_network),
-        base::Bind(&BinanceNativeWorker::OnGetDepositInfo,
-                   weak_factory_.GetWeakPtr()));
+        base::BindOnce(&BinanceNativeWorker::OnGetDepositInfo,
+                       weak_factory_.GetWeakPtr()));
   }
 }
 
@@ -227,8 +227,8 @@ void BinanceNativeWorker::ConfirmConvert(
   if (binance_service_) {
     binance_service_->ConfirmConvert(
         base::android::ConvertJavaStringToUTF8(env, quote_id),
-        base::Bind(&BinanceNativeWorker::OnConfirmConvert,
-                   weak_factory_.GetWeakPtr()));
+        base::BindOnce(&BinanceNativeWorker::OnConfirmConvert,
+                       weak_factory_.GetWeakPtr()));
   }
 }
 
@@ -242,7 +242,7 @@ void BinanceNativeWorker::OnConfirmConvert(bool success,
 
 void BinanceNativeWorker::GetConvertAssets(JNIEnv* env) {
   if (binance_service_) {
-    binance_service_->GetConvertAssets(base::Bind(
+    binance_service_->GetConvertAssets(base::BindOnce(
         &BinanceNativeWorker::OnGetConvertAssets, weak_factory_.GetWeakPtr()));
   }
 }
@@ -259,7 +259,7 @@ void BinanceNativeWorker::OnGetConvertAssets(
 
 void BinanceNativeWorker::RevokeToken(JNIEnv* env) {
   if (binance_service_) {
-    binance_service_->RevokeToken(base::Bind(
+    binance_service_->RevokeToken(base::BindOnce(
         &BinanceNativeWorker::OnRevokeToken, weak_factory_.GetWeakPtr()));
   }
 }

browser/brave_browser_process_impl.cc

@@ -98,7 +98,8 @@ namespace {
 // Initializes callback for SystemRequestHandler
 void InitSystemRequestHandlerCallback() {
   network::SystemRequestHandler::OnBeforeSystemRequestCallback
-      before_system_request_callback = base::Bind(brave::OnBeforeSystemRequest);
+      before_system_request_callback =
+          base::BindRepeating(brave::OnBeforeSystemRequest);
   network::SystemRequestHandler::GetInstance()
       ->RegisterOnBeforeSystemRequestCallback(before_system_request_callback);
 }
@@ -146,14 +147,14 @@ void BraveBrowserProcessImpl::Init() {
   UpdateBraveDarkMode();
   pref_change_registrar_.Add(
       kBraveDarkMode,
-      base::Bind(&BraveBrowserProcessImpl::OnBraveDarkModeChanged,
-                 base::Unretained(this)));
+      base::BindRepeating(&BraveBrowserProcessImpl::OnBraveDarkModeChanged,
+                          base::Unretained(this)));
 
 #if BUILDFLAG(ENABLE_TOR)
   pref_change_registrar_.Add(
       tor::prefs::kTorDisabled,
-      base::Bind(&BraveBrowserProcessImpl::OnTorEnabledChanged,
-                 base::Unretained(this)));
+      base::BindRepeating(&BraveBrowserProcessImpl::OnTorEnabledChanged,
+                          base::Unretained(this)));
 #endif
 
   InitSystemRequestHandlerCallback();

browser/brave_rewards/android/brave_rewards_native_worker.cc

@@ -218,10 +218,8 @@ void BraveRewardsNativeWorker::OnGetRewardsParameters(
   }
 
   if (rewards_service) {
-    rewards_service->FetchBalance(
-      base::Bind(
-        &BraveRewardsNativeWorker::OnBalance,
-        weak_factory_.GetWeakPtr()));
+    rewards_service->FetchBalance(base::BindOnce(
+        &BraveRewardsNativeWorker::OnBalance, weak_factory_.GetWeakPtr()));
   }
 }
 
@@ -265,9 +263,8 @@ void BraveRewardsNativeWorker::FetchGrants(JNIEnv* env) {
 
 void BraveRewardsNativeWorker::StartProcess(JNIEnv* env) {
   if (brave_rewards_service_) {
-    brave_rewards_service_->StartProcess(base::Bind(
-          &BraveRewardsNativeWorker::OnStartProcess,
-          weak_factory_.GetWeakPtr()));
+    brave_rewards_service_->StartProcess(base::BindOnce(
+        &BraveRewardsNativeWorker::OnStartProcess, weak_factory_.GetWeakPtr()));
   }
 }
 
@@ -389,17 +386,17 @@ base::android::ScopedJavaLocalRef<jobjectArray>
 
 void BraveRewardsNativeWorker::GetPendingContributionsTotal(JNIEnv* env) {
   if (brave_rewards_service_) {
-    brave_rewards_service_->GetPendingContributionsTotal(base::Bind(
-          &BraveRewardsNativeWorker::OnGetPendingContributionsTotal,
-          weak_factory_.GetWeakPtr()));
+    brave_rewards_service_->GetPendingContributionsTotal(base::BindOnce(
+        &BraveRewardsNativeWorker::OnGetPendingContributionsTotal,
+        weak_factory_.GetWeakPtr()));
   }
 }
 
 void BraveRewardsNativeWorker::GetRecurringDonations(JNIEnv* env) {
   if (brave_rewards_service_) {
-    brave_rewards_service_->GetRecurringTips(base::Bind(
-          &BraveRewardsNativeWorker::OnGetRecurringTips,
-          weak_factory_.GetWeakPtr()));
+    brave_rewards_service_->GetRecurringTips(
+        base::BindOnce(&BraveRewardsNativeWorker::OnGetRecurringTips,
+                       weak_factory_.GetWeakPtr()));
   }
 }
 
@@ -426,8 +423,8 @@ bool BraveRewardsNativeWorker::IsCurrentPublisherInRecurrentDonations(
 void BraveRewardsNativeWorker::GetAutoContributeProperties(JNIEnv* env) {
   if (brave_rewards_service_) {
     brave_rewards_service_->GetAutoContributeProperties(
-        base::Bind(&BraveRewardsNativeWorker::OnGetAutoContributeProperties,
-                   weak_factory_.GetWeakPtr()));
+        base::BindOnce(&BraveRewardsNativeWorker::OnGetAutoContributeProperties,
+                       weak_factory_.GetWeakPtr()));
   }
 }
 
@@ -452,17 +449,17 @@ bool BraveRewardsNativeWorker::IsAutoContributeEnabled(JNIEnv* env) {
 
 void BraveRewardsNativeWorker::GetReconcileStamp(JNIEnv* env) {
   if (brave_rewards_service_) {
-    brave_rewards_service_->GetReconcileStamp(base::Bind(
-            &BraveRewardsNativeWorker::OnGetGetReconcileStamp,
-            weak_factory_.GetWeakPtr()));
+    brave_rewards_service_->GetReconcileStamp(
+        base::BindOnce(&BraveRewardsNativeWorker::OnGetGetReconcileStamp,
+                       weak_factory_.GetWeakPtr()));
   }
 }
 
 void BraveRewardsNativeWorker::ResetTheWholeState(JNIEnv* env) {
   if (brave_rewards_service_) {
-    brave_rewards_service_->CompleteReset(base::Bind(
-           &BraveRewardsNativeWorker::OnResetTheWholeState,
-           weak_factory_.GetWeakPtr()));
+    brave_rewards_service_->CompleteReset(
+        base::BindOnce(&BraveRewardsNativeWorker::OnResetTheWholeState,
+                       weak_factory_.GetWeakPtr()));
   } else {
     JNIEnv* env = base::android::AttachCurrentThread();
 
@@ -680,8 +677,8 @@ void BraveRewardsNativeWorker::ProcessRewardsPageUrl(JNIEnv* env,
     std::string cpath = base::android::ConvertJavaStringToUTF8(env, path);
     std::string cquery = base::android::ConvertJavaStringToUTF8(env, query);
     auto callback =
-        base::Bind(&BraveRewardsNativeWorker::OnProcessRewardsPageUrl,
-                   weak_factory_.GetWeakPtr());
+        base::BindOnce(&BraveRewardsNativeWorker::OnProcessRewardsPageUrl,
+                       weak_factory_.GetWeakPtr());
     brave_rewards_service_->ProcessRewardsPageUrl(cpath, cquery, callback);
   }
 }

browser/brave_stats/brave_stats_updater.cc

@@ -329,8 +329,8 @@ void BraveStatsUpdater::QueueServerPing() {
     pref_change_registrar_->Init(pref_service_);
     pref_change_registrar_->Add(
         kReferralInitialization,
-        base::Bind(&BraveStatsUpdater::OnReferralInitialization,
-                   base::Unretained(this)));
+        base::BindRepeating(&BraveStatsUpdater::OnReferralInitialization,
+                            base::Unretained(this)));
   }
   if (ads_enabled) {
     DetectUncertainFuture();

browser/brave_stats/brave_stats_updater_browsertest.cc

@@ -71,7 +71,7 @@ class BraveStatsUpdaterBrowserTest : public InProcessBrowserTest {
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     embedded_test_server()->RegisterRequestHandler(
-        base::Bind(&HandleRequestForStats));
+        base::BindRepeating(&HandleRequestForStats));
     ASSERT_TRUE(embedded_test_server()->Start());
     command_line->AppendSwitchASCII(
         brave_stats::switches::kBraveStatsUpdaterServer,

browser/devtools/brave_devtools_ui_bindings_browsertest.cc

@@ -37,24 +37,24 @@ IN_PROC_BROWSER_TEST_F(BraveDevToolsUIBindingsBrowserTest, ThemeTest) {
   auto* devtools_ui_bindings = new BraveDevToolsUIBindings(web_contents);
   DCHECK(devtools_ui_bindings);
   devtools_ui_bindings->GetPreferences(
-      base::Bind(&BraveDevToolsUIBindingsBrowserTest::GetPreferenceCallback,
-                 base::Unretained(this)));
+      base::BindOnce(&BraveDevToolsUIBindingsBrowserTest::GetPreferenceCallback,
+                     base::Unretained(this)));
   // Check current devtools' theme is same as native theme when user doesn't
   // change devtools' theme explicitely.
   EXPECT_EQ(ui_theme_, "\"dark\"");
 
   dark_mode::SetBraveDarkModeType(
     dark_mode::BraveDarkModeType::BRAVE_DARK_MODE_TYPE_LIGHT);
   devtools_ui_bindings->GetPreferences(
-      base::Bind(&BraveDevToolsUIBindingsBrowserTest::GetPreferenceCallback,
-                 base::Unretained(this)));
+      base::BindOnce(&BraveDevToolsUIBindingsBrowserTest::GetPreferenceCallback,
+                     base::Unretained(this)));
   // In devtools, default is used as light.
   EXPECT_EQ(ui_theme_, "\"default\"");
 
   // When user sets devtools' theme explicitely, respect user's setting.
   devtools_ui_bindings->SetPreference("uiTheme", "\"dark\"");
   devtools_ui_bindings->GetPreferences(
-      base::Bind(&BraveDevToolsUIBindingsBrowserTest::GetPreferenceCallback,
-                 base::Unretained(this)));
+      base::BindOnce(&BraveDevToolsUIBindingsBrowserTest::GetPreferenceCallback,
+                     base::Unretained(this)));
   EXPECT_EQ(ui_theme_, "\"dark\"");
 }

browser/extensions/api/brave_rewards_api.cc

@@ -122,9 +122,8 @@ BraveRewardsGetPublisherInfoFunction::Run() {
 
   rewards_service->GetPublisherInfo(
       params->publisher_key,
-      base::Bind(
-          &BraveRewardsGetPublisherInfoFunction::OnGetPublisherInfo,
-          this));
+      base::BindOnce(&BraveRewardsGetPublisherInfoFunction::OnGetPublisherInfo,
+                     base::Unretained(this)));
 
   return RespondLater();
 }
@@ -170,9 +169,9 @@ BraveRewardsGetPublisherPanelInfoFunction::Run() {
 
   rewards_service->GetPublisherPanelInfo(
       params->publisher_key,
-      base::Bind(
+      base::BindOnce(
           &BraveRewardsGetPublisherPanelInfoFunction::OnGetPublisherPanelInfo,
-          this));
+          base::Unretained(this)));
 
   return RespondLater();
 }
@@ -225,11 +224,10 @@ BraveRewardsSavePublisherInfoFunction::Run() {
   publisher_info->favicon_url = params->fav_icon_url;
 
   rewards_service->SavePublisherInfo(
-      params->window_id,
-      std::move(publisher_info),
-      base::Bind(
+      params->window_id, std::move(publisher_info),
+      base::BindOnce(
           &BraveRewardsSavePublisherInfoFunction::OnSavePublisherInfo,
-          this));
+          base::Unretained(this)));
 
   return RespondLater();
 }
@@ -277,10 +275,6 @@ ExtensionFunction::ResponseAction BraveRewardsTipSiteFunction::Run() {
   return RespondNow(NoArguments());
 }
 
-BraveRewardsTipUserFunction::BraveRewardsTipUserFunction()
-    : weak_factory_(this) {
-}
-
 BraveRewardsTipUserFunction::~BraveRewardsTipUserFunction() {
 }
 
@@ -331,8 +325,8 @@ void BraveRewardsTipUserFunction::OnProcessStarted(
   }
   rewards_service->GetPublisherInfo(
       publisher_key,
-      base::Bind(&BraveRewardsTipUserFunction::OnTipUserGetPublisherInfo,
-                 this));
+      base::BindOnce(&BraveRewardsTipUserFunction::OnTipUserGetPublisherInfo,
+                     base::Unretained(this)));
 }
 
 void BraveRewardsTipUserFunction::OnTipUserGetPublisherInfo(
@@ -368,11 +362,9 @@ void BraveRewardsTipUserFunction::OnTipUserGetPublisherInfo(
   }
 
   rewards_service->SavePublisherInfo(
-      0,
-      std::move(publisher_info),
-      base::Bind(&BraveRewardsTipUserFunction::
-                 OnTipUserSavePublisherInfo,
-                 weak_factory_.GetWeakPtr()));
+      0, std::move(publisher_info),
+      base::BindOnce(&BraveRewardsTipUserFunction::OnTipUserSavePublisherInfo,
+                     base::Unretained(this)));
 }
 
 void BraveRewardsTipUserFunction::OnTipUserSavePublisherInfo(
@@ -650,9 +642,9 @@ BraveRewardsGetPendingContributionsTotalFunction::Run() {
     return RespondNow(OneArgument(base::Value(0.0)));
   }
 
-  rewards_service->GetPendingContributionsTotal(base::Bind(
-        &BraveRewardsGetPendingContributionsTotalFunction::OnGetPendingTotal,
-        this));
+  rewards_service->GetPendingContributionsTotal(base::BindOnce(
+      &BraveRewardsGetPendingContributionsTotalFunction::OnGetPendingTotal,
+      base::Unretained(this)));
   return RespondLater();
 }
 
@@ -747,11 +739,9 @@ BraveRewardsSaveRecurringTipFunction::Run() {
   }
 
   rewards_service_->SaveRecurringTip(
-      params->publisher_key,
-      params->new_amount,
-      base::Bind(
-          &BraveRewardsSaveRecurringTipFunction::OnSaveRecurringTip,
-          this));
+      params->publisher_key, params->new_amount,
+      base::BindOnce(&BraveRewardsSaveRecurringTipFunction::OnSaveRecurringTip,
+                     base::Unretained(this)));
 
   return RespondLater();
 }
@@ -798,9 +788,9 @@ BraveRewardsGetRecurringTipsFunction::Run() {
     return RespondNow(Error("Rewards service is not initialized"));
   }
 
-  rewards_service->GetRecurringTips(base::Bind(
-        &BraveRewardsGetRecurringTipsFunction::OnGetRecurringTips,
-        this));
+  rewards_service->GetRecurringTips(
+      base::BindOnce(&BraveRewardsGetRecurringTipsFunction::OnGetRecurringTips,
+                     base::Unretained(this)));
   return RespondLater();
 }
 
@@ -1187,9 +1177,9 @@ BraveRewardsGetAnonWalletStatusFunction::Run() {
     return RespondNow(Error("Rewards service is not initialized"));
   }
 
-  rewards_service->GetAnonWalletStatus(base::Bind(
-        &BraveRewardsGetAnonWalletStatusFunction::OnGetAnonWalletStatus,
-        this));
+  rewards_service->GetAnonWalletStatus(base::BindOnce(
+      &BraveRewardsGetAnonWalletStatusFunction::OnGetAnonWalletStatus,
+      base::Unretained(this)));
   return RespondLater();
 }