[WIP not ready for review] ServiceWorker Download support.

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 <utility>
 
 #include "base/bind.h"
@@ skipping 14 matching lines @@
 #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_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/loader/resource_request_info_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
+#include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/web_contents/web_contents_impl.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_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/storage_partition.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/log/net_log_source_type.h"
 #include "net/log/net_log_with_source.h"
 #include "net/url_request/url_request_context.h"
 #include "storage/browser/blob/blob_url_request_job_factory.h"
 #include "url/origin.h"
 
 namespace content {
 namespace {
 
 std::unique_ptr<UrlDownloader, BrowserThread::DeleteOnIOThread> BeginDownload(
     std::unique_ptr<DownloadUrlParameters> params,
     content::ResourceContext* resource_context,
+    scoped_refptr<ServiceWorkerContextWrapper> service_worker_context,
     uint32_t download_id,
     base::WeakPtr<DownloadManagerImpl> download_manager) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   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));
   }
 
   // If there's a valid renderer process associated with the request, then the
   // request should be driven by the ResourceLoader. Pass it over to the
   // 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), params->referrer(), resource_context,
-        params->content_initiated(), params->render_process_host_id(),
-        params->render_view_host_routing_id(),
+        service_worker_context.get(), params->content_initiated(),
+        params->render_process_host_id(), params->render_view_host_routing_id(),
         params->render_frame_host_routing_id(),
+        params->service_worker_provider_id(),
         params->do_not_prompt_for_login());
 
     // If the download was accepted, the DownloadResourceHandler is now
     // responsible for driving the request to completion.
     if (reason == DOWNLOAD_INTERRUPT_REASON_NONE)
       return nullptr;
 
     // Otherwise, create an interrupted download.
     std::unique_ptr<DownloadCreateInfo> failed_created_info(
         new DownloadCreateInfo(base::Time::Now(), net::NetLogWithSource(),
@@ skipping 380 matching lines @@
 
 // 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(
     std::unique_ptr<content::DownloadUrlParameters> params,
     uint32_t id) {
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&BeginDownload, base::Passed(&params),
-                 browser_context_->GetResourceContext(), id,
+                 browser_context_->GetResourceContext(),
+                 scoped_refptr<ServiceWorkerContextWrapper>(), id,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&DownloadManagerImpl::AddUrlDownloader,
                  weak_factory_.GetWeakPtr()));
 }
 
 void DownloadManagerImpl::SetDownloadItemFactoryForTesting(
     std::unique_ptr<DownloadItemFactory> item_factory) {
   item_factory_ = std::move(item_factory);
 }
 
@@ skipping 29 matching lines @@
       return;
     }
   }
 }
 
 // static
 DownloadInterruptReason DownloadManagerImpl::BeginDownloadRequest(
     std::unique_ptr<net::URLRequest> url_request,
     const Referrer& referrer,
     ResourceContext* resource_context,
+    ServiceWorkerContextWrapper* service_worker_context,
     bool is_content_initiated,
     int render_process_id,
     int render_view_route_id,
     int render_frame_route_id,
+    int service_worker_provider_id,
     bool do_not_prompt_for_login) {
   if (ResourceDispatcherHostImpl::Get()->is_shutdown())
     return 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(), referrer,
       true,  // download.
       render_process_id, render_view_route_id, render_frame_route_id,
-      resource_context);
+      service_worker_provider_id, resource_context, service_worker_context);
 
   // We treat a download as a main frame load, and thus update the policy URL on
   // redirects.
   //
   // TODO(davidben): Is this correct? If this came from a
   // ViewHostMsg_DownloadUrl in a frame, should it have first-party URL set
   // appropriately?
   url_request->set_first_party_url_policy(
       net::URLRequest::UPDATE_FIRST_PARTY_URL_ON_REDIRECT);
 
@@ skipping 77 matching lines @@
       base::Bind(&EmptyFilter);
   // The null times make the date range unbounded.
   int num_deleted = RemoveDownloadsByURLAndTime(
       empty_filter, base::Time(), base::Time());
   RecordClearAllSize(num_deleted);
   return num_deleted;
 }
 
 void DownloadManagerImpl::DownloadUrl(
     std::unique_ptr<DownloadUrlParameters> params) {
+  scoped_refptr<ServiceWorkerContextWrapper> service_worker_context;
+  RenderProcessHost* render_process_host =
+      RenderProcessHost::FromID(params->render_process_host_id());
+  if (render_process_host) {
+    StoragePartition* partition = render_process_host->GetStoragePartition();
+    if (partition) {
+      service_worker_context = static_cast<ServiceWorkerContextWrapper*>(
+          partition->GetServiceWorkerContext());
+    }
+  }
   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::PostTaskAndReplyWithResult(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&BeginDownload, base::Passed(&params),
                  browser_context_->GetResourceContext(),
+                 std::move(service_worker_context),
                  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) {
@@ skipping 97 matching lines @@
   if (delegate_)
     delegate_->OpenDownload(download);
 }
 
 void DownloadManagerImpl::ShowDownloadInShell(DownloadItemImpl* download) {
   if (delegate_)
     delegate_->ShowDownloadInShell(download);
 }
 
 }  // namespace content