[Feed] Guard all callbacks given to native with bridge weak ptrs.

Bug: 900416
Change-Id: I3fed64b4968a75a7bc2279fca1169dbc2c0b0244
Reviewed-on: https://chromium-review.googlesource.com/c/1330334
Commit-Queue: Sky Malice <skym@chromium.org>
Reviewed-by: Filip Gorski <fgorski@chromium.org>
Cr-Commit-Position: refs/heads/master@{#607838}

chrome/android/feed/core/java/src/org/chromium/chrome/browser/feed/FeedNetworkBridge.java

@@ -48,7 +48,10 @@ public class FeedNetworkBridge implements NetworkClient {
     }
 
     @Override
-    public void close() {}
+    public void close() {
+        assert mNativeBridge != 0;
+        nativeCancelRequests(mNativeBridge);
+    }
 
     @CalledByNative
     private static HttpResponse createHttpResponse(int code, byte[] body) {
@@ -59,4 +62,5 @@ public class FeedNetworkBridge implements NetworkClient {
     private native void nativeDestroy(long nativeFeedNetworkBridge);
     private native void nativeSendNetworkRequest(long nativeFeedNetworkBridge, String url,
             String requestType, byte[] body, Callback<HttpResponse> resultCallback);
+    private native void nativeCancelRequests(long nativeFeedNetworkBridge);
 }

chrome/android/feed/core/java/src/org/chromium/chrome/browser/feed/TestNetworkClient.java

@@ -30,6 +30,7 @@ import org.chromium.base.VisibleForTesting;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 /** A network client that returns configurable responses
  *  modified from com.google.android.libraries.feed.mocknetworkclient.MockServerNetworkClient
@@ -39,6 +40,7 @@ public class TestNetworkClient implements NetworkClient {
 
     private final ExtensionRegistryLite mExtensionRegistry;
     private final long mResponseDelay;
+    private final AtomicBoolean mAlreadyClosed = new AtomicBoolean(false);
 
     private MockServer mMockServer;
 
@@ -46,7 +48,7 @@ public class TestNetworkClient implements NetworkClient {
         Configuration config = new Configuration.Builder().build();
         mExtensionRegistry = ExtensionRegistryLite.newInstance();
         mExtensionRegistry.add(FeedRequest.feedRequest);
-        // TODO(aluo): Add ability to delay responses
+        // TODO(aluo): Add ability to delay responses.
         mResponseDelay = config.getValueOrDefault(ConfigKey.MOCK_SERVER_DELAY_MS, 0L);
         mMockServer = MockServer.getDefaultInstance();
     }
@@ -83,7 +85,7 @@ public class TestNetworkClient implements NetworkClient {
 
     @Override
     public void send(HttpRequest httpRequest, Consumer<HttpResponse> responseConsumer) {
-        // TODO(aluo): Add ability to respond with HTTP Errors
+        // TODO(aluo): Add ability to respond with HTTP Errors.
         try {
             Request request = getRequest(httpRequest);
             ByteString requestToken =
@@ -114,12 +116,11 @@ public class TestNetworkClient implements NetworkClient {
 
     private void delayedAccept(HttpResponse httpResponse, Consumer<HttpResponse> responseConsumer) {
         if (mResponseDelay <= 0) {
-            responseConsumer.accept(httpResponse);
-            return;
+            maybeAccept(httpResponse, responseConsumer);
+        } else {
+            ThreadUtils.postOnUiThreadDelayed(
+                    () -> maybeAccept(httpResponse, responseConsumer), mResponseDelay);
         }
-
-        ThreadUtils.postOnUiThreadDelayed(
-                () -> responseConsumer.accept(httpResponse), mResponseDelay);
     }
 
     private Request getRequest(HttpRequest httpRequest) throws IOException {
@@ -138,7 +139,9 @@ public class TestNetworkClient implements NetworkClient {
     }
 
     @Override
-    public void close() {}
+    public void close() {
+        mAlreadyClosed.set(true);
+    }
 
     private HttpResponse createHttpResponse(Response response) {
         try {
@@ -153,4 +156,10 @@ public class TestNetworkClient implements NetworkClient {
             throw new RuntimeException(e);
         }
     }
+
+    private void maybeAccept(HttpResponse httpResponse, Consumer<HttpResponse> responseConsumer) {
+        if (!mAlreadyClosed.get()) {
+            responseConsumer.accept(httpResponse);
+        }
+    }
 }

chrome/browser/android/feed/feed_content_bridge.cc

@@ -40,54 +40,6 @@ using base::android::ToJavaArrayOfByteArray;
 using base::android::ToJavaArrayOfStrings;
 using base::android::JavaByteArrayToString;
 
-namespace {
-
-void OnLoadContentDone(ScopedJavaGlobalRef<jobject> success_callback,
-                       ScopedJavaGlobalRef<jobject> failure_callback,
-                       bool success,
-                       std::vector<FeedContentDatabase::KeyAndData> pairs) {
-  std::vector<std::string> keys;
-  std::vector<std::string> data;
-  for (auto pair : pairs) {
-    keys.push_back(std::move(pair.first));
-    data.push_back(std::move(pair.second));
-  }
-
-  JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jobjectArray> j_keys = ToJavaArrayOfStrings(env, keys);
-  ScopedJavaLocalRef<jobjectArray> j_data = ToJavaArrayOfByteArray(env, data);
-
-  // Create Java Map by JNI call.
-  ScopedJavaLocalRef<jobject> j_pairs =
-      Java_FeedContentBridge_createKeyAndDataMap(env, j_keys, j_data);
-
-  if (!success) {
-    RunObjectCallbackAndroid(failure_callback, nullptr);
-    return;
-  }
-  RunObjectCallbackAndroid(success_callback, j_pairs);
-}
-
-void OnLoadAllContentKeysDone(ScopedJavaGlobalRef<jobject> success_callback,
-                              ScopedJavaGlobalRef<jobject> failure_callback,
-                              bool success,
-                              std::vector<std::string> keys) {
-  JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jobjectArray> j_keys = ToJavaArrayOfStrings(env, keys);
-
-  if (!success) {
-    RunObjectCallbackAndroid(failure_callback, nullptr);
-    return;
-  }
-  RunObjectCallbackAndroid(success_callback, j_keys);
-}
-
-void OnStorageCommitDone(ScopedJavaGlobalRef<jobject> callback, bool success) {
-  RunBooleanCallbackAndroid(callback, success);
-}
-
-}  // namespace
-
 static jlong JNI_FeedContentBridge_Init(
     JNIEnv* env,
     const JavaParamRef<jobject>& j_this,
@@ -125,8 +77,9 @@ void FeedContentBridge::LoadContent(
   ScopedJavaGlobalRef<jobject> failure_callback(j_failure_callback);
 
   feed_content_database_->LoadContent(
-      keys,
-      base::BindOnce(&OnLoadContentDone, success_callback, failure_callback));
+      keys, base::BindOnce(&FeedContentBridge::OnLoadContentDone,
+                           weak_ptr_factory_.GetWeakPtr(), success_callback,
+                           failure_callback));
 }
 
 void FeedContentBridge::LoadContentByPrefix(
@@ -140,8 +93,9 @@ void FeedContentBridge::LoadContentByPrefix(
   ScopedJavaGlobalRef<jobject> failure_callback(j_failure_callback);
 
   feed_content_database_->LoadContentByPrefix(
-      prefix,
-      base::BindOnce(&OnLoadContentDone, success_callback, failure_callback));
+      prefix, base::BindOnce(&FeedContentBridge::OnLoadContentDone,
+                             weak_ptr_factory_.GetWeakPtr(), success_callback,
+                             failure_callback));
 }
 
 void FeedContentBridge::LoadAllContentKeys(
@@ -153,7 +107,8 @@ void FeedContentBridge::LoadAllContentKeys(
   ScopedJavaGlobalRef<jobject> failure_callback(j_failure_callback);
 
   feed_content_database_->LoadAllContentKeys(base::BindOnce(
-      &OnLoadAllContentKeysDone, success_callback, failure_callback));
+      &FeedContentBridge::OnLoadAllContentKeysDone,
+      weak_ptr_factory_.GetWeakPtr(), success_callback, failure_callback));
 }
 
 void FeedContentBridge::CommitContentMutation(
@@ -165,7 +120,8 @@ void FeedContentBridge::CommitContentMutation(
 
   feed_content_database_->CommitContentMutation(
       std::move(content_mutation_),
-      base::BindOnce(&OnStorageCommitDone, callback));
+      base::BindOnce(&FeedContentBridge::OnStorageCommitDone,
+                     weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void FeedContentBridge::CreateContentMutation(JNIEnv* j_env,
@@ -220,4 +176,52 @@ void FeedContentBridge::AppendDeleteAllOperation(
   content_mutation_->AppendDeleteAllOperation();
 }
 
+void FeedContentBridge::OnLoadContentDone(
+    ScopedJavaGlobalRef<jobject> success_callback,
+    ScopedJavaGlobalRef<jobject> failure_callback,
+    bool success,
+    std::vector<FeedContentDatabase::KeyAndData> pairs) {
+  std::vector<std::string> keys;
+  std::vector<std::string> data;
+  for (auto pair : pairs) {
+    keys.push_back(std::move(pair.first));
+    data.push_back(std::move(pair.second));
+  }
+
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jobjectArray> j_keys = ToJavaArrayOfStrings(env, keys);
+  ScopedJavaLocalRef<jobjectArray> j_data = ToJavaArrayOfByteArray(env, data);
+
+  // Create Java Map by JNI call.
+  ScopedJavaLocalRef<jobject> j_pairs =
+      Java_FeedContentBridge_createKeyAndDataMap(env, j_keys, j_data);
+
+  if (!success) {
+    RunObjectCallbackAndroid(failure_callback, nullptr);
+    return;
+  }
+  RunObjectCallbackAndroid(success_callback, j_pairs);
+}
+
+void FeedContentBridge::OnLoadAllContentKeysDone(
+    ScopedJavaGlobalRef<jobject> success_callback,
+    ScopedJavaGlobalRef<jobject> failure_callback,
+    bool success,
+    std::vector<std::string> keys) {
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jobjectArray> j_keys = ToJavaArrayOfStrings(env, keys);
+
+  if (!success) {
+    RunObjectCallbackAndroid(failure_callback, nullptr);
+    return;
+  }
+  RunObjectCallbackAndroid(success_callback, j_keys);
+}
+
+void FeedContentBridge::OnStorageCommitDone(
+    ScopedJavaGlobalRef<jobject> callback,
+    bool success) {
+  RunBooleanCallbackAndroid(callback, success);
+}
+
 }  // namespace feed

chrome/browser/android/feed/feed_content_bridge.h

@@ -69,6 +69,19 @@ class FeedContentBridge {
                                 const base::android::JavaRef<jobject>& j_this);
 
  private:
+  void OnLoadContentDone(
+      base::android::ScopedJavaGlobalRef<jobject> success_callback,
+      base::android::ScopedJavaGlobalRef<jobject> failure_callback,
+      bool success,
+      std::vector<FeedContentDatabase::KeyAndData> pairs);
+  void OnLoadAllContentKeysDone(
+      base::android::ScopedJavaGlobalRef<jobject> success_callback,
+      base::android::ScopedJavaGlobalRef<jobject> failure_callback,
+      bool success,
+      std::vector<std::string> keys);
+  void OnStorageCommitDone(base::android::ScopedJavaGlobalRef<jobject> callback,
+                           bool success);
+
   // This unique_ptr will hold a list of ContentOperations which are not
   // committed yet. After commit to database, this unique_ptr will be reset.
   std::unique_ptr<ContentMutation> content_mutation_;

chrome/browser/android/feed/feed_journal_bridge.cc

@@ -34,58 +34,6 @@ using base::android::ScopedJavaLocalRef;
 using base::android::ToJavaArrayOfByteArray;
 using base::android::ToJavaArrayOfStrings;
 
-namespace {
-
-void OnLoadJournalDone(
-    base::android::ScopedJavaGlobalRef<jobject> success_callback,
-    base::android::ScopedJavaGlobalRef<jobject> failure_callback,
-    bool success,
-    std::vector<std::string> entries) {
-  JNIEnv* env = AttachCurrentThread();
-
-  if (success) {
-    RunObjectCallbackAndroid(success_callback,
-                             ToJavaArrayOfByteArray(env, entries));
-  } else {
-    RunObjectCallbackAndroid(failure_callback, nullptr);
-  }
-}
-
-void OnLoadJournalKeyDone(
-    base::android::ScopedJavaGlobalRef<jobject> success_callback,
-    base::android::ScopedJavaGlobalRef<jobject> failure_callback,
-    bool success,
-    std::vector<std::string> entries) {
-  JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jobjectArray> j_entries =
-      ToJavaArrayOfStrings(env, entries);
-
-  if (success) {
-    RunObjectCallbackAndroid(success_callback, j_entries);
-  } else {
-    RunObjectCallbackAndroid(failure_callback, nullptr);
-  }
-}
-
-void OnStorageCheckExistingCallbackDone(
-    ScopedJavaGlobalRef<jobject> success_callback,
-    ScopedJavaGlobalRef<jobject> failure_callback,
-    bool success,
-    bool exists) {
-  if (success) {
-    RunBooleanCallbackAndroid(success_callback, exists);
-  } else {
-    RunObjectCallbackAndroid(failure_callback, nullptr);
-  }
-}
-
-void OnStorageBooleanCallbackDone(ScopedJavaGlobalRef<jobject> callback,
-                                  bool exists) {
-  RunBooleanCallbackAndroid(callback, exists);
-}
-
-}  // namespace
-
 static jlong JNI_FeedJournalBridge_Init(
     JNIEnv* env,
     const JavaParamRef<jobject>& j_this,
@@ -115,89 +63,92 @@ void FeedJournalBridge::Destroy(JNIEnv* env, const JavaRef<jobject>& j_this) {
 
 void FeedJournalBridge::LoadJournal(
     JNIEnv* j_env,
-    const base::android::JavaRef<jobject>& j_this,
-    const base::android::JavaRef<jstring>& j_journal_name,
-    const base::android::JavaRef<jobject>& j_success_callback,
-    const base::android::JavaRef<jobject>& j_failure_callback) {
+    const JavaRef<jobject>& j_this,
+    const JavaRef<jstring>& j_journal_name,
+    const JavaRef<jobject>& j_success_callback,
+    const JavaRef<jobject>& j_failure_callback) {
   std::string journal_name = ConvertJavaStringToUTF8(j_env, j_journal_name);
   ScopedJavaGlobalRef<jobject> success_callback(j_success_callback);
   ScopedJavaGlobalRef<jobject> failure_callback(j_failure_callback);
 
   feed_journal_database_->LoadJournal(
-      journal_name,
-      base::BindOnce(&OnLoadJournalDone, success_callback, failure_callback));
+      journal_name, base::BindOnce(&FeedJournalBridge::OnLoadJournalDone,
+                                   weak_ptr_factory_.GetWeakPtr(),
+                                   success_callback, failure_callback));
 }
 
 void FeedJournalBridge::CommitJournalMutation(
     JNIEnv* j_env,
-    const base::android::JavaRef<jobject>& j_this,
-    const base::android::JavaRef<jobject>& j_callback) {
+    const JavaRef<jobject>& j_this,
+    const JavaRef<jobject>& j_callback) {
   DCHECK(journal_mutation_);
   ScopedJavaGlobalRef<jobject> callback(j_callback);
 
   feed_journal_database_->CommitJournalMutation(
       std::move(journal_mutation_),
-      base::BindOnce(&OnStorageBooleanCallbackDone, callback));
+      base::BindOnce(&FeedJournalBridge::OnStorageBooleanCallbackDone,
+                     weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void FeedJournalBridge::DoesJournalExist(
     JNIEnv* j_env,
-    const base::android::JavaRef<jobject>& j_this,
-    const base::android::JavaRef<jstring>& j_journal_name,
-    const base::android::JavaRef<jobject>& j_success_callback,
-    const base::android::JavaRef<jobject>& j_failure_callback) {
+    const JavaRef<jobject>& j_this,
+    const JavaRef<jstring>& j_journal_name,
+    const JavaRef<jobject>& j_success_callback,
+    const JavaRef<jobject>& j_failure_callback) {
   std::string journal_name = ConvertJavaStringToUTF8(j_env, j_journal_name);
   ScopedJavaGlobalRef<jobject> success_callback(j_success_callback);
   ScopedJavaGlobalRef<jobject> failure_callback(j_failure_callback);
 
   feed_journal_database_->DoesJournalExist(
-      journal_name, base::BindOnce(&OnStorageCheckExistingCallbackDone,
-                                   success_callback, failure_callback));
+      journal_name,
+      base::BindOnce(&FeedJournalBridge::OnStorageCheckExistingCallbackDone,
+                     weak_ptr_factory_.GetWeakPtr(), success_callback,
+                     failure_callback));
 }
 
 void FeedJournalBridge::LoadAllJournalKeys(
     JNIEnv* j_env,
-    const base::android::JavaRef<jobject>& j_this,
-    const base::android::JavaRef<jobject>& j_success_callback,
-    const base::android::JavaRef<jobject>& j_failure_callback) {
+    const JavaRef<jobject>& j_this,
+    const JavaRef<jobject>& j_success_callback,
+    const JavaRef<jobject>& j_failure_callback) {
   ScopedJavaGlobalRef<jobject> success_callback(j_success_callback);
   ScopedJavaGlobalRef<jobject> failure_callback(j_failure_callback);
 
   feed_journal_database_->LoadAllJournalKeys(base::BindOnce(
-      &OnLoadJournalKeyDone, success_callback, failure_callback));
+      &FeedJournalBridge::OnLoadJournalKeyDone, weak_ptr_factory_.GetWeakPtr(),
+      success_callback, failure_callback));
 }
 
-void FeedJournalBridge::DeleteAllJournals(
-    JNIEnv* j_env,
-    const base::android::JavaRef<jobject>& j_this,
-    const base::android::JavaRef<jobject>& j_callback) {
+void FeedJournalBridge::DeleteAllJournals(JNIEnv* j_env,
+                                          const JavaRef<jobject>& j_this,
+                                          const JavaRef<jobject>& j_callback) {
   ScopedJavaGlobalRef<jobject> callback(j_callback);
 
   feed_journal_database_->DeleteAllJournals(
-      base::BindOnce(&OnStorageBooleanCallbackDone, callback));
+      base::BindOnce(&FeedJournalBridge::OnStorageBooleanCallbackDone,
+                     weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void FeedJournalBridge::StartJournalMutation(
     JNIEnv* j_env,
-    const base::android::JavaRef<jobject>& j_this,
-    const base::android::JavaRef<jstring>& j_journal_name) {
+    const JavaRef<jobject>& j_this,
+    const JavaRef<jstring>& j_journal_name) {
   DCHECK(!journal_mutation_);
   std::string journal_name = ConvertJavaStringToUTF8(j_env, j_journal_name);
   journal_mutation_ =
       std::make_unique<JournalMutation>(std::move(journal_name));
 }
 
-void FeedJournalBridge::DeleteJournalMutation(
-    JNIEnv* j_env,
-    const base::android::JavaRef<jobject>& j_this) {
+void FeedJournalBridge::DeleteJournalMutation(JNIEnv* j_env,
+                                              const JavaRef<jobject>& j_this) {
   DCHECK(journal_mutation_);
   journal_mutation_.reset();
 }
 
-void FeedJournalBridge::AddAppendOperation(
-    JNIEnv* j_env,
-    const base::android::JavaRef<jobject>& j_this,
-    const base::android::JavaRef<jbyteArray>& j_value) {
+void FeedJournalBridge::AddAppendOperation(JNIEnv* j_env,
+                                           const JavaRef<jobject>& j_this,
+                                           const JavaRef<jbyteArray>& j_value) {
   DCHECK(journal_mutation_);
   std::vector<uint8_t> bytes_vector;
   JavaByteArrayToByteVector(j_env, j_value, &bytes_vector);
@@ -207,19 +158,67 @@ void FeedJournalBridge::AddAppendOperation(
 
 void FeedJournalBridge::AddCopyOperation(
     JNIEnv* j_env,
-    const base::android::JavaRef<jobject>& j_this,
-    const base::android::JavaRef<jstring>& j_to_journal_name) {
+    const JavaRef<jobject>& j_this,
+    const JavaRef<jstring>& j_to_journal_name) {
   DCHECK(journal_mutation_);
   std::string to_journal_name =
       ConvertJavaStringToUTF8(j_env, j_to_journal_name);
   journal_mutation_->AddCopyOperation(std::move(to_journal_name));
 }
 
-void FeedJournalBridge::AddDeleteOperation(
-    JNIEnv* j_env,
-    const base::android::JavaRef<jobject>& j_this) {
+void FeedJournalBridge::AddDeleteOperation(JNIEnv* j_env,
+                                           const JavaRef<jobject>& j_this) {
   DCHECK(journal_mutation_);
   journal_mutation_->AddDeleteOperation();
 }
 
+void FeedJournalBridge::OnLoadJournalDone(
+    ScopedJavaGlobalRef<jobject> success_callback,
+    ScopedJavaGlobalRef<jobject> failure_callback,
+    bool success,
+    std::vector<std::string> entries) {
+  JNIEnv* env = AttachCurrentThread();
+
+  if (success) {
+    RunObjectCallbackAndroid(success_callback,
+                             ToJavaArrayOfByteArray(env, entries));
+  } else {
+    RunObjectCallbackAndroid(failure_callback, nullptr);
+  }
+}
+
+void FeedJournalBridge::OnLoadJournalKeyDone(
+    ScopedJavaGlobalRef<jobject> success_callback,
+    ScopedJavaGlobalRef<jobject> failure_callback,
+    bool success,
+    std::vector<std::string> entries) {
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jobjectArray> j_entries =
+      ToJavaArrayOfStrings(env, entries);
+
+  if (success) {
+    RunObjectCallbackAndroid(success_callback, j_entries);
+  } else {
+    RunObjectCallbackAndroid(failure_callback, nullptr);
+  }
+}
+
+void FeedJournalBridge::OnStorageCheckExistingCallbackDone(
+    ScopedJavaGlobalRef<jobject> success_callback,
+    ScopedJavaGlobalRef<jobject> failure_callback,
+    bool success,
+    bool exists) {
+  if (success) {
+    RunBooleanCallbackAndroid(success_callback, exists);
+  } else {
+    RunObjectCallbackAndroid(failure_callback, nullptr);
+  }
+}
+
+void FeedJournalBridge::OnStorageBooleanCallbackDone(
+    ScopedJavaGlobalRef<jobject> callback,
+    bool exists) {
+  RunBooleanCallbackAndroid(callback, exists);
+}
+
 }  // namespace feed

chrome/browser/android/feed/feed_journal_bridge.h

@@ -73,6 +73,25 @@ class FeedJournalBridge {
                           const base::android::JavaRef<jobject>& j_this);
 
  private:
+  void OnLoadJournalDone(
+      base::android::ScopedJavaGlobalRef<jobject> success_callback,
+      base::android::ScopedJavaGlobalRef<jobject> failure_callback,
+      bool success,
+      std::vector<std::string> entries);
+  void OnLoadJournalKeyDone(
+      base::android::ScopedJavaGlobalRef<jobject> success_callback,
+      base::android::ScopedJavaGlobalRef<jobject> failure_callback,
+      bool success,
+      std::vector<std::string> entries);
+  void OnStorageCheckExistingCallbackDone(
+      base::android::ScopedJavaGlobalRef<jobject> success_callback,
+      base::android::ScopedJavaGlobalRef<jobject> failure_callback,
+      bool success,
+      bool exists);
+  void OnStorageBooleanCallbackDone(
+      base::android::ScopedJavaGlobalRef<jobject> callback,
+      bool exists);
+
   // This unique_ptr will hold a list of JournalOperations which are not
   // committed yet. After send |journal_mutation_| to database, this unique_ptr
   // will be reset.

chrome/browser/android/feed/feed_network_bridge.cc

@@ -5,7 +5,6 @@
 #include "chrome/browser/android/feed/feed_network_bridge.h"
 
 #include <utility>
-#include <vector>
 
 #include "base/android/callback_android.h"
 #include "base/android/jni_android.h"
@@ -27,23 +26,8 @@ using base::android::ScopedJavaGlobalRef;
 
 namespace feed {
 
-namespace {
-
-void OnResult(const ScopedJavaGlobalRef<jobject>& j_callback,
-              int32_t http_code,
-              std::vector<uint8_t> response_bytes) {
-  JNIEnv* env = base::android::AttachCurrentThread();
-  ScopedJavaLocalRef<jbyteArray> j_response_bytes =
-      base::android::ToJavaByteArray(env, response_bytes);
-  ScopedJavaLocalRef<jobject> j_http_response =
-      Java_FeedNetworkBridge_createHttpResponse(env, http_code,
-                                                j_response_bytes);
-  base::android::RunObjectCallbackAndroid(j_callback, j_http_response);
-}
-
-}  // namespace
-
-FeedNetworkBridge::FeedNetworkBridge(const JavaParamRef<jobject>& j_profile) {
+FeedNetworkBridge::FeedNetworkBridge(const JavaParamRef<jobject>& j_profile)
+    : weak_factory_(this) {
   Profile* profile = ProfileAndroid::FromProfileAndroid(j_profile);
   FeedHostService* host_service =
       FeedHostServiceFactory::GetForBrowserContext(profile);
@@ -51,6 +35,8 @@ FeedNetworkBridge::FeedNetworkBridge(const JavaParamRef<jobject>& j_profile) {
   DCHECK(networking_host_);
 }
 
+FeedNetworkBridge::~FeedNetworkBridge() = default;
+
 static jlong JNI_FeedNetworkBridge_Init(
     JNIEnv* env,
     const JavaParamRef<jobject>& j_this,
@@ -72,7 +58,8 @@ void FeedNetworkBridge::SendNetworkRequest(
     const JavaParamRef<jobject>& j_callback) {
   auto url = GURL(ConvertJavaStringToUTF8(env, j_url));
   FeedNetworkingHost::ResponseCallback callback =
-      base::BindOnce(&OnResult, ScopedJavaGlobalRef<jobject>(env, j_callback));
+      base::BindOnce(&FeedNetworkBridge::OnResult, weak_factory_.GetWeakPtr(),
+                     ScopedJavaGlobalRef<jobject>(env, j_callback));
   std::vector<uint8_t> request_body;
   base::android::JavaByteArrayToByteVector(env, j_body, &request_body);
 
@@ -80,4 +67,21 @@ void FeedNetworkBridge::SendNetworkRequest(
                          std::move(request_body), std::move(callback));
 }
 
+void FeedNetworkBridge::CancelRequests(JNIEnv* env,
+                                       const JavaParamRef<jobject>& j_this) {
+  networking_host_->CancelRequests();
+}
+
+void FeedNetworkBridge::OnResult(const ScopedJavaGlobalRef<jobject>& j_callback,
+                                 int32_t http_code,
+                                 std::vector<uint8_t> response_bytes) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  ScopedJavaLocalRef<jbyteArray> j_response_bytes =
+      base::android::ToJavaByteArray(env, response_bytes);
+  ScopedJavaLocalRef<jobject> j_http_response =
+      Java_FeedNetworkBridge_createHttpResponse(env, http_code,
+                                                j_response_bytes);
+  base::android::RunObjectCallbackAndroid(j_callback, j_http_response);
+}
+
 }  // namespace feed

chrome/browser/android/feed/feed_network_bridge.h

@@ -6,9 +6,11 @@
 #define CHROME_BROWSER_ANDROID_FEED_FEED_NETWORK_BRIDGE_H_
 
 #include <jni.h>
+#include <vector>
 
 #include "base/android/scoped_java_ref.h"
 #include "base/macros.h"
+#include "base/memory/weak_ptr.h"
 
 namespace feed {
 
@@ -22,6 +24,7 @@ class FeedNetworkBridge {
  public:
   explicit FeedNetworkBridge(
       const base::android::JavaParamRef<jobject>& j_profile);
+  ~FeedNetworkBridge();
 
   void Destroy(JNIEnv* env, const base::android::JavaParamRef<jobject>& j_this);
 
@@ -33,9 +36,18 @@ class FeedNetworkBridge {
       const base::android::JavaParamRef<jbyteArray>& j_body,
       const base::android::JavaParamRef<jobject>& j_callback);
 
+  void CancelRequests(JNIEnv* env,
+                      const base::android::JavaParamRef<jobject>& j_this);
+
  private:
+  void OnResult(const base::android::ScopedJavaGlobalRef<jobject>& j_callback,
+                int32_t http_code,
+                std::vector<uint8_t> response_bytes);
+
   FeedNetworkingHost* networking_host_;
 
+  base::WeakPtrFactory<FeedNetworkBridge> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(FeedNetworkBridge);
 };
 

chrome/browser/android/feed/feed_offline_bridge.cc

@@ -28,18 +28,6 @@ using base::android::ScopedJavaLocalRef;
 
 namespace feed {
 
-namespace {
-
-void OnGetOfflineStatus(ScopedJavaGlobalRef<jobject> callback,
-                        std::vector<std::string> urls) {
-  JNIEnv* env = base::android::AttachCurrentThread();
-  ScopedJavaLocalRef<jobjectArray> j_urls =
-      base::android::ToJavaArrayOfStrings(env, urls);
-  RunObjectCallbackAndroid(callback, j_urls);
-}
-
-}  // namespace
-
 static jlong JNI_FeedOfflineBridge_Init(
     JNIEnv* env,
     const JavaParamRef<jobject>& j_this,
@@ -90,7 +78,8 @@ void FeedOfflineBridge::GetOfflineStatus(JNIEnv* env,
   base::android::AppendJavaStringArrayToStringVector(env, j_urls, &urls);
   ScopedJavaGlobalRef<jobject> callback(j_callback);
   offline_host_->GetOfflineStatus(
-      std::move(urls), base::BindOnce(&OnGetOfflineStatus, callback));
+      std::move(urls), base::BindOnce(&FeedOfflineBridge::OnGetOfflineStatus,
+                                      weak_factory_.GetWeakPtr(), callback));
 }
 
 void FeedOfflineBridge::OnContentRemoved(
@@ -170,4 +159,13 @@ void FeedOfflineBridge::NotifyStatusChange(const std::string& url,
                                             available_offline);
 }
 
+void FeedOfflineBridge::OnGetOfflineStatus(
+    ScopedJavaGlobalRef<jobject> callback,
+    std::vector<std::string> urls) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  ScopedJavaLocalRef<jobjectArray> j_urls =
+      base::android::ToJavaArrayOfStrings(env, urls);
+  RunObjectCallbackAndroid(callback, j_urls);
+}
+
 }  // namespace feed

chrome/browser/android/feed/feed_offline_bridge.h

@@ -79,6 +79,9 @@ class FeedOfflineBridge {
   // call FeedOfflineHost::OnGetKnownContentDone() on async completion.
   void TriggerGetKnownContent();
 
+  void OnGetOfflineStatus(base::android::ScopedJavaGlobalRef<jobject> callback,
+                          std::vector<std::string> urls);
+
   // Reference to the Java half of this bridge. Always valid.
   base::android::ScopedJavaGlobalRef<jobject> j_this_;
 

chrome/browser/android/feed/feed_scheduler_bridge.cc

@@ -46,7 +46,7 @@ FeedSchedulerBridge::FeedSchedulerBridge(const JavaRef<jobject>& j_this,
                           weak_factory_.GetWeakPtr()));
 }
 
-FeedSchedulerBridge::~FeedSchedulerBridge() {}
+FeedSchedulerBridge::~FeedSchedulerBridge() = default;
 
 void FeedSchedulerBridge::Destroy(JNIEnv* env, const JavaRef<jobject>& j_this) {
   delete this;
@@ -86,9 +86,9 @@ void FeedSchedulerBridge::OnFixedTimer(
     JNIEnv* env,
     const JavaRef<jobject>& j_this,
     const base::android::JavaRef<jobject>& j_callback) {
-  base::OnceClosure callback =
-      base::BindOnce(&base::android::RunObjectCallbackAndroid,
-                     ScopedJavaGlobalRef<jobject>(j_callback), nullptr);
+  base::OnceClosure callback = base::BindOnce(
+      &FeedSchedulerBridge::FixedTimerHandlingDone, weak_factory_.GetWeakPtr(),
+      ScopedJavaGlobalRef<jobject>(j_callback));
   scheduler_host_->OnFixedTimer(std::move(callback));
 }
 
@@ -114,4 +114,9 @@ void FeedSchedulerBridge::CancelWakeUp() {
   Java_FeedSchedulerBridge_cancelWakeUp(env, j_this_);
 }
 
+void FeedSchedulerBridge::FixedTimerHandlingDone(
+    ScopedJavaGlobalRef<jobject> j_callback) {
+  base::android::RunObjectCallbackAndroid(j_callback, nullptr);
+}
+
 }  // namespace feed

chrome/browser/android/feed/feed_scheduler_bridge.h

@@ -68,6 +68,9 @@ class FeedSchedulerBridge {
   // Cancels previously scheduled background task.
   void CancelWakeUp();
 
+  void FixedTimerHandlingDone(
+      base::android::ScopedJavaGlobalRef<jobject> j_callback);
+
   // Reference to the Java half of this bridge. Always valid.
   base::android::ScopedJavaGlobalRef<jobject> j_this_;