Logging and check fail crbug/612358

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;
   }
   NOTREACHED() << result;
   return n::TYPE_FAILED;
 }
 
 }  // namespace
 
+class ServiceWorkerURLRequestJob::BlobConstructionWaiter {
+ public:
+  explicit BlobConstructionWaiter(ServiceWorkerURLRequestJob* owner)
+      : owner_(owner), weak_factory_(this) {
+    TRACE_EVENT_ASYNC_BEGIN1("ServiceWorker", "BlobConstructionWaiter", this,
+                             "URL", owner_->request()->url().spec());
+    owner_->request()->net_log().BeginEvent(
+        net::NetLog::TYPE_SERVICE_WORKER_WAITING_FOR_REQUEST_BODY_BLOB);
+  }
+
+  ~BlobConstructionWaiter() {
+    owner_->request()->net_log().EndEvent(
+        net::NetLog::TYPE_SERVICE_WORKER_WAITING_FOR_REQUEST_BODY_BLOB,
+        net::NetLog::BoolCallback("success", phase_ == Phase::SUCCESS));
+    TRACE_EVENT_ASYNC_END1("ServiceWorker", "BlobConstructionWaiter", this,
+                           "Success", phase_ == Phase::SUCCESS);
+  }
+
+  void RunOnComplete(const base::Callback<void(bool)>& callback) {
+    DCHECK_EQ(static_cast<int>(Phase::INITIAL), static_cast<int>(phase_));
+    phase_ = Phase::WAITING;
+    num_pending_request_body_blobs_ = 0;
+    callback_ = callback;
+
+    for (const ResourceRequestBody::Element& element :
+         *(owner_->body_->elements())) {
+      if (element.type() != ResourceRequestBody::Element::TYPE_BLOB)
+        continue;
+
+      std::unique_ptr<storage::BlobDataHandle> handle =
+          owner_->blob_storage_context_->GetBlobDataFromUUID(
+              element.blob_uuid());
+      if (handle->IsBroken()) {
+        Complete(false);
+        return;
+      }
+      if (handle->IsBeingBuilt()) {
+        ++num_pending_request_body_blobs_;
+        handle->RunOnConstructionComplete(
+            base::Bind(&BlobConstructionWaiter::OneRequestBodyBlobCompleted,
+                       weak_factory_.GetWeakPtr()));
+      }
+    }
+
+    if (num_pending_request_body_blobs_ == 0)
+      Complete(true);
+  }
+
+ private:
+  enum class Phase { INITIAL, WAITING, SUCCESS, FAIL };
+
+  void OneRequestBodyBlobCompleted(
+      bool success,
+      storage::IPCBlobCreationCancelCode cancel_code) {
+    DCHECK_GT(num_pending_request_body_blobs_, 0UL);
+
+    if (success)
+      --num_pending_request_body_blobs_;
+    else
+      num_pending_request_body_blobs_ = 0;
+
+    if (num_pending_request_body_blobs_ == 0)
+      Complete(success);
+  }
+
+  void Complete(bool success) {
+    DCHECK_EQ(static_cast<int>(Phase::WAITING), static_cast<int>(phase_));
+    phase_ = success ? Phase::SUCCESS : Phase::FAIL;
+    // Destroys |this|.
+    callback_.Run(success);
+  }
+
+  // Owns and must outlive |this|.
+  ServiceWorkerURLRequestJob* owner_;
+
+  scoped_refptr<ResourceRequestBody> body_;
+  base::Callback<void(bool)> callback_;
+  size_t num_pending_request_body_blobs_ = 0;
+  Phase phase_ = Phase::INITIAL;
+  base::WeakPtrFactory<BlobConstructionWaiter> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(BlobConstructionWaiter);
+};
+
 bool ServiceWorkerURLRequestJob::Delegate::RequestStillValid(
     ServiceWorkerMetrics::URLRequestJobResult* result) {
   return true;
 }
 
 ServiceWorkerURLRequestJob::ServiceWorkerURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     const std::string& client_id,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
@@ skipping 24 matching lines @@
       frame_type_(frame_type),
       fall_back_required_(false),
       body_(body),
       fetch_type_(fetch_type),
       weak_factory_(this) {
   DCHECK(delegate_) << "ServiceWorkerURLRequestJob requires a delegate";
 }
 
 ServiceWorkerURLRequestJob::~ServiceWorkerURLRequestJob() {
   ClearStream();
+  blob_construction_waiter_.reset();
 
   if (!ShouldRecordResult())
     return;
   ServiceWorkerMetrics::URLRequestJobResult result =
       ServiceWorkerMetrics::REQUEST_JOB_ERROR_KILLED;
   if (response_body_type_ == STREAM)
     result = ServiceWorkerMetrics::REQUEST_JOB_ERROR_KILLED_WITH_STREAM;
   else if (response_body_type_ == BLOB)
     result = ServiceWorkerMetrics::REQUEST_JOB_ERROR_KILLED_WITH_BLOB;
   RecordResult(result);
@@ skipping 235 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()) {
+        DCHECK(!blob_construction_waiter_);
+        blob_construction_waiter_.reset(new BlobConstructionWaiter(this));
+        blob_construction_waiter_->RunOnComplete(
+            base::Bind(&ServiceWorkerURLRequestJob::RequestBodyBlobsCompleted,
+                       GetWeakPtr()));
         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();
+      RequestBodyBlobsCompleted(true);
       return;
   }
 
   NOTREACHED();
 }
 
 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())
+  if (HasRequestBody())
     CreateRequestBodyBlob(&blob_uuid, &blob_size);
   std::unique_ptr<ServiceWorkerFetchRequest> request(
       new ServiceWorkerFetchRequest());
   request->mode = request_mode_;
   request->is_main_resource_load = IsMainResourceLoad();
   request->request_context_type = request_context_type_;
   request->frame_type = frame_type_;
   request->url = request_->url();
   request->method = request_->method();
   const net::HttpRequestHeaders& headers = request_->extra_request_headers();
@@ skipping 17 matching lines @@
     CHECK(
         request_->referrer_policy() ==
         net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE);
     request->referrer =
         Referrer(GURL(request_->referrer()), blink::WebReferrerPolicyDefault);
   }
   request->fetch_type = fetch_type_;
   return request;
 }
 
-bool ServiceWorkerURLRequestJob::CreateRequestBodyBlob(std::string* blob_uuid,
+void ServiceWorkerURLRequestJob::CreateRequestBodyBlob(std::string* blob_uuid,
                                                        uint64_t* blob_size) {
-  if (!body_.get() || !blob_storage_context_)
-    return false;
-
+  DCHECK(HasRequestBody());
   // To ensure the blobs stick around until the end of the reading.
   std::vector<std::unique_ptr<storage::BlobDataHandle>> handles;
   std::vector<std::unique_ptr<storage::BlobDataSnapshot>> snapshots;
   // TODO(dmurph): Allow blobs to be added below, so that the context can
   // efficiently re-use blob items for the new blob.
   std::vector<const ResourceRequestBody::Element*> resolved_elements;
   for (const ResourceRequestBody::Element& element : (*body_->elements())) {
     if (element.type() != ResourceRequestBody::Element::TYPE_BLOB) {
       resolved_elements.push_back(&element);
       continue;
@@ skipping 44 matching lines @@
         break;
       default:
         NOTIMPLEMENTED();
     }
   }
 
   request_body_blob_data_handle_ =
       blob_storage_context_->AddFinishedBlob(&blob_builder);
   *blob_uuid = uuid;
   *blob_size = total_size;
-  return true;
 }
 
 void ServiceWorkerURLRequestJob::DidPrepareFetchEvent() {
   worker_ready_time_ = base::TimeTicks::Now();
   load_timing_info_.send_start = worker_ready_time_;
 }
 
 void ServiceWorkerURLRequestJob::DidDispatchFetchEvent(
     ServiceWorkerStatusCode status,
     ServiceWorkerFetchEventResult fetch_result,
@@ skipping 280 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() {
+  // URLRequest::has_upload() must be checked since its upload data may have
+  // been cleared while handling a redirect.
+  return request_->has_upload() && body_.get() && blob_storage_context_;
+}
+
+void ServiceWorkerURLRequestJob::RequestBodyBlobsCompleted(bool success) {
+  blob_construction_waiter_.reset();
+  if (!success) {
+    RecordResult(
+        ServiceWorkerMetrics::REQUEST_JOB_ERROR_REQUEST_BODY_BLOB_FAILED);
+    // TODO(falken): This and below should probably be NotifyStartError, not
+    // DeliverErrorResponse. But changing it causes
+    // ServiceWorkerURLRequestJobTest.DeletedProviderHostBeforeFetchEvent to
+    // fail.
+    DeliverErrorResponse();
+    return;
+  }
+
+  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();
+}
+
 }  // namespace content