Sends the blob uuid of the request body to the ServiceWorker.

This changes the followings:
 - ResourceDispatcherHostImpl passes the reference of ResourceRequestBody to ServiceWorkerControlleeRequestHandler via ServiceWorkerProviderHost.
 - ServiceWorkerControlleeRequestHandler keeps the reference of ResourceRequestBody and pass it to ServiceWorkerURLRequestJob when MaybeCreateJob() is called.
 - ServiceWorkerURLRequestJob keeps the reference of ResourceRequestBody and creates BlobDataHandle and ServiceWorkerFetchRequest from URLRequest and ResourceRequestBody when StartRequest() is called.
 - ServiceWorkerURLRequestJob passes the ServiceWorkerFetchRequest to ServiceWorkerFetchDispatcher in StartRequest() and ServiceWorkerVersion will send the blob uuid and the size of the blob using IPC to the renederer process.
 - BlobDataHandle is kept during the lifetime of ServiceWorkerURLRequestJob.

 - In the ServiceWorker side, WebServiceWorkerRequest::setBlob() will be called with the blob uuid and the size of the blob.
   WebServiceWorkerRequest::setBlob() is introduced in https://codereview.chromium.org/483603003/


This cl depends on https://codereview.chromium.org/483603003/ and https://codereview.chromium.org/483613004/ .

BUG=402387

Review URL: https://codereview.chromium.org/475333002

Cr-Commit-Position: refs/heads/master@{#290795}
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@290795 0039d316-1c4b-4281-b951-d872f2087c98

content/browser/loader/resource_dispatcher_host_impl.cc

@@ -1116,7 +1116,8 @@ void ResourceDispatcherHostImpl::BeginRequest(
       GetBlobStorageContext(filter_),
       child_id,
       request_data.service_worker_provider_id,
-      request_data.resource_type);
+      request_data.resource_type,
+      request_data.request_body);
 
   // Have the appcache associate its extra info with the request.
   AppCacheInterceptor::SetExtraRequestInfo(

content/browser/service_worker/service_worker_controllee_request_handler.cc

@@ -10,6 +10,7 @@
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_url_request_job.h"
 #include "content/browser/service_worker/service_worker_utils.h"
+#include "content/common/resource_request_body.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_util.h"
@@ -21,13 +22,15 @@ ServiceWorkerControlleeRequestHandler::ServiceWorkerControlleeRequestHandler(
     base::WeakPtr<ServiceWorkerContextCore> context,
     base::WeakPtr<ServiceWorkerProviderHost> provider_host,
     base::WeakPtr<webkit_blob::BlobStorageContext> blob_storage_context,
-    ResourceType resource_type)
+    ResourceType resource_type,
+    scoped_refptr<ResourceRequestBody> body)
     : ServiceWorkerRequestHandler(context,
                                   provider_host,
                                   blob_storage_context,
                                   resource_type),
       is_main_resource_load_(
           ServiceWorkerUtils::IsMainResourceType(resource_type)),
+      body_(body),
       weak_factory_(this) {
 }
 
@@ -79,7 +82,7 @@ net::URLRequestJob* ServiceWorkerControlleeRequestHandler::MaybeCreateJob(
   DCHECK(!job_.get() || job_->ShouldForwardToServiceWorker());
 
   job_ = new ServiceWorkerURLRequestJob(
-      request, network_delegate, provider_host_, blob_storage_context_);
+      request, network_delegate, provider_host_, blob_storage_context_, body_);
   if (is_main_resource_load_)
     PrepareForMainResource(request->url());
   else

content/browser/service_worker/service_worker_controllee_request_handler.h

@@ -15,6 +15,7 @@ class URLRequest;
 
 namespace content {
 
+class ResourceRequestBody;
 class ServiceWorkerRegistration;
 class ServiceWorkerURLRequestJob;
 class ServiceWorkerVersion;
@@ -28,7 +29,8 @@ class CONTENT_EXPORT ServiceWorkerControlleeRequestHandler
       base::WeakPtr<ServiceWorkerContextCore> context,
       base::WeakPtr<ServiceWorkerProviderHost> provider_host,
       base::WeakPtr<webkit_blob::BlobStorageContext> blob_storage_context,
-      ResourceType resource_type);
+      ResourceType resource_type,
+      scoped_refptr<ResourceRequestBody> body);
   virtual ~ServiceWorkerControlleeRequestHandler();
 
   // Called via custom URLRequestJobFactory.
@@ -59,6 +61,7 @@ class CONTENT_EXPORT ServiceWorkerControlleeRequestHandler
 
   bool is_main_resource_load_;
   scoped_refptr<ServiceWorkerURLRequestJob> job_;
+  scoped_refptr<ResourceRequestBody> body_;
   base::WeakPtrFactory<ServiceWorkerControlleeRequestHandler> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerControlleeRequestHandler);

content/browser/service_worker/service_worker_controllee_request_handler_unittest.cc

@@ -15,6 +15,7 @@
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_url_request_job.h"
 #include "content/browser/service_worker/service_worker_utils.h"
+#include "content/common/resource_request_body.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/url_request/url_request_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -98,7 +99,8 @@ TEST_F(ServiceWorkerControlleeRequestHandlerTest, ActivateWaitingVersion) {
           context()->AsWeakPtr(),
           provider_host_,
           base::WeakPtr<webkit_blob::BlobStorageContext>(),
-          RESOURCE_TYPE_MAIN_FRAME));
+          RESOURCE_TYPE_MAIN_FRAME,
+          scoped_refptr<ResourceRequestBody>()));
   scoped_refptr<net::URLRequestJob> job =
       handler->MaybeCreateJob(request.get(), NULL);
   ServiceWorkerURLRequestJob* sw_job =

content/browser/service_worker/service_worker_fetch_dispatcher.cc

@@ -6,30 +6,17 @@
 
 #include "base/bind.h"
 #include "content/browser/service_worker/service_worker_version.h"
-#include "content/public/browser/resource_request_info.h"
-#include "content/public/common/page_transition_types.h"
-#include "net/url_request/url_request.h"
 
 namespace content {
 
 ServiceWorkerFetchDispatcher::ServiceWorkerFetchDispatcher(
-    net::URLRequest* request,
+    scoped_ptr<ServiceWorkerFetchRequest> request,
     ServiceWorkerVersion* version,
     const FetchCallback& callback)
     : version_(version),
       callback_(callback),
+      request_(request.Pass()),
       weak_factory_(this) {
-  request_.url = request->url();
-  request_.method = request->method();
-  const net::HttpRequestHeaders& headers = request->extra_request_headers();
-  for (net::HttpRequestHeaders::Iterator it(headers); it.GetNext();)
-    request_.headers[it.name()] = it.value();
-  request_.referrer = GURL(request->referrer());
-  const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
-  if (info) {
-    request_.is_reload = PageTransitionCoreTypeIs(info->GetPageTransition(),
-                                                 PAGE_TRANSITION_RELOAD);
-  }
 }
 
 ServiceWorkerFetchDispatcher::~ServiceWorkerFetchDispatcher() {}
@@ -69,7 +56,7 @@ void ServiceWorkerFetchDispatcher::DidFailActivation() {
 
 void ServiceWorkerFetchDispatcher::DispatchFetchEvent() {
   version_->DispatchFetchEvent(
-      request_,
+      *request_.get(),
       base::Bind(&ServiceWorkerFetchDispatcher::DidFinish,
                  weak_factory_.GetWeakPtr()));
 }

content/browser/service_worker/service_worker_fetch_dispatcher.h

@@ -11,10 +11,6 @@
 #include "content/common/service_worker/service_worker_status_code.h"
 #include "content/common/service_worker/service_worker_types.h"
 
-namespace net {
-class URLRequest;
-}
-
 namespace content {
 
 class ServiceWorkerVersion;
@@ -26,8 +22,7 @@ class ServiceWorkerFetchDispatcher {
                               ServiceWorkerFetchEventResult,
                               const ServiceWorkerResponse&)> FetchCallback;
 
-  ServiceWorkerFetchDispatcher(
-      net::URLRequest* request,
+  ServiceWorkerFetchDispatcher(scoped_ptr<ServiceWorkerFetchRequest> request,
                                ServiceWorkerVersion* version,
                                const FetchCallback& callback);
   ~ServiceWorkerFetchDispatcher();
@@ -46,7 +41,7 @@ class ServiceWorkerFetchDispatcher {
 
   scoped_refptr<ServiceWorkerVersion> version_;
   FetchCallback callback_;
-  ServiceWorkerFetchRequest request_;
+  scoped_ptr<ServiceWorkerFetchRequest> request_;
   base::WeakPtrFactory<ServiceWorkerFetchDispatcher> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerFetchDispatcher);

content/browser/service_worker/service_worker_provider_host.cc

@@ -14,6 +14,7 @@
 #include "content/browser/service_worker/service_worker_registration_handle.h"
 #include "content/browser/service_worker/service_worker_utils.h"
 #include "content/browser/service_worker/service_worker_version.h"
+#include "content/common/resource_request_body.h"
 #include "content/common/service_worker/service_worker_messages.h"
 
 namespace content {
@@ -186,7 +187,8 @@ void ServiceWorkerProviderHost::UnassociateRegistration() {
 scoped_ptr<ServiceWorkerRequestHandler>
 ServiceWorkerProviderHost::CreateRequestHandler(
     ResourceType resource_type,
-    base::WeakPtr<webkit_blob::BlobStorageContext> blob_storage_context) {
+    base::WeakPtr<webkit_blob::BlobStorageContext> blob_storage_context,
+    scoped_refptr<ResourceRequestBody> body) {
   if (IsHostToRunningServiceWorker()) {
     return scoped_ptr<ServiceWorkerRequestHandler>(
         new ServiceWorkerContextRequestHandler(
@@ -196,7 +198,7 @@ ServiceWorkerProviderHost::CreateRequestHandler(
       active_version()) {
     return scoped_ptr<ServiceWorkerRequestHandler>(
         new ServiceWorkerControlleeRequestHandler(
-            context_, AsWeakPtr(), blob_storage_context, resource_type));
+            context_, AsWeakPtr(), blob_storage_context, resource_type, body));
   }
   return scoped_ptr<ServiceWorkerRequestHandler>();
 }

content/browser/service_worker/service_worker_provider_host.h

@@ -25,6 +25,7 @@ class BlobStorageContext;
 
 namespace content {
 
+class ResourceRequestBody;
 class ServiceWorkerContextCore;
 class ServiceWorkerDispatcherHost;
 class ServiceWorkerRequestHandler;
@@ -92,7 +93,8 @@ class CONTENT_EXPORT ServiceWorkerProviderHost
   // the request doesn't require special handling.
   scoped_ptr<ServiceWorkerRequestHandler> CreateRequestHandler(
       ResourceType resource_type,
-      base::WeakPtr<webkit_blob::BlobStorageContext> blob_storage_context);
+      base::WeakPtr<webkit_blob::BlobStorageContext> blob_storage_context,
+      scoped_refptr<ResourceRequestBody> body);
 
   // Returns true if |registration| can be associated with this provider.
   bool CanAssociateRegistration(ServiceWorkerRegistration* registration);

content/browser/service_worker/service_worker_request_handler.cc

@@ -12,6 +12,7 @@
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_url_request_job.h"
 #include "content/browser/service_worker/service_worker_utils.h"
+#include "content/common/resource_request_body.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_interceptor.h"
@@ -50,7 +51,8 @@ void ServiceWorkerRequestHandler::InitializeHandler(
     webkit_blob::BlobStorageContext* blob_storage_context,
     int process_id,
     int provider_id,
-    ResourceType resource_type) {
+    ResourceType resource_type,
+    scoped_refptr<ResourceRequestBody> body) {
   if (!request->url().SchemeIsHTTPOrHTTPS())
     return;
 
@@ -65,8 +67,8 @@ void ServiceWorkerRequestHandler::InitializeHandler(
     return;
 
   scoped_ptr<ServiceWorkerRequestHandler> handler(
-      provider_host->CreateRequestHandler(resource_type,
-                                          blob_storage_context->AsWeakPtr()));
+      provider_host->CreateRequestHandler(
+          resource_type, blob_storage_context->AsWeakPtr(), body));
   if (!handler)
     return;
 

content/browser/service_worker/service_worker_request_handler.h

@@ -25,6 +25,7 @@ class BlobStorageContext;
 
 namespace content {
 
+class ResourceRequestBody;
 class ServiceWorkerContextCore;
 class ServiceWorkerContextWrapper;
 class ServiceWorkerProviderHost;
@@ -46,7 +47,8 @@ class CONTENT_EXPORT ServiceWorkerRequestHandler
       webkit_blob::BlobStorageContext* blob_storage_context,
       int process_id,
       int provider_id,
-      ResourceType resource_type);
+      ResourceType resource_type,
+      scoped_refptr<ResourceRequestBody> body);
 
   // Returns the handler attached to |request|. This may return NULL
   // if no handler is attached.

content/browser/service_worker/service_worker_url_request_job.cc

@@ -9,9 +9,15 @@
 #include <vector>
 
 #include "base/bind.h"
+#include "base/guid.h"
 #include "base/strings/stringprintf.h"
 #include "content/browser/service_worker/service_worker_fetch_dispatcher.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
+#include "content/common/resource_request_body.h"
+#include "content/common/service_worker/service_worker_types.h"
+#include "content/public/browser/blob_handle.h"
+#include "content/public/browser/resource_request_info.h"
+#include "content/public/common/page_transition_types.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
@@ -26,12 +32,14 @@ ServiceWorkerURLRequestJob::ServiceWorkerURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     base::WeakPtr<ServiceWorkerProviderHost> provider_host,
-    base::WeakPtr<webkit_blob::BlobStorageContext> blob_storage_context)
+    base::WeakPtr<webkit_blob::BlobStorageContext> blob_storage_context,
+    scoped_refptr<ResourceRequestBody> body)
     : net::URLRequestJob(request, network_delegate),
       provider_host_(provider_host),
       response_type_(NOT_DETERMINED),
       is_started_(false),
       blob_storage_context_(blob_storage_context),
+      body_(body),
       weak_factory_(this) {
 }
 
@@ -216,11 +224,11 @@ void ServiceWorkerURLRequestJob::StartRequest() {
     case FORWARD_TO_SERVICE_WORKER:
       DCHECK(provider_host_ && provider_host_->active_version());
       DCHECK(!fetch_dispatcher_);
-
       // Send a fetch event to the ServiceWorker associated to the
       // provider_host.
       fetch_dispatcher_.reset(new ServiceWorkerFetchDispatcher(
-          request(), provider_host_->active_version(),
+          CreateFetchRequest(),
+          provider_host_->active_version(),
           base::Bind(&ServiceWorkerURLRequestJob::DidDispatchFetchEvent,
                      weak_factory_.GetWeakPtr())));
       fetch_dispatcher_->Run();
@@ -230,6 +238,90 @@ void ServiceWorkerURLRequestJob::StartRequest() {
   NOTREACHED();
 }
 
+scoped_ptr<ServiceWorkerFetchRequest>
+ServiceWorkerURLRequestJob::CreateFetchRequest() {
+  std::string blob_uuid;
+  uint64 blob_size = 0;
+  CreateRequestBodyBlob(&blob_uuid, &blob_size);
+  scoped_ptr<ServiceWorkerFetchRequest> request(
+      new ServiceWorkerFetchRequest());
+
+  request->url = request_->url();
+  request->method = request_->method();
+  const net::HttpRequestHeaders& headers = request_->extra_request_headers();
+  for (net::HttpRequestHeaders::Iterator it(headers); it.GetNext();)
+    request->headers[it.name()] = it.value();
+  request->blob_uuid = blob_uuid;
+  request->blob_size = blob_size;
+  request->referrer = GURL(request_->referrer());
+  const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request_);
+  if (info) {
+    request->is_reload = PageTransitionCoreTypeIs(info->GetPageTransition(),
+                                                  PAGE_TRANSITION_RELOAD);
+  }
+  return request.Pass();
+}
+
+bool ServiceWorkerURLRequestJob::CreateRequestBodyBlob(std::string* blob_uuid,
+                                                       uint64* blob_size) {
+  if (!body_ || !blob_storage_context_)
+    return false;
+  const std::string uuid(base::GenerateGUID());
+  uint64 size = 0;
+  std::vector<const ResourceRequestBody::Element*> resolved_elements;
+  for (size_t i = 0; i < body_->elements()->size(); ++i) {
+    const ResourceRequestBody::Element& element = (*body_->elements())[i];
+    if (element.type() != ResourceRequestBody::Element::TYPE_BLOB) {
+      resolved_elements.push_back(&element);
+      continue;
+    }
+    scoped_ptr<webkit_blob::BlobDataHandle> handle =
+        blob_storage_context_->GetBlobDataFromUUID(element.blob_uuid());
+    if (handle->data()->items().empty())
+      continue;
+    for (size_t i = 0; i < handle->data()->items().size(); ++i) {
+      const webkit_blob::BlobData::Item& item = handle->data()->items().at(i);
+      DCHECK_NE(webkit_blob::BlobData::Item::TYPE_BLOB, item.type());
+      resolved_elements.push_back(&item);
+    }
+  }
+  scoped_refptr<webkit_blob::BlobData> blob_data =
+      new webkit_blob::BlobData(uuid);
+  for (size_t i = 0; i < resolved_elements.size(); ++i) {
+    const ResourceRequestBody::Element& element = *resolved_elements[i];
+    size += element.length();
+    switch (element.type()) {
+      case ResourceRequestBody::Element::TYPE_BYTES:
+        blob_data->AppendData(element.bytes(), element.length());
+        break;
+      case ResourceRequestBody::Element::TYPE_FILE:
+        blob_data->AppendFile(element.path(),
+                              element.offset(),
+                              element.length(),
+                              element.expected_modification_time());
+        break;
+      case ResourceRequestBody::Element::TYPE_BLOB:
+        // Blob elements should be resolved beforehand.
+        NOTREACHED();
+        break;
+      case ResourceRequestBody::Element::TYPE_FILE_FILESYSTEM:
+        blob_data->AppendFileSystemFile(element.filesystem_url(),
+                                        element.offset(),
+                                        element.length(),
+                                        element.expected_modification_time());
+        break;
+      default:
+        NOTIMPLEMENTED();
+    }
+  }
+
+  request_body_blob_data_handle_ =
+      blob_storage_context_->AddFinishedBlob(blob_data.get());
+  *blob_uuid = uuid;
+  *blob_size = size;
+  return true;
+}
+
 void ServiceWorkerURLRequestJob::DidDispatchFetchEvent(
     ServiceWorkerStatusCode status,
     ServiceWorkerFetchEventResult fetch_result,

content/browser/service_worker/service_worker_url_request_job.h

@@ -17,11 +17,13 @@
 #include "net/url_request/url_request_job.h"
 
 namespace webkit_blob {
+class BlobDataHandle;
 class BlobStorageContext;
 }
 
 namespace content {
 
+class ResourceRequestBody;
 class ServiceWorkerContextCore;
 class ServiceWorkerFetchDispatcher;
 class ServiceWorkerProviderHost;
@@ -34,7 +36,8 @@ class CONTENT_EXPORT ServiceWorkerURLRequestJob
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate,
       base::WeakPtr<ServiceWorkerProviderHost> provider_host,
-      base::WeakPtr<webkit_blob::BlobStorageContext> blob_storage_context);
+      base::WeakPtr<webkit_blob::BlobStorageContext> blob_storage_context,
+      scoped_refptr<ResourceRequestBody> body);
 
   // Sets the response type.
   void FallbackToNetwork();
@@ -100,6 +103,14 @@ class CONTENT_EXPORT ServiceWorkerURLRequestJob
   void MaybeStartRequest();
   void StartRequest();
 
+  // Creates ServiceWorkerFetchRequest from |request_| and |body_|.
+  scoped_ptr<ServiceWorkerFetchRequest> CreateFetchRequest();
+
+  // Creates BlobDataHandle of the request body from |body_|. This handle
+  // |request_body_blob_data_handle_| will be deleted when
+  // ServiceWorkerURLRequestJob is deleted.
+  bool CreateRequestBodyBlob(std::string* blob_uuid, uint64* blob_size);
+
   // For FORWARD_TO_SERVICE_WORKER case.
   void DidDispatchFetchEvent(ServiceWorkerStatusCode status,
                              ServiceWorkerFetchEventResult fetch_result,
@@ -133,6 +144,10 @@ class CONTENT_EXPORT ServiceWorkerURLRequestJob
   scoped_ptr<ServiceWorkerFetchDispatcher> fetch_dispatcher_;
   base::WeakPtr<webkit_blob::BlobStorageContext> blob_storage_context_;
   scoped_ptr<net::URLRequest> blob_request_;
+  // ResourceRequestBody has a collection of BlobDataHandles attached to it
+  // using the userdata mechanism. So we have to keep it not to free the blobs.
+  scoped_refptr<ResourceRequestBody> body_;
+  scoped_ptr<webkit_blob::BlobDataHandle> request_body_blob_data_handle_;
 
   base::WeakPtrFactory<ServiceWorkerURLRequestJob> weak_factory_;
 

content/browser/service_worker/service_worker_url_request_job_unittest.cc

@@ -17,6 +17,7 @@
 #include "content/browser/service_worker/service_worker_test_utils.h"
 #include "content/browser/service_worker/service_worker_url_request_job.h"
 #include "content/browser/service_worker/service_worker_version.h"
+#include "content/common/resource_request_body.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/public/browser/blob_handle.h"
 #include "content/public/test/test_browser_context.h"
@@ -56,8 +57,12 @@ class MockHttpProtocolHandler
   virtual net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
-    ServiceWorkerURLRequestJob* job = new ServiceWorkerURLRequestJob(
-        request, network_delegate, provider_host_, blob_storage_context_);
+    ServiceWorkerURLRequestJob* job =
+        new ServiceWorkerURLRequestJob(request,
+                                       network_delegate,
+                                       provider_host_,
+                                       blob_storage_context_,
+                                       scoped_refptr<ResourceRequestBody>());
     job->ForwardToServiceWorker();
     return job;
   }

content/common/service_worker/service_worker_messages.h

@@ -35,6 +35,8 @@ IPC_STRUCT_TRAITS_BEGIN(content::ServiceWorkerFetchRequest)
   IPC_STRUCT_TRAITS_MEMBER(url)
   IPC_STRUCT_TRAITS_MEMBER(method)
   IPC_STRUCT_TRAITS_MEMBER(headers)
+  IPC_STRUCT_TRAITS_MEMBER(blob_uuid)
+  IPC_STRUCT_TRAITS_MEMBER(blob_size)
   IPC_STRUCT_TRAITS_MEMBER(referrer)
   IPC_STRUCT_TRAITS_MEMBER(is_reload)
 IPC_STRUCT_TRAITS_END()

content/common/service_worker/service_worker_types.cc

@@ -6,7 +6,8 @@
 
 namespace content {
 
-ServiceWorkerFetchRequest::ServiceWorkerFetchRequest() : is_reload(false) {
+ServiceWorkerFetchRequest::ServiceWorkerFetchRequest()
+    : blob_size(0), is_reload(false) {
 }
 
 ServiceWorkerFetchRequest::ServiceWorkerFetchRequest(
@@ -18,6 +19,7 @@ ServiceWorkerFetchRequest::ServiceWorkerFetchRequest(
     : url(url),
       method(method),
       headers(headers),
+      blob_size(0),
       referrer(referrer),
       is_reload(is_reload) {
 }

content/common/service_worker/service_worker_types.h

@@ -42,8 +42,6 @@ enum ServiceWorkerFetchEventResult {
 };
 
 // To dispatch fetch request from browser to child process.
-// TODO(kinuko): This struct will definitely need more fields and
-// we'll probably want to have response struct/class too.
 struct CONTENT_EXPORT ServiceWorkerFetchRequest {
   ServiceWorkerFetchRequest();
   ServiceWorkerFetchRequest(const GURL& url,
@@ -56,6 +54,8 @@ struct CONTENT_EXPORT ServiceWorkerFetchRequest {
   GURL url;
   std::string method;
   std::map<std::string, std::string> headers;
+  std::string blob_uuid;
+  uint64 blob_size;
   GURL referrer;
   bool is_reload;
 };

content/renderer/service_worker/service_worker_script_context.cc

@@ -149,6 +149,10 @@ void ServiceWorkerScriptContext::OnFetchEvent(
     webRequest.setHeader(blink::WebString::fromUTF8(it->first),
                          blink::WebString::fromUTF8(it->second));
   }
+  if (!request.blob_uuid.empty()) {
+    webRequest.setBlob(blink::WebString::fromUTF8(request.blob_uuid),
+                       request.blob_size);
+  }
   webRequest.setReferrer(blink::WebString::fromUTF8(request.referrer.spec()),
                          blink::WebReferrerPolicyDefault);
   webRequest.setIsReload(request.is_reload);