Disambiguate RunCallbackAndroid.

RunCallbackAndroid was very commonly bound into a callback itself, and
due to being overloaded, it was difficult for base::Bind to figure work
correctly. This change changes each version to have a unique name and
updates all call sites. If there was a useless method previously
disambiguating this change removes it.

Additionally any lint violations were fixed.

TBR=nyquist, carlosk, treib, tedchoc, fgorski, boliu, maxmorin

Bug: 857155
Change-Id: Ia09c936983b95f466c831bade04821ab29ebb14a
Reviewed-on: https://chromium-review.googlesource.com/1117619
Commit-Queue: Sky Malice <skym@chromium.org>
Reviewed-by: Sky Malice <skym@chromium.org>
Reviewed-by: Tommy Nyquist <nyquist@chromium.org>
Reviewed-by: Bo <boliu@chromium.org>
Reviewed-by: Ted Choc <tedchoc@chromium.org>
Reviewed-by: Carlos Knippschild <carlosk@chromium.org>
Reviewed-by: Max Morin <maxmorin@chromium.org>
Reviewed-by: Filip Gorski <fgorski@chromium.org>
Reviewed-by: Marc Treib <treib@chromium.org>
Reviewed-by: agrieve <agrieve@chromium.org>
Cr-Commit-Position: refs/heads/master@{#571952}

base/android/callback_android.cc

@@ -12,17 +12,17 @@
 namespace base {
 namespace android {
 
-void RunCallbackAndroid(const JavaRef<jobject>& callback,
-                        const JavaRef<jobject>& arg) {
+void RunObjectCallbackAndroid(const JavaRef<jobject>& callback,
+                              const JavaRef<jobject>& arg) {
   Java_Helper_onObjectResultFromNative(AttachCurrentThread(), callback, arg);
 }
 
-void RunCallbackAndroid(const JavaRef<jobject>& callback, bool arg) {
+void RunBooleanCallbackAndroid(const JavaRef<jobject>& callback, bool arg) {
   Java_Helper_onBooleanResultFromNative(AttachCurrentThread(), callback,
                                         static_cast<jboolean>(arg));
 }
 
-void RunCallbackAndroid(const JavaRef<jobject>& callback, int arg) {
+void RunIntCallbackAndroid(const JavaRef<jobject>& callback, int arg) {
   Java_Helper_onIntResultFromNative(AttachCurrentThread(), callback, arg);
 }
 
@@ -33,8 +33,8 @@ void RunStringCallbackAndroid(const JavaRef<jobject>& callback,
   Java_Helper_onObjectResultFromNative(env, callback, java_string);
 }
 
-void RunCallbackAndroid(const JavaRef<jobject>& callback,
-                        const std::vector<uint8_t>& arg) {
+void RunByteArrayCallbackAndroid(const JavaRef<jobject>& callback,
+                                 const std::vector<uint8_t>& arg) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_bytes = ToJavaByteArray(env, arg);
   Java_Helper_onObjectResultFromNative(env, callback, j_bytes);

base/android/callback_android.h

@@ -6,6 +6,7 @@
 #define BASE_ANDROID_CALLBACK_ANDROID_H_
 
 #include <jni.h>
+#include <string>
 #include <vector>
 
 #include "base/android/scoped_java_ref.h"
@@ -16,19 +17,20 @@
 namespace base {
 namespace android {
 
-void BASE_EXPORT RunCallbackAndroid(const JavaRef<jobject>& callback,
-                                    const JavaRef<jobject>& arg);
+void BASE_EXPORT RunObjectCallbackAndroid(const JavaRef<jobject>& callback,
+                                          const JavaRef<jobject>& arg);
 
-void BASE_EXPORT RunCallbackAndroid(const JavaRef<jobject>& callback,
-                                    bool arg);
+void BASE_EXPORT RunBooleanCallbackAndroid(const JavaRef<jobject>& callback,
+                                           bool arg);
 
-void BASE_EXPORT RunCallbackAndroid(const JavaRef<jobject>& callback, int arg);
+void BASE_EXPORT RunIntCallbackAndroid(const JavaRef<jobject>& callback,
+                                       int arg);
 
 void BASE_EXPORT RunStringCallbackAndroid(const JavaRef<jobject>& callback,
                                           const std::string& arg);
 
-void BASE_EXPORT RunCallbackAndroid(const JavaRef<jobject>& callback,
-                                    const std::vector<uint8_t>& arg);
+void BASE_EXPORT RunByteArrayCallbackAndroid(const JavaRef<jobject>& callback,
+                                             const std::vector<uint8_t>& arg);
 
 }  // namespace android
 }  // namespace base

chrome/browser/android/contextual_suggestions/contextual_suggestions_bridge.cc

@@ -189,7 +189,7 @@ void ContextualSuggestionsBridge::OnSuggestionsAvailable(
 
   RegisterSyntheticFieldTrials(result);
 
-  RunCallbackAndroid(j_callback, j_result);
+  RunObjectCallbackAndroid(j_callback, j_result);
 }
 
 void ContextualSuggestionsBridge::OnImageFetched(
@@ -199,7 +199,7 @@ void ContextualSuggestionsBridge::OnImageFetched(
   if (!image.IsEmpty())
     j_bitmap = gfx::ConvertToJavaBitmap(image.ToSkBitmap());
 
-  RunCallbackAndroid(j_callback, j_bitmap);
+  RunObjectCallbackAndroid(j_callback, j_bitmap);
 }
 
 }  // namespace contextual_suggestions

chrome/browser/android/download/service/download_background_task.cc

@@ -16,11 +16,6 @@ using base::android::JavaParamRef;
 namespace download {
 namespace android {
 
-void CallTaskFinishedCallback(const base::android::JavaRef<jobject>& j_callback,
-                              bool needs_reschedule) {
-  RunCallbackAndroid(j_callback, needs_reschedule);
-}
-
 // static
 void JNI_DownloadBackgroundTask_StartBackgroundTask(
     JNIEnv* env,
@@ -32,7 +27,7 @@ void JNI_DownloadBackgroundTask_StartBackgroundTask(
   DCHECK(profile);
 
   TaskFinishedCallback finish_callback =
-      base::BindOnce(&CallTaskFinishedCallback,
+      base::BindOnce(&base::android::RunBooleanCallbackAndroid,
                      base::android::ScopedJavaGlobalRef<jobject>(jcallback));
 
   DownloadService* download_service =

chrome/browser/android/explore_sites/explore_sites_bridge.cc

@@ -4,6 +4,9 @@
 
 #include "chrome/browser/android/explore_sites/explore_sites_bridge.h"
 
+#include <string>
+#include <utility>
+
 #include "base/android/callback_android.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ -68,7 +71,7 @@ void GotNTPCategoriesFromJson(
     }
   }
 
-  base::android::RunCallbackAndroid(j_callback_ref, j_result_ref);
+  base::android::RunObjectCallbackAndroid(j_callback_ref, j_result_ref);
 }
 
 void OnGetIconDone(std::unique_ptr<image_fetcher::ImageFetcher> image_fetcher,
@@ -80,7 +83,7 @@ void OnGetIconDone(std::unique_ptr<image_fetcher::ImageFetcher> image_fetcher,
   if (!image.IsEmpty()) {
     j_bitmap = gfx::ConvertToJavaBitmap(image.ToSkBitmap());
   }
-  base::android::RunCallbackAndroid(j_callback_obj, j_bitmap);
+  base::android::RunObjectCallbackAndroid(j_callback_obj, j_bitmap);
 
   // Delete |image_fetcher| when appropriate.
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE,

chrome/browser/android/feed/feed_image_loader_bridge.cc

@@ -75,7 +75,7 @@ void FeedImageLoaderBridge::OnImageFetched(
   if (!image.IsEmpty()) {
     j_bitmap = gfx::ConvertToJavaBitmap(image.ToSkBitmap());
   }
-  RunCallbackAndroid(callback, j_bitmap);
+  RunObjectCallbackAndroid(callback, j_bitmap);
 }
 
 }  // namespace feed

chrome/browser/android/feed/feed_image_loader_bridge.h

@@ -11,30 +11,28 @@
 
 namespace feed {
 
-using base::android::JavaParamRef;
-using base::android::ScopedJavaGlobalRef;
-
 class FeedImageManager;
 
 // Native counterpart of FeedImageLoaderBridge.java. Holds non-owning pointers
 // to native implementation, to which operations are delegated. Results are
 // passed back by a single argument callback so
-// base::android::RunCallbackAndroid() can be used. This bridge is instantiated,
-// owned, and destroyed from Java.
+// base::android::RunObjectCallbackAndroid() can be used. This bridge is
+// instantiated, owned, and destroyed from Java.
 class FeedImageLoaderBridge {
  public:
   explicit FeedImageLoaderBridge(FeedImageManager* feed_image_manager);
   ~FeedImageLoaderBridge();
 
-  void Destroy(JNIEnv* j_env, const JavaParamRef<jobject>& j_this);
+  void Destroy(JNIEnv* j_env,
+               const base::android::JavaParamRef<jobject>& j_this);
 
   void FetchImage(JNIEnv* j_env,
-                  const JavaParamRef<jobject>& j_this,
-                  const JavaParamRef<jobjectArray>& j_urls,
-                  const JavaParamRef<jobject>& j_callback);
+                  const base::android::JavaParamRef<jobject>& j_this,
+                  const base::android::JavaParamRef<jobjectArray>& j_urls,
+                  const base::android::JavaParamRef<jobject>& j_callback);
 
  private:
-  void OnImageFetched(ScopedJavaGlobalRef<jobject> callback,
+  void OnImageFetched(base::android::ScopedJavaGlobalRef<jobject> callback,
                       const gfx::Image& image);
 
   FeedImageManager* feed_image_manager_;

chrome/browser/android/feed/feed_network_bridge.cc

@@ -38,7 +38,7 @@ void OnResult(const ScopedJavaGlobalRef<jobject>& j_callback,
   ScopedJavaLocalRef<jobject> j_http_response =
       Java_FeedNetworkBridge_createHttpResponse(env, http_code,
                                                 j_response_bytes);
-  base::android::RunCallbackAndroid(j_callback, j_http_response);
+  base::android::RunObjectCallbackAndroid(j_callback, j_http_response);
 }
 
 }  // namespace

chrome/browser/android/feed/feed_network_bridge.h

@@ -16,8 +16,8 @@ class FeedNetworkingHost;
 
 // Native counterpart of FeedNetworkBridge.java. Holds non-owning pointers to
 // native implementation, to which operations are delegated. Results are passed
-// back by a single argument callback so base::android::RunCallbackAndroid() can
-// be used. This bridge is instantiated, owned, and destroyed from Java.
+// back by a single argument callback so base::android::RunObjectCallbackAndroid
+// can be used. This bridge is instantiated, owned, and destroyed from Java.
 class FeedNetworkBridge {
  public:
   explicit FeedNetworkBridge(

chrome/browser/android/ntp/ntp_snippets_bridge.cc

@@ -5,6 +5,8 @@
 #include "chrome/browser/android/ntp/ntp_snippets_bridge.h"
 
 #include <jni.h>
+#include <set>
+#include <string>
 #include <utility>
 #include <vector>
 
@@ -377,7 +379,7 @@ void NTPSnippetsBridge::OnImageFetched(ScopedJavaGlobalRef<jobject> callback,
   if (!image.IsEmpty()) {
     j_bitmap = gfx::ConvertToJavaBitmap(image.ToSkBitmap());
   }
-  RunCallbackAndroid(callback, j_bitmap);
+  RunObjectCallbackAndroid(callback, j_bitmap);
 }
 
 void NTPSnippetsBridge::OnSuggestionsFetched(
@@ -389,14 +391,14 @@ void NTPSnippetsBridge::OnSuggestionsFetched(
   // TODO(fhorschig, dgn): Allow refetch or show notification acc. to status.
   JNIEnv* env = AttachCurrentThread();
   if (status.IsSuccess()) {
-    RunCallbackAndroid(
+    RunObjectCallbackAndroid(
         success_callback,
         JNI_SnippetsBridge_ToJavaSuggestionList(env, category, suggestions));
   } else {
     // The second parameter here means nothing - it was more convenient to pass
     // a Callback (which has 1 parameter) over to the native side than a
     // Runnable (which has no parameters). We ignore the parameter Java-side.
-    RunCallbackAndroid(failure_callback, 0);
+    RunIntCallbackAndroid(failure_callback, 0);
   }
 }
 

chrome/browser/android/password_ui_view_android.cc

@@ -240,14 +240,12 @@ void PasswordUIViewAndroid::PostSerializedPasswords(
         *export_target_for_testing_ = serialization_result;
       } else {
         if (serialization_result.entries_count) {
-          base::android::RunCallbackAndroid(success_callback,
-                                            serialization_result.entries_count);
+          base::android::RunIntCallbackAndroid(
+              success_callback, serialization_result.entries_count);
         } else {
-          base::android::RunCallbackAndroid(
-              error_callback, base::android::ConvertUTF8ToJavaString(
-                                  base::android::AttachCurrentThread(),
-                                  logging::SystemErrorCodeToString(
-                                      serialization_result.error)));
+          base::android::RunStringCallbackAndroid(
+              error_callback,
+              logging::SystemErrorCodeToString(serialization_result.error));
         }
       }
       break;

chrome/browser/android/preferences/website_preference_bridge.cc

@@ -705,7 +705,7 @@ void OnStorageInfoReady(const ScopedJavaGlobalRef<jobject>& java_callback,
         env, list, host, static_cast<jint>(i->type), i->usage);
   }
 
-  base::android::RunCallbackAndroid(java_callback, list);
+  base::android::RunObjectCallbackAndroid(java_callback, list);
 }
 
 void OnLocalStorageCleared(const ScopedJavaGlobalRef<jobject>& java_callback) {
@@ -776,7 +776,7 @@ void OnLocalStorageModelInfoLoaded(
         env, map, origin, full_origin, info.size, important);
   }
 
-  base::android::RunCallbackAndroid(java_callback, map);
+  base::android::RunObjectCallbackAndroid(java_callback, map);
 }
 
 }  // anonymous namespace

chrome/browser/android/rlz/rlz_ping_handler.cc

@@ -4,6 +4,8 @@
 
 #include "chrome/browser/android/rlz/rlz_ping_handler.h"
 
+#include <utility>
+
 #include "base/android/callback_android.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ -55,7 +57,7 @@ void RlzPingHandler::Ping(
     const base::android::JavaParamRef<jstring>& j_id,
     const base::android::JavaParamRef<jobject>& j_callback) {
   if (!j_brand || !j_language || !j_events || !j_id || !j_callback) {
-    base::android::RunCallbackAndroid(j_callback, false);
+    base::android::RunBooleanCallbackAndroid(j_callback, false);
     delete this;
     return;
   }
@@ -146,7 +148,7 @@ void RlzPingHandler::OnSimpleLoaderComplete(
 
   // TODO(yusufo) : Investigate what else can be checked for validity that is
   // specific to the ping
-  base::android::RunCallbackAndroid(j_callback_, valid);
+  base::android::RunBooleanCallbackAndroid(j_callback_, valid);
   delete this;
 }
 

chrome/browser/android/rlz/rlz_ping_handler.h

@@ -8,6 +8,7 @@
 #include <jni.h>
 #include <memory>
 #include <string>
+
 #include "base/android/scoped_java_ref.h"
 #include "base/memory/ref_counted.h"
 

chrome/browser/android/signin/signin_manager_android.cc

@@ -2,10 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <vector>
-
 #include "chrome/browser/android/signin/signin_manager_android.h"
 
+#include <utility>
+#include <vector>
+
 #include "base/android/callback_android.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
@@ -130,7 +131,7 @@ class ProfileDataRemover : public content::BrowsingDataRemover::Observer {
 void UserManagementDomainFetched(
     base::android::ScopedJavaGlobalRef<jobject> callback,
     const std::string& dm_token, const std::string& client_id) {
-  base::android::RunCallbackAndroid(callback, !dm_token.empty());
+  base::android::RunBooleanCallbackAndroid(callback, !dm_token.empty());
 }
 
 }  // namespace

chrome/browser/android/webapk/webapk_update_manager.cc

@@ -31,12 +31,6 @@ using base::android::ScopedJavaGlobalRef;
 
 namespace {
 
-// Called after saving the update request proto either succeeds or fails.
-void OnStoredUpdateRequest(const JavaRef<jobject>& java_callback,
-                           bool success) {
-  base::android::RunCallbackAndroid(java_callback, success);
-}
-
 // Called after the update either succeeds or fails.
 void OnUpdated(const JavaRef<jobject>& java_callback,
                WebApkInstallResult result,
@@ -128,7 +122,7 @@ static void JNI_WebApkUpdateManager_StoreWebApkUpdateRequestToFile(
       base::FilePath(update_request_path), info, primary_icon, badge_icon,
       webapk_package, std::to_string(java_webapk_version),
       icon_url_to_murmur2_hash, java_is_manifest_stale, update_reason,
-      base::BindOnce(&OnStoredUpdateRequest,
+      base::BindOnce(&base::android::RunBooleanCallbackAndroid,
                      ScopedJavaGlobalRef<jobject>(java_callback)));
 }
 

chrome/browser/offline_pages/android/background_scheduler_bridge.cc

@@ -22,16 +22,6 @@ using base::android::ScopedJavaLocalRef;
 namespace offline_pages {
 namespace android {
 
-namespace {
-
-// C++ callback that delegates to Java callback.
-void ProcessingDoneCallback(
-    const ScopedJavaGlobalRef<jobject>& j_callback_obj, bool result) {
-  base::android::RunCallbackAndroid(j_callback_obj, result);
-}
-
-}  // namespace
-
 // JNI call to start request processing in scheduled mode.
 static jboolean JNI_BackgroundSchedulerBridge_StartScheduledProcessing(
     JNIEnv* env,
@@ -55,7 +45,9 @@ static jboolean JNI_BackgroundSchedulerBridge_StartScheduledProcessing(
       static_cast<net::NetworkChangeNotifier::ConnectionType>(
           j_net_connection_type));
   return coordinator->StartScheduledProcessing(
-      device_conditions, base::Bind(&ProcessingDoneCallback, j_callback_ref));
+      device_conditions,
+      base::BindRepeating(&base::android::RunBooleanCallbackAndroid,
+                          j_callback_ref));
 }
 
 // JNI call to stop request processing in scheduled mode.
@@ -87,7 +79,8 @@ void BackgroundSchedulerBridge::Schedule(
 }
 
 void BackgroundSchedulerBridge::BackupSchedule(
-    const TriggerConditions& trigger_conditions, long delay_in_seconds) {
+    const TriggerConditions& trigger_conditions,
+    int64_t delay_in_seconds) {
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_conditions =
       CreateTriggerConditions(env, trigger_conditions.require_power_connected,

chrome/browser/offline_pages/android/background_scheduler_bridge.h

@@ -5,9 +5,11 @@
 #ifndef CHROME_BROWSER_OFFLINE_PAGES_ANDROID_BACKGROUND_SCHEDULER_BRIDGE_H_
 #define CHROME_BROWSER_OFFLINE_PAGES_ANDROID_BACKGROUND_SCHEDULER_BRIDGE_H_
 
-#include "components/offline_pages/core/background/scheduler.h"
+#include <stdint.h>
+#include <memory>
 
 #include "base/android/jni_android.h"
+#include "components/offline_pages/core/background/scheduler.h"
 
 namespace offline_pages {
 namespace android {
@@ -22,7 +24,7 @@ class BackgroundSchedulerBridge : public Scheduler {
   // Scheduler implementation.
   void Schedule(const TriggerConditions& trigger_conditions) override;
   void BackupSchedule(const TriggerConditions& trigger_conditions,
-                      long delay_in_seconds) override;
+                      int64_t delay_in_seconds) override;
   void Unschedule() override;
   const DeviceConditions& GetCurrentDeviceConditions() override;
 

chrome/browser/offline_pages/android/cct_request_observer.cc

@@ -4,6 +4,8 @@
 
 #include "chrome/browser/offline_pages/android/cct_request_observer.h"
 
+#include <utility>
+
 #include "base/android/callback_android.h"
 #include "base/android/jni_int_wrapper.h"
 #include "base/android/jni_string.h"
@@ -60,7 +62,7 @@ void CCTRequestObserver::OnCompleted(
           env, as_jint(static_cast<int>(status)),
           base::android::ConvertUTF8ToJavaString(env, request.client_id().id));
 
-  base::android::RunCallbackAndroid(j_callback_, callback_info);
+  base::android::RunObjectCallbackAndroid(j_callback_, callback_info);
 }
 
 void CCTRequestObserver::OnChanged(const SavePageRequest& request) {}

chrome/browser/offline_pages/android/evaluation/offline_page_evaluation_bridge.cc

@@ -4,6 +4,11 @@
 
 #include "chrome/browser/offline_pages/android/evaluation/offline_page_evaluation_bridge.h"
 
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
 #include "base/android/callback_android.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
@@ -109,12 +114,7 @@ void GetAllPagesCallback(
   JNIEnv* env = base::android::AttachCurrentThread();
   JNI_OfflinePageEvaluationBridge_ToJavaOfflinePageList(env, j_result_obj,
                                                         result);
-  base::android::RunCallbackAndroid(j_callback_obj, j_result_obj);
-}
-
-void OnPushRequestsDone(const ScopedJavaGlobalRef<jobject>& j_callback_obj,
-                        bool result) {
-  base::android::RunCallbackAndroid(j_callback_obj, result);
+  base::android::RunObjectCallbackAndroid(j_callback_obj, j_result_obj);
 }
 
 void OnGetAllRequestsDone(
@@ -125,13 +125,13 @@ void OnGetAllRequestsDone(
   ScopedJavaLocalRef<jobjectArray> j_result_obj =
       JNI_OfflinePageEvaluationBridge_CreateJavaSavePageRequests(
           env, std::move(all_requests));
-  base::android::RunCallbackAndroid(j_callback_obj, j_result_obj);
+  base::android::RunObjectCallbackAndroid(j_callback_obj, j_result_obj);
 }
 
 void OnRemoveRequestsDone(const ScopedJavaGlobalRef<jobject>& j_callback_obj,
                           const MultipleItemStatuses& removed_request_results) {
-  base::android::RunCallbackAndroid(j_callback_obj,
-                                    int(removed_request_results.size()));
+  base::android::RunIntCallbackAndroid(
+      j_callback_obj, static_cast<int>(removed_request_results.size()));
 }
 
 std::unique_ptr<KeyedService> GetTestingRequestCoordinator(
@@ -322,10 +322,10 @@ bool OfflinePageEvaluationBridge::PushRequestProcessing(
     const JavaParamRef<jobject>& j_callback_obj) {
   ScopedJavaGlobalRef<jobject> j_callback_ref(j_callback_obj);
   DCHECK(request_coordinator_);
-  base::android::RunCallbackAndroid(j_callback_obj, false);
+  base::android::RunBooleanCallbackAndroid(j_callback_obj, false);
 
-  return request_coordinator_->StartImmediateProcessing(
-      base::Bind(&OnPushRequestsDone, j_callback_ref));
+  return request_coordinator_->StartImmediateProcessing(base::BindRepeating(
+      &base::android::RunBooleanCallbackAndroid, j_callback_ref));
 }
 
 void OfflinePageEvaluationBridge::SavePageLater(

chrome/browser/offline_pages/android/offline_page_bridge.cc

@@ -115,7 +115,7 @@ void MultipleOfflinePageItemCallback(
     const OfflinePageModel::MultipleOfflinePageItemResult& result) {
   JNIEnv* env = base::android::AttachCurrentThread();
   JNI_SavePageRequest_ToJavaOfflinePageList(env, j_result_obj, result);
-  base::android::RunCallbackAndroid(j_callback_obj, j_result_obj);
+  base::android::RunObjectCallbackAndroid(j_callback_obj, j_result_obj);
 }
 
 void SavePageCallback(const ScopedJavaGlobalRef<jobject>& j_callback_obj,
@@ -131,7 +131,8 @@ void SavePageCallback(const ScopedJavaGlobalRef<jobject>& j_callback_obj,
 
 void DeletePageCallback(const ScopedJavaGlobalRef<jobject>& j_callback_obj,
                         OfflinePageModel::DeletePageResult result) {
-  base::android::RunCallbackAndroid(j_callback_obj, static_cast<int>(result));
+  base::android::RunIntCallbackAndroid(j_callback_obj,
+                                       static_cast<int>(result));
 }
 
 void SelectPageCallback(const ScopedJavaGlobalRef<jobject>& j_callback_obj,
@@ -141,7 +142,7 @@ void SelectPageCallback(const ScopedJavaGlobalRef<jobject>& j_callback_obj,
 
   if (!result.empty())
     j_result = JNI_SavePageRequest_ToJavaOfflinePageItem(env, result.front());
-  base::android::RunCallbackAndroid(j_callback_obj, j_result);
+  base::android::RunObjectCallbackAndroid(j_callback_obj, j_result);
 }
 
 void SingleOfflinePageItemCallback(
@@ -152,7 +153,7 @@ void SingleOfflinePageItemCallback(
 
   if (result)
     j_result = JNI_SavePageRequest_ToJavaOfflinePageItem(env, *result);
-  base::android::RunCallbackAndroid(j_callback_obj, j_result);
+  base::android::RunObjectCallbackAndroid(j_callback_obj, j_result);
 }
 
 void CheckForNewOfflineContentCallback(
@@ -165,15 +166,7 @@ void CheckForNewOfflineContentCallback(
   ScopedJavaLocalRef<jstring> j_result =
       base::android::ConvertUTF16ToJavaString(env, relevant_host);
 
-  base::android::RunCallbackAndroid(j_callback_obj, j_result);
-}
-
-void GetLaunchUrlByOfflineIdCallback(
-    const ScopedJavaGlobalRef<jobject>& j_callback_obj,
-    const std::string& result) {
-  JNIEnv* env = base::android::AttachCurrentThread();
-  base::android::RunCallbackAndroid(j_callback_obj,
-                                    ConvertUTF8ToJavaString(env, result));
+  base::android::RunObjectCallbackAndroid(j_callback_obj, j_result);
 }
 
 void GetLaunchUrlBySizeAndDigestCallback(
@@ -185,7 +178,7 @@ void GetLaunchUrlBySizeAndDigestCallback(
       Java_OfflinePageBridge_createLoadUrlParams(
           env, ConvertUTF8ToJavaString(env, url.spec()),
           ConvertUTF8ToJavaString(env, extra_headers));
-  base::android::RunCallbackAndroid(j_callback_obj, loadUrlParams);
+  base::android::RunObjectCallbackAndroid(j_callback_obj, loadUrlParams);
 }
 
 void ValidateFileCallback(const ScopedJavaGlobalRef<jobject>& j_callback_obj,
@@ -200,13 +193,7 @@ void ValidateFileCallback(const ScopedJavaGlobalRef<jobject>& j_callback_obj,
     launch_url = url;
   else
     launch_url = net::FilePathToFileURL(file_path);
-  GetLaunchUrlByOfflineIdCallback(j_callback_obj, launch_url.spec());
-}
-
-void AcquireFileAccessPermissionCallback(
-    const ScopedJavaGlobalRef<jobject>& j_callback_obj,
-    bool granted) {
-  base::android::RunCallbackAndroid(j_callback_obj, granted);
+  base::android::RunStringCallbackAndroid(j_callback_obj, launch_url.spec());
 }
 
 ScopedJavaLocalRef<jobjectArray> JNI_SavePageRequest_CreateJavaSavePageRequests(
@@ -247,7 +234,7 @@ void OnGetAllRequestsDone(
   ScopedJavaLocalRef<jobjectArray> j_result_obj =
       JNI_SavePageRequest_CreateJavaSavePageRequests(env,
                                                      std::move(all_requests));
-  base::android::RunCallbackAndroid(j_callback_obj, j_result_obj);
+  base::android::RunObjectCallbackAndroid(j_callback_obj, j_result_obj);
 }
 
 UpdateRequestResult ToUpdateRequestResult(ItemActionStatus status) {
@@ -290,15 +277,13 @@ void OnRemoveRequestsDone(const ScopedJavaGlobalRef<jobject>& j_callback_obj,
 
 void SavePageLaterCallback(const ScopedJavaGlobalRef<jobject>& j_callback_obj,
                            AddRequestResult value) {
-  base::android::RunCallbackAndroid(j_callback_obj, static_cast<int>(value));
+  base::android::RunIntCallbackAndroid(j_callback_obj, static_cast<int>(value));
 }
 
 void PublishPageDone(
     const ScopedJavaGlobalRef<jobject>& j_published_callback_obj,
     const base::FilePath& file_path,
     SavePageResult result) {
-  JNIEnv* env = base::android::AttachCurrentThread();
-
   base::FilePath file_path_or_empty;
   if (result != SavePageResult::SUCCESS)
     file_path_or_empty = file_path;
@@ -306,9 +291,8 @@ void PublishPageDone(
   UMA_HISTOGRAM_ENUMERATION("OfflinePages.Sharing.PublishInternalPageResult",
                             result, SavePageResult::RESULT_COUNT);
 
-  base::android::RunCallbackAndroid(
-      j_published_callback_obj,
-      ConvertUTF8ToJavaString(env, file_path.value()));
+  base::android::RunStringCallbackAndroid(j_published_callback_obj,
+                                          file_path.value());
 }
 
 }  // namespace
@@ -794,7 +778,7 @@ void OfflinePageBridge::GetRequestsInQueue(
   if (!coordinator) {
     // Callback with null to signal that results are unavailable.
     const JavaParamRef<jobject> empty_result(nullptr);
-    base::android::RunCallbackAndroid(j_callback_obj, empty_result);
+    base::android::RunObjectCallbackAndroid(j_callback_obj, empty_result);
     return;
   }
 
@@ -819,7 +803,7 @@ void OfflinePageBridge::RemoveRequestsFromQueue(
   if (!coordinator) {
     // Callback with null to signal that results are unavailable.
     const JavaParamRef<jobject> empty_result(nullptr);
-    base::android::RunCallbackAndroid(j_callback_obj, empty_result);
+    base::android::RunObjectCallbackAndroid(j_callback_obj, empty_result);
     return;
   }
 
@@ -965,12 +949,13 @@ void OfflinePageBridge::GetPageByOfflineIdDone(
     const ScopedJavaGlobalRef<jobject>& j_callback_obj,
     const OfflinePageItem* offline_page) {
   if (!offline_page) {
-    GetLaunchUrlByOfflineIdCallback(j_callback_obj, std::string());
+    base::android::RunStringCallbackAndroid(j_callback_obj, std::string());
     return;
   }
 
   if (offline_page_model_->IsArchiveInInternalDir(offline_page->file_path)) {
-    GetLaunchUrlByOfflineIdCallback(j_callback_obj, offline_page->url.spec());
+    base::android::RunStringCallbackAndroid(j_callback_obj,
+                                            offline_page->url.spec());
     return;
   }
 
@@ -1034,12 +1019,12 @@ void OfflinePageBridge::AcquireFileAccessPermission(
   content::WebContents* web_contents =
       content::WebContents::FromJavaWebContents(j_web_contents);
   if (!web_contents) {
-    AcquireFileAccessPermissionCallback(j_callback_ref, false);
+    base::android::RunBooleanCallbackAndroid(j_callback_ref, false);
     return;
   }
   OfflinePageUtils::AcquireFileAccessPermission(
-      web_contents,
-      base::BindOnce(&AcquireFileAccessPermissionCallback, j_callback_ref));
+      web_contents, base::BindOnce(&base::android::RunBooleanCallbackAndroid,
+                                   j_callback_ref));
 }
 
 void OfflinePageBridge::NotifyIfDoneLoading() const {

chrome/browser/supervised_user/child_accounts/child_account_service_android.cc

@@ -21,7 +21,7 @@ using base::android::AttachCurrentThread;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::JavaParamRef;
 using base::android::JavaRef;
-using base::android::RunCallbackAndroid;
+using base::android::RunBooleanCallbackAndroid;
 using base::android::ScopedJavaGlobalRef;
 
 void JNI_ChildAccountService_ListenForChildStatusReceived(
@@ -31,10 +31,9 @@ void JNI_ChildAccountService_ListenForChildStatusReceived(
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   ChildAccountService* service = ChildAccountServiceFactory::GetForProfile(
       profile_manager->GetLastUsedProfile());
-  // Needed to disambiguate RunCallbackAndroid
-  void (*runCallback)(const JavaRef<jobject>&, bool) = &RunCallbackAndroid;
-  service->AddChildStatusReceivedCallback(base::BindOnce(
-      runCallback, ScopedJavaGlobalRef<jobject>(callback), true));
+  service->AddChildStatusReceivedCallback(
+      base::BindOnce(&RunBooleanCallbackAndroid,
+                     ScopedJavaGlobalRef<jobject>(callback), true));
 }
 
 void ReauthenticateChildAccount(content::WebContents* web_contents,

chrome/browser/ui/android/context_menu_helper.cc

@@ -6,7 +6,7 @@
 
 #include <stdint.h>
 
-#include <vector>
+#include <map>
 
 #include "base/android/callback_android.h"
 #include "base/android/jni_string.h"
@@ -51,14 +51,14 @@ class ContextMenuHelperImageRequest : public ImageDecoder::ImageRequest {
 
  protected:
   void OnImageDecoded(const SkBitmap& decoded_image) override {
-    base::android::RunCallbackAndroid(jcallback_,
-                                      gfx::ConvertToJavaBitmap(&decoded_image));
+    base::android::RunObjectCallbackAndroid(
+        jcallback_, gfx::ConvertToJavaBitmap(&decoded_image));
     delete this;
   }
 
   void OnDecodeImageFailed() override {
     base::android::ScopedJavaLocalRef<jobject> j_bitmap;
-    base::android::RunCallbackAndroid(jcallback_, j_bitmap);
+    base::android::RunObjectCallbackAndroid(jcallback_, j_bitmap);
     delete this;
   }
 
@@ -77,7 +77,7 @@ void OnRetrieveImageForShare(
     const base::android::JavaRef<jobject>& jcallback,
     const std::vector<uint8_t>& thumbnail_data,
     const gfx::Size& original_size) {
-  base::android::RunCallbackAndroid(jcallback, thumbnail_data);
+  base::android::RunByteArrayCallbackAndroid(jcallback, thumbnail_data);
 }
 
 void OnRetrieveImageForContextMenu(
@@ -94,7 +94,7 @@ ContextMenuHelper::ContextMenuHelper(content::WebContents* web_contents)
     : web_contents_(web_contents) {
   JNIEnv* env = base::android::AttachCurrentThread();
   java_obj_.Reset(
-      env, Java_ContextMenuHelper_create(env, reinterpret_cast<long>(this),
+      env, Java_ContextMenuHelper_create(env, reinterpret_cast<int64_t>(this),
                                          web_contents_->GetJavaWebContents())
                .obj());
   DCHECK(!java_obj_.is_null());

components/feature_engagement/internal/android/tracker_impl_android.cc

@@ -159,11 +159,8 @@ void TrackerImplAndroid::AddOnInitializedCallback(
     JNIEnv* env,
     const base::android::JavaRef<jobject>& jobj,
     const base::android::JavaParamRef<jobject>& j_callback_obj) {
-  // Disambiguate RunCallbackAndroid to get the reference to the bool version.
-  void (*runBoolCallback)(const base::android::JavaRef<jobject>&, bool) =
-      &base::android::RunCallbackAndroid;
   tracker_impl_->AddOnInitializedCallback(base::BindOnce(
-      runBoolCallback,
+      &base::android::RunBooleanCallbackAndroid,
       base::android::ScopedJavaGlobalRef<jobject>(j_callback_obj)));
 }
 

components/offline_items_collection/core/android/offline_content_aggregator_bridge.cc

@@ -5,6 +5,8 @@
 #include "components/offline_items_collection/core/android/offline_content_aggregator_bridge.h"
 
 #include <memory>
+#include <utility>
+#include <vector>
 
 #include "base/android/callback_android.h"
 #include "base/android/jni_string.h"
@@ -52,14 +54,14 @@ void GetVisualsForItemHelperCallback(
 void RunGetAllItemsCallback(const base::android::JavaRef<jobject>& j_callback,
                             const std::vector<OfflineItem>& items) {
   JNIEnv* env = AttachCurrentThread();
-  RunCallbackAndroid(j_callback,
-                     OfflineItemBridge::CreateOfflineItemList(env, items));
+  RunObjectCallbackAndroid(
+      j_callback, OfflineItemBridge::CreateOfflineItemList(env, items));
 }
 
 void RunGetItemByIdCallback(const base::android::JavaRef<jobject>& j_callback,
                             const base::Optional<OfflineItem>& item) {
   JNIEnv* env = AttachCurrentThread();
-  RunCallbackAndroid(
+  RunObjectCallbackAndroid(
       j_callback, item.has_value()
                       ? OfflineItemBridge::CreateOfflineItem(env, item.value())
                       : nullptr);

components/offline_pages/core/background/scheduler.h

@@ -5,6 +5,8 @@
 #ifndef COMPONENTS_OFFLINE_PAGES_CORE_BACKGROUND_SCHEDULER_H_
 #define COMPONENTS_OFFLINE_PAGES_CORE_BACKGROUND_SCHEDULER_H_
 
+#include <stdint.h>
+
 #include "components/offline_pages/core/background/device_conditions.h"
 
 namespace offline_pages {
@@ -38,7 +40,7 @@ class Scheduler {
   // so we can continue processing background download requests.  This will
   // not overwrite existing tasks.
   virtual void BackupSchedule(const TriggerConditions& trigger_conditions,
-                              long delay_in_seconds) = 0;
+                              int64_t delay_in_seconds) = 0;
 
   // Unschedules the currently scheduled task, if any.
   virtual void Unschedule() = 0;

components/offline_pages/core/background/scheduler_stub.cc

@@ -30,7 +30,7 @@ void SchedulerStub::Schedule(const TriggerConditions& trigger_conditions) {
 }
 
 void SchedulerStub::BackupSchedule(const TriggerConditions& trigger_conditions,
-                                   long delay_in_seconds) {
+                                   int64_t delay_in_seconds) {
   backup_schedule_called_ = true;
   schedule_delay_ = delay_in_seconds;
   trigger_conditions_ = trigger_conditions;

components/offline_pages/core/background/scheduler_stub.h

@@ -5,6 +5,8 @@
 #ifndef COMPONENTS_OFFLINE_PAGES_CORE_BACKGROUND_SCHEDULER_STUB_H_
 #define COMPONENTS_OFFLINE_PAGES_CORE_BACKGROUND_SCHEDULER_STUB_H_
 
+#include <stdint.h>
+
 #include "components/offline_pages/core/background/scheduler.h"
 
 namespace offline_pages {
@@ -19,7 +21,7 @@ class SchedulerStub : public Scheduler {
   void Schedule(const TriggerConditions& trigger_conditions) override;
 
   void BackupSchedule(const TriggerConditions& trigger_conditions,
-                      long delay_in_seconds) override;
+                      int64_t delay_in_seconds) override;
 
   // Unschedules the currently scheduled task, if any.
   void Unschedule() override;
@@ -42,7 +44,7 @@ class SchedulerStub : public Scheduler {
   bool backup_schedule_called_;
   bool unschedule_called_;
   bool get_current_device_conditions_called_;
-  long schedule_delay_;
+  int64_t schedule_delay_;
   DeviceConditions device_conditions_;
   TriggerConditions trigger_conditions_;
 };

content/browser/frame_host/render_frame_host_android.cc

@@ -4,6 +4,8 @@
 
 #include "content/browser/frame_host/render_frame_host_android.h"
 
+#include <utility>
+
 #include "base/android/callback_android.h"
 #include "base/android/jni_string.h"
 #include "base/android/unguessable_token_android.h"
@@ -28,12 +30,12 @@ void OnGetCanonicalUrlForSharing(
     const base::android::JavaRef<jobject>& jcallback,
     const base::Optional<GURL>& url) {
   if (!url) {
-    base::android::RunCallbackAndroid(jcallback, ScopedJavaLocalRef<jstring>());
+    base::android::RunObjectCallbackAndroid(jcallback,
+                                            ScopedJavaLocalRef<jstring>());
     return;
   }
 
-  base::android::RunCallbackAndroid(
-      jcallback, ConvertUTF8ToJavaString(AttachCurrentThread(), url->spec()));
+  base::android::RunStringCallbackAndroid(jcallback, url->spec());
 }
 }  // namespace
 

media/base/android/media_drm_storage_bridge.cc

@@ -23,7 +23,8 @@ using base::android::AttachCurrentThread;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::JavaByteArrayToByteVector;
 using base::android::JavaParamRef;
-using base::android::RunCallbackAndroid;
+using base::android::RunBooleanCallbackAndroid;
+using base::android::RunObjectCallbackAndroid;
 using base::android::ScopedJavaLocalRef;
 using base::android::ToJavaByteArray;
 
@@ -128,7 +129,7 @@ void MediaDrmStorageBridge::OnClearInfo(
 
 void MediaDrmStorageBridge::RunAndroidBoolCallback(JavaObjectPtr j_callback,
                                                    bool success) {
-  RunCallbackAndroid(*j_callback, success);
+  RunBooleanCallbackAndroid(*j_callback, success);
 }
 
 void MediaDrmStorageBridge::OnInitialized(
@@ -147,7 +148,7 @@ void MediaDrmStorageBridge::OnSessionDataLoaded(
     const std::string& session_id,
     std::unique_ptr<MediaDrmStorage::SessionData> session_data) {
   if (!session_data) {
-    RunCallbackAndroid(*j_callback, ScopedJavaLocalRef<jobject>());
+    RunObjectCallbackAndroid(*j_callback, ScopedJavaLocalRef<jobject>());
     return;
   }
 
@@ -158,8 +159,9 @@ void MediaDrmStorageBridge::OnSessionDataLoaded(
   ScopedJavaLocalRef<jstring> j_mime =
       ConvertUTF8ToJavaString(env, session_data->mime_type);
 
-  RunCallbackAndroid(*j_callback, Java_PersistentInfo_create(
-                                      env, j_eme_id, j_key_set_id, j_mime));
+  RunObjectCallbackAndroid(
+      *j_callback,
+      Java_PersistentInfo_create(env, j_eme_id, j_key_set_id, j_mime));
 }
 
 }  // namespace media