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/browser_thread.h"
 #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_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"
 
 namespace content {
 namespace {
 
-void BeginDownload(scoped_ptr<DownloadUrlParameters> params) {
+void BeginDownload(scoped_ptr<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 33 matching lines @@
   save_info->file_stream = params->GetFileStream();
 
   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(),
       save_info.Pass(),
+      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 50 matching lines @@
           received_bytes,
           total_bytes,
           state,
           opened,
           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,
         DownloadId download_id,
         const std::string& mime_type,
         const net::BoundNetLog& bound_net_log) OVERRIDE {
       return new DownloadItemImpl(delegate, path, url, download_id,
@@ skipping 149 matching lines @@
   browser_context_ = browser_context;
 
   return true;
 }
 
 DownloadItem* DownloadManagerImpl::StartDownload(
     scoped_ptr<DownloadCreateInfo> info,
     scoped_ptr<ByteStreamReader> stream) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  net::BoundNetLog bound_net_log =
-      net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD);
-
   FilePath default_download_directory;
   if (delegate_) {
     FilePath website_save_directory;      // Unused
     bool skip_dir_check = false;          // Unused
     delegate_->GetSaveDir(GetBrowserContext(), &website_save_directory,
                           &default_download_directory, &skip_dir_check);
   }
 
   // We create the DownloadItem before the DownloadFile because the
   // DownloadItem already needs to handle a state in which there is
   // no associated DownloadFile (history downloads, !IN_PROGRESS downloads)
-  DownloadItemImpl* download =
-      CreateDownloadItem(info.get(), bound_net_log);
+  DownloadItemImpl* download = CreateDownloadItem(info.get());
+  net::BoundNetLog bound_net_log = download->GetBoundNetLog();
   scoped_ptr<DownloadFile> download_file(
       file_factory_->CreateFile(
           info->save_info.Pass(), default_download_directory,
           info->url(), info->referrer_url,
           delegate_->GenerateFileHash(),
           stream.Pass(), bound_net_log,
           download->DestinationObserverAsWeakPtr()));
-  download->Start(download_file.Pass());
+  scoped_ptr<DownloadRequestHandleInterface> req_handle(
+      new DownloadRequestHandle(info->request_handle));
+  download->Start(download_file.Pass(), req_handle.Pass());
 
   // Delay notification until after Start() so that download_file is bound
   // to download and all the usual setters (e.g. Cancel) work.
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadCreated(this, download));
 
   return download;
 }
 
 void DownloadManagerImpl::CheckForHistoryFilesRemoval() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 32 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (ContainsKey(downloads_, download_id))
     downloads_[download_id]->OnDownloadedFileRemoved();
 }
 
 BrowserContext* DownloadManagerImpl::GetBrowserContext() const {
   return browser_context_;
 }
 
 DownloadItemImpl* DownloadManagerImpl::CreateDownloadItem(
-    DownloadCreateInfo* info, const net::BoundNetLog& bound_net_log) {
+    DownloadCreateInfo* info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!info->download_id.IsValid())
     info->download_id = GetNextId();
-  DownloadItemImpl* download = item_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;
+  bool resuming = ContainsKey(downloads_, download_id);
+  if (resuming) {
+    download = downloads_[download_id];
+    DCHECK(download != NULL);
+    DCHECK(download->IsInProgress());
+  }
+
+  if (download) {
+    // Reuse an interrupted |DownloadItem|.
+    DCHECK(download->IsInterrupted());
+  } else {
+    // Create a new |DownloadItem|.
+    // |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 =
+        net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD);
+    download = item_factory_->CreateActiveItem(this, *info, bound_net_log);
+
+    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;
 
   return download;
 }
 
 DownloadItemImpl* DownloadManagerImpl::CreateSavePackageDownloadItem(
     const FilePath& main_file_path,
     const GURL& page_url,
     const std::string& mime_type,
@@ skipping 33 matching lines @@
 void DownloadManagerImpl::DownloadCompleted(DownloadItemImpl* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(download);
   active_downloads_.erase(download->GetId());
   AssertStateConsistent(download);
 }
 
 void DownloadManagerImpl::CancelDownload(int32 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 (!ContainsKey(active_downloads_, download_id))
+    return;
+
+  DownloadItem* download = active_downloads_[download_id];
+
+  VLOG(20) << __FUNCTION__ << "() download = " << download->DebugString(true);
+
+  if (!download->IsInProgress())
+    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);
 }
 
+// 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::ResumeInterruptedDownload(
+    scoped_ptr<content::DownloadUrlParameters> params,
+    content::DownloadId id) {
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&BeginDownload, base::Passed(params.Pass()), id));
+}
+
 void DownloadManagerImpl::RemoveFromActiveList(DownloadItemImpl* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(download);
   active_downloads_.erase(download->GetId());
 }
 
 void DownloadManagerImpl::SetDownloadItemFactoryForTesting(
     scoped_ptr<DownloadItemFactory> item_factory) {
   item_factory_ = item_factory.Pass();
 }
@@ skipping 65 matching lines @@
   return num_deleted;
 }
 
 void DownloadManagerImpl::DownloadUrl(
     scoped_ptr<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::Passed(params.Pass())));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(
+          &BeginDownload,
+          base::Passed(params.Pass()),
+          DownloadId()));
 }
 
 void DownloadManagerImpl::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void DownloadManagerImpl::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
@@ skipping 107 matching lines @@
        it != downloads_.end(); ++it) {
     DownloadItemImpl* item = it->second;
     if (item->IsComplete() &&
         !item->GetOpened())
       ++num_unopened;
   }
   RecordOpensOutstanding(num_unopened);
 }
 
 }  // namespace content