[Downloads] Consolidate Java DownloadItem/Info creation

chrome/browser/android/download/download_manager_service.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/download/download_manager_service.h"
 
 #include "base/android/jni_string.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/android/download/download_controller.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/mime_util/mime_util.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/download_item.h"
+#include "jni/DownloadInfo_jni.h"
+#include "jni/DownloadItem_jni.h"
 #include "jni/DownloadManagerService_jni.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using base::android::JavaParamRef;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ScopedJavaLocalRef;
 
 namespace {
 
 bool ShouldShowDownloadItem(content::DownloadItem* item) {
   return !item->IsTemporary();
 }
 
 void UpdateNotifier(DownloadManagerService* service,
                     content::DownloadManager* manager,
                     std::unique_ptr<AllDownloadItemNotifier>& notifier) {
   if (manager) {
     if (!notifier || notifier->GetManager() != manager)
       notifier.reset(new AllDownloadItemNotifier(manager, service));
   } else {
     notifier.reset(nullptr);
   }
 }
 
-void RemoveDownloadsFromDownloadManager(
-    content::DownloadManager* manager,
-    const base::FilePath& path) {
-  if (!manager)
-    return;
-  content::DownloadManager::DownloadVector all_items;
-  manager->GetAllDownloads(&all_items);
-
-  for (size_t i = 0; i < all_items.size(); i++) {
-    content::DownloadItem* item = all_items[i];
-    if (item->GetState() == content::DownloadItem::COMPLETE &&
-        item->GetTargetFilePath() == path) {
-      item->Remove();
-    }
-  }
-}
-
 ScopedJavaLocalRef<jobject> CreateJavaDownloadItem(
     JNIEnv* env, content::DownloadItem* item) {
-  return Java_DownloadManagerService_createDownloadItem(
-      env,
-      ConvertUTF8ToJavaString(env, item->GetGuid()),
-      ConvertUTF8ToJavaString(env,
-                              item->GetFileNameToReportUser().value()),
-      ConvertUTF8ToJavaString(env, item->GetTargetFilePath().value()),
-      ConvertUTF8ToJavaString(env, item->GetTabUrl().spec()),
-      ConvertUTF8ToJavaString(env, item->GetMimeType()),
-      item->GetStartTime().ToJavaTime(), item->GetTotalBytes(),
-      item->GetFileExternallyRemoved(),
-      item->GetBrowserContext()->IsOffTheRecord(),
-      item->GetState(),
-      item->PercentComplete(),
-      item->IsPaused());
+  return Java_DownloadItem_createDownloadItem(
+      env, DownloadManagerService::CreateJavaDownloadInfo(env, item),
+      item->GetStartTime().ToJavaTime(), item->GetFileExternallyRemoved());
 }
 
 }  // namespace
 
 // static
 bool DownloadManagerService::RegisterDownloadManagerService(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 // static
 void DownloadManagerService::OnDownloadCanceled(
     content::DownloadItem* download,
     DownloadController::DownloadCancelReason reason) {
   bool has_no_external_storage =
       (reason == DownloadController::CANCEL_REASON_NO_EXTERNAL_STORAGE);
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jstring> jname =
       ConvertUTF8ToJavaString(env, download->GetURL().ExtractFileName());
   Java_DownloadManagerService_onDownloadItemCanceled(env, jname,
                                                      has_no_external_storage);
   DownloadController::RecordDownloadCancelReason(reason);
 }
 
 // static
 DownloadManagerService* DownloadManagerService::GetInstance() {
   return base::Singleton<DownloadManagerService>::get();
 }
 
+// static
+ScopedJavaLocalRef<jobject> DownloadManagerService::CreateJavaDownloadInfo(
+    JNIEnv* env, content::DownloadItem* item) {
+  ui::PageTransition base_transition =
+      ui::PageTransitionStripQualifier(item->GetTransitionType());
+  bool user_initiated =
+      (item->GetTransitionType() & ui::PAGE_TRANSITION_FROM_ADDRESS_BAR) ||
+      base_transition == ui::PAGE_TRANSITION_TYPED ||
+      base_transition == ui::PAGE_TRANSITION_AUTO_BOOKMARK ||
+      base_transition == ui::PAGE_TRANSITION_GENERATED ||
+      base_transition == ui::PAGE_TRANSITION_RELOAD ||
+      base_transition == ui::PAGE_TRANSITION_KEYWORD;
+  bool has_user_gesture = item->HasUserGesture() || user_initiated;
+
+  base::TimeDelta time_delta;
+  item->TimeRemaining(&time_delta);
+
+  return Java_DownloadInfo_createDownloadInfo(
+      env,
+      ConvertUTF8ToJavaString(env, item->GetGuid()),
+      ConvertUTF8ToJavaString(env,
+                              item->GetFileNameToReportUser().value()),
+      ConvertUTF8ToJavaString(env, item->GetTargetFilePath().value()),
+      ConvertUTF8ToJavaString(env, item->GetTabUrl().spec()),
+      ConvertUTF8ToJavaString(env, item->GetMimeType()),
+      item->GetReceivedBytes(),
+      item->GetBrowserContext()->IsOffTheRecord(),
+      item->GetState(),
+      item->PercentComplete(),
+      item->IsPaused(),
+      has_user_gesture,
+      item->CanResume(),
+      ConvertUTF8ToJavaString(env, item->GetOriginalUrl().spec()),
+      ConvertUTF8ToJavaString(env, item->GetReferrerUrl().spec()),
+      time_delta.InMilliseconds());
+}
+
 static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& jobj) {
   Profile* profile = ProfileManager::GetActiveUserProfile();
   DownloadManagerService* service = DownloadManagerService::GetInstance();
   service->Init(env, jobj);
   DownloadService* download_service =
       DownloadServiceFactory::GetForBrowserContext(profile);
   DownloadHistory* history = download_service->GetDownloadHistory();
   if (history)
     history->AddObserver(service);
   return reinterpret_cast<intptr_t>(service);
@@ skipping 95 matching lines @@
   // requests to check for externally removed downloads.
   if (!is_history_query_complete_)
     return;
 
   content::DownloadManager* manager = GetDownloadManager(is_off_the_record);
   if (!manager)
     return;
   manager->CheckForHistoryFilesRemoval();
 }
 
-void DownloadManagerService::RemoveDownloadsForPath(
-    const base::FilePath& path) {
-  content::DownloadManager* manager = GetDownloadManager(false);
-  RemoveDownloadsFromDownloadManager(manager, path);
-  manager = GetDownloadManager(true);
-  RemoveDownloadsFromDownloadManager(manager, path);
-}
-
 void DownloadManagerService::CancelDownload(
     JNIEnv* env,
     jobject obj,
     const JavaParamRef<jstring>& jdownload_guid,
     bool is_off_the_record,
     bool is_notification_dismissed) {
   std::string download_guid = ConvertJavaStringToUTF8(env, jdownload_guid);
   DownloadController::RecordDownloadCancelReason(
       is_notification_dismissed ?
           DownloadController::CANCEL_REASON_NOTIFICATION_DISMISSED :
@@ skipping 198 matching lines @@
 }
 
 // static
 jboolean IsSupportedMimeType(
     JNIEnv* env,
     const JavaParamRef<jclass>& clazz,
     const JavaParamRef<jstring>& jmime_type) {
   std::string mime_type = ConvertJavaStringToUTF8(env, jmime_type);
   return mime_util::IsSupportedMimeType(mime_type);
 }