Bypass ServiceWorker when the request originates from isolated world.

third_party/WebKit/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 38 matching lines @@
 bool IsRedirectStatusCode(int statusCode)
 {
     return (statusCode == 301 || statusCode == 302 || statusCode == 303 || statusCode == 307 || statusCode == 308);
 }
 
 } // namespace
 
 class FetchManager::Loader final : public GarbageCollectedFinalized<FetchManager::Loader>, public ThreadableLoaderClient, public ContextLifecycleObserver {
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(FetchManager::Loader);
 public:
-    static Loader* create(ExecutionContext* executionContext, FetchManager* fetchManager, ScriptPromiseResolver* resolver, FetchRequestData* request)
+    static Loader* create(ExecutionContext* executionContext, FetchManager* fetchManager, ScriptPromiseResolver* resolver, FetchRequestData* request, bool isIsolatedWorld)
     {
-        return new Loader(executionContext, fetchManager, resolver, request);
+        return new Loader(executionContext, fetchManager, resolver, request, isIsolatedWorld);
     }
 
     ~Loader() override;
     DECLARE_VIRTUAL_TRACE();
 
     void didReceiveResponse(unsigned long, const ResourceResponse&, PassOwnPtr<WebDataConsumerHandle>) override;
     void didFinishLoading(unsigned long, double) override;
     void didFail(const ResourceError&) override;
     void didFailAccessControlCheck(const ResourceError&) override;
     void didFailRedirectCheck() override;
@@ skipping 72 matching lines @@
         Member<Response> m_response;
         Member<FetchManager::Loader> m_loader;
         String m_integrityMetadata;
         KURL m_url;
         OwnPtr<WebDataConsumerHandle::Reader> m_reader;
         Vector<char> m_buffer;
         bool m_finished;
     };
 
 private:
-    Loader(ExecutionContext*, FetchManager*, ScriptPromiseResolver*, FetchRequestData*);
+    Loader(ExecutionContext*, FetchManager*, ScriptPromiseResolver*, FetchRequestData*, bool isIsolatedWorld);
 
     void performBasicFetch();
     void performNetworkError(const String& message);
     void performHTTPFetch(bool corsFlag, bool corsPreflightFlag);
     void performDataFetch();
     void failed(const String& message);
     void notifyFinished();
     Document* document() const;
     void loadSucceeded();
 
     Member<FetchManager> m_fetchManager;
     Member<ScriptPromiseResolver> m_resolver;
     Member<FetchRequestData> m_request;
     RefPtr<ThreadableLoader> m_loader;
     bool m_failed;
     bool m_finished;
     int m_responseHttpStatusCode;
     Member<SRIVerifier> m_integrityVerifier;
     bool m_didFinishLoading;
+    bool m_isIsolatedWorld;
 };
 
-FetchManager::Loader::Loader(ExecutionContext* executionContext, FetchManager* fetchManager, ScriptPromiseResolver* resolver, FetchRequestData* request)
+FetchManager::Loader::Loader(ExecutionContext* executionContext, FetchManager* fetchManager, ScriptPromiseResolver* resolver, FetchRequestData* request, bool isIsolatedWorld)
     : ContextLifecycleObserver(executionContext)
     , m_fetchManager(fetchManager)
     , m_resolver(resolver)
     , m_request(request)
     , m_failed(false)
     , m_finished(false)
     , m_responseHttpStatusCode(0)
     , m_integrityVerifier(nullptr)
     , m_didFinishLoading(false)
+    , m_isIsolatedWorld(isIsolatedWorld)
 {
 }
 
 FetchManager::Loader::~Loader()
 {
     ASSERT(!m_loader);
 }
 
 DEFINE_TRACE(FetchManager::Loader)
 {
@@ skipping 352 matching lines @@
             referrerURL = document->outgoingReferrer();
         } else if (executionContext()->isWorkerGlobalScope()) {
             referrerURL = executionContext()->url().strippedForUseAsReferrer();
         }
         request.setHTTPReferrer(SecurityPolicy::generateReferrer(policy, m_request->url(), referrerURL));
     } else {
         // Note that generateReferrer generates |no-referrer| from |no-referrer|
         // referrer string (i.e. String()).
         request.setHTTPReferrer(SecurityPolicy::generateReferrer(policy, m_request->url(), m_request->referrerString()));
     }
+    request.setSkipServiceWorker(m_isIsolatedWorld);

[Mike West, 2015/11/05 08:27:27]

Doesn't this override the setting in cases where we don't want to override it?
Like, we skip the SW for CORS preflights, right? We should continue skipping
those even when (especially when!) the preflight comes from a request in the
main world.

[horo, 2015/11/05 08:47:10]

No.
DocumentThreadableLoader calls createAccessControlPreflightRequest() to create a
request for CORS preflight, and createAccessControlPreflightRequest() set the
skip flag.
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

 
     // "3. Append `Host`, ..."
     // FIXME: Implement this when the spec is fixed.
 
     // "4.If |HTTPRequest|'s force Origin header flag is set, append `Origin`/
     // |HTTPRequest|'s origin, serialized and utf-8 encoded, to |HTTPRequest|'s
     // header list."
     // We set Origin header in updateRequestForAccessControl() called from
     // DocumentThreadableLoader::makeCrossOriginAccessRequest
 
@@ skipping 105 matching lines @@
 #endif
 }
 
 ScriptPromise FetchManager::fetch(ScriptState* scriptState, FetchRequestData* request)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     request->setContext(WebURLRequest::RequestContextFetch);
 
-    Loader* loader = Loader::create(m_executionContext, this, resolver, request);
+    Loader* loader = Loader::create(m_executionContext, this, resolver, request, scriptState->world().isIsolatedWorld());
     m_loaders.add(loader);
     loader->start();
     return promise;
 }
 
 void FetchManager::stop()
 {
     ASSERT(!m_isStopped);
     m_isStopped = true;
     for (auto& loader : m_loaders)
         loader->dispose();
 }
 
 void FetchManager::onLoaderFinished(Loader* loader)
 {
     m_loaders.remove(loader);
     loader->dispose();
 }
 
 DEFINE_TRACE(FetchManager)
 {
     visitor->trace(m_executionContext);
     visitor->trace(m_loaders);
 }
 
 } // namespace blink