BASELINE: Update Chromium to 66.0.3359.156

Change-Id: I0c9831ad39911a086b6377b16f995ad75a51e441
Reviewed-by: Michal Klocek <michal.klocek@qt.io>

1 files changed, 222 insertions, 129 deletions

diff --git a/chromium/content/browser/download/download_manager_impl.cc b/chromium/content/browser/download/download_manager_impl.cc
index 11eb1d3b732..02470e87915 100644
--- a/chromium/content/browser/download/download_manager_impl.cc
+++ b/chromium/content/browser/download/download_manager_impl.cc
@@ -25,14 +25,19 @@
 #include "build/build_config.h"
 #include "components/download/downloader/in_progress/download_entry.h"
 #include "components/download/downloader/in_progress/in_progress_cache_impl.h"
+#include "components/download/public/common/download_create_info.h"
+#include "components/download/public/common/download_interrupt_reasons.h"
+#include "components/download/public/common/download_request_handle_interface.h"
+#include "components/download/public/common/download_stats.h"
+#include "components/download/public/common/download_task_runner.h"
+#include "components/download/public/common/download_url_parameters.h"
 #include "content/browser/byte_stream.h"
 #include "content/browser/child_process_security_policy_impl.h"
-#include "content/browser/download/download_create_info.h"
+#include "content/browser/download/download_file.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/download/download_task_runner.h"
+#include "content/browser/download/download_resource_handler.h"
 #include "content/browser/download/download_utils.h"
 #include "content/browser/download/resource_downloader.h"
 #include "content/browser/download/url_downloader.h"
@@ -44,9 +49,8 @@
 #include "content/common/throttling_url_loader.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/content_browser_client.h"
-#include "content/public/browser/download_interrupt_reasons.h"
+#include "content/public/browser/download_item_utils.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_frame_host.h"
@@ -54,7 +58,6 @@
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/browser_side_navigation_policy.h"
-#include "content/public/common/content_features.h"
 #include "content/public/common/previews_state.h"
 #include "content/public/common/referrer.h"
 #include "net/base/elements_upload_data_stream.h"
@@ -63,6 +66,8 @@
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/url_request/url_request_context.h"
 #include "services/metrics/public/cpp/ukm_source_id.h"
+#include "services/network/public/cpp/features.h"
+#include "storage/browser/blob/blob_url_loader_factory.h"
 #include "storage/browser/blob/blob_url_request_job_factory.h"
 #include "url/origin.h"
 
@@ -102,13 +107,13 @@ bool CanRequestURLFromRenderer(int render_process_id, GURL url) {
 }
 
 void CreateInterruptedDownload(
-    DownloadUrlParameters* params,
-    DownloadInterruptReason reason,
+    download::DownloadUrlParameters* params,
+    download::DownloadInterruptReason reason,
     base::WeakPtr<DownloadManagerImpl> download_manager) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  std::unique_ptr<DownloadCreateInfo> failed_created_info(
-      new DownloadCreateInfo(base::Time::Now(),
-                             base::WrapUnique(new DownloadSaveInfo)));
+  std::unique_ptr<download::DownloadCreateInfo> failed_created_info(
+      new download::DownloadCreateInfo(
+          base::Time::Now(), base::WrapUnique(new download::DownloadSaveInfo)));
   failed_created_info->url_chain.push_back(params->url());
   failed_created_info->result = reason;
   std::unique_ptr<ByteStreamReader> empty_byte_stream;
@@ -129,21 +134,22 @@ download::DownloadEntry CreateDownloadEntryFromItem(
     download_id = base::RandUint64();
   } while (download_id == 0);
 
-  return download::DownloadEntry(
-      item.GetGuid(), ToDownloadSource(item.download_source()), download_id);
+  return download::DownloadEntry(item.GetGuid(), item.download_source(),
+                                 download_id);
 }
 
 DownloadManagerImpl::UniqueUrlDownloadHandlerPtr BeginDownload(
-    std::unique_ptr<DownloadUrlParameters> params,
+    std::unique_ptr<download::DownloadUrlParameters> params,
+    std::unique_ptr<storage::BlobDataHandle> blob_data_handle,
     content::ResourceContext* resource_context,
     uint32_t download_id,
     base::WeakPtr<DownloadManagerImpl> download_manager) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
+  params->set_blob_storage_context_getter(
+      base::BindOnce(&BlobStorageContextGetter, resource_context));
   std::unique_ptr<net::URLRequest> url_request =
       DownloadRequestCore::CreateRequestOnIOThread(download_id, params.get());
-  std::unique_ptr<storage::BlobDataHandle> blob_data_handle =
-      params->GetBlobDataHandle();
   if (blob_data_handle) {
     storage::BlobProtocolHandler::SetRequestedBlobDataHandle(
         url_request.get(), std::move(blob_data_handle));
@@ -154,12 +160,13 @@ DownloadManagerImpl::UniqueUrlDownloadHandlerPtr BeginDownload(
   // ResourceDispatcherHostImpl which will in turn pass it along to the
   // ResourceLoader.
   if (params->render_process_host_id() >= 0) {
-    DownloadInterruptReason reason = DownloadManagerImpl::BeginDownloadRequest(
-        std::move(url_request), resource_context, params.get());
+    download::DownloadInterruptReason reason =
+        DownloadManagerImpl::BeginDownloadRequest(
+            std::move(url_request), resource_context, params.get());
 
     // If the download was accepted, the DownloadResourceHandler is now
     // responsible for driving the request to completion.
-    if (reason == DOWNLOAD_INTERRUPT_REASON_NONE)
+    if (reason == download::DOWNLOAD_INTERRUPT_REASON_NONE)
       return nullptr;
 
     // Otherwise, create an interrupted download.
@@ -174,10 +181,10 @@ DownloadManagerImpl::UniqueUrlDownloadHandlerPtr BeginDownload(
 }
 
 DownloadManagerImpl::UniqueUrlDownloadHandlerPtr BeginResourceDownload(
-    std::unique_ptr<DownloadUrlParameters> params,
+    std::unique_ptr<download::DownloadUrlParameters> params,
     std::unique_ptr<network::ResourceRequest> request,
+    std::unique_ptr<storage::BlobDataHandle> blob_data_handle,
     scoped_refptr<URLLoaderFactoryGetter> url_loader_factory_getter,
-    scoped_refptr<storage::FileSystemContext> file_system_context,
     uint32_t download_id,
     base::WeakPtr<DownloadManagerImpl> download_manager,
     const GURL& site_url,
@@ -189,24 +196,30 @@ DownloadManagerImpl::UniqueUrlDownloadHandlerPtr BeginResourceDownload(
   if (params->render_process_host_id() >= 0 &&
       !CanRequestURLFromRenderer(params->render_process_host_id(),
                                  params->url())) {
-    CreateInterruptedDownload(params.get(),
-                              DOWNLOAD_INTERRUPT_REASON_NETWORK_INVALID_REQUEST,
-                              download_manager);
+    CreateInterruptedDownload(
+        params.get(),
+        download::DOWNLOAD_INTERRUPT_REASON_NETWORK_INVALID_REQUEST,
+        download_manager);
     return nullptr;
   }
 
-  ResourceRequestInfo::WebContentsGetter getter = base::BindRepeating(
-      WebContentsImpl::FromRenderFrameHostID, params->render_process_host_id(),
-      params->render_frame_host_routing_id());
-
+  network::mojom::URLLoaderFactory* url_loader_factory =
+      url_loader_factory_getter->GetNetworkFactory();
+  if (params->url().SchemeIs(url::kBlobScheme)) {
+    network::mojom::URLLoaderFactoryPtr url_loader_factory_ptr;
+    storage::BlobURLLoaderFactory::Create(
+        std::move(blob_data_handle), params->url(),
+        mojo::MakeRequest(&url_loader_factory_ptr));
+    url_loader_factory = url_loader_factory_ptr.get();
+  }
   // TODO(qinmin): Check the storage permission before creating the URLLoader.
   // This is already done for context menu download, but it is missing for
   // download service and download resumption.
   return DownloadManagerImpl::UniqueUrlDownloadHandlerPtr(
-      ResourceDownloader::BeginDownload(
-          download_manager, std::move(params), std::move(request),
-          url_loader_factory_getter, file_system_context, getter, site_url,
-          tab_url, tab_referrer_url, download_id, false)
+      ResourceDownloader::BeginDownload(download_manager, std::move(params),
+                                        std::move(request), url_loader_factory,
+                                        site_url, tab_url, tab_referrer_url,
+                                        download_id, false)
           .release());
 }
 
@@ -235,13 +248,13 @@ class DownloadItemFactoryImpl : public DownloadItemFactory {
       int64_t received_bytes,
       int64_t total_bytes,
       const std::string& hash,
-      DownloadItem::DownloadState state,
-      DownloadDangerType danger_type,
-      DownloadInterruptReason interrupt_reason,
+      download::DownloadItem::DownloadState state,
+      download::DownloadDangerType danger_type,
+      download::DownloadInterruptReason interrupt_reason,
       bool opened,
       base::Time last_access_time,
       bool transient,
-      const std::vector<DownloadItem::ReceivedSlice>& received_slices)
+      const std::vector<download::DownloadItem::ReceivedSlice>& received_slices)
       override {
     return new DownloadItemImpl(
         delegate, guid, download_id, current_path, target_path, url_chain,
@@ -251,9 +264,10 @@ class DownloadItemFactoryImpl : public DownloadItemFactory {
         opened, last_access_time, transient, received_slices);
   }
 
-  DownloadItemImpl* CreateActiveItem(DownloadItemImplDelegate* delegate,
-                                     uint32_t download_id,
-                                     const DownloadCreateInfo& info) override {
+  DownloadItemImpl* CreateActiveItem(
+      DownloadItemImplDelegate* delegate,
+      uint32_t download_id,
+      const download::DownloadCreateInfo& info) override {
     return new DownloadItemImpl(delegate, download_id, info);
   }
 
@@ -263,7 +277,8 @@ class DownloadItemFactoryImpl : public DownloadItemFactory {
       const base::FilePath& path,
       const GURL& url,
       const std::string& mime_type,
-      std::unique_ptr<DownloadRequestHandleInterface> request_handle) override {
+      std::unique_ptr<download::DownloadRequestHandleInterface> request_handle)
+      override {
     return new DownloadItemImpl(delegate, download_id, path, url, mime_type,
                                 std::move(request_handle));
   }
@@ -280,16 +295,16 @@ base::FilePath GetTemporaryDownloadDirectory() {
 
 // Responsible for persisting the in-progress metadata associated with a
 // download.
-class InProgressDownloadObserver : public DownloadItem::Observer {
+class InProgressDownloadObserver : public download::DownloadItem::Observer {
  public:
   explicit InProgressDownloadObserver(
       download::InProgressCache* in_progress_cache);
   ~InProgressDownloadObserver() override;
 
  private:
-  // DownloadItem::Observer
-  void OnDownloadUpdated(DownloadItem* download) override;
-  void OnDownloadRemoved(DownloadItem* download) override;
+  // download::DownloadItem::Observer
+  void OnDownloadUpdated(download::DownloadItem* download) override;
+  void OnDownloadRemoved(download::DownloadItem* download) override;
 
   // The persistent cache to store in-progress metadata.
   download::InProgressCache* in_progress_cache_;
@@ -303,19 +318,20 @@ InProgressDownloadObserver::InProgressDownloadObserver(
 
 InProgressDownloadObserver::~InProgressDownloadObserver() = default;
 
-void InProgressDownloadObserver::OnDownloadUpdated(DownloadItem* download) {
+void InProgressDownloadObserver::OnDownloadUpdated(
+    download::DownloadItem* download) {
   // TODO(crbug.com/778425): Properly handle fail/resume/retry for downloads
   // that are in the INTERRUPTED state for a long time.
   if (!in_progress_cache_)
     return;
 
   switch (download->GetState()) {
-    case DownloadItem::DownloadState::COMPLETE:
-    case DownloadItem::DownloadState::CANCELLED:
+    case download::DownloadItem::DownloadState::COMPLETE:
+    case download::DownloadItem::DownloadState::CANCELLED:
       if (in_progress_cache_)
         in_progress_cache_->RemoveEntry(download->GetGuid());
       break;
-    case DownloadItem::DownloadState::IN_PROGRESS:
+    case download::DownloadItem::DownloadState::IN_PROGRESS:
       // TODO(crbug.com/778425): After RetrieveEntry has been implemented, do a
       // check to make sure the entry exists in the cache.
       break;
@@ -324,7 +340,8 @@ void InProgressDownloadObserver::OnDownloadUpdated(DownloadItem* download) {
   }
 }
 
-void InProgressDownloadObserver::OnDownloadRemoved(DownloadItem* download) {
+void InProgressDownloadObserver::OnDownloadRemoved(
+    download::DownloadItem* download) {
   if (!in_progress_cache_)
     return;
 
@@ -350,10 +367,11 @@ DownloadManagerImpl::~DownloadManagerImpl() {
 
 DownloadItemImpl* DownloadManagerImpl::CreateActiveItem(
     uint32_t id,
-    const DownloadCreateInfo& info) {
+    const download::DownloadCreateInfo& info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!base::ContainsKey(downloads_, id));
   DownloadItemImpl* download = item_factory_->CreateActiveItem(this, id, info);
+
   downloads_[id] = base::WrapUnique(download);
   downloads_by_guid_[download->GetGuid()] = download;
   return download;
@@ -365,7 +383,7 @@ void DownloadManagerImpl::GetNextId(const DownloadIdCallback& callback) {
     delegate_->GetNextId(callback);
     return;
   }
-  static uint32_t next_id = content::DownloadItem::kInvalidId + 1;
+  static uint32_t next_id = download::DownloadItem::kInvalidId + 1;
   callback.Run(next_id++);
 }
 
@@ -379,9 +397,10 @@ void DownloadManagerImpl::DetermineDownloadTarget(
   if (!delegate_ || !delegate_->DetermineDownloadTarget(item, callback)) {
     base::FilePath target_path = item->GetForcedFilePath();
     // TODO(asanka): Determine a useful path if |target_path| is empty.
-    callback.Run(target_path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
-                 DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, target_path,
-                 DOWNLOAD_INTERRUPT_REASON_NONE);
+    callback.Run(target_path,
+                 download::DownloadItem::TARGET_DISPOSITION_OVERWRITE,
+                 download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, target_path,
+                 download::DOWNLOAD_INTERRUPT_REASON_NONE);
   }
 }
 
@@ -460,7 +479,7 @@ void DownloadManagerImpl::Shutdown() {
   // file.
   for (const auto& it : downloads_) {
     DownloadItemImpl* download = it.second.get();
-    if (download->GetState() == DownloadItem::IN_PROGRESS)
+    if (download->GetState() == download::DownloadItem::IN_PROGRESS)
       download->Cancel(false);
   }
   downloads_.clear();
@@ -475,23 +494,45 @@ void DownloadManagerImpl::Shutdown() {
   delegate_ = nullptr;
 }
 
+bool DownloadManagerImpl::InterceptDownload(
+    const download::DownloadCreateInfo& info) {
+  WebContents* web_contents = WebContentsImpl::FromRenderFrameHostID(
+      info.render_process_id, info.render_frame_id);
+  if (!delegate_ ||
+      !delegate_->InterceptDownloadIfApplicable(
+          info.url(), info.mime_type, info.request_origin, web_contents)) {
+    return false;
+  }
+  if (info.request_handle)
+    info.request_handle->CancelRequest(false);
+  return true;
+}
+
 void DownloadManagerImpl::StartDownload(
-    std::unique_ptr<DownloadCreateInfo> info,
+    std::unique_ptr<download::DownloadCreateInfo> info,
     std::unique_ptr<DownloadManager::InputStream> stream,
-    const DownloadUrlParameters::OnStartedCallback& on_started) {
+    const download::DownloadUrlParameters::OnStartedCallback& on_started) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(info);
 
-  // |stream| is only non-nil if the download request was successful.
-  DCHECK(
-      (info->result == DOWNLOAD_INTERRUPT_REASON_NONE && !stream->IsEmpty()) ||
-      (info->result != DOWNLOAD_INTERRUPT_REASON_NONE && stream->IsEmpty()));
-  DVLOG(20) << __func__
-            << "() result=" << DownloadInterruptReasonToString(info->result);
   uint32_t download_id = info->download_id;
-  const bool new_download = (download_id == content::DownloadItem::kInvalidId);
+  bool new_download = (download_id == download::DownloadItem::kInvalidId);
+  if (new_download &&
+      info->result == download::DOWNLOAD_INTERRUPT_REASON_NONE &&
+      InterceptDownload(*info)) {
+    download::GetDownloadTaskRunner()->DeleteSoon(FROM_HERE, stream.release());
+    return;
+  }
+
+  // |stream| is only non-nil if the download request was successful.
+  DCHECK((info->result == download::DOWNLOAD_INTERRUPT_REASON_NONE &&
+          !stream->IsEmpty()) ||
+         (info->result != download::DOWNLOAD_INTERRUPT_REASON_NONE &&
+          stream->IsEmpty()));
+  DVLOG(20) << __func__ << "() result="
+            << download::DownloadInterruptReasonToString(info->result);
   if (new_download)
-    RecordDownloadConnectionSecurity(info->url(), info->url_chain);
+    download::RecordDownloadConnectionSecurity(info->url(), info->url_chain);
   base::Callback<void(uint32_t)> got_id(base::Bind(
       &DownloadManagerImpl::StartDownloadWithId, weak_factory_.GetWeakPtr(),
       base::Passed(&info), base::Passed(&stream), on_started, new_download));
@@ -503,13 +544,13 @@ void DownloadManagerImpl::StartDownload(
 }
 
 void DownloadManagerImpl::StartDownloadWithId(
-    std::unique_ptr<DownloadCreateInfo> info,
+    std::unique_ptr<download::DownloadCreateInfo> info,
     std::unique_ptr<DownloadManager::InputStream> stream,
-    const DownloadUrlParameters::OnStartedCallback& on_started,
+    const download::DownloadUrlParameters::OnStartedCallback& on_started,
     bool new_download,
     uint32_t id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK_NE(content::DownloadItem::kInvalidId, id);
+  DCHECK_NE(download::DownloadItem::kInvalidId, id);
   DownloadItemImpl* download = nullptr;
   if (new_download) {
     download = CreateActiveItem(id, *info);
@@ -517,20 +558,28 @@ void DownloadManagerImpl::StartDownloadWithId(
     auto item_iterator = downloads_.find(id);
     // Trying to resume an interrupted download.
     if (item_iterator == downloads_.end() ||
-        (item_iterator->second->GetState() == DownloadItem::CANCELLED)) {
+        (item_iterator->second->GetState() ==
+         download::DownloadItem::CANCELLED)) {
       // If the download is no longer known to the DownloadManager, then it was
       // removed after it was resumed. Ignore. If the download is cancelled
       // while resuming, then also ignore the request.
-      info->request_handle->CancelRequest(true);
+      if (info->request_handle)
+        info->request_handle->CancelRequest(true);
       if (!on_started.is_null())
-        on_started.Run(nullptr, DOWNLOAD_INTERRUPT_REASON_USER_CANCELED);
+        on_started.Run(nullptr,
+                       download::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED);
       // The ByteStreamReader lives and dies on the download sequence.
-      if (info->result == DOWNLOAD_INTERRUPT_REASON_NONE)
-        GetDownloadTaskRunner()->DeleteSoon(FROM_HERE, stream.release());
+      if (info->result == download::DOWNLOAD_INTERRUPT_REASON_NONE)
+        download::GetDownloadTaskRunner()->DeleteSoon(FROM_HERE,
+                                                      stream.release());
       return;
     }
     download = item_iterator->second.get();
   }
+  DownloadItemUtils::AttachInfo(
+      download, GetBrowserContext(),
+      WebContentsImpl::FromRenderFrameHostID(info->render_process_id,
+                                             info->render_frame_id));
 
   base::FilePath default_download_directory;
 #if defined(USE_X11)
@@ -547,6 +596,12 @@ void DownloadManagerImpl::StartDownloadWithId(
                           &default_download_directory, &skip_dir_check);
   }
 #endif
+  if (default_download_directory.empty()) {
+    // |default_download_directory| can still be empty if ContentBrowserClient
+    // returned an empty path for the downloads directory.
+    default_download_directory =
+        GetContentClient()->browser()->GetDefaultDownloadDirectory();
+  }
 
   if (delegate_) {
     download::InProgressCache* in_progress_cache =
@@ -571,15 +626,15 @@ void DownloadManagerImpl::StartDownloadWithId(
 
   std::unique_ptr<DownloadFile> download_file;
 
-  if (info->result == DOWNLOAD_INTERRUPT_REASON_NONE) {
+  if (info->result == download::DOWNLOAD_INTERRUPT_REASON_NONE) {
     DCHECK(stream.get());
     download_file.reset(file_factory_->CreateFile(
         std::move(info->save_info), default_download_directory,
         std::move(stream), id, download->DestinationObserverAsWeakPtr()));
   }
   // It is important to leave info->save_info intact in the case of an interrupt
-  // so that the DownloadItem can salvage what it can out of a failed resumption
-  // attempt.
+  // so that the download::DownloadItem can salvage what it can out of a failed
+  // resumption attempt.
 
   download->Start(std::move(download_file), std::move(info->request_handle),
                   *info);
@@ -595,7 +650,7 @@ void DownloadManagerImpl::StartDownloadWithId(
   }
 
   if (!on_started.is_null())
-    on_started.Run(download, DOWNLOAD_INTERRUPT_REASON_NONE);
+    on_started.Run(download, download::DOWNLOAD_INTERRUPT_REASON_NONE);
 }
 
 void DownloadManagerImpl::CheckForHistoryFilesRemoval() {
@@ -608,9 +663,8 @@ void DownloadManagerImpl::CheckForHistoryFilesRemoval() {
 
 void DownloadManagerImpl::CheckForFileRemoval(DownloadItemImpl* download_item) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if ((download_item->GetState() == DownloadItem::COMPLETE) &&
-      !download_item->GetFileExternallyRemoved() &&
-      delegate_) {
+  if ((download_item->GetState() == download::DownloadItem::COMPLETE) &&
+      !download_item->GetFileExternallyRemoved() && delegate_) {
     delegate_->CheckForFileExistence(
         download_item,
         base::BindOnce(&DownloadManagerImpl::OnFileExistenceChecked,
@@ -641,13 +695,16 @@ void DownloadManagerImpl::CreateSavePackageDownloadItem(
     const base::FilePath& main_file_path,
     const GURL& page_url,
     const std::string& mime_type,
-    std::unique_ptr<DownloadRequestHandleInterface> request_handle,
+    int render_process_id,
+    int render_frame_id,
+    std::unique_ptr<download::DownloadRequestHandleInterface> request_handle,
     const ukm::SourceId ukm_source_id,
     const DownloadItemImplCreated& item_created) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   GetNextId(base::Bind(
       &DownloadManagerImpl::CreateSavePackageDownloadItemWithId,
       weak_factory_.GetWeakPtr(), main_file_path, page_url, mime_type,
+      render_process_id, render_frame_id,
       base::Passed(std::move(request_handle)), ukm_source_id, item_created));
 }
 
@@ -655,15 +712,20 @@ void DownloadManagerImpl::CreateSavePackageDownloadItemWithId(
     const base::FilePath& main_file_path,
     const GURL& page_url,
     const std::string& mime_type,
-    std::unique_ptr<DownloadRequestHandleInterface> request_handle,
+    int render_process_id,
+    int render_frame_id,
+    std::unique_ptr<download::DownloadRequestHandleInterface> request_handle,
     const ukm::SourceId ukm_source_id,
     const DownloadItemImplCreated& item_created,
     uint32_t id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK_NE(content::DownloadItem::kInvalidId, id);
+  DCHECK_NE(download::DownloadItem::kInvalidId, id);
   DCHECK(!base::ContainsKey(downloads_, id));
   DownloadItemImpl* download_item = item_factory_->CreateSavePageItem(
       this, id, main_file_path, page_url, mime_type, std::move(request_handle));
+  DownloadItemUtils::AttachInfo(download_item, GetBrowserContext(),
+                                WebContentsImpl::FromRenderFrameHostID(
+                                    render_process_id, render_frame_id));
   downloads_[download_item->GetId()] = base::WrapUnique(download_item);
   DCHECK(!base::ContainsKey(downloads_by_guid_, download_item->GetGuid()));
   downloads_by_guid_[download_item->GetGuid()] = download_item;
@@ -692,9 +754,9 @@ void DownloadManagerImpl::CreateSavePackageDownloadItemWithId(
 // ResourceDispatcherHost, and let it send us responses like a regular
 // download.
 void DownloadManagerImpl::ResumeInterruptedDownload(
-    std::unique_ptr<content::DownloadUrlParameters> params,
+    std::unique_ptr<download::DownloadUrlParameters> params,
     uint32_t id) {
-  BeginDownloadInternal(std::move(params), id);
+  BeginDownloadInternal(std::move(params), nullptr, id);
 }
 
 
@@ -728,17 +790,20 @@ void DownloadManagerImpl::AddUrlDownloadHandler(
 }
 
 // static
-DownloadInterruptReason DownloadManagerImpl::BeginDownloadRequest(
+download::DownloadInterruptReason DownloadManagerImpl::BeginDownloadRequest(
     std::unique_ptr<net::URLRequest> url_request,
     ResourceContext* resource_context,
-    DownloadUrlParameters* params) {
+    download::DownloadUrlParameters* params) {
   if (ResourceDispatcherHostImpl::Get()->is_shutdown())
-    return DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN;
+    return download::DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN;
 
   // The URLRequest needs to be initialized with the referrer and other
   // information prior to issuing it.
   ResourceDispatcherHostImpl::Get()->InitializeURLRequest(
-      url_request.get(), params->referrer(),
+      url_request.get(),
+      Referrer(params->referrer(),
+               Referrer::NetReferrerPolicyToBlinkReferrerPolicy(
+                   params->referrer_policy())),
       true,  // download.
       params->render_process_host_id(), params->render_view_host_routing_id(),
       params->render_frame_host_routing_id(), PREVIEWS_OFF, resource_context);
@@ -756,13 +821,13 @@ DownloadInterruptReason DownloadManagerImpl::BeginDownloadRequest(
 
   // Check if the renderer is permitted to request the requested URL.
   if (!CanRequestURLFromRenderer(params->render_process_host_id(), url))
-    return DOWNLOAD_INTERRUPT_REASON_NETWORK_INVALID_REQUEST;
+    return download::DOWNLOAD_INTERRUPT_REASON_NETWORK_INVALID_REQUEST;
 
   const net::URLRequestContext* request_context = url_request->context();
   if (!request_context->job_factory()->IsHandledProtocol(url.scheme())) {
     DVLOG(1) << "Download request for unsupported protocol: "
              << url.possibly_invalid_spec();
-    return DOWNLOAD_INTERRUPT_REASON_NETWORK_INVALID_REQUEST;
+    return download::DOWNLOAD_INTERRUPT_REASON_NETWORK_INVALID_REQUEST;
   }
 
   // From this point forward, the |DownloadResourceHandler| is responsible for
@@ -771,13 +836,14 @@ DownloadInterruptReason DownloadManagerImpl::BeginDownloadRequest(
   // Find a better way to create the DownloadResourceHandler instance.
   std::unique_ptr<ResourceHandler> handler(
       DownloadResourceHandler::CreateForNewRequest(url_request.get(),
+                                                   params->request_origin(),
                                                    params->download_source()));
 
   ResourceDispatcherHostImpl::Get()->BeginURLRequest(
       std::move(url_request), std::move(handler), true,  // download
       params->content_initiated(), params->do_not_prompt_for_login(),
       resource_context);
-  return DOWNLOAD_INTERRUPT_REASON_NONE;
+  return download::DOWNLOAD_INTERRUPT_REASON_NONE;
 }
 
 void DownloadManagerImpl::InterceptNavigation(
@@ -794,6 +860,7 @@ void DownloadManagerImpl::InterceptNavigation(
 
   const GURL& url = resource_request->url;
   const std::string& method = resource_request->method;
+
   ResourceRequestInfo::WebContentsGetter web_contents_getter =
       base::BindRepeating(WebContents::FromFrameTreeNodeId, frame_tree_node_id);
 
@@ -821,7 +888,7 @@ int DownloadManagerImpl::RemoveDownloadsByURLAndTime(
     // Increment done here to protect against invalidation below.
     ++it;
 
-    if (download->GetState() != DownloadItem::IN_PROGRESS &&
+    if (download->GetState() != download::DownloadItem::IN_PROGRESS &&
         url_filter.Run(download->GetURL()) &&
         download->GetStartTime() >= remove_begin &&
         (remove_end.is_null() || download->GetStartTime() < remove_end)) {
@@ -833,16 +900,24 @@ int DownloadManagerImpl::RemoveDownloadsByURLAndTime(
 }
 
 void DownloadManagerImpl::DownloadUrl(
-    std::unique_ptr<DownloadUrlParameters> params) {
+    std::unique_ptr<download::DownloadUrlParameters> params) {
+  DownloadUrl(std::move(params), nullptr);
+}
+
+void DownloadManagerImpl::DownloadUrl(
+    std::unique_ptr<download::DownloadUrlParameters> params,
+    std::unique_ptr<storage::BlobDataHandle> blob_data_handle) {
   if (params->post_id() >= 0) {
     // Check this here so that the traceback is more useful.
     DCHECK(params->prefer_cache());
     DCHECK_EQ("POST", params->method());
   }
 
-  RecordDownloadCountWithSource(DownloadCountTypes::DOWNLOAD_TRIGGERED_COUNT,
-                                params->download_source());
-  BeginDownloadInternal(std::move(params), content::DownloadItem::kInvalidId);
+  download::RecordDownloadCountWithSource(
+      download::DownloadCountTypes::DOWNLOAD_TRIGGERED_COUNT,
+      params->download_source());
+  BeginDownloadInternal(std::move(params), std::move(blob_data_handle),
+                        download::DownloadItem::kInvalidId);
 }
 
 void DownloadManagerImpl::AddObserver(Observer* observer) {
@@ -853,7 +928,7 @@ void DownloadManagerImpl::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
-DownloadItem* DownloadManagerImpl::CreateDownloadItem(
+download::DownloadItem* DownloadManagerImpl::CreateDownloadItem(
     const std::string& guid,
     uint32_t id,
     const base::FilePath& current_path,
@@ -872,13 +947,13 @@ DownloadItem* DownloadManagerImpl::CreateDownloadItem(
     int64_t received_bytes,
     int64_t total_bytes,
     const std::string& hash,
-    DownloadItem::DownloadState state,
-    DownloadDangerType danger_type,
-    DownloadInterruptReason interrupt_reason,
+    download::DownloadItem::DownloadState state,
+    download::DownloadDangerType danger_type,
+    download::DownloadInterruptReason interrupt_reason,
     bool opened,
     base::Time last_access_time,
     bool transient,
-    const std::vector<DownloadItem::ReceivedSlice>& received_slices) {
+    const std::vector<download::DownloadItem::ReceivedSlice>& received_slices) {
   if (base::ContainsKey(downloads_, id)) {
     NOTREACHED();
     return nullptr;
@@ -890,6 +965,7 @@ DownloadItem* DownloadManagerImpl::CreateDownloadItem(
       start_time, end_time, etag, last_modified, received_bytes, total_bytes,
       hash, state, danger_type, interrupt_reason, opened, last_access_time,
       transient, received_slices);
+  DownloadItemUtils::AttachInfo(item, GetBrowserContext(), nullptr);
   downloads_[id] = base::WrapUnique(item);
   downloads_by_guid_[guid] = item;
   for (auto& observer : observers_)
@@ -934,7 +1010,7 @@ bool DownloadManagerImpl::IsManagerInitialized() const {
 int DownloadManagerImpl::InProgressCount() const {
   int count = 0;
   for (const auto& it : downloads_) {
-    if (it.second->GetState() == DownloadItem::IN_PROGRESS)
+    if (it.second->GetState() == download::DownloadItem::IN_PROGRESS)
       ++count;
   }
   return count;
@@ -943,33 +1019,37 @@ int DownloadManagerImpl::InProgressCount() const {
 int DownloadManagerImpl::NonMaliciousInProgressCount() const {
   int count = 0;
   for (const auto& it : downloads_) {
-    if (it.second->GetState() == DownloadItem::IN_PROGRESS &&
-        it.second->GetDangerType() != DOWNLOAD_DANGER_TYPE_DANGEROUS_URL &&
-        it.second->GetDangerType() != DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT &&
-        it.second->GetDangerType() != DOWNLOAD_DANGER_TYPE_DANGEROUS_HOST &&
+    if (it.second->GetState() == download::DownloadItem::IN_PROGRESS &&
+        it.second->GetDangerType() !=
+            download::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL &&
         it.second->GetDangerType() !=
-            DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED) {
+            download::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT &&
+        it.second->GetDangerType() !=
+            download::DOWNLOAD_DANGER_TYPE_DANGEROUS_HOST &&
+        it.second->GetDangerType() !=
+            download::DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED) {
       ++count;
     }
   }
   return count;
 }
 
-DownloadItem* DownloadManagerImpl::GetDownload(uint32_t download_id) {
+download::DownloadItem* DownloadManagerImpl::GetDownload(uint32_t download_id) {
   return base::ContainsKey(downloads_, download_id)
              ? downloads_[download_id].get()
              : nullptr;
 }
 
-DownloadItem* DownloadManagerImpl::GetDownloadByGuid(const std::string& guid) {
+download::DownloadItem* DownloadManagerImpl::GetDownloadByGuid(
+    const std::string& guid) {
   return base::ContainsKey(downloads_by_guid_, guid) ? downloads_by_guid_[guid]
                                                      : nullptr;
 }
 
 void DownloadManagerImpl::OnUrlDownloadStarted(
-    std::unique_ptr<DownloadCreateInfo> download_create_info,
+    std::unique_ptr<download::DownloadCreateInfo> download_create_info,
     std::unique_ptr<DownloadManager::InputStream> stream,
-    const DownloadUrlParameters::OnStartedCallback& callback) {
+    const download::DownloadUrlParameters::OnStartedCallback& callback) {
   StartDownload(std::move(download_create_info), std::move(stream), callback);
 }
 
@@ -993,11 +1073,11 @@ void DownloadManagerImpl::OpenDownload(DownloadItemImpl* download) {
   int num_unopened = 0;
   for (const auto& it : downloads_) {
     DownloadItemImpl* item = it.second.get();
-    if ((item->GetState() == DownloadItem::COMPLETE) &&
+    if ((item->GetState() == download::DownloadItem::COMPLETE) &&
         !item->GetOpened())
       ++num_unopened;
   }
-  RecordOpensOutstanding(num_unopened);
+  download::RecordOpensOutstanding(num_unopened);
 
   if (delegate_)
     delegate_->OpenDownload(download);
@@ -1026,11 +1106,21 @@ void DownloadManagerImpl::InterceptNavigationOnChecksComplete(
   if (!is_download_allowed)
     return;
 
+  int render_process_id = -1;
+  int render_frame_id = -1;
+  WebContents* web_contents = web_contents_getter.Run();
+  if (web_contents) {
+    RenderFrameHost* render_frame_host = web_contents->GetMainFrame();
+    if (render_frame_host) {
+      render_process_id = render_frame_host->GetProcess()->GetID();
+      render_frame_id = render_frame_host->GetRoutingID();
+    }
+  }
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::BindOnce(&DownloadManagerImpl::CreateDownloadHandlerForNavigation,
-                     weak_factory_.GetWeakPtr(), web_contents_getter,
-                     std::move(resource_request), std::move(url_chain),
+                     weak_factory_.GetWeakPtr(), std::move(resource_request),
+                     render_process_id, render_frame_id, std::move(url_chain),
                      suggested_filename, std::move(response),
                      std::move(cert_status),
                      std::move(url_loader_client_endpoints)));
@@ -1039,8 +1129,9 @@ void DownloadManagerImpl::InterceptNavigationOnChecksComplete(
 // static
 void DownloadManagerImpl::CreateDownloadHandlerForNavigation(
     base::WeakPtr<DownloadManagerImpl> download_manager,
-    ResourceRequestInfo::WebContentsGetter web_contents_getter,
     std::unique_ptr<network::ResourceRequest> resource_request,
+    int render_process_id,
+    int render_frame_id,
     std::vector<GURL> url_chain,
     const base::Optional<std::string>& suggested_filename,
     scoped_refptr<network::ResourceResponse> response,
@@ -1050,9 +1141,9 @@ void DownloadManagerImpl::CreateDownloadHandlerForNavigation(
 
   std::unique_ptr<ResourceDownloader> resource_downloader =
       ResourceDownloader::InterceptNavigationResponse(
-          download_manager, std::move(resource_request),
-          std::move(web_contents_getter), std::move(url_chain),
-          suggested_filename, std::move(response), std::move(cert_status),
+          download_manager, std::move(resource_request), render_process_id,
+          render_frame_id, std::move(url_chain), suggested_filename,
+          std::move(response), std::move(cert_status),
           std::move(url_loader_client_endpoints));
 
   BrowserThread::PostTask(
@@ -1064,9 +1155,10 @@ void DownloadManagerImpl::CreateDownloadHandlerForNavigation(
 }
 
 void DownloadManagerImpl::BeginDownloadInternal(
-    std::unique_ptr<content::DownloadUrlParameters> params,
+    std::unique_ptr<download::DownloadUrlParameters> params,
+    std::unique_ptr<storage::BlobDataHandle> blob_data_handle,
     uint32_t id) {
-  if (base::FeatureList::IsEnabled(features::kNetworkService)) {
+  if (base::FeatureList::IsEnabled(network::features::kNetworkService)) {
     std::unique_ptr<network::ResourceRequest> request =
         CreateResourceRequest(params.get());
     StoragePartitionImpl* storage_partition =
@@ -1088,21 +1180,22 @@ void DownloadManagerImpl::BeginDownloadInternal(
 
     BrowserThread::PostTaskAndReplyWithResult(
         BrowserThread::IO, FROM_HERE,
-        base::BindOnce(
-            &BeginResourceDownload, std::move(params), std::move(request),
-            storage_partition->url_loader_factory_getter(),
-            base::WrapRefCounted(storage_partition->GetFileSystemContext()), id,
-            weak_factory_.GetWeakPtr(), site_url, tab_url, tab_referrer_url),
+        base::BindOnce(&BeginResourceDownload, std::move(params),
+                       std::move(request), std::move(blob_data_handle),
+                       storage_partition->url_loader_factory_getter(), id,
+                       weak_factory_.GetWeakPtr(), site_url, tab_url,
+                       tab_referrer_url),
         base::BindOnce(&DownloadManagerImpl::AddUrlDownloadHandler,
                        weak_factory_.GetWeakPtr()));
   } else {
     BrowserThread::PostTaskAndReplyWithResult(
         BrowserThread::IO, FROM_HERE,
         base::BindOnce(&BeginDownload, std::move(params),
+                       std::move(blob_data_handle),
                        browser_context_->GetResourceContext(), id,
                        weak_factory_.GetWeakPtr()),
-         base::BindOnce(&DownloadManagerImpl::AddUrlDownloadHandler,
-                        weak_factory_.GetWeakPtr()));
+        base::BindOnce(&DownloadManagerImpl::AddUrlDownloadHandler,
+                       weak_factory_.GetWeakPtr()));
    }
 }