Adds request queue removal capability to OfflinePageBridge.

chrome/browser/android/offline_pages/offline_page_bridge.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/android/offline_pages/offline_page_bridge.h"
 
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/android/callback_android.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "chrome/browser/android/offline_pages/offline_page_mhtml_archiver.h"
 #include "chrome/browser/android/offline_pages/offline_page_model_factory.h"
 #include "chrome/browser/android/offline_pages/offline_page_utils.h"
 #include "chrome/browser/android/offline_pages/request_coordinator_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_android.h"
 #include "components/offline_pages/background/request_coordinator.h"
+#include "components/offline_pages/background/request_queue.h"
 #include "components/offline_pages/background/save_page_request.h"
 #include "components/offline_pages/offline_page_feature.h"
 #include "components/offline_pages/offline_page_item.h"
 #include "components/offline_pages/offline_page_model.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/web_contents.h"
 #include "jni/OfflinePageBridge_jni.h"
 #include "jni/SavePageRequest_jni.h"
 #include "net/base/filename_util.h"
 
@@ skipping 128 matching lines @@
 
 void OnGetAllRequestsDone(const ScopedJavaGlobalRef<jobject>& j_callback_obj,
                           const std::vector<SavePageRequest>& all_requests) {
   JNIEnv* env = base::android::AttachCurrentThread();
 
   ScopedJavaLocalRef<jobjectArray> j_result_obj =
       CreateJavaSavePageRequests(env, all_requests);
   base::android::RunCallbackAndroid(j_callback_obj, j_result_obj);
 }
 
+void OnRemoveRequestsDone(
+    const ScopedJavaGlobalRef<jobject>& j_callback_obj,
+    const RequestQueue::UpdateMultipleRequestResults& removed_request_results) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+
+  std::vector<int> update_request_results;
+  std::vector<int64_t> update_request_ids;
+
+  for (std::pair<int64_t, RequestQueue::UpdateRequestResult> remove_result :
+       removed_request_results) {
+    update_request_ids.emplace_back(std::get<0>(remove_result));
+    update_request_results.emplace_back(
+        static_cast<int>(std::get<1>(remove_result)));
+  }
+
+  ScopedJavaLocalRef<jlongArray> j_result_ids =
+      base::android::ToJavaLongArray(env, update_request_ids);
+  ScopedJavaLocalRef<jintArray> j_result_codes =
+      base::android::ToJavaIntArray(env, update_request_results);
+
+  Java_RequestsRemovedCallback_onResult(env, j_callback_obj, j_result_ids,
+                                        j_result_codes);
+}
+
 }  // namespace
 
 static jboolean IsOfflinePagesEnabled(JNIEnv* env,
                                           const JavaParamRef<jclass>& clazz) {
   return offline_pages::IsOfflinePagesEnabled();
 }
 
 static jboolean IsOfflineBookmarksEnabled(JNIEnv* env,
                                           const JavaParamRef<jclass>& clazz) {
   return offline_pages::IsOfflineBookmarksEnabled();
@@ skipping 283 matching lines @@
     // Callback with null to signal that results are unavailable.
     const JavaParamRef<jobject> empty_result(nullptr);
     base::android::RunCallbackAndroid(j_callback_obj, empty_result);
     return;
   }
 
   coordinator->GetAllRequests(
       base::Bind(&OnGetAllRequestsDone, j_callback_ref));
 }
 
+void OfflinePageBridge::RemoveRequestsFromQueue(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jlongArray>& j_request_ids_array,
+    const JavaParamRef<jobject>& j_callback_obj) {
+  std::vector<int64_t> request_ids;
+  base::android::JavaLongArrayToInt64Vector(env, j_request_ids_array,
+                                            &request_ids);
+  ScopedJavaGlobalRef<jobject> j_callback_ref(j_callback_obj);
+
+  RequestCoordinator* coordinator =
+      offline_pages::RequestCoordinatorFactory::GetInstance()
+          ->GetForBrowserContext(browser_context_);
+
+  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);
+    return;
+  }
+
+  coordinator->RemoveRequests(
+      request_ids, base::Bind(&OnRemoveRequestsDone, j_callback_ref));
+}
+
 void OfflinePageBridge::NotifyIfDoneLoading() const {
   if (!offline_page_model_->is_loaded())
     return;
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_OfflinePageBridge_offlinePageModelLoaded(env, java_ref_);
 }
 
 
 ScopedJavaLocalRef<jobject> OfflinePageBridge::CreateClientId(
     JNIEnv* env,
     const ClientId& client_id) const {
   return Java_OfflinePageBridge_createClientId(
       env, ConvertUTF8ToJavaString(env, client_id.name_space),
       ConvertUTF8ToJavaString(env, client_id.id));
 }
 
 bool RegisterOfflinePageBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace android
 }  // namespace offline_pages