Allow a foreign fetch event handler to not handle an event.

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_);
-  // 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
-  DCHECK(!IsFallbackToRendererNeeded() ||
-         (fetch_type_ == ServiceWorkerFetchType::FOREIGN_FETCH));
+  DCHECK(!IsFallbackToRendererNeeded());
   response_type_ = FALLBACK_TO_NETWORK;
   MaybeStartRequest();
 }
 
 void ServiceWorkerURLRequestJob::FallbackToNetworkOrRenderer() {
   DCHECK_EQ(NOT_DETERMINED, response_type_);
-  // 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
   DCHECK_NE(ServiceWorkerFetchType::FOREIGN_FETCH, fetch_type_);
   if (IsFallbackToRendererNeeded()) {
     response_type_ = FALLBACK_TO_RENDERER;
   } else {
     response_type_ = FALLBACK_TO_NETWORK;
   }
   MaybeStartRequest();
 }
 
 void ServiceWorkerURLRequestJob::ForwardToServiceWorker() {
@@ skipping 592 matching lines @@
   if (ShouldRecordResult())
     RecordResult(ServiceWorkerMetrics::REQUEST_JOB_FALLBACK_RESPONSE);
   response_type_ = FALLBACK_TO_NETWORK;
   NotifyRestartRequired();
   return;
 }
 
 void ServiceWorkerURLRequestJob::FinalizeFallbackToRenderer() {
   // 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;
+  DCHECK_NE(fetch_type_, ServiceWorkerFetchType::FOREIGN_FETCH);
+  fall_back_required_ = true;
   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 return a fall_back_required response to the renderer.
+  // If fetch_type is |FOREIGN_FETCH| any required CORS checks will have already
+  // been done in the renderer (and if a preflight was necesary the request
+  // would never have reached foreign fetch), so such requests can always
+  // fallback to the network directly.
   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;
@@ skipping 135 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