Allowing registering arbitrary schemes as supporting the fetch API.

Source/modules/fetch/FetchManager.cpp

 // 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 "config.h"
 #include "modules/fetch/FetchManager.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 16 matching lines @@
 #include "modules/fetch/BodyStreamBuffer.h"
 #include "modules/fetch/CompositeDataConsumerHandle.h"
 #include "modules/fetch/DataConsumerHandleUtil.h"
 #include "modules/fetch/FetchFormDataConsumerHandle.h"
 #include "modules/fetch/FetchRequestData.h"
 #include "modules/fetch/Response.h"
 #include "modules/fetch/ResponseInit.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
+#include "platform/weborigin/SchemeRegistry.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/WebURLRequest.h"
 #include "wtf/HashSet.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 namespace {
 
@@ skipping 342 matching lines @@
     // "- |request|'s mode is |no CORS|"
     if (m_request->mode() == WebURLRequest::FetchRequestModeNoCORS) {
         // "Set |request|'s response tainting to |opaque|."
         m_request->setResponseTainting(FetchRequestData::OpaqueTainting);
         // "The result of performing a basic fetch using |request|."
         performBasicFetch();
         return;
     }
 
     // "- |request|'s url's scheme is not one of 'http' and 'https'"
     if (!m_request->url().protocolIsInHTTPFamily()) {

[hiroshige, 2015/08/27 09:39:51]

shouldTreatURLSchemeAsSupportingFetchAPI() should be used also here if we want
to allow CORS requests to the chrome-extension:// scheme.

         // "A network error."
         performNetworkError("Fetch API cannot load " + m_request->url().string() + ". URL scheme must be \"http\" or \"https\" for CORS request.");
         return;
     }
 
     // "- |request|'s mode is |CORS-with-forced-preflight|.
     // "- |request|'s unsafe request flag is set and either |request|'s method
     // is not a simple method or a header in |request|'s header list is not a
     // simple header"
     if (m_request->mode() == WebURLRequest::FetchRequestModeCORSWithForcedPreflight
@@ skipping 23 matching lines @@
     if (m_loader) {
         m_loader->cancel();
         m_loader.clear();
     }
 }
 
 void FetchManager::Loader::performBasicFetch()
 {
     // "To perform a basic fetch using |request|, switch on |request|'s url's
     // scheme, and run the associated steps:"
-    if (m_request->url().protocolIsInHTTPFamily()) {
+    if (SchemeRegistry::shouldTreatURLSchemeAsSupportingFetchAPI(m_request->url().protocol())) {

[pdr., 2015/08/25 21:25:09]

This code is in the critical path but has to wait for a mutex. Is that
acceptable perf-wise?

[not at google - send to devlin, 2015/08/25 22:04:45]

(I will defer to fetch owner to answer this)

[tyoshino (SeeGerritForStatus), 2015/08/26 07:24:48]

We already have one in DocumentThreadableLoader. As we visit here only once for
each fetch(), it should be acceptable.

Ideally, this kind of registry should be initialized and frozen like ones in
src/url/url_util.cc (has just DCHECK on standard_schemes_locked). I'm not sure
we can do it on Blink.

         // "Return the result of performing an HTTP fetch using |request|."
         performHTTPFetch(false, false);
     } else {
         // FIXME: implement other protocols.
         performNetworkError("Fetch API cannot load " + m_request->url().string() + ". URL scheme \"" + m_request->url().protocol() + "\" is not supported.");
     }
 }
 
 void FetchManager::Loader::performNetworkError(const String& message)
 {
     failed(message);
 }
 
 void FetchManager::Loader::performHTTPFetch(bool corsFlag, bool corsPreflightFlag)
 {
-    ASSERT(m_request->url().protocolIsInHTTPFamily());
+    ASSERT(SchemeRegistry::shouldTreatURLSchemeAsSupportingFetchAPI(m_request->url().protocol()));
     // CORS preflight fetch procedure is implemented inside DocumentThreadableLoader.
 
     // "1. Let |HTTPRequest| be a copy of |request|, except that |HTTPRequest|'s
     //  body is a tee of |request|'s body."
     // We use ResourceRequest class for HTTPRequest.
     // FIXME: Support body.
     ResourceRequest request(m_request->url());
     request.setRequestContext(m_request->context());
     request.setHTTPMethod(m_request->method());
     const Vector<OwnPtr<FetchHeaderList::Header>>& list = m_request->headerList()->list();
@@ skipping 128 matching lines @@
 
 DEFINE_TRACE(FetchManager)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_executionContext);
     visitor->trace(m_loaders);
 #endif
 }
 
 } // namespace blink