Download resumption - Preliminary

content/browser/download/download_manager_impl.cc

 // Copyright (c) 2012 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 "content/browser/download/download_manager_impl.h"
 
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 21 matching lines @@
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_manager_delegate.h"
 #include "content/public/browser/download_persistent_store_info.h"
 #include "content/public/browser/download_url_parameters.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/web_contents_delegate.h"
+#include "content/public/common/referrer.h"
 #include "net/base/load_flags.h"
 #include "net/base/upload_data.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/glue/webkit_glue.h"
 
 using content::BrowserThread;
 using content::DownloadId;
 using content::DownloadItem;
 using content::DownloadPersistentStoreInfo;
 using content::ResourceDispatcherHostImpl;
@@ skipping 16 matching lines @@
   virtual ~SavePageData() {}
 
  private:
   static const char kKey[];
 
   DISALLOW_COPY_AND_ASSIGN(SavePageData);
 };
 
 const char SavePageData::kKey[] = "DownloadItem SavePageData";
 
-void BeginDownload(content::DownloadUrlParameters* params) {
+void BeginDownload(content::DownloadUrlParameters* params,
+                   DownloadId download_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // ResourceDispatcherHost{Base} is-not-a URLRequest::Delegate, and
   // DownloadUrlParameters can-not include resource_dispatcher_host_impl.h, so
   // we must down cast. RDHI is the only subclass of RDH as of 2012 May 4.
   scoped_ptr<net::URLRequest> request(
       params->resource_context()->GetRequestContext()->CreateRequest(
           params->url(), NULL));
   request->set_referrer(params->referrer().url.spec());
   webkit_glue::ConfigureURLRequestForReferrerPolicy(
       request.get(), params->referrer().policy);
@@ skipping 21 matching lines @@
         iter->first, iter->second, false/*overwrite*/);
   }
   params->resource_dispatcher_host()->BeginDownload(
       request.Pass(),
       params->content_initiated(),
       params->resource_context(),
       params->render_process_host_id(),
       params->render_view_host_routing_id(),
       params->prefer_cache(),
       params->save_info(),
+      params->last_modified(),
+      params->etag(),
+      download_id,
       params->callback());
 }
 
 class MapValueIteratorAdapter {
  public:
   explicit MapValueIteratorAdapter(
       base::hash_map<int64, DownloadItem*>::const_iterator iter)
     : iter_(iter) {
   }
   ~MapValueIteratorAdapter() {}
@@ skipping 40 matching lines @@
         DownloadItemImplDelegate* delegate,
         content::DownloadId download_id,
         const content::DownloadPersistentStoreInfo& info,
         const net::BoundNetLog& bound_net_log) OVERRIDE {
       return new DownloadItemImpl(delegate, download_id, info, bound_net_log);
     }
 
     virtual DownloadItemImpl* CreateActiveItem(
         DownloadItemImplDelegate* delegate,
         const DownloadCreateInfo& info,
-        scoped_ptr<DownloadRequestHandleInterface> request_handle,
         const net::BoundNetLog& bound_net_log) OVERRIDE {
-      return new DownloadItemImpl(delegate, info, request_handle.Pass(),
-                                  bound_net_log);
+      return new DownloadItemImpl(delegate, info, bound_net_log);
     }
 
     virtual DownloadItemImpl* CreateSavePageItem(
         DownloadItemImplDelegate* delegate,
         const FilePath& path,
         const GURL& url,
         content::DownloadId download_id,
         const std::string& mime_type,
         const net::BoundNetLog& bound_net_log) OVERRIDE {
       return new DownloadItemImpl(delegate, path, url, download_id,
@@ skipping 152 matching lines @@
 
   return true;
 }
 
 // We have received a message from DownloadFileManager about a new download.
 DownloadItem* DownloadManagerImpl::StartDownload(
     scoped_ptr<DownloadCreateInfo> info,
     scoped_ptr<content::ByteStreamReader> stream) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  bool resuming =
+      (downloads_.find(info->download_id.local()) != downloads_.end());
+
   // |bound_net_log| will be used for logging both the download item's and
   // the download file's events.
   net::BoundNetLog bound_net_log = CreateDownloadItem(info.get());
 
   // If info->download_id was unknown on entry to this function, it was
   // assigned in CreateDownloadItem.
   DownloadId download_id = info->download_id;
 
   if (delegate_) {
     FilePath website_save_directory;      // Unused
     bool skip_dir_check = false;          // Unused
     delegate_->GetSaveDir(GetBrowserContext(), &website_save_directory,
                           &info->default_download_directory, &skip_dir_check);
   }
 
   DownloadFileManager::CreateDownloadFileCallback callback(
-      base::Bind(&DownloadManagerImpl::OnDownloadFileCreated,
+      base::Bind(resuming ?
+                     &DownloadManagerImpl::ContinueStartingDownload :
+                     &DownloadManagerImpl::OnDownloadFileCreated,
                  this, download_id.local()));
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DownloadFileManager::CreateDownloadFile,
                  file_manager_, base::Passed(info.Pass()),
                  base::Passed(stream.Pass()), make_scoped_refptr(this),
                  (delegate_ && delegate_->GenerateFileHash()), bound_net_log,
                  callback));
 
   return GetDownload(download_id.local());
 }
 
+// We have received a message from DownloadFileManager about a new download.
+void DownloadManagerImpl::ContinueStartingDownload(
+    int32 download_id, content::DownloadInterruptReason reason) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (reason != content::DOWNLOAD_INTERRUPT_REASON_NONE) {
+    OnDownloadInterrupted(download_id, reason);
+    // TODO(rdsmith): It makes no sense to continue along the
+    // regular download path after we've gotten an error.  But it's
+    // the way the code has historically worked, and this allows us
+    // to get the download persisted and observers of the download manager
+    // notified, so tests work.  When we execute all side effects of cancel
+    // (including queue removal) immedately rather than waiting for
+    // persistence we should replace this comment with a "return;".
+  }
+
+  DownloadItem* download = GetActiveDownload(download_id);
+  if (!download)
+    return;
+
+  MaybeCompleteDownload(download_id);
+}
+
 void DownloadManagerImpl::OnDownloadFileCreated(
     int32 download_id, content::DownloadInterruptReason reason) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (reason != content::DOWNLOAD_INTERRUPT_REASON_NONE) {
     OnDownloadInterrupted(download_id, reason);
     // TODO(rdsmith): It makes no sense to continue along the
     // regular download path after we've gotten an error.  But it's
     // the way the code has historically worked, and this allows us
     // to get the download persisted and observers of the download manager
     // notified, so tests work.  When we execute all side effects of cancel
     // (including queue removal) immedately rather than waiting for
     // persistence we should replace this comment with a "return;".
   }
@@ skipping 74 matching lines @@
 }
 
 content::BrowserContext* DownloadManagerImpl::GetBrowserContext() const {
   return browser_context_;
 }
 
 net::BoundNetLog DownloadManagerImpl::CreateDownloadItem(
     DownloadCreateInfo* info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  net::BoundNetLog bound_net_log =
-      net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD);
+  // |bound_net_log| will be used for logging the both the download item's and
+  // the download file's events.
+  net::BoundNetLog bound_net_log;
+
   if (!info->download_id.IsValid())
     info->download_id = GetNextId();
-  DownloadItemImpl* download = factory_->CreateActiveItem(
-      this, *info,
-      scoped_ptr<DownloadRequestHandleInterface>(
-          new DownloadRequestHandle(info->request_handle)).Pass(),
-      bound_net_log);
 
-  DCHECK(!ContainsKey(downloads_, download->GetId()));
-  downloads_[download->GetId()] = download;
+  int32 download_id = info->download_id.local();
+  DownloadItemImpl* download = NULL;
+  scoped_ptr<DownloadRequestHandleInterface> req_handle(
+      new DownloadRequestHandle(info->request_handle));
+  bool resuming = (downloads_.find(download_id) != downloads_.end());
+  if (resuming) {
+    download = downloads_[download_id];
+    DCHECK(download != NULL);
+  }
+
+  if (download) {
+    // Reuse an interrupted |DownloadItem|.
+    DCHECK(download->IsInterrupted());
+    bound_net_log = download->GetBoundNetLog();  // Connect to its net log.
+    download->Resume(req_handle.Pass());
+  } else {
+    // Create a new |DownloadItem|.
+    bound_net_log =
+        net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD);
+    download = factory_->CreateActiveItem(this, *info, bound_net_log);
+
+    download->SetRequest(req_handle.Pass());
+
+    DCHECK(!ContainsKey(downloads_, download->GetId()));
+    downloads_[download->GetId()] = download;
+  }
+
+  DVLOG(20) << __FUNCTION__ << "()"
+            << " info " << info->DebugString()
+            << " download " << download->DebugString(true);
+
   DCHECK(!ContainsKey(active_downloads_, download->GetId()));
   active_downloads_[download->GetId()] = download;
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadCreated(this, download));
 
   return bound_net_log;
 }
 
 DownloadItemImpl* DownloadManagerImpl::CreateSavePackageDownloadItem(
     const FilePath& main_file_path,
     const GURL& page_url,
@@ skipping 50 matching lines @@
            << " size = " << size;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If it's not in active_downloads_, that means it was cancelled; just
   // ignore the notification.
   if (active_downloads_.count(download_id) == 0)
     return;
 
   DownloadItemImpl* download = active_downloads_[download_id];
   download->OnAllDataSaved(size, hash);
-  MaybeCompleteDownload(download);
+  MaybeCompleteDownload(download_id);
 }
 
 void DownloadManagerImpl::AssertStateConsistent(
     DownloadItemImpl* download) const {
   CHECK(ContainsKey(downloads_, download->GetId()));
 
   int64 state = download->GetState();
   base::debug::Alias(&state);
   if (ContainsKey(active_downloads_, download->GetId())) {
     if (download->IsPersisted())
@@ skipping 34 matching lines @@
 // When SavePackage downloads MHTML to GData (see
 // SavePackageFilePickerChromeOS), GData calls MaybeCompleteDownload() like it
 // does for non-SavePackage downloads, but SavePackage downloads never satisfy
 // IsDownloadReadyForCompletion(). GDataDownloadObserver manually calls
 // DownloadItem::UpdateObservers() when the upload completes so that SavePackage
 // notices that the upload has completed and runs its normal Finish() pathway.
 // MaybeCompleteDownload() is never the mechanism by which SavePackage completes
 // downloads. SavePackage always uses its own Finish() to mark downloads
 // complete.
 
-void DownloadManagerImpl::MaybeCompleteDownload(
-    DownloadItemImpl* download) {
+void DownloadManagerImpl::MaybeCompleteDownload(int32 download_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // This can be called from |DownloadItemImpl::OnDownloadedFileRemoved()|,
+  // without the download being active.
+  DCHECK(ContainsKey(downloads_, download_id));
+  if (!ContainsKey(active_downloads_, download_id))
+    return;
+  DownloadItemImpl* download = active_downloads_[download_id];
+
   VLOG(20) << __FUNCTION__ << "()" << " download = "
-           << download->DebugString(false);
+           << download->DebugString(true);
 
   if (!IsDownloadReadyForCompletion(download))
     return;
 
   // TODO(rdsmith): DCHECK that we only pass through this point
   // once per download.  The natural way to do this is by a state
   // transition on the DownloadItem.
 
   // Confirm we're in the proper set of states to be here;
   // have all data, have a history handle, (validated or safe).
@@ skipping 15 matching lines @@
   VLOG(20) << __FUNCTION__ << "()" << " executing: download = "
            << download->DebugString(false);
 
   if (delegate_)
     delegate_->UpdateItemInPersistentStore(download);
   download->OnDownloadCompleting();
 }
 
 void DownloadManagerImpl::MaybeCompleteDownloadById(int download_id) {
   if (ContainsKey(active_downloads_, download_id))
-    MaybeCompleteDownload(active_downloads_[download_id]);
+    MaybeCompleteDownload(download_id);
 }
 
 void DownloadManagerImpl::DownloadCompleted(DownloadItemImpl* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(download);
   if (delegate_)
     delegate_->UpdateItemInPersistentStore(download);
   active_downloads_.erase(download->GetId());
   AssertStateConsistent(download);
 }
 
 void DownloadManagerImpl::CancelDownload(int32 download_id) {
+  DownloadItem* download = GetActiveDownload(download_id);
   // A cancel at the right time could remove the download from the
   // |active_downloads_| map before we get here.
-  if (ContainsKey(active_downloads_, download_id))
-    active_downloads_[download_id]->Cancel(true);
+  if (!download)
+    return;
+
+  download->Cancel(true);
 }
 
 void DownloadManagerImpl::DownloadStopped(DownloadItemImpl* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   VLOG(20) << __FUNCTION__ << "()"
            << " download = " << download->DebugString(true);
 
   RemoveFromActiveList(download);
   // This function is called from the DownloadItem, so DI state
   // should already have been updated.
   AssertStateConsistent(download);
 
   DCHECK(file_manager_);
-  download->OffThreadCancel();
+
+  if (download->IsInterrupted())
+    download->OffThreadInterrupt();
+  else
+    download->OffThreadCancel();
 }
 
 void DownloadManagerImpl::OnDownloadInterrupted(
     int32 download_id,
     content::DownloadInterruptReason reason) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!ContainsKey(active_downloads_, download_id))
     return;
+
+  VLOG(20) << __FUNCTION__ << "()"
+           << " reason " << InterruptReasonDebugString(reason)
+           << " download = "
+           << active_downloads_[download_id]->DebugString(true);
+
   active_downloads_[download_id]->Interrupt(reason);
 }
 
+// Resume a download of a specific URL. We send the request to the
+// ResourceDispatcherHost, and let it send us responses like a regular
+// download.
+void DownloadManagerImpl::RestartInterruptedDownload(
+    DownloadItemImpl* download,
+    const content::DownloadUrlParameters::OnStartedCallback& callback) {

[Randy Smith (Not in Mondays), 2012/10/15 00:36:08]

If we've already got a download item, let's not used OnStartedCallback--let's
report the error through the DI.

+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  // Handle the case of clicking 'Resume' in the download shelf.
+  DCHECK(download);
+  DCHECK(download->IsInterrupted());
+
+  DVLOG(20) << __FUNCTION__ << "()"
+            << " download = " << download->DebugString(true);
+
+  // Restart the download.
+  WebContents* contents = GetWebContents(download);
+  if (!contents) {
+    if (!callback.is_null())
+      callback.Run(download, net::ERR_ACCESS_DENIED);
+    return;
+  }
+
+  content::DownloadSaveInfo save_info;
+  save_info.file_path = download->GetFullPath();
+  save_info.offset = download->GetReceivedBytes();
+  save_info.hash_state = download->GetHashState();
+
+  content::DownloadUrlParameters* download_params =
+      new content::DownloadUrlParameters(
+        download->GetOriginalUrl(),
+        contents->GetRenderProcessHost()->GetID(),
+        contents->GetRenderViewHost()->GetRoutingID(),
+        contents->GetBrowserContext()->GetResourceContext(),
+        save_info);
+
+  content::Referrer referrer(download->GetReferrerUrl(),
+                             WebKit::WebReferrerPolicyDefault);
+  download_params->set_referrer(referrer);
+  download_params->set_last_modified(download->GetLastModifiedTime());
+  download_params->set_etag(download->GetETag());
+  download_params->set_callback(callback);
+
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(
+          &BeginDownload,
+          base::Owned(download_params),
+          download->GetGlobalId()));
+}
+
+DownloadItem* DownloadManagerImpl::GetActiveDownload(int32 download_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DownloadMap::iterator it = active_downloads_.find(download_id);
+  if (it == active_downloads_.end())
+    return NULL;
+
+  DownloadItem* download = it->second;
+
+  DCHECK(download);
+  DCHECK_EQ(download_id, download->GetId());
+
+  return download;
+}
+
 void DownloadManagerImpl::RemoveFromActiveList(DownloadItemImpl* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(download);
 
   // Clean up will happen when the history system create callback runs if we
   // don't have a valid db_handle yet.
   if (download->IsPersisted()) {
     active_downloads_.erase(download->GetId());
     if (delegate_)
       delegate_->UpdateItemInPersistentStore(download);
@@ skipping 71 matching lines @@
   return num_deleted;
 }
 
 void DownloadManagerImpl::DownloadUrl(
     scoped_ptr<content::DownloadUrlParameters> params) {
   if (params->post_id() >= 0) {
     // Check this here so that the traceback is more useful.
     DCHECK(params->prefer_cache());
     DCHECK(params->method() == "POST");
   }
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
-      &BeginDownload, base::Owned(params.release())));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(
+          &BeginDownload,
+          base::Owned(params.release()),
+          DownloadId()));
 }
 
 void DownloadManagerImpl::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
   // TODO: It is the responsibility of the observers to query the
   // DownloadManager. Remove the following call from here and update all
   // observers.
   observer->ModelChanged(this);
 }
 
@@ skipping 76 matching lines @@
            << " download = " << item->DebugString(true);
 
   // If the download is still in progress, try to complete it.
   //
   // Otherwise, download has been cancelled or interrupted before we've
   // received the DB handle.  We 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 (item->IsInProgress()) {
-    MaybeCompleteDownload(item);
+    MaybeCompleteDownload(item->GetId());
   } else {
-    DCHECK(item->IsCancelled());
+    DCHECK(item->IsCancelled() || item->IsInterrupted())
+        << " download = " << item->DebugString(true);
     active_downloads_.erase(item->GetId());
     if (delegate_)
       delegate_->UpdateItemInPersistentStore(item);
     item->UpdateObservers();
   }
 }
 
 void DownloadManagerImpl::ShowDownloadInBrowser(DownloadItemImpl* download) {
   // The 'contents' may no longer exist if the user closed the contents before
   // we get this start completion event.
-  WebContents* content = download->GetWebContents();
-
-  // If the contents no longer exists, we ask the embedder to suggest another
-  // contents.
-  if (!content && delegate_)
-    content = delegate_->GetAlternativeWebContentsToNotifyForDownload();
+  WebContents* content = GetWebContents(download);
 
   if (content && content->GetDelegate())
     content->GetDelegate()->OnStartDownload(content, download);
 }
 
 int DownloadManagerImpl::InProgressCount() const {
   // Don't use active_downloads_.count() because Cancel() leaves items in
   // active_downloads_ if they haven't made it into the persistent store yet.
   // Need to actually look at each item's state.
   int count = 0;
@@ skipping 118 matching lines @@
 void DownloadManagerImpl::DownloadRenamedToFinalName(
     DownloadItemImpl* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // If the rename failed, we receive an OnDownloadInterrupted() call before we
   // receive the DownloadRenamedToFinalName() call.
   if (delegate_) {
     delegate_->UpdatePathForItemInPersistentStore(
         download, download->GetFullPath());
   }
 }
+
+WebContents* DownloadManagerImpl::GetWebContents(const DownloadItem* download) {
+  WebContents* web_contents = download->GetWebContents();
+  // If the original download_id was created from the history DB, its
+  // |DownloadRequestHandle| will not be valid, and we won't get a proper
+  // |WebContents| pointer from it.
+  if (!web_contents)
+    web_contents = delegate_->GetAlternativeWebContentsToNotifyForDownload();
+
+  return web_contents;
+}