ServiceWorker: Add an API to fallback to renderer for CORS preflight

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 232 matching lines @@
       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);
 }
 
 void ServiceWorkerURLRequestJob::FallbackToNetwork() {
   DCHECK_EQ(NOT_DETERMINED, response_type_);
+  DCHECK(!IsFallbackToRendererNeeded());
   response_type_ = FALLBACK_TO_NETWORK;
   MaybeStartRequest();
 }
 
+void ServiceWorkerURLRequestJob::FallbackToNetworkOrRenderer() {
+  DCHECK_EQ(NOT_DETERMINED, response_type_);
+  DCHECK(fetch_type_ != ServiceWorkerFetchType::FOREIGN_FETCH);
+  if (IsFallbackToRendererNeeded()) {
+    response_type_ = FALLBACK_TO_RENDERER;
+  } else {
+    response_type_ = FALLBACK_TO_NETWORK;
+  }
+  MaybeStartRequest();
+}
+
 void ServiceWorkerURLRequestJob::ForwardToServiceWorker() {
   DCHECK_EQ(NOT_DETERMINED, response_type_);
   response_type_ = FORWARD_TO_SERVICE_WORKER;
   MaybeStartRequest();
 }
 
 void ServiceWorkerURLRequestJob::Start() {
   is_started_ = true;
   MaybeStartRequest();
 }
@@ skipping 225 matching lines @@
 
 void ServiceWorkerURLRequestJob::StartRequest() {
   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();
+      FinalizeFallbackToNetwork();
+      return;
+
+    case FALLBACK_TO_RENDERER:
+      FinalizeFallbackToRenderer();
       return;
 
     case FORWARD_TO_SERVICE_WORKER:
       if (HasRequestBody()) {
         DCHECK(!blob_construction_waiter_);
         blob_construction_waiter_.reset(new BlobConstructionWaiter(this));
         blob_construction_waiter_->RunOnComplete(
             base::Bind(&ServiceWorkerURLRequestJob::RequestBodyBlobsCompleted,
                        GetWeakPtr()));
         return;
@@ skipping 175 matching lines @@
     RecordResult(result);
     DeliverErrorResponse();
     return;
   }
 
   if (status != SERVICE_WORKER_OK) {
     RecordResult(ServiceWorkerMetrics::REQUEST_JOB_ERROR_FETCH_EVENT_DISPATCH);
     if (IsMainResourceLoad()) {
       // Using the service worker failed, so fallback to network.
       delegate_->MainResourceLoadFailed();
-      response_type_ = FALLBACK_TO_NETWORK;
-      NotifyRestartRequired();
+      FinalizeFallbackToNetwork();
     } else {
       DeliverErrorResponse();
     }
     return;
   }
 
   if (fetch_result == SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK) {
-    ServiceWorkerMetrics::RecordFallbackedRequestMode(request_mode_);
-    // When the request_mode is |CORS| or |CORS-with-forced-preflight| and the
-    // origin of the request URL is different from the security origin of the
-    // document, we can't simply fallback to the network in the browser process.
-    // It is because the CORS preflight logic is implemented in the renderer. So
-    // we returns a fall_back_required response to the renderer.
-    if ((request_mode_ == FETCH_REQUEST_MODE_CORS ||
-         request_mode_ == FETCH_REQUEST_MODE_CORS_WITH_FORCED_PREFLIGHT) &&
-        !request()->initiator().IsSameOriginWith(
-            url::Origin(request()->url()))) {
-      // TODO(mek): http://crbug.com/604084 Figure out what to do about CORS
-      // preflight and fallbacks for foreign fetch events.
-      fall_back_required_ =
-          fetch_type_ != ServiceWorkerFetchType::FOREIGN_FETCH;
-      RecordResult(ServiceWorkerMetrics::REQUEST_JOB_FALLBACK_FOR_CORS);
-      CreateResponseHeader(
-          400, "Service Worker Fallback Required", ServiceWorkerHeaderMap());
-      CommitResponseHeader();
-      return;
+    // TODO(shimazu): Remove the condition of FOREIGN_FETCH after figuring out
+    // what to do about CORS preflight and fallbacks for foreign fetch events.
+    // http://crbug.com/604084
+    if (IsFallbackToRendererNeeded() ||
+        fetch_type_ == ServiceWorkerFetchType::FOREIGN_FETCH) {
+      FinalizeFallbackToRenderer();

[falken, 2016/07/05 06:49:28]

Does this patch change behavior for foreign fetch? It looks like before this
patch, a foreign fetch event could reach lines 732-734. Or is request_mode_
always FETCH_REQUEST_MODE_CORS_* when event type is foreign fetch?

[shimazu, 2016/07/06 06:27:35]

Oh, I misunderstood the condition of fetch_type_. It's not what I indended.
Fixed.

+    } else {
+      FinalizeFallbackToNetwork();
     }
-    // Change the response type and restart the request to fallback to
-    // the network.
-    RecordResult(ServiceWorkerMetrics::REQUEST_JOB_FALLBACK_RESPONSE);
-    response_type_ = FALLBACK_TO_NETWORK;
-    NotifyRestartRequired();
     return;
   }
 
   // We should have a response now.
   DCHECK_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, fetch_result);
 
   // A response with status code 0 is Blink telling us to respond with network
   // error.
   if (response.status_code == 0) {
     RecordStatusZeroResponseError(response.error);
@@ skipping 114 matching lines @@
 }
 
 void ServiceWorkerURLRequestJob::DeliverErrorResponse() {
   // TODO(falken): Print an error to the console of the ServiceWorker and of
   // the requesting page.
   CreateResponseHeader(
       500, "Service Worker Response Error", ServiceWorkerHeaderMap());
   CommitResponseHeader();
 }
 
+void ServiceWorkerURLRequestJob::FinalizeFallbackToNetwork() {
+  // Restart this request to create a new job. The default job (which will hit
+  // network) will be created in the next time because our request handler will
+  // return nullptr after restarting and this means our interceptor does not
+  // intercept.
+  if (ShouldRecordResult())
+    RecordResult(ServiceWorkerMetrics::REQUEST_JOB_FALLBACK_RESPONSE);
+  response_type_ = FALLBACK_TO_NETWORK;
+  NotifyRestartRequired();
+  return;
+}
+
+void ServiceWorkerURLRequestJob::FinalizeFallbackToRenderer() {
+  ServiceWorkerMetrics::RecordFallbackedRequestMode(request_mode_);
+  // TODO(mek): http://crbug.com/604084 Figure out what to do about CORS
+  // preflight and fallbacks for foreign fetch events.
+  fall_back_required_ = fetch_type_ != ServiceWorkerFetchType::FOREIGN_FETCH;
+  if (ShouldRecordResult())
+    RecordResult(ServiceWorkerMetrics::REQUEST_JOB_FALLBACK_FOR_CORS);
+  CreateResponseHeader(400, "Service Worker Fallback Required",
+                       ServiceWorkerHeaderMap());
+  response_type_ = FALLBACK_TO_RENDERER;
+  CommitResponseHeader();
+}
+
+bool ServiceWorkerURLRequestJob::IsFallbackToRendererNeeded() const {
+  // When the request_mode is |CORS| or |CORS-with-forced-preflight| and the
+  // origin of the request URL is different from the security origin of the
+  // document, we can't simply fallback to the network in the browser process.
+  // It is because the CORS preflight logic is implemented in the renderer. So
+  // we returns a fall_back_required response to the renderer.
+  return !IsMainResourceLoad() &&
+         (fetch_type_ != ServiceWorkerFetchType::FOREIGN_FETCH) &&
+         (request_mode_ == FETCH_REQUEST_MODE_CORS ||
+          request_mode_ == FETCH_REQUEST_MODE_CORS_WITH_FORCED_PREFLIGHT) &&
+         !request()->initiator().IsSameOriginWith(
+             url::Origin(request()->url()));
+}
+
 void ServiceWorkerURLRequestJob::SetResponseBodyType(ResponseBodyType type) {
   DCHECK_EQ(response_body_type_, UNKNOWN);
   DCHECK_NE(type, UNKNOWN);
   response_body_type_ = type;
 }
 
 bool ServiceWorkerURLRequestJob::ShouldRecordResult() {
   return !did_record_result_ && is_started_ &&
          response_type_ == FORWARD_TO_SERVICE_WORKER;
 }
@@ skipping 55 matching lines @@
 }
 
 void ServiceWorkerURLRequestJob::NotifyRestartRequired() {
   ServiceWorkerResponseInfo::ForRequest(request_, true)
       ->OnPrepareToRestart(worker_start_time_, worker_ready_time_);
   delegate_->OnPrepareToRestart();
   URLRequestJob::NotifyRestartRequired();
 }
 
 void ServiceWorkerURLRequestJob::OnStartCompleted() const {
-  if (response_type_ != FORWARD_TO_SERVICE_WORKER) {
+  if (response_type_ != FORWARD_TO_SERVICE_WORKER &&
+      response_type_ != FALLBACK_TO_RENDERER) {
     ServiceWorkerResponseInfo::ForRequest(request_, true)
         ->OnStartCompleted(
             false /* was_fetched_via_service_worker */,
             false /* was_fallback_required */,
             GURL() /* original_url_via_service_worker */,
             blink::WebServiceWorkerResponseTypeDefault,
             base::TimeTicks() /* service_worker_start_time */,
             base::TimeTicks() /* service_worker_ready_time */,
             false /* respons_is_in_cache_storage */,
             std::string() /* response_cache_storage_cache_name */,
@@ skipping 50 matching lines @@
       CreateFetchRequest(), active_worker, resource_type_, request()->net_log(),
       base::Bind(&ServiceWorkerURLRequestJob::DidPrepareFetchEvent,
                  weak_factory_.GetWeakPtr(), active_worker),
       base::Bind(&ServiceWorkerURLRequestJob::DidDispatchFetchEvent,
                  weak_factory_.GetWeakPtr())));
   worker_start_time_ = base::TimeTicks::Now();
   fetch_dispatcher_->Run();
 }
 
 }  // namespace content