Adding WebContent-free Download

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"
 #include "base/debug/alias.h"
 #include "base/i18n/case_conversion.h"
 #include "base/logging.h"
+#include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/supports_user_data.h"
 #include "base/synchronization/lock.h"
 #include "build/build_config.h"
 #include "content/browser/byte_stream.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_file_factory.h"
 #include "content/browser/download/download_item_factory.h"
 #include "content/browser/download/download_item_impl.h"
 #include "content/browser/download/download_stats.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/browser_context.h"
-#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/elements_upload_data_stream.h"
 #include "net/base/load_flags.h"
 #include "net/base/request_priority.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/url_request/url_request_context.h"
 #include "url/origin.h"
 
 namespace content {
 namespace {
 
-void BeginDownload(scoped_ptr<DownloadUrlParameters> params,
-                   uint32 download_id) {
+UrlDownloader* BeginDownload(

[asanka, 2015/12/08 21:53:56]

You can return a scoped_ptr<UrlDownloader, DeleteOnIOThread>. That way we won't
leak the object if the task gets dropped on the floor.

It's valid to invoke the default constructor for a scoped_ptr<>. I.e. you can do
scoped_ptr<UrlDownloader>() when you want to return a nullptr. (in case that's
the reason you are returning a raw pointer).

Unfortunately, scoped_ptr<>()s don't atomatically convert to another
scoped_ptr<> type if the deleters aren't implicitly convertible. So you'll need
to repackage the output of UrlDownloader::BeginDownload() into the right
scoped_ptr<> type or have UrlDownloader::BeginDownload() return a
scoped_ptr<UrlDownloader, DeleteOnIOThread>.

Either is OK, but the former is preferable since it assumes that the caller
takes responsibility for deleting the UrlDownloader on the correct thread.

[svaldez, 2015/12/09 17:20:41]

We can't since using PostTask... with a scoped_ptr return type results in a
const scoped_ptr& which prevents us from changing its scope.

[asanka, 2015/12/10 16:27:55]

PostTaskAndReplyWithResult() correctly forwards move only types. The receiving
function can accept a scoped_ptr<>.

+    scoped_ptr<DownloadUrlParameters> params,
+    uint32 download_id,
+    base::WeakPtr<DownloadManagerImpl> download_manager) {
   DCHECK_CURRENTLY_ON(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(), net::DEFAULT_PRIORITY, NULL));
   request->set_method(params->method());
   if (!params->post_body().empty()) {
     const std::string& body = params->post_body();
@@ skipping 49 matching lines @@
   }
 
   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 = params->GetFile();
 
-  ResourceDispatcherHost::Get()->BeginDownload(
-      request.Pass(),
-      params->referrer(),
-      params->content_initiated(),
-      params->resource_context(),
-      params->render_process_host_id(),
-      params->render_view_host_routing_id(),
-      params->render_frame_host_routing_id(),
-      params->prefer_cache(),
-      params->do_not_prompt_for_login(),
-      save_info.Pass(),
-      download_id,
-      params->callback());
+  if (params->render_process_host_id() != -1) {
+    ResourceDispatcherHost::Get()->BeginDownload(
+        request.Pass(), params->referrer(), params->content_initiated(),
+        params->resource_context(), params->render_process_host_id(),
+        params->render_view_host_routing_id(),
+        params->render_frame_host_routing_id(), params->prefer_cache(),
+        params->do_not_prompt_for_login(), save_info.Pass(), download_id,
+        params->callback());
+    return nullptr;
+  }
+  return UrlDownloader::BeginDownload(
+             download_manager, request.Pass(), params->referrer(), false,
+             params->prefer_cache(), true, save_info.Pass(), download_id,
+             params->callback())
+      .release();
 }
 
 class DownloadItemFactoryImpl : public DownloadItemFactory {
  public:
   DownloadItemFactoryImpl() {}
   ~DownloadItemFactoryImpl() override {}
 
   DownloadItemImpl* CreatePersistedItem(
       DownloadItemImplDelegate* delegate,
       uint32 download_id,
@@ skipping 359 matching lines @@
                     OnSavePackageSuccessfullyFinished(this, download_item));
 }
 
 // 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,
     uint32 id) {
   RecordDownloadSource(INITIATED_BY_RESUMPTION);
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&BeginDownload, base::Passed(&params), id));
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&BeginDownload, base::Passed(&params), id,
+                 weak_factory_.GetWeakPtr()),
+      base::Bind(&DownloadManagerImpl::AddUrlDownloader,
+                 weak_factory_.GetWeakPtr()));
 }
 
 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();
 }
 
 DownloadFileFactory* DownloadManagerImpl::GetDownloadFileFactoryForTesting() {
   return file_factory_.get();
 }
 
 void DownloadManagerImpl::DownloadRemoved(DownloadItemImpl* download) {
   if (!download)
     return;
 
   uint32 download_id = download->GetId();
   if (downloads_.erase(download_id) == 0)
     return;
   delete download;
 }
 
+void DownloadManagerImpl::AddUrlDownloader(UrlDownloader* downloader) {
+  if (downloader) {
+    url_downloaders_.push_back(
+        scoped_ptr<UrlDownloader, BrowserThread::DeleteOnIOThread>(downloader));
+  }
+}
+
+void DownloadManagerImpl::RemoveUrlDownloader(UrlDownloader* downloader) {
+  for (auto ptr = url_downloaders_.begin(); ptr != url_downloaders_.end();
+       ++ptr) {
+    if (ptr->get() == downloader) {
+      url_downloaders_.erase(ptr);
+      return;
+    }
+  }
+}
+
 namespace {
 
 bool RemoveDownloadBetween(base::Time remove_begin,
                            base::Time remove_end,
                            const DownloadItemImpl* download_item) {
   return download_item->GetStartTime() >= remove_begin &&
          (remove_end.is_null() || download_item->GetStartTime() < remove_end);
 }
 
 bool RemoveDownloadByOriginAndTime(const url::Origin& origin,
@@ skipping 50 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_EQ("POST", params->method());
   }
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, base::Bind(
-      &BeginDownload, base::Passed(&params),
-      content::DownloadItem::kInvalidId));
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&BeginDownload, base::Passed(&params),
+                 content::DownloadItem::kInvalidId, weak_factory_.GetWeakPtr()),
+      base::Bind(&DownloadManagerImpl::AddUrlDownloader,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void DownloadManagerImpl::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void DownloadManagerImpl::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
@@ skipping 96 matching lines @@
   if (delegate_)
     delegate_->OpenDownload(download);
 }
 
 void DownloadManagerImpl::ShowDownloadInShell(DownloadItemImpl* download) {
   if (delegate_)
     delegate_->ShowDownloadInShell(download);
 }
 
 }  // namespace content