Preliminary work on resuming downloads whose connections have expired.

chrome/browser/download/download_manager.cc

 // Copyright (c) 2010 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/download/download_manager.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/callback.h"
 #include "base/file_util.h"
@@ skipping 57 matching lines @@
 
   if (file_manager_) {
     ChromeThread::PostTask(ChromeThread::FILE, FROM_HERE,
         NewRunnableMethod(file_manager_,
                           &DownloadFileManager::OnDownloadManagerShutdown,
                           this));
   }
 
   // 'in_progress_' may contain DownloadItems that have not finished the start
   // complete (from the history service) and thus aren't in downloads_.
+  // It may also contain DownloadItems that have been interrupted.
   DownloadMap::iterator it = in_progress_.begin();
   std::set<DownloadItem*> to_remove;
   for (; it != in_progress_.end(); ++it) {
     DownloadItem* download = it->second;
     if (download->safety_state() == DownloadItem::DANGEROUS) {
       // Forget about any download that the user did not approve.
       // Note that we cannot call download->Remove() this would invalidate our
       // iterator.
       to_remove.insert(download);
       continue;
     }
-    DCHECK_EQ(DownloadItem::IN_PROGRESS, download->state());
+    DCHECK(download->IsPartialDownload());
     download->Cancel(false);
     download_history_->UpdateEntry(download);
     if (download->db_handle() == DownloadHistory::kUninitializedHandle) {
       // An invalid handle means that 'download' does not yet exist in
       // 'downloads_', so we have to delete it here.
       delete download;
     }
   }
 
   // 'dangerous_finished_' contains all complete downloads that have not been
@@ skipping 61 matching lines @@
   }
 }
 
 void DownloadManager::GetCurrentDownloads(
     const FilePath& dir_path, std::vector<DownloadItem*>* result) {
   DCHECK(result);
 
   for (DownloadMap::iterator it = downloads_.begin();
        it != downloads_.end(); ++it) {
     if (!it->second->is_temporary() &&
-        (it->second->state() == DownloadItem::IN_PROGRESS ||
-         it->second->safety_state() == DownloadItem::DANGEROUS) &&
-        (dir_path.empty() || it->second->full_path().DirName() == dir_path))
+        (it->second->IsPartialDownload() ||
+            (it->second->safety_state() == DownloadItem::DANGEROUS)) &&
+        (dir_path.empty() ||
+            (it->second->full_path().DirName() == dir_path))) {
       result->push_back(it->second);
+    }
   }
 }
 
 void DownloadManager::SearchDownloads(const string16& query,
                                       std::vector<DownloadItem*>* result) {
   DCHECK(result);
 
   string16 query_lower(l10n_util::ToLower(query));
 
   for (DownloadMap::iterator it = downloads_.begin();
@@ skipping 109 matching lines @@
     else if (info->is_extension_install &&
              !ExtensionsService::IsDownloadFromGallery(info->url,
                                                        info->referrer_url)) {
       info->is_dangerous = true;
     }
   }
 
   // We need to move over to the download thread because we don't want to stat
   // the suggested path on the UI thread.
   ChromeThread::PostTask(
-      ChromeThread::FILE, FROM_HERE,
+      ChromeThread::FILE,
+      FROM_HERE,
       NewRunnableMethod(
           this, &DownloadManager::CheckIfSuggestedPathExists, info));
 }
 
 void DownloadManager::CheckIfSuggestedPathExists(DownloadCreateInfo* info) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
   DCHECK(info);
 
   // Check writability of the suggested path. If we can't write to it, default
   // to the user's "My Documents" directory. We'll prompt them in this case.
@@ skipping 46 matching lines @@
   if (!info->prompt_user_for_save_location &&
       info->save_info.file_path.empty()) {
     if (info->is_dangerous)
       file_util::WriteFile(info->suggested_path, "", 0);
     else
       file_util::WriteFile(download_util::GetCrDownloadPath(
           info->suggested_path), "", 0);
   }
 
   ChromeThread::PostTask(
-      ChromeThread::UI, FROM_HERE,
+      ChromeThread::UI,
+      FROM_HERE,
       NewRunnableMethod(this,
                         &DownloadManager::OnPathExistenceAvailable,
                         info));
 }
 
 void DownloadManager::OnPathExistenceAvailable(DownloadCreateInfo* info) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   DCHECK(info);
 
   if (info->prompt_user_for_save_location) {
@@ skipping 22 matching lines @@
   }
 }
 
 void DownloadManager::CreateDownloadItem(DownloadCreateInfo* info,
                                          const FilePath& target_path) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
   scoped_ptr<DownloadCreateInfo> infop(info);
   info->path = target_path;
 
-  DownloadItem* download = new DownloadItem(this, *info,
-                                            profile_->IsOffTheRecord());
-  DCHECK(!ContainsKey(in_progress_, info->download_id));
-  in_progress_[info->download_id] = download;
+  DownloadItem* download = NULL;
+  // For partial downloads, reuse the existing DownloadItem.
+  if (info->is_partial_download && (info->download_id != -1)) {
+    DownloadMap::iterator it = in_progress_.find(info->download_id);
+    if (it != in_progress_.end()) {
+      download = it->second;
+      download->Resumed(info->request_id);
+    }
+  }
+  if (!download) {
+    download = new DownloadItem(this, *info, profile_->IsOffTheRecord());
+    DCHECK(!ContainsKey(in_progress_, info->download_id));
+    in_progress_[info->download_id] = download;
+  }
 
   bool download_finished = ContainsKey(pending_finished_downloads_,
                                        info->download_id);
 
   if (download_finished || info->is_dangerous) {
     // The download has already finished or the download is not safe.
     // We can now rename the file to its final name (or its tentative name
     // in dangerous download cases).
     ChromeThread::PostTask(
-        ChromeThread::FILE, FROM_HERE,
+        ChromeThread::FILE,
+        FROM_HERE,
         NewRunnableMethod(
             file_manager_, &DownloadFileManager::OnFinalDownloadName,
             download->id(), target_path, !info->is_dangerous, this));
   } else {
     // The download hasn't finished and it is a safe download.  We need to
     // rename it to its intermediate '.crdownload' path.
     FilePath download_path = download_util::GetCrDownloadPath(target_path);
     ChromeThread::PostTask(
-        ChromeThread::FILE, FROM_HERE,
+        ChromeThread::FILE,
+        FROM_HERE,
         NewRunnableMethod(
             file_manager_, &DownloadFileManager::OnIntermediateDownloadName,
             download->id(), download_path, this));
     download->set_need_final_rename(true);
   }
 
   if (download_finished) {
     // If the download already completed by the time we reached this point, then
     // notify observers that it did.
     OnAllDataSaved(info->download_id,
@@ skipping 11 matching lines @@
 void DownloadManager::UpdateDownload(int32 download_id, int64 size) {
   DownloadMap::iterator it = in_progress_.find(download_id);
   if (it != in_progress_.end()) {
     DownloadItem* download = it->second;
     download->Update(size);
     download_history_->UpdateEntry(download);
   }
   UpdateAppIcon();
 }
 
+void DownloadManager::OnResponseCompleted(int32 download_id,
+                                          int64 size,
+                                          int os_error) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+  if (os_error == 0) {
+    OnAllDataSaved(download_id, size);
+  } else {
+    DownloadError(download_id, size, os_error);
+  }
+}
+
 void DownloadManager::OnAllDataSaved(int32 download_id, int64 size) {
   DownloadMap::iterator it = in_progress_.find(download_id);
   if (it == in_progress_.end()) {
     // The download is done, but the user hasn't selected a final location for
     // it yet (the Save As dialog box is probably still showing), so just keep
     // track of the fact that this download id is complete, when the
     // DownloadItem is constructed later we'll notify its completion then.
     PendingFinishedMap::iterator erase_it =
         pending_finished_downloads_.find(download_id);
     DCHECK(erase_it == pending_finished_downloads_.end());
@@ skipping 24 matching lines @@
   // ProceedWithFinishedDangerousDownload.
   if (download->safety_state() == DownloadItem::DANGEROUS) {
     dangerous_finished_[download_id] = download;
     return;
   }
 
   if (download->safety_state() == DownloadItem::DANGEROUS_BUT_VALIDATED) {
     // We first need to rename the downloaded file from its temporary name to
     // its final name before we can continue.
     ChromeThread::PostTask(
-      ChromeThread::FILE, FROM_HERE,
+        ChromeThread::FILE,
+        FROM_HERE,
         NewRunnableMethod(
             this, &DownloadManager::ProceedWithFinishedDangerousDownload,
             download->db_handle(),
             download->full_path(), download->original_name()));
     return;
   }
 
   if (download->need_final_rename()) {
     ChromeThread::PostTask(
-        ChromeThread::FILE, FROM_HERE,
+        ChromeThread::FILE,
+        FROM_HERE,
         NewRunnableMethod(
             file_manager_, &DownloadFileManager::OnFinalDownloadName,
             download->id(), download->full_path(), false, this));
     return;
   }
 
   ContinueDownloadFinished(download);
 }
 
+void DownloadManager::DownloadError(int32 download_id,
+                                    int64 size,
+                                    int os_error) {
+  DownloadMap::iterator it = in_progress_.find(download_id);
+  // If enough time passes, the download item could be
+  // removed from the |in_progress_| map before we get here.
+  if (it == in_progress_.end())
+    return;
+
+  DownloadItem* download = it->second;
+  download->Interrupted(size, os_error);
+
+  LOG(INFO) << "Error " << download->last_os_error() << " at offset "
+            << download->received_bytes() << " for file at \""
+            << download->url().spec() << "\"";
+
+  // Clean up will happen when the history system create callback runs if we
+  // don't have a valid db_handle yet, and otherwise when we restart.
+  if (download->db_handle() != DownloadHistory::kUninitializedHandle)
+    download_history_->UpdateEntry(download);
+
+  UpdateAppIcon();
+
+  // Notify our observers that we are interrupted.
+  download->UpdateObservers();
+}
+
 void DownloadManager::DownloadRenamedToFinalName(int download_id,
                                                  const FilePath& full_path) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
   DownloadItem* item = GetDownloadItem(download_id);
   if (!item)
     return;
   item->OnNameFinalized();
 
   // This was called from DownloadFinished; continue to call
@@ skipping 31 matching lines @@
     // file gets the same name.
     uniquifier = download_util::GetUniquePathNumber(new_path);
     if (uniquifier > 0)
       download_util::AppendNumberToPath(&new_path, uniquifier);
     success = file_util::Move(path, new_path);
   } else {
     NOTREACHED();
   }
 
   ChromeThread::PostTask(
-      ChromeThread::UI, FROM_HERE,
+      ChromeThread::UI,
+      FROM_HERE,
       NewRunnableMethod(this, &DownloadManager::DangerousDownloadRenamed,
                         download_handle, success, new_path, uniquifier));
 }
 
 // Call from the file thread when the finished dangerous download was renamed.
 void DownloadManager::DangerousDownloadRenamed(int64 download_handle,
                                                bool success,
                                                const FilePath& new_path,
                                                int new_path_uniquifier) {
   DownloadMap::iterator it = downloads_.find(download_handle);
@@ skipping 32 matching lines @@
                             download->render_process_id(),
                             download->request_id());
   UpdateAppIcon();
 }
 
 void DownloadManager::DownloadCancelledInternal(int download_id,
                                                 int render_process_id,
                                                 int request_id) {
   // Cancel the network request.  RDH is guaranteed to outlive the IO thread.
   ChromeThread::PostTask(
-      ChromeThread::IO, FROM_HERE,
+      ChromeThread::IO,
+      FROM_HERE,
       NewRunnableFunction(&download_util::CancelDownloadRequest,
                           g_browser_process->resource_dispatcher_host(),
                           render_process_id,
                           request_id));
 
   ChromeThread::PostTask(
-      ChromeThread::FILE, FROM_HERE,
+      ChromeThread::FILE,
+      FROM_HERE,
       NewRunnableMethod(
           file_manager_, &DownloadFileManager::CancelDownload, download_id));
 }
 
 void DownloadManager::PauseDownload(int32 download_id, bool pause) {
   DownloadMap::iterator it = in_progress_.find(download_id);
   if (it == in_progress_.end())
     return;
 
   DownloadItem* download = it->second;
   if (pause == download->is_paused())
     return;
 
   ChromeThread::PostTask(
-      ChromeThread::IO, FROM_HERE,
+      ChromeThread::IO,
+      FROM_HERE,
       NewRunnableMethod(this,
                         &DownloadManager::PauseDownloadRequest,
                         g_browser_process->resource_dispatcher_host(),
                         download->render_process_id(),
                         download->request_id(),
                         pause));
 }
 
+void DownloadManager::RestartDownload(int32 download_id) {
+  // Handle the case of clicking 'Resume' in the download shelf.
+  DownloadMap::iterator it = in_progress_.find(download_id);
+  if (it == in_progress_.end())
+    return;
+
+  DownloadItem* download = it->second;
+  if (!download->IsInterruptedDownload())
+    return;
+
+  // Restart the download.
+  // |info| is cleaned up in ResourceDispatcherHost::RestartRequestAsync().
+  DownloadCreateInfo* info = new DownloadCreateInfo(
+      download->full_path(),
+      download->url(),
+      download->start_time(),
+      download->received_bytes(),
+      download->total_bytes(),
+      DownloadItem::IN_PROGRESS,    // Don't want this to show INTERRUPTED.
+      -1);
+  info->referrer_url = download->referrer_url();
+
+  // Inform the ResourceDispatcherHost that we're restarting the download.
+  ChromeThread::PostTask(
+      ChromeThread::IO,
+      FROM_HERE,
+      NewRunnableMethod(this,
+                        &DownloadManager::RestartDownloadRequest,
+                        g_browser_process->resource_dispatcher_host(),
+                        download->render_process_id(),
+                        download->request_id(),
+                        info));
+}
+
 void DownloadManager::UpdateAppIcon() {
   int64 total_bytes = 0;
   int64 received_bytes = 0;
   int download_count = 0;
   bool progress_known = true;
 
   for (DownloadMap::iterator i = in_progress_.begin();
        i != in_progress_.end();
        ++i) {
     ++download_count;
@@ skipping 24 matching lines @@
 }
 
 void DownloadManager::PauseDownloadRequest(ResourceDispatcherHost* rdh,
                                            int render_process_id,
                                            int request_id,
                                            bool pause) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   rdh->PauseRequest(render_process_id, request_id, pause);
 }
 
+void DownloadManager::RestartDownloadRequest(ResourceDispatcherHost* rdh,
+                                             int render_process_id,
+                                             int request_id,
+                                             DownloadCreateInfo* info) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
+  rdh->RestartRequest(render_process_id, request_id, info);
+}
+
 void DownloadManager::RemoveDownload(int64 download_handle) {
   DownloadMap::iterator it = downloads_.find(download_handle);
   if (it == downloads_.end())
     return;
 
   // Make history update.
   DownloadItem* download = it->second;
   download_history_->RemoveEntry(download);
 
   // Remove from our tables and delete.
@@ skipping 77 matching lines @@
   DownloadUrlToFile(url, referrer, referrer_charset, DownloadSaveInfo(),
                     tab_contents);
 }
 
 void DownloadManager::DownloadUrlToFile(const GURL& url,
                                         const GURL& referrer,
                                         const std::string& referrer_charset,
                                         const DownloadSaveInfo& save_info,
                                         TabContents* tab_contents) {
   DCHECK(tab_contents);
-  ChromeThread::PostTask(ChromeThread::IO, FROM_HERE,
+  ChromeThread::PostTask(
+      ChromeThread::IO,
+      FROM_HERE,
       NewRunnableFunction(&download_util::DownloadUrl,
                           url,
                           referrer,
                           referrer_charset,
                           save_info,
                           g_browser_process->resource_dispatcher_host(),
                           tab_contents->GetRenderProcessHost()->id(),
                           tab_contents->render_view_host()->routing_id(),
                           request_context_getter_));
 }
@@ skipping 42 matching lines @@
   DCHECK_EQ(DownloadItem::DANGEROUS, download->safety_state());
   download->set_safety_state(DownloadItem::DANGEROUS_BUT_VALIDATED);
   download->UpdateObservers();
 
   // If the download is not complete, nothing to do.  The required
   // post-processing will be performed when it does complete.
   if (download->state() != DownloadItem::COMPLETE)
     return;
 
   ChromeThread::PostTask(
-      ChromeThread::FILE, FROM_HERE,
+      ChromeThread::FILE,
+      FROM_HERE,
       NewRunnableMethod(
           this, &DownloadManager::ProceedWithFinishedDangerousDownload,
           download->db_handle(), download->full_path(),
           download->original_name()));
 }
 
 // Operations posted to us from the history service ----------------------------
 
 // The history service has retrieved all download entries. 'entries' contains
 // 'DownloadCreateInfo's in sorted order (by ascending start_time).
@@ skipping 10 matching lines @@
 // Once the new DownloadItem's creation info has been committed to the history
 // service, we associate the DownloadItem with the db handle, update our
 // 'downloads_' map and inform observers.
 void DownloadManager::OnCreateDownloadEntryComplete(DownloadCreateInfo info,
                                                     int64 db_handle) {
   DownloadMap::iterator it = in_progress_.find(info.download_id);
   DCHECK(it != in_progress_.end());
 
   DownloadItem* download = it->second;
 
-  // It's not immediately obvious, but HistoryBackend::CreateDownload() can
-  // call this function with an invalid |db_handle|. For instance, this can
-  // happen when the history database is offline. We cannot have multiple
-  // DownloadItems with the same invalid db_handle, so we need to assign a
-  // unique |db_handle| here.
-  if (db_handle == DownloadHistory::kUninitializedHandle)
-    db_handle = download_history_->GetNextFakeDbHandle();
+  if (download->db_handle() != DownloadHistory::kUninitializedHandle) {
+    // We're reusing the download.
+  } else {
+    // It's not immediately obvious, but HistoryBackend::CreateDownload() can
+    // call this function with an invalid |db_handle|. For instance, this can
+    // happen when the history database is offline. We cannot have multiple
+    // DownloadItems with the same invalid db_handle, so we need to assign a
+    // unique |db_handle| here.
+    if (db_handle == DownloadHistory::kUninitializedHandle)
+      db_handle = download_history_->GetNextFakeDbHandle();
 
-  DCHECK(download->db_handle() == DownloadHistory::kUninitializedHandle);
-  download->set_db_handle(db_handle);
+    DCHECK(download->db_handle() == DownloadHistory::kUninitializedHandle);
+    download->set_db_handle(db_handle);
 
-  // Insert into our full map.
-  DCHECK(downloads_.find(download->db_handle()) == downloads_.end());
-  downloads_[download->db_handle()] = download;
+    // Insert into our full map.
+    DCHECK(downloads_.find(download->db_handle()) == downloads_.end());
+    downloads_[download->db_handle()] = download;
+  }
 
   // Show in the appropropriate browser UI.
   ShowDownloadInBrowser(info, download);
 
   // Inform interested objects about the new download.
   NotifyModelChanged();
 
   // If this download has been completed before we've received the db handle,
   // post one final message to the history service so that it can be properly
   // in sync with the DownloadItem's completion status, and also inform any
   // observers so that they get more than just the start notification.
   if (download->state() != DownloadItem::IN_PROGRESS) {
-    in_progress_.erase(it);
+    if (!download->IsInterruptedDownload())
+      in_progress_.erase(it);
     download_history_->UpdateEntry(download);
     download->UpdateObservers();
   }
 
   UpdateAppIcon();
 }
 
 void DownloadManager::ShowDownloadInBrowser(const DownloadCreateInfo& info,
                                             DownloadItem* download) {
   // The 'contents' may no longer exist if the user closed the tab before we
@@ skipping 55 matching lines @@
     observed_download_manager_->RemoveObserver(this);
 }
 
 void DownloadManager::OtherDownloadManagerObserver::ModelChanged() {
   observing_download_manager_->NotifyModelChanged();
 }
 
 void DownloadManager::OtherDownloadManagerObserver::ManagerGoingDown() {
   observed_download_manager_ = NULL;
 }