service worker: Wait for request body blobs to finish construction

content/browser/service_worker/service_worker_url_request_job.cc

 // Copyright 2014 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/service_worker/service_worker_url_request_job.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 70 matching lines @@
     case m::REQUEST_JOB_ERROR_STREAM_ABORTED:
       return n::TYPE_SERVICE_WORKER_ERROR_STREAM_ABORTED;
     case m::REQUEST_JOB_ERROR_KILLED:
       return n::TYPE_SERVICE_WORKER_ERROR_KILLED;
     case m::REQUEST_JOB_ERROR_KILLED_WITH_BLOB:
       return n::TYPE_SERVICE_WORKER_ERROR_KILLED_WITH_BLOB;
     case m::REQUEST_JOB_ERROR_KILLED_WITH_STREAM:
       return n::TYPE_SERVICE_WORKER_ERROR_KILLED_WITH_STREAM;
     case m::REQUEST_JOB_ERROR_BAD_DELEGATE:
       return n::TYPE_SERVICE_WORKER_ERROR_BAD_DELEGATE;
+    case m::REQUEST_JOB_ERROR_REQUEST_BODY_BLOB_FAILED:
+      return n::TYPE_SERVICE_WORKER_ERROR_REQUEST_BODY_BLOB_FAILED;
     // We can't log if there's no request; fallthrough.
     case m::REQUEST_JOB_ERROR_NO_REQUEST:
     // Obsolete types; fallthrough.
     case m::REQUEST_JOB_ERROR_DESTROYED:
     case m::REQUEST_JOB_ERROR_DESTROYED_WITH_BLOB:
     case m::REQUEST_JOB_ERROR_DESTROYED_WITH_STREAM:
     // Invalid type.
     case m::NUM_REQUEST_JOB_RESULT_TYPES:
       NOTREACHED() << result;
   }
@@ skipping 295 matching lines @@
 void ServiceWorkerURLRequestJob::MaybeStartRequest() {
   if (is_started_ && response_type_ != NOT_DETERMINED) {
     // Start asynchronously.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&ServiceWorkerURLRequestJob::StartRequest,
                               weak_factory_.GetWeakPtr()));
   }
 }
 
 void ServiceWorkerURLRequestJob::StartRequest() {
-  if (request()) {
-    request()->net_log().AddEvent(
-        net::NetLog::TYPE_SERVICE_WORKER_START_REQUEST);
-  }
+  request()->net_log().AddEvent(net::NetLog::TYPE_SERVICE_WORKER_START_REQUEST);
 
   switch (response_type_) {
     case NOT_DETERMINED:
       NOTREACHED();
       return;
 
     case FALLBACK_TO_NETWORK:
       // Restart the request to create a new job. Our request handler will
       // return nullptr, and the default job (which will hit network) should be
       // created.
       NotifyRestartRequired();
       return;
 
     case FORWARD_TO_SERVICE_WORKER:
-      ServiceWorkerMetrics::URLRequestJobResult result =
-          ServiceWorkerMetrics::REQUEST_JOB_ERROR_BAD_DELEGATE;
-      ServiceWorkerVersion* active_worker =
-          delegate_->GetServiceWorkerVersion(&result);
-      if (!active_worker) {
-        RecordResult(result);
-        DeliverErrorResponse();
+      if (HasRequestBody()) {
+        WaitForRequestBobyBlobsToComplete();
         return;
       }
 
-      DCHECK(!fetch_dispatcher_);
-      // Send a fetch event to the ServiceWorker associated to the
-      // provider_host.
-      fetch_dispatcher_.reset(new ServiceWorkerFetchDispatcher(
-          CreateFetchRequest(), active_worker, resource_type_,
-          base::Bind(&ServiceWorkerURLRequestJob::DidPrepareFetchEvent,
-                     weak_factory_.GetWeakPtr()),
-          base::Bind(&ServiceWorkerURLRequestJob::DidDispatchFetchEvent,
-                     weak_factory_.GetWeakPtr())));
-      worker_start_time_ = base::TimeTicks::Now();
-      fetch_dispatcher_->Run();
+      DispatchToWorker();
       return;
   }
 
   NOTREACHED();
 }
 
+void ServiceWorkerURLRequestJob::DispatchToWorker() {
+  ServiceWorkerMetrics::URLRequestJobResult result =
+      ServiceWorkerMetrics::REQUEST_JOB_ERROR_BAD_DELEGATE;
+  ServiceWorkerVersion* active_worker =
+      delegate_->GetServiceWorkerVersion(&result);
+  if (!active_worker) {
+    RecordResult(result);
+    DeliverErrorResponse();
+    return;
+  }
+
+  DCHECK(!fetch_dispatcher_);
+  fetch_dispatcher_.reset(new ServiceWorkerFetchDispatcher(
+      CreateFetchRequest(), active_worker, resource_type_,
+      base::Bind(&ServiceWorkerURLRequestJob::DidPrepareFetchEvent,
+                 weak_factory_.GetWeakPtr()),
+      base::Bind(&ServiceWorkerURLRequestJob::DidDispatchFetchEvent,
+                 weak_factory_.GetWeakPtr())));
+  worker_start_time_ = base::TimeTicks::Now();
+  fetch_dispatcher_->Run();
+}
+
 std::unique_ptr<ServiceWorkerFetchRequest>
 ServiceWorkerURLRequestJob::CreateFetchRequest() {
   std::string blob_uuid;
   uint64_t blob_size = 0;
   // The upload data in URLRequest may have been cleared while handing redirect.
   if (request_->has_upload())
     CreateRequestBodyBlob(&blob_uuid, &blob_size);
   std::unique_ptr<ServiceWorkerFetchRequest> request(
       new ServiceWorkerFetchRequest());
   request->mode = request_mode_;
@@ skipping 393 matching lines @@
                          fall_back_required_, response_url_,
                          service_worker_response_type_, worker_start_time_,
                          worker_ready_time_, response_is_in_cache_storage_,
                          response_cache_storage_cache_name_);
 }
 
 bool ServiceWorkerURLRequestJob::IsMainResourceLoad() const {
   return ServiceWorkerUtils::IsMainResourceType(resource_type_);
 }
 
+bool ServiceWorkerURLRequestJob::HasRequestBody() {
+  // |has_upload| must be checked since it may have been cleared while handling
+  // a redirect.
+  return request_->has_upload() && body_.get() && blob_storage_context_;
+}
+
+void ServiceWorkerURLRequestJob::WaitForRequestBobyBlobsToComplete() {
+  DCHECK(HasRequestBody());
+
+  num_pending_request_body_blobs_ = 0;
+  for (const ResourceRequestBody::Element& element : (*body_->elements())) {
+    if (element.type() == ResourceRequestBody::Element::TYPE_BLOB)
+      ++num_pending_request_body_blobs_;
+  }
+
+  if (num_pending_request_body_blobs_ == 0) {
+    DispatchToWorker();
+    return;
+  }
+
+  TRACE_EVENT_ASYNC_BEGIN1(
+      "ServiceWorker",
+      "ServiceWorkerURLRequestJob::WaitForRequestBobyBlobsToComplete", this,
+      "URL", request()->url().spec());
+  request()->net_log().AddEvent(
+      net::NetLog::TYPE_SERVICE_WORKER_REQUEST_BODY_BLOB_CONSTRUCTION_STARTED);
+
+  for (const ResourceRequestBody::Element& element : (*body_->elements())) {
+    if (element.type() == ResourceRequestBody::Element::TYPE_BLOB) {
+      std::unique_ptr<storage::BlobDataHandle> handle =

[dmurph, 2016/05/11 21:35:58]

You can check if the blob is building before calling that method, to remove
unnecessary callbacks.

handle->IsBeingBuilt(), I believe.

To keep the performance of the above counting, you could decrement the count
here if it's not building, and then at the end check if it's already 0.

You'll be guarenteed that the construction complete is called later, as long as
it IS being built.

[falken, 2016/05/12 08:49:33]

Done.　I had considered that but was worried about the "Broken" case. I think the
new patch covers it.

+          blob_storage_context_->GetBlobDataFromUUID(element.blob_uuid());
+      handle->RunOnConstructionComplete(
+          base::Bind(&ServiceWorkerURLRequestJob::OneRequestBodyBlobCompleted,
+                     GetWeakPtr()));
+    }
+  }
+}
+
+void ServiceWorkerURLRequestJob::OneRequestBodyBlobCompleted(
+    bool success,
+    storage::IPCBlobCreationCancelCode cancel_code) {
+  if (num_pending_request_body_blobs_ == 0) {
+    // We already ran the callback.
+    return;
+  }
+
+  if (success)
+    --num_pending_request_body_blobs_;
+  else
+    num_pending_request_body_blobs_ = 0;
+
+  if (num_pending_request_body_blobs_ == 0)
+    RequestBodyBlobsCompleted(success, cancel_code);
+}
+
+void ServiceWorkerURLRequestJob::RequestBodyBlobsCompleted(
+    bool success,
+    storage::IPCBlobCreationCancelCode cancel_code) {
+  TRACE_EVENT_ASYNC_END2(
+      "ServiceWorker",
+      "ServiceWorkerURLRequestJob::WaitForRequestBobyBlobsToComplete", this,
+      "Success", success, "IPCBlobCreationCancelCode",
+      static_cast<int>(cancel_code));
+
+  if (!success) {
+    RecordResult(
+        ServiceWorkerMetrics::REQUEST_JOB_ERROR_REQUEST_BODY_BLOB_FAILED);
+    NotifyStartError(net::URLRequestStatus::FromError(net::ERR_FAILED));
+    return;
+  }
+
+  request()->net_log().AddEvent(
+      net::NetLog::TYPE_SERVICE_WORKER_REQUEST_BODY_BLOB_CONSTRUCTION_FINISHED);
+  DispatchToWorker();
+}
+
 }  // namespace content