Preliminary work on resuming downloads whose connections have expired.

chrome/browser/download/download_file_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_file_manager.h"
 
 #include "base/file_util.h"
 #include "base/stl_util-inl.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
@@ skipping 60 matching lines @@
 void DownloadFileManager::OnShutdown() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
   StopUpdateTimer();
   STLDeleteValues(&downloads_);
 }
 
 void DownloadFileManager::CreateDownloadFile(
     DownloadCreateInfo* info, DownloadManager* download_manager) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
 
-  scoped_ptr<DownloadFile> download_file(
-      new DownloadFile(info, download_manager));
-  if (!download_file->Initialize()) {
-    ChromeThread::PostTask(
-        ChromeThread::IO, FROM_HERE,
-        NewRunnableFunction(&download_util::CancelDownloadRequest,
-                            resource_dispatcher_host_,
-                            info->child_id,
-                            info->request_id));
-    delete info;
-    return;
+  // See if we are reusing a download ID.
+  DownloadFile* download_file = NULL;
+  if (info->download_id != -1) {
+    DownloadFileMap::iterator item = downloads_.find(info->download_id);

[Paweł Hajdan Jr., 2010/10/01 09:03:55]

This is wrong, as said (and I think fixed) in
http://codereview.chromium.org/3273013/show

+    if (item != downloads_.end()) {
+      download_file = item->second;
+      download_file->ReOpen();
+    }
+  }
+  if (!download_file) {
+    download_file =  new DownloadFile(info, download_manager);
+    if (!download_file->Initialize()) {
+      ChromeThread::PostTask(
+          ChromeThread::IO,
+          FROM_HERE,
+          NewRunnableFunction(&download_util::CancelDownloadRequest,
+                              resource_dispatcher_host_,
+                              info->child_id,
+                              info->request_id));
+      delete info;
+      return;
+    }
+
+    DCHECK(GetDownloadFile(info->download_id) == NULL);
+    downloads_[info->download_id] = download_file;
   }
 
-  DCHECK(GetDownloadFile(info->download_id) == NULL);
-  downloads_[info->download_id] = download_file.release();
   // TODO(phajdan.jr): fix the duplication of path info below.
   info->path = info->save_info.file_path;
 
   // The file is now ready, we can un-pause the request and start saving data.
   ChromeThread::PostTask(
-      ChromeThread::IO, FROM_HERE,
-      NewRunnableMethod(this, &DownloadFileManager::ResumeDownloadRequest,
-                        info->child_id, info->request_id));
+      ChromeThread::IO,
+      FROM_HERE,
+      NewRunnableMethod(this,
+                        &DownloadFileManager::ResumeDownloadRequest,
+                        info->child_id,
+                        info->request_id));
 
   StartUpdateTimer();
 
   ChromeThread::PostTask(
-      ChromeThread::UI, FROM_HERE,
+      ChromeThread::UI,
+      FROM_HERE,
       NewRunnableMethod(download_manager,
-                        &DownloadManager::StartDownload, info));
+                        &DownloadManager::StartDownload,
+                        info));
 }
 
 void DownloadFileManager::ResumeDownloadRequest(int child_id, int request_id) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   // This balances the pause in DownloadResourceHandler::OnResponseStarted.
   resource_dispatcher_host_->PauseRequest(child_id, request_id, false);
 }
 
 DownloadFile* DownloadFileManager::GetDownloadFile(int id) {
@@ skipping 51 matching lines @@
                             info->request_id));
     delete info;
     return;
   }
 
   ChromeThread::PostTask(ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(this, &DownloadFileManager::CreateDownloadFile,
                         info, manager));
 }
 
+int DownloadFileManager::GetDownloadId(const GURL& url,
+                                       const FilePath& path) const {
+  FilePath crpath = download_util::GetCrDownloadPath(path);
+  DownloadFileMap::const_iterator it = downloads_.begin();
+  DownloadFileMap::const_iterator last = downloads_.end();
+  for (; it != last; ++it) {
+    const DownloadFile* download = it->second;
+    if (download && (download->MatchesUrlAndPath(url, crpath)))
+      return download->id();
+  }
+  return -1;
+}
+
 // We don't forward an update to the UI thread here, since we want to throttle
 // the UI update rate via a periodic timer. If the user has cancelled the
 // download (in the UI thread), we may receive a few more updates before the IO
 // thread gets the cancel message: we just delete the data since the
 // DownloadFile has been deleted.
 void DownloadFileManager::UpdateDownload(int id, DownloadBuffer* buffer) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
   std::vector<DownloadBuffer::Contents> contents;
   {
     AutoLock auto_lock(buffer->lock);
     contents.swap(buffer->contents);
   }
 
   DownloadFile* download = GetDownloadFile(id);
   for (size_t i = 0; i < contents.size(); ++i) {
     net::IOBuffer* data = contents[i].first;
     const int data_len = contents[i].second;
     if (download)
       download->AppendDataToFile(data->data(), data_len);
     data->Release();
   }
 }
 
-void DownloadFileManager::OnResponseCompleted(int id, DownloadBuffer* buffer) {
+void DownloadFileManager::OnResponseCompleted(
+    int id,
+    DownloadBuffer* buffer,
+    int os_error,
+    const std::string& security_info) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
   delete buffer;
-  DownloadFileMap::iterator it = downloads_.find(id);
-  if (it != downloads_.end()) {
-    DownloadFile* download = it->second;
+  DownloadFile* download = GetDownloadFile(id);
+  if (download) {
+    // Closes the file.  In the case of an error, it closes the temporary
+    // (.crdownload) one; otherwise it closes the original download file name.
+    DCHECK(!os_error ==
+        !download_util::IsCrDownloadPath(download->full_path()));
     download->Finish();
 
     DownloadManager* download_manager = download->GetDownloadManager();
     if (download_manager) {
       ChromeThread::PostTask(
-          ChromeThread::UI, FROM_HERE,
+          ChromeThread::UI,
+          FROM_HERE,
           NewRunnableMethod(
-              download_manager, &DownloadManager::OnAllDataSaved,
-              id, download->bytes_so_far()));
+              download_manager,
+              &DownloadManager::OnResponseCompleted,
+              id,
+              download->bytes_so_far(),
+              os_error));
     }
 
     // We need to keep the download around until the UI thread has finalized
     // the name.
     if (download->path_renamed()) {
-      downloads_.erase(it);
+      downloads_.erase(downloads_.find(id));
       delete download;
     }
   }
 
   if (downloads_.empty())
     StopUpdateTimer();
 }
 
 // This method will be sent via a user action, or shutdown on the UI thread, and
 // run on the download thread. Since this message has been sent from the UI
@@ skipping 35 matching lines @@
     downloads_.erase((*i)->id());
     delete *i;
   }
 }
 
 // Actions from the UI thread and run on the download thread
 
 // The DownloadManager in the UI thread has provided an intermediate .crdownload
 // name for the download specified by 'id'. Rename the in progress download.
 void DownloadFileManager::OnIntermediateDownloadName(
-    int id, const FilePath& full_path, DownloadManager* download_manager)
-{
+    int id, const FilePath& full_path, DownloadManager* download_manager) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
   DownloadFileMap::iterator it = downloads_.find(id);
   if (it == downloads_.end())
     return;
 
   DownloadFile* download = it->second;
   if (!download->Rename(full_path, false)) {
     // Error. Between the time the UI thread generated 'full_path' to the time
     // this code runs, something happened that prevents us from renaming.
     CancelDownloadOnRename(id);
@@ skipping 64 matching lines @@
   if (!download_manager) {
     download->CancelDownloadRequest(resource_dispatcher_host_);
     return;
   }
 
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(download_manager,
                         &DownloadManager::DownloadCancelled, id));
 }