[Offline pages] Hooking up cancel/pause/resume buttons for offline page related notifications

chrome/browser/android/offline_pages/downloads/offline_page_download_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/downloads/offline_page_download_bridge.h"
 
 #include <vector>
 
 #include "base/android/jni_string.h"
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/guid.h"
+#include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/android/offline_pages/downloads/offline_page_notification_bridge.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/request_coordinator_factory.h"
 #include "chrome/browser/android/tab_android.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/client_namespace_constants.h"
 #include "components/offline_pages/downloads/download_ui_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/OfflinePageDownloadBridge_jni.h"
 #include "net/base/filename_util.h"
 #include "url/gurl.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ConvertUTF16ToJavaString;
 using base::android::JavaParamRef;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
 
 namespace offline_pages {
 namespace android {
 
 namespace {
 
+using RequestContinuationCallback =
+    base::Callback<void(const std::vector<int64_t>&)>;
+
 void ToJavaOfflinePageDownloadItemList(
     JNIEnv* env,
     jobject j_result_obj,
     const std::vector<const DownloadUIItem*>& items) {
   for (const auto item : items) {
     Java_OfflinePageDownloadBridge_createDownloadItemAndAddToList(
         env, j_result_obj, ConvertUTF8ToJavaString(env, item->guid),
         ConvertUTF8ToJavaString(env, item->url.spec()),
         ConvertUTF16ToJavaString(env, item->title),
         ConvertUTF8ToJavaString(env, item->target_path.value()),
         item->start_time.ToJavaTime(), item->total_bytes);
   }
 }
 
 ScopedJavaLocalRef<jobject> ToJavaOfflinePageDownloadItem(
     JNIEnv* env,
     const DownloadUIItem& item) {
   return Java_OfflinePageDownloadBridge_createDownloadItem(
       env, ConvertUTF8ToJavaString(env, item.guid),
       ConvertUTF8ToJavaString(env, item.url.spec()),
       ConvertUTF16ToJavaString(env, item.title),
       ConvertUTF8ToJavaString(env, item.target_path.value()),
       item.start_time.ToJavaTime(), item.total_bytes);
 }
+
+void FilterRequestsByGuid(const std::string& guid,
+                          const RequestContinuationCallback& callback,

[dewittj, 2016/08/25 17:26:57]

Using a callback here is fancy but maybe less readable than just calling
FitlerRequestsByGuid directly inside the continuation functions.

[fgorski, 2016/08/25 18:09:01]

Done.

+                          const std::vector<SavePageRequest>& requests) {
+  std::vector<int64_t> request_ids;
+  for (const SavePageRequest& request : requests) {
+    if (request.client_id().id == guid &&
+        (request.client_id().name_space == kDownloadNamespace ||

[dewittj, 2016/08/25 17:26:57]

Any chance you can make a function NamespaceIsUsedForDownloads (or similar) in
the client_namespace_constants file so that anyone adding a namespace knows
whether to consider this case?

[fgorski, 2016/08/25 18:09:01]

Good idea, but I'd rather have it in separate patch. We might have more of cases
like that around the code.

crbug.com/641053

+         request.client_id().name_space == kAsyncNamespace)) {
+      request_ids.push_back(request.request_id());
+    }
+  }
+  callback.Run(request_ids);
+}
+
+void CancelRequestCallback(const RequestQueue::UpdateMultipleRequestResults&) {
+  // Results ignored here, as UI uses observer to update itself.
+}
+
+void CancelRequestsContinuation(RequestCoordinator* coordinator,

[dewittj, 2016/08/25 17:26:57]

As we discussed offline, I'd recommend passing a BrowserContext* here and using
RequestCoordinatorFactory just as a way to ensure that there aren't any
ReqeustCoordinator lifetime issues.

[fgorski, 2016/08/25 18:09:01]

Done.

+                                const std::vector<int64_t>& request_ids) {
+  coordinator->RemoveRequests(request_ids, base::Bind(&CancelRequestCallback));
+}
+
+void PauseRequestsContinuation(RequestCoordinator* coordinator,
+                               const std::vector<int64_t>& request_ids) {
+  coordinator->PauseRequests(request_ids);
+}
+
+void ResumeRequestsContinuation(RequestCoordinator* coordinator,
+                                const std::vector<int64_t>& request_ids) {
+  coordinator->ResumeRequests(request_ids);
+}
+
 }  // namespace
 
 OfflinePageDownloadBridge::OfflinePageDownloadBridge(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
-    DownloadUIAdapter* download_ui_adapter)
+    DownloadUIAdapter* download_ui_adapter,
+    content::BrowserContext* browser_context)
     : weak_java_ref_(env, obj),
-      download_ui_adapter_(download_ui_adapter) {
+      download_ui_adapter_(download_ui_adapter),
+      browser_context_(browser_context) {
   DCHECK(download_ui_adapter_);
   download_ui_adapter_->AddObserver(this);
 }
 
 OfflinePageDownloadBridge::~OfflinePageDownloadBridge() {}
 
 // static
 bool OfflinePageDownloadBridge::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
@@ skipping 62 matching lines @@
   TabAndroid* tab = TabAndroid::GetNativeTab(env, j_tab);
   if (!tab)
     return;
 
   content::WebContents* web_contents = tab->web_contents();
   if (!web_contents)
     return;
 
   offline_pages::OfflinePageModel* offline_page_model =
       OfflinePageModelFactory::GetForBrowserContext(
-      tab->GetProfile()->GetOriginalProfile());
+          tab->GetProfile()->GetOriginalProfile());
   if (!offline_page_model)
     return;
 
   GURL url = web_contents->GetLastCommittedURL();
   auto archiver =
       base::MakeUnique<offline_pages::OfflinePageMHTMLArchiver>(web_contents);
 
   offline_pages::ClientId client_id;
   client_id.name_space = offline_pages::kDownloadNamespace;
   client_id.id = base::GenerateGUID();
 
   DownloadUIItem item;
   item.guid = client_id.id;
   item.url = url;
 
   OfflinePageNotificationBridge bridge;
   bridge.NotifyDownloadProgress(item);
 
   offline_page_model->SavePage(
       url, client_id, 0ul, std::move(archiver),
       base::Bind(&OfflinePageDownloadBridge::SavePageCallback, item));
 }
 
+void OfflinePageDownloadBridge::CancelDownload(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jstring>& j_guid) {
+  std::string guid = ConvertJavaStringToUTF8(env, j_guid);
+  RequestCoordinator* request_coordinator =
+      RequestCoordinatorFactory::GetForBrowserContext(browser_context_);
+
+  request_coordinator->GetAllRequests(
+      base::Bind(&FilterRequestsByGuid, guid,
+                 base::Bind(&CancelRequestsContinuation, request_coordinator)));
+}
+
+void OfflinePageDownloadBridge::PauseDownload(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jstring>& j_guid) {
+  std::string guid = ConvertJavaStringToUTF8(env, j_guid);
+  RequestCoordinator* request_coordinator =
+      RequestCoordinatorFactory::GetForBrowserContext(browser_context_);
+
+  request_coordinator->GetAllRequests(
+      base::Bind(&FilterRequestsByGuid, guid,
+                 base::Bind(&PauseRequestsContinuation, request_coordinator)));
+}
+
+void OfflinePageDownloadBridge::ResumeDownload(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jstring>& j_guid) {
+  std::string guid = ConvertJavaStringToUTF8(env, j_guid);
+  RequestCoordinator* request_coordinator =
+      RequestCoordinatorFactory::GetForBrowserContext(browser_context_);
+
+  request_coordinator->GetAllRequests(
+      base::Bind(&FilterRequestsByGuid, guid,
+                 base::Bind(&ResumeRequestsContinuation, request_coordinator)));
+}
+
 void OfflinePageDownloadBridge::ItemsLoaded() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = weak_java_ref_.get(env);
   if (obj.is_null())
     return;
   Java_OfflinePageDownloadBridge_downloadItemsLoaded(env, obj);
 }
 
 void OfflinePageDownloadBridge::ItemAdded(const DownloadUIItem& item) {
   JNIEnv* env = AttachCurrentThread();
@@ skipping 18 matching lines @@
   ScopedJavaLocalRef<jobject> obj = weak_java_ref_.get(env);
   if (obj.is_null())
     return;
   Java_OfflinePageDownloadBridge_downloadItemUpdated(
       env, obj, ToJavaOfflinePageDownloadItem(env, item));
 }
 
 static jlong Init(JNIEnv* env,
                   const JavaParamRef<jobject>& obj,
                   const JavaParamRef<jobject>& j_profile) {
-  Profile* profile = ProfileAndroid::FromProfileAndroid(j_profile);
+  content::BrowserContext* browser_context =
+      ProfileAndroid::FromProfileAndroid(j_profile);
+
   OfflinePageModel* offline_page_model =
-      OfflinePageModelFactory::GetForBrowserContext(profile);
+      OfflinePageModelFactory::GetForBrowserContext(browser_context);
 
   DownloadUIAdapter* adapter =
       DownloadUIAdapter::FromOfflinePageModel(offline_page_model);
 
   return reinterpret_cast<jlong>(
-      new OfflinePageDownloadBridge(env, obj, adapter));
+      new OfflinePageDownloadBridge(env, obj, adapter, browser_context));
 }
 
 }  // namespace android
 }  // namespace offline_pages