Ask download manager to remove a download if it is overwritten by another

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"
@@ skipping 26 matching lines @@
                     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 &&

[Theresa, 2016/09/21 17:40:43]

Is it possible to interleave downloading items with the same path e.g. download
really_big_video.mp4 3x in a row, overwriting each time. I'm wondering if it's
possible that checking DownloadItem::COMPLETE will leave pending downloads that
all reference the same path?

[qinmin, 2016/09/21 21:20:29]

If a download starts (or resumes) with the same target path as another ongoing
download, the new comer will fail.
So multiple ongoing downloads cannot have the same target path.

+        item->GetTargetFilePath() == path) {
+      item->Remove();
+    }
+  }
+}
+
 }  // 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 jlong Init(JNIEnv* env, const JavaParamRef<jobject>& jobj) {
   Profile* profile = ProfileManager::GetActiveUserProfile();
-  DownloadManagerService* service =
-      new DownloadManagerService(env, jobj);
+  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);
 }
 
-DownloadManagerService::DownloadManagerService(
+DownloadManagerService::DownloadManagerService()
+    : is_history_query_complete_(false) {
+}
+
+DownloadManagerService::~DownloadManagerService() {}
+
+void DownloadManagerService::Init(
     JNIEnv* env,
-    jobject obj)
-    : java_ref_(env, obj),
-      is_history_query_complete_(false) {
+    jobject obj) {
+  java_ref_.Reset(env, obj);
   DownloadControllerBase::Get()->SetDefaultDownloadFileName(
       l10n_util::GetStringUTF8(IDS_DEFAULT_DOWNLOAD_FILENAME));
 }
 
-DownloadManagerService::~DownloadManagerService() {}
-
 void DownloadManagerService::ResumeDownload(
     JNIEnv* env,
     jobject obj,
     const JavaParamRef<jstring>& jdownload_guid,
     bool is_off_the_record) {
   std::string download_guid = ConvertJavaStringToUTF8(env, jdownload_guid);
   if (is_history_query_complete_ || is_off_the_record)
     ResumeDownloadInternal(download_guid, is_off_the_record);
   else
     EnqueueDownloadAction(download_guid, RESUME);
@@ skipping 76 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::RemoveExternallyRemovedDownloads(
+    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 191 matching lines @@
   content::DownloadManager* manager =
       content::BrowserContext::GetDownloadManager(profile);
 
   // Update notifiers to monitor any newly created DownloadManagers.
   updateNotifier(
       this, manager,
       is_off_the_record ? off_the_record_notifier_ : original_notifier_);
 
   return manager;
 }