Initial CL for Downloads resumption.

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_bytes_element_reader.h"
 #include "net/base/upload_data_stream.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 10 matching lines @@
     // The POST in this case does not have an actual body, and only works
     // when retrieving data from cache. This is done because we don't want
     // to do a re-POST without user consent, and currently don't have a good
     // plan on how to display the UI for that.
     DCHECK(params->prefer_cache());
     DCHECK(params->method() == "POST");
     ScopedVector<net::UploadElementReader> element_readers;
     request->set_upload(make_scoped_ptr(
         new net::UploadDataStream(&element_readers, params->post_id())));
   }
+
+  // If we're not at the beginning of the file, retrieve only the remaining
+  // portion.
+  if (params->offset() > 0) {
+    request->SetExtraRequestHeaderByName(
+        "Range",
+        StringPrintf("bytes=%" PRId64 "-", params->offset()),
+        true);
+
+    // If we've asked for a range, we want to make sure that we only
+    // get that range if our current copy of the information is good.
+    if (!params->last_modified().empty()) {
+      request->SetExtraRequestHeaderByName("If-Unmodified-Since",
+                                           params->last_modified(),
+                                           true);
+    }
+    if (!params->etag().empty()) {
+      request->SetExtraRequestHeaderByName("If-Match", params->etag(), true);
+    }
+  }
+
   for (DownloadUrlParameters::RequestHeadersType::const_iterator iter
            = params->request_headers_begin();
        iter != params->request_headers_end();
        ++iter) {
     request->SetExtraRequestHeaderByName(
         iter->first, iter->second, false/*overwrite*/);
   }
 
   scoped_ptr<DownloadSaveInfo> save_info(new DownloadSaveInfo());
   save_info->file_path = params->file_path();
   save_info->suggested_name = params->suggested_name();
   save_info->offset = params->offset();
   save_info->hash_state = params->hash_state();
   save_info->prompt_for_save_location = params->prompt();
   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(),
+      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 143 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 = GetOrCreateDownloadItem(info.get());
   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,
+          stream.Pass(), download->GetBoundNetLog(),
           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 31 matching lines @@
 void DownloadManagerImpl::OnFileRemovalDetected(int32 download_id) {
   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) {
+DownloadItemImpl* DownloadManagerImpl::GetOrCreateDownloadItem(
+    DownloadCreateInfo* info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!info->download_id.IsValid())

[benjhayden, 2013/01/08 16:41:17]

Just to be clear, this allows mischievous callers to set the id for a new
download, maybe non-sequentially. Do we care?

[Randy Smith (Not in Mondays), 2013/01/09 22:34:37]

That's why I didn't want it as part of the DownloadUrlParameters :-}.  My goal
is that no public interface exposes the ability to set the DownloadId.  The only
entry point I can imagine that's currently used outside the download system is
RDH::BeginDownload(), and that's an entry point I'd love to restrict to only the
download system.  Do you see any others?

(Note here that "public interface" is being used conceptually;
RDH::BeginDownload() may stay public on RDH, but with a note on it saying that
it's an internal download system routine and that the right entry point is
DM::DownloadUrl().)

     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;
+  DownloadItemImpl* download = NULL;
+  if (ContainsKey(downloads_, info->download_id.local())) {
+    // Resuming an existing download.
+    download = downloads_[info->download_id.local()];
+    DCHECK(download->IsInterrupted());
+  } else {
+    // New download
+    net::BoundNetLog bound_net_log =
+        net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD);
+    download = item_factory_->CreateActiveItem(this, *info, bound_net_log);
+    downloads_[download->GetId()] = download;
+  }
+
   return download;
 }
 
 DownloadItemImpl* DownloadManagerImpl::CreateSavePackageDownloadItem(
     const FilePath& main_file_path,
     const GURL& page_url,
     const std::string& mime_type,
     DownloadItem::Observer* observer) {
   net::BoundNetLog bound_net_log =
       net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD);
@@ skipping 17 matching lines @@
   return download_item;
 }
 
 void DownloadManagerImpl::CancelDownload(int32 download_id) {
   DownloadItem* download = GetDownload(download_id);
   if (!download || !download->IsInProgress())
     return;
   download->Cancel(true);
 }
 
+// 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::SetDownloadItemFactoryForTesting(
     scoped_ptr<DownloadItemFactory> item_factory) {
   item_factory_ = item_factory.Pass();
 }
 
 void DownloadManagerImpl::SetDownloadFileFactoryForTesting(
     scoped_ptr<DownloadFileFactory> file_factory) {
   file_factory_ = file_factory.Pass();
 }
 
@@ skipping 59 matching lines @@
 }
 
 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)));
+      &BeginDownload, base::Passed(&params), DownloadId()));
 }
 
 void DownloadManagerImpl::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void DownloadManagerImpl::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
@@ skipping 69 matching lines @@
        it != downloads_.end(); ++it) {
     DownloadItemImpl* item = it->second;
     if (item->IsComplete() &&
         !item->GetOpened())
       ++num_unopened;
   }
   RecordOpensOutstanding(num_unopened);
 }
 
 }  // namespace content