[Offline Pages] Clear remaining requests after test harness finishes.

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

 // Copyright 2016 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/evaluation/offline_page_evaluation_bridge.h"
 
 #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/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
 #include "chrome/browser/android/offline_pages/background_scheduler_bridge.h"
 #include "chrome/browser/android/offline_pages/downloads/offline_page_notification_bridge.h"
 #include "chrome/browser/android/offline_pages/evaluation/evaluation_test_scheduler.h"
 #include "chrome/browser/android/offline_pages/offline_page_model_factory.h"
 #include "chrome/browser/android/offline_pages/prerendering_offliner_factory.h"
 #include "chrome/browser/android/offline_pages/request_coordinator_factory.h"
 #include "chrome/browser/net/nqe/ui_network_quality_estimator_service.h"
@@ skipping 53 matching lines @@
 ScopedJavaLocalRef<jobject> ToJavaSavePageRequest(
     JNIEnv* env,
     const SavePageRequest& request) {
   return Java_SavePageRequest_create(
       env, static_cast<int>(request.request_state()), request.request_id(),
       ConvertUTF8ToJavaString(env, request.url().spec()),
       ConvertUTF8ToJavaString(env, request.client_id().name_space),
       ConvertUTF8ToJavaString(env, request.client_id().id));
 }
 
+ScopedJavaLocalRef<jobjectArray> CreateJavaSavePageRequests(
+    JNIEnv* env,
+    std::vector<std::unique_ptr<SavePageRequest>> requests) {
+  ScopedJavaLocalRef<jclass> save_page_request_clazz = base::android::GetClass(
+      env, "org/chromium/chrome/browser/offlinepages/SavePageRequest");
+  jobjectArray joa = env->NewObjectArray(
+      requests.size(), save_page_request_clazz.obj(), nullptr);
+  base::android::CheckException(env);
+
+  for (size_t i = 0; i < requests.size(); i++) {
+    SavePageRequest request = *(requests[i]);
+    ScopedJavaLocalRef<jobject> j_save_page_request =
+        ToJavaSavePageRequest(env, request);
+    env->SetObjectArrayElement(joa, i, j_save_page_request.obj());
+  }
+
+  return ScopedJavaLocalRef<jobjectArray>(env, joa);
+}
+
 void GetAllPagesCallback(
     const ScopedJavaGlobalRef<jobject>& j_result_obj,
     const ScopedJavaGlobalRef<jobject>& j_callback_obj,
     const OfflinePageModel::MultipleOfflinePageItemResult& result) {
   JNIEnv* env = base::android::AttachCurrentThread();
   ToJavaOfflinePageList(env, j_result_obj.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);
 }
 
+void OnGetAllRequestsDone(
+    const ScopedJavaGlobalRef<jobject>& j_callback_obj,
+    std::vector<std::unique_ptr<SavePageRequest>> all_requests) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+
+  ScopedJavaLocalRef<jobjectArray> j_result_obj =
+      CreateJavaSavePageRequests(env, std::move(all_requests));
+  base::android::RunCallbackAndroid(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()));
+}
 }  // namespace
 
 static ScopedJavaLocalRef<jobject> GetBridgeForProfile(
     JNIEnv* env,
     const JavaParamRef<jclass>& jcaller,
     const JavaParamRef<jobject>& j_profile,
     const jboolean j_use_evaluation_scheduler) {
   Profile* profile = ProfileAndroid::FromProfileAndroid(j_profile);
 
   OfflinePageModel* offline_page_model =
@@ skipping 168 matching lines @@
   offline_pages::ClientId client_id;
   client_id.name_space = ConvertJavaStringToUTF8(env, j_namespace);
   client_id.id = ConvertJavaStringToUTF8(env, j_client_id);
 
   request_coordinator_->SavePageLater(
       GURL(ConvertJavaStringToUTF8(env, j_url)), client_id,
       static_cast<bool>(user_requested),
       RequestCoordinator::RequestAvailability::ENABLED_FOR_OFFLINER);
 }
 
+void OfflinePageEvaluationBridge::GetRequestsInQueue(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jobject>& j_callback_obj) {
+  ScopedJavaGlobalRef<jobject> j_callback_ref(j_callback_obj);
+  request_coordinator_->GetAllRequests(
+      base::Bind(&OnGetAllRequestsDone, j_callback_ref));
+}
+
+void OfflinePageEvaluationBridge::RemoveRequestsFromQueue(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jlongArray>& j_request_ids,
+    const JavaParamRef<jobject>& j_callback_obj) {
+  std::vector<int64_t> request_ids;
+  base::android::JavaLongArrayToInt64Vector(env, j_request_ids, &request_ids);
+  ScopedJavaGlobalRef<jobject> j_callback_ref(j_callback_obj);
+  request_coordinator_->RemoveRequests(
+      request_ids, base::Bind(&OnRemoveRequestsDone, j_callback_ref));
+}
+
 void OfflinePageEvaluationBridge::NotifyIfDoneLoading() const {
   if (!offline_page_model_->is_loaded())
     return;
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_OfflinePageEvaluationBridge_offlinePageModelLoaded(env, java_ref_);
 }
 
 }  // namespace android
 }  // namespace offline_pages