From b7d2138f668f1cd1c299ddc869916d2fc6cb7eb4 Mon Sep 17 00:00:00 2001 From: "jianli@chromium.org" Date: Tue, 16 Jun 2009 21:00:29 +0000 Subject: [PATCH] 2009-06-16 Jian Li Reviewed by David Levin. Bug 26450: Rename values of enum RedirectOriginCheck to make them clearer. https://bugs.webkit.org/show_bug.cgi?id=26450 * loader/DocumentThreadableLoader.cpp: (WebCore::DocumentThreadableLoader::create): (WebCore::DocumentThreadableLoader::DocumentThreadableLoader): (WebCore::DocumentThreadableLoader::willSendRequest): * loader/DocumentThreadableLoader.h: * loader/ThreadableLoader.cpp: (WebCore::ThreadableLoader::create): (WebCore::ThreadableLoader::loadResourceSynchronously): * loader/ThreadableLoader.h: * workers/Worker.cpp: (WebCore::Worker::Worker): * workers/WorkerContext.cpp: (WebCore::WorkerContext::importScripts): * loader/WorkerThreadableLoader.cpp: (WebCore::WorkerThreadableLoader::WorkerThreadableLoader): (WebCore::WorkerThreadableLoader::loadResourceSynchronously): (WebCore::WorkerThreadableLoader::MainThreadBridge::MainThreadBridge): (WebCore::WorkerThreadableLoader::MainThreadBridge::mainThreadCreateLoader): * loader/WorkerThreadableLoader.h: (WebCore::WorkerThreadableLoader::create): * workers/WorkerScriptLoader.cpp: (WebCore::WorkerScriptLoader::loadSynchronously): (WebCore::WorkerScriptLoader::loadAsynchronously): * workers/WorkerScriptLoader.h: (WebCore::WorkerContext::importScripts): * xml/XMLHttpRequest.cpp: (WebCore::XMLHttpRequest::loadRequestAsynchronously): git-svn-id: https://svn.webkit.org/repository/webkit/trunk@44737 268f45cc-cd09-0410-ab3c-d52691b4dbfc --- WebCore/ChangeLog | 36 +++++++++++++++++++++++++++++ WebCore/loader/DocumentThreadableLoader.cpp | 12 +++++----- WebCore/loader/DocumentThreadableLoader.h | 6 ++--- WebCore/loader/ThreadableLoader.cpp | 8 +++---- WebCore/loader/ThreadableLoader.h | 8 +++---- WebCore/loader/WorkerThreadableLoader.cpp | 16 ++++++------- WebCore/loader/WorkerThreadableLoader.h | 12 +++++----- WebCore/workers/Worker.cpp | 2 +- WebCore/workers/WorkerContext.cpp | 2 +- WebCore/workers/WorkerScriptLoader.cpp | 8 +++---- WebCore/workers/WorkerScriptLoader.h | 4 ++-- WebCore/xml/XMLHttpRequest.cpp | 2 +- 12 files changed, 76 insertions(+), 40 deletions(-) diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog index 9c8c8bc..66b7a2d 100644 --- a/WebCore/ChangeLog +++ b/WebCore/ChangeLog @@ -1,3 +1,39 @@ +2009-06-16 Jian Li + + Reviewed by David Levin. + + Bug 26450: Rename values of enum RedirectOriginCheck to make them + clearer. + https://bugs.webkit.org/show_bug.cgi?id=26450 + + * loader/DocumentThreadableLoader.cpp: + (WebCore::DocumentThreadableLoader::create): + (WebCore::DocumentThreadableLoader::DocumentThreadableLoader): + (WebCore::DocumentThreadableLoader::willSendRequest): + * loader/DocumentThreadableLoader.h: + * loader/ThreadableLoader.cpp: + (WebCore::ThreadableLoader::create): + (WebCore::ThreadableLoader::loadResourceSynchronously): + * loader/ThreadableLoader.h: + * workers/Worker.cpp: + (WebCore::Worker::Worker): + * workers/WorkerContext.cpp: + (WebCore::WorkerContext::importScripts): + * loader/WorkerThreadableLoader.cpp: + (WebCore::WorkerThreadableLoader::WorkerThreadableLoader): + (WebCore::WorkerThreadableLoader::loadResourceSynchronously): + (WebCore::WorkerThreadableLoader::MainThreadBridge::MainThreadBridge): + (WebCore::WorkerThreadableLoader::MainThreadBridge::mainThreadCreateLoader): + * loader/WorkerThreadableLoader.h: + (WebCore::WorkerThreadableLoader::create): + * workers/WorkerScriptLoader.cpp: + (WebCore::WorkerScriptLoader::loadSynchronously): + (WebCore::WorkerScriptLoader::loadAsynchronously): + * workers/WorkerScriptLoader.h: + (WebCore::WorkerContext::importScripts): + * xml/XMLHttpRequest.cpp: + (WebCore::XMLHttpRequest::loadRequestAsynchronously): + 2009-06-16 Tony Chang Reviewed by Darin Fisher. diff --git a/WebCore/loader/DocumentThreadableLoader.cpp b/WebCore/loader/DocumentThreadableLoader.cpp index 0de62ce..ae6702b 100644 --- a/WebCore/loader/DocumentThreadableLoader.cpp +++ b/WebCore/loader/DocumentThreadableLoader.cpp @@ -77,26 +77,26 @@ void DocumentThreadableLoader::loadResourceSynchronously(Document* document, con client.didFinishLoading(identifier); } -PassRefPtr DocumentThreadableLoader::create(Document* document, ThreadableLoaderClient* client, const ResourceRequest& request, LoadCallbacks callbacksSetting, ContentSniff contentSniff, StoredCredentials storedCredentials, RedirectOriginCheck redirectOriginCheck) +PassRefPtr DocumentThreadableLoader::create(Document* document, ThreadableLoaderClient* client, const ResourceRequest& request, LoadCallbacks callbacksSetting, ContentSniff contentSniff, StoredCredentials storedCredentials, CrossOriginRedirectPolicy crossOriginRedirectPolicy) { ASSERT(document); - RefPtr loader = adoptRef(new DocumentThreadableLoader(document, client, request, callbacksSetting, contentSniff, storedCredentials, redirectOriginCheck)); + RefPtr loader = adoptRef(new DocumentThreadableLoader(document, client, request, callbacksSetting, contentSniff, storedCredentials, crossOriginRedirectPolicy)); if (!loader->m_loader) loader = 0; return loader.release(); } -DocumentThreadableLoader::DocumentThreadableLoader(Document* document, ThreadableLoaderClient* client, const ResourceRequest& request, LoadCallbacks callbacksSetting, ContentSniff contentSniff, StoredCredentials storedCredentials, RedirectOriginCheck redirectOriginCheck) +DocumentThreadableLoader::DocumentThreadableLoader(Document* document, ThreadableLoaderClient* client, const ResourceRequest& request, LoadCallbacks callbacksSetting, ContentSniff contentSniff, StoredCredentials storedCredentials, CrossOriginRedirectPolicy crossOriginRedirectPolicy) : m_client(client) , m_document(document) , m_allowStoredCredentials(storedCredentials == AllowStoredCredentials) , m_sameOriginRequest(document->securityOrigin()->canRequest(request.url())) - , m_checkRedirectOrigin(redirectOriginCheck == RequireSameRedirectOrigin) + , m_denyCrossOriginRedirect(crossOriginRedirectPolicy == DenyCrossOriginRedirect) { ASSERT(document); ASSERT(client); ASSERT(storedCredentials == AllowStoredCredentials || storedCredentials == DoNotAllowStoredCredentials); - ASSERT(redirectOriginCheck == RequireSameRedirectOrigin || redirectOriginCheck == AllowDifferentRedirectOrigin); + ASSERT(crossOriginRedirectPolicy == DenyCrossOriginRedirect || crossOriginRedirectPolicy == AllowCrossOriginRedirect); m_loader = SubresourceLoader::create(document->frame(), this, request, false, callbacksSetting == SendLoadCallbacks, contentSniff == SniffContent); } @@ -123,7 +123,7 @@ void DocumentThreadableLoader::willSendRequest(SubresourceLoader* loader, Resour ASSERT_UNUSED(loader, loader == m_loader); // FIXME: This needs to be fixed to follow the redirect correctly even for cross-domain requests. - if (m_checkRedirectOrigin && !m_document->securityOrigin()->canRequest(request.url())) { + if (m_denyCrossOriginRedirect && !m_document->securityOrigin()->canRequest(request.url())) { RefPtr protect(this); m_client->didFailRedirectCheck(); request = ResourceRequest(); diff --git a/WebCore/loader/DocumentThreadableLoader.h b/WebCore/loader/DocumentThreadableLoader.h index 079c725..465475f 100644 --- a/WebCore/loader/DocumentThreadableLoader.h +++ b/WebCore/loader/DocumentThreadableLoader.h @@ -45,7 +45,7 @@ namespace WebCore { class DocumentThreadableLoader : public RefCounted, public ThreadableLoader, private SubresourceLoaderClient { public: static void loadResourceSynchronously(Document*, const ResourceRequest&, ThreadableLoaderClient&, StoredCredentials); - static PassRefPtr create(Document*, ThreadableLoaderClient*, const ResourceRequest&, LoadCallbacks, ContentSniff, StoredCredentials, RedirectOriginCheck); + static PassRefPtr create(Document*, ThreadableLoaderClient*, const ResourceRequest&, LoadCallbacks, ContentSniff, StoredCredentials, CrossOriginRedirectPolicy); virtual ~DocumentThreadableLoader(); virtual void cancel(); @@ -58,7 +58,7 @@ namespace WebCore { virtual void derefThreadableLoader() { deref(); } private: - DocumentThreadableLoader(Document*, ThreadableLoaderClient*, const ResourceRequest&, LoadCallbacks, ContentSniff, StoredCredentials, RedirectOriginCheck); + DocumentThreadableLoader(Document*, ThreadableLoaderClient*, const ResourceRequest&, LoadCallbacks, ContentSniff, StoredCredentials, CrossOriginRedirectPolicy); virtual void willSendRequest(SubresourceLoader*, ResourceRequest&, const ResourceResponse& redirectResponse); virtual void didSendData(SubresourceLoader*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent); @@ -76,7 +76,7 @@ namespace WebCore { Document* m_document; bool m_allowStoredCredentials; bool m_sameOriginRequest; - bool m_checkRedirectOrigin; + bool m_denyCrossOriginRedirect; }; } // namespace WebCore diff --git a/WebCore/loader/ThreadableLoader.cpp b/WebCore/loader/ThreadableLoader.cpp index 7b9c6c6..b174af7 100644 --- a/WebCore/loader/ThreadableLoader.cpp +++ b/WebCore/loader/ThreadableLoader.cpp @@ -40,18 +40,18 @@ namespace WebCore { -PassRefPtr ThreadableLoader::create(ScriptExecutionContext* context, ThreadableLoaderClient* client, const ResourceRequest& request, LoadCallbacks callbacksSetting, ContentSniff contentSniff, StoredCredentials storedCredentials, RedirectOriginCheck redirectOriginCheck) +PassRefPtr ThreadableLoader::create(ScriptExecutionContext* context, ThreadableLoaderClient* client, const ResourceRequest& request, LoadCallbacks callbacksSetting, ContentSniff contentSniff, StoredCredentials storedCredentials, CrossOriginRedirectPolicy crossOriginRedirectPolicy) { ASSERT(client); ASSERT(context); #if ENABLE(WORKERS) if (context->isWorkerContext()) - return WorkerThreadableLoader::create(static_cast(context), client, WorkerRunLoop::defaultMode(), request, callbacksSetting, contentSniff, storedCredentials, redirectOriginCheck); + return WorkerThreadableLoader::create(static_cast(context), client, WorkerRunLoop::defaultMode(), request, callbacksSetting, contentSniff, storedCredentials, crossOriginRedirectPolicy); #endif // ENABLE(WORKERS) ASSERT(context->isDocument()); - return DocumentThreadableLoader::create(static_cast(context), client, request, callbacksSetting, contentSniff, storedCredentials, redirectOriginCheck); + return DocumentThreadableLoader::create(static_cast(context), client, request, callbacksSetting, contentSniff, storedCredentials, crossOriginRedirectPolicy); } void ThreadableLoader::loadResourceSynchronously(ScriptExecutionContext* context, const ResourceRequest& request, ThreadableLoaderClient& client, StoredCredentials storedCredentials) @@ -60,7 +60,7 @@ void ThreadableLoader::loadResourceSynchronously(ScriptExecutionContext* context #if ENABLE(WORKERS) if (context->isWorkerContext()) { - WorkerThreadableLoader::loadResourceSynchronously(static_cast(context), request, client, storedCredentials, RequireSameRedirectOrigin); + WorkerThreadableLoader::loadResourceSynchronously(static_cast(context), request, client, storedCredentials, DenyCrossOriginRedirect); return; } #endif // ENABLE(WORKERS) diff --git a/WebCore/loader/ThreadableLoader.h b/WebCore/loader/ThreadableLoader.h index 0a4c4e3..87ae229 100644 --- a/WebCore/loader/ThreadableLoader.h +++ b/WebCore/loader/ThreadableLoader.h @@ -58,9 +58,9 @@ namespace WebCore { DoNotAllowStoredCredentials }; - enum RedirectOriginCheck { - RequireSameRedirectOrigin, - AllowDifferentRedirectOrigin + enum CrossOriginRedirectPolicy { + DenyCrossOriginRedirect, + AllowCrossOriginRedirect }; // Useful for doing loader operations from any thread (not threadsafe, @@ -68,7 +68,7 @@ namespace WebCore { class ThreadableLoader : Noncopyable { public: static void loadResourceSynchronously(ScriptExecutionContext*, const ResourceRequest&, ThreadableLoaderClient&, StoredCredentials); - static PassRefPtr create(ScriptExecutionContext*, ThreadableLoaderClient*, const ResourceRequest&, LoadCallbacks, ContentSniff, StoredCredentials, RedirectOriginCheck); + static PassRefPtr create(ScriptExecutionContext*, ThreadableLoaderClient*, const ResourceRequest&, LoadCallbacks, ContentSniff, StoredCredentials, CrossOriginRedirectPolicy); virtual void cancel() = 0; void ref() { refThreadableLoader(); } diff --git a/WebCore/loader/WorkerThreadableLoader.cpp b/WebCore/loader/WorkerThreadableLoader.cpp index 8153ad8..4d12b8d 100644 --- a/WebCore/loader/WorkerThreadableLoader.cpp +++ b/WebCore/loader/WorkerThreadableLoader.cpp @@ -54,10 +54,10 @@ namespace WebCore { static const char loadResourceSynchronouslyMode[] = "loadResourceSynchronouslyMode"; WorkerThreadableLoader::WorkerThreadableLoader(WorkerContext* workerContext, ThreadableLoaderClient* client, const String& taskMode, const ResourceRequest& request, LoadCallbacks callbacksSetting, - ContentSniff contentSniff, StoredCredentials storedCredentials, RedirectOriginCheck redirectOriginCheck) + ContentSniff contentSniff, StoredCredentials storedCredentials, CrossOriginRedirectPolicy crossOriginRedirectPolicy) : m_workerContext(workerContext) , m_workerClientWrapper(ThreadableLoaderClientWrapper::create(client)) - , m_bridge(*(new MainThreadBridge(m_workerClientWrapper, m_workerContext->thread()->workerLoaderProxy(), taskMode, request, callbacksSetting, contentSniff, storedCredentials, redirectOriginCheck))) + , m_bridge(*(new MainThreadBridge(m_workerClientWrapper, m_workerContext->thread()->workerLoaderProxy(), taskMode, request, callbacksSetting, contentSniff, storedCredentials, crossOriginRedirectPolicy))) { } @@ -66,7 +66,7 @@ WorkerThreadableLoader::~WorkerThreadableLoader() m_bridge.destroy(); } -void WorkerThreadableLoader::loadResourceSynchronously(WorkerContext* workerContext, const ResourceRequest& request, ThreadableLoaderClient& client, StoredCredentials storedCredentials, RedirectOriginCheck redirectOriginCheck) +void WorkerThreadableLoader::loadResourceSynchronously(WorkerContext* workerContext, const ResourceRequest& request, ThreadableLoaderClient& client, StoredCredentials storedCredentials, CrossOriginRedirectPolicy crossOriginRedirectPolicy) { WorkerRunLoop& runLoop = workerContext->thread()->runLoop(); @@ -75,7 +75,7 @@ void WorkerThreadableLoader::loadResourceSynchronously(WorkerContext* workerCont mode.append(String::number(runLoop.createUniqueId())); ContentSniff contentSniff = request.url().isLocalFile() ? SniffContent : DoNotSniffContent; - RefPtr loader = WorkerThreadableLoader::create(workerContext, &client, mode, request, DoNotSendLoadCallbacks, contentSniff, storedCredentials, redirectOriginCheck); + RefPtr loader = WorkerThreadableLoader::create(workerContext, &client, mode, request, DoNotSendLoadCallbacks, contentSniff, storedCredentials, crossOriginRedirectPolicy); MessageQueueWaitResult result = MessageQueueMessageReceived; while (!loader->done() && result != MessageQueueTerminated) @@ -92,20 +92,20 @@ void WorkerThreadableLoader::cancel() WorkerThreadableLoader::MainThreadBridge::MainThreadBridge(PassRefPtr workerClientWrapper, WorkerLoaderProxy& loaderProxy, const String& taskMode, const ResourceRequest& request, LoadCallbacks callbacksSetting, ContentSniff contentSniff, StoredCredentials storedCredentials, - RedirectOriginCheck redirectOriginCheck) + CrossOriginRedirectPolicy crossOriginRedirectPolicy) : m_workerClientWrapper(workerClientWrapper) , m_loaderProxy(loaderProxy) , m_taskMode(taskMode.copy()) { ASSERT(m_workerClientWrapper.get()); - m_loaderProxy.postTaskToLoader(createCallbackTask(&MainThreadBridge::mainThreadCreateLoader, this, request, callbacksSetting, contentSniff, storedCredentials, redirectOriginCheck)); + m_loaderProxy.postTaskToLoader(createCallbackTask(&MainThreadBridge::mainThreadCreateLoader, this, request, callbacksSetting, contentSniff, storedCredentials, crossOriginRedirectPolicy)); } WorkerThreadableLoader::MainThreadBridge::~MainThreadBridge() { } -void WorkerThreadableLoader::MainThreadBridge::mainThreadCreateLoader(ScriptExecutionContext* context, MainThreadBridge* thisPtr, auto_ptr requestData, LoadCallbacks callbacksSetting, ContentSniff contentSniff, StoredCredentials storedCredentials, RedirectOriginCheck redirectOriginCheck) +void WorkerThreadableLoader::MainThreadBridge::mainThreadCreateLoader(ScriptExecutionContext* context, MainThreadBridge* thisPtr, auto_ptr requestData, LoadCallbacks callbacksSetting, ContentSniff contentSniff, StoredCredentials storedCredentials, CrossOriginRedirectPolicy crossOriginRedirectPolicy) { ASSERT(isMainThread()); ASSERT(context->isDocument()); @@ -117,7 +117,7 @@ void WorkerThreadableLoader::MainThreadBridge::mainThreadCreateLoader(ScriptExec // FIXME: If the a site requests a local resource, then this will return a non-zero value but the sync path // will return a 0 value. Either this should return 0 or the other code path should do a callback with // a failure. - thisPtr->m_mainThreadLoader = ThreadableLoader::create(context, thisPtr, *request, callbacksSetting, contentSniff, storedCredentials, redirectOriginCheck); + thisPtr->m_mainThreadLoader = ThreadableLoader::create(context, thisPtr, *request, callbacksSetting, contentSniff, storedCredentials, crossOriginRedirectPolicy); ASSERT(thisPtr->m_mainThreadLoader); } diff --git a/WebCore/loader/WorkerThreadableLoader.h b/WebCore/loader/WorkerThreadableLoader.h index a36bedf..8b11b70 100644 --- a/WebCore/loader/WorkerThreadableLoader.h +++ b/WebCore/loader/WorkerThreadableLoader.h @@ -55,10 +55,10 @@ namespace WebCore { class WorkerThreadableLoader : public RefCounted, public ThreadableLoader { public: - static void loadResourceSynchronously(WorkerContext*, const ResourceRequest&, ThreadableLoaderClient&, StoredCredentials, RedirectOriginCheck); - static PassRefPtr create(WorkerContext* workerContext, ThreadableLoaderClient* client, const String& taskMode, const ResourceRequest& request, LoadCallbacks callbacksSetting, ContentSniff contentSniff, StoredCredentials storedCredentials, RedirectOriginCheck redirectOriginCheck) + static void loadResourceSynchronously(WorkerContext*, const ResourceRequest&, ThreadableLoaderClient&, StoredCredentials, CrossOriginRedirectPolicy); + static PassRefPtr create(WorkerContext* workerContext, ThreadableLoaderClient* client, const String& taskMode, const ResourceRequest& request, LoadCallbacks callbacksSetting, ContentSniff contentSniff, StoredCredentials storedCredentials, CrossOriginRedirectPolicy crossOriginRedirectPolicy) { - return adoptRef(new WorkerThreadableLoader(workerContext, client, taskMode, request, callbacksSetting, contentSniff, storedCredentials, redirectOriginCheck)); + return adoptRef(new WorkerThreadableLoader(workerContext, client, taskMode, request, callbacksSetting, contentSniff, storedCredentials, crossOriginRedirectPolicy)); } ~WorkerThreadableLoader(); @@ -97,7 +97,7 @@ namespace WebCore { class MainThreadBridge : ThreadableLoaderClient { public: // All executed on the worker context's thread. - MainThreadBridge(PassRefPtr, WorkerLoaderProxy&, const String& taskMode, const ResourceRequest&, LoadCallbacks, ContentSniff, StoredCredentials, RedirectOriginCheck); + MainThreadBridge(PassRefPtr, WorkerLoaderProxy&, const String& taskMode, const ResourceRequest&, LoadCallbacks, ContentSniff, StoredCredentials, CrossOriginRedirectPolicy); void cancel(); void destroy(); @@ -109,7 +109,7 @@ namespace WebCore { static void mainThreadDestroy(ScriptExecutionContext*, MainThreadBridge*); ~MainThreadBridge(); - static void mainThreadCreateLoader(ScriptExecutionContext*, MainThreadBridge*, std::auto_ptr, LoadCallbacks, ContentSniff, StoredCredentials, RedirectOriginCheck); + static void mainThreadCreateLoader(ScriptExecutionContext*, MainThreadBridge*, std::auto_ptr, LoadCallbacks, ContentSniff, StoredCredentials, CrossOriginRedirectPolicy); static void mainThreadCancel(ScriptExecutionContext*, MainThreadBridge*); virtual void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent); virtual void didReceiveResponse(const ResourceResponse&); @@ -133,7 +133,7 @@ namespace WebCore { String m_taskMode; }; - WorkerThreadableLoader(WorkerContext*, ThreadableLoaderClient*, const String& taskMode, const ResourceRequest&, LoadCallbacks, ContentSniff, StoredCredentials, RedirectOriginCheck); + WorkerThreadableLoader(WorkerContext*, ThreadableLoaderClient*, const String& taskMode, const ResourceRequest&, LoadCallbacks, ContentSniff, StoredCredentials, CrossOriginRedirectPolicy); RefPtr m_workerContext; RefPtr m_workerClientWrapper; diff --git a/WebCore/workers/Worker.cpp b/WebCore/workers/Worker.cpp index b4ced28..a810dda 100644 --- a/WebCore/workers/Worker.cpp +++ b/WebCore/workers/Worker.cpp @@ -66,7 +66,7 @@ Worker::Worker(const String& url, ScriptExecutionContext* context, ExceptionCode } m_scriptLoader = new WorkerScriptLoader(); - m_scriptLoader->loadAsynchronously(scriptExecutionContext(), m_scriptURL, RequireSameRedirectOrigin, this); + m_scriptLoader->loadAsynchronously(scriptExecutionContext(), m_scriptURL, DenyCrossOriginRedirect, this); setPendingActivity(this); // The worker context does not exist while loading, so we must ensure that the worker object is not collected, as well as its event listeners. } diff --git a/WebCore/workers/WorkerContext.cpp b/WebCore/workers/WorkerContext.cpp index 57b2189..fd05062 100644 --- a/WebCore/workers/WorkerContext.cpp +++ b/WebCore/workers/WorkerContext.cpp @@ -274,7 +274,7 @@ void WorkerContext::importScripts(const Vector& urls, const String& call for (Vector::const_iterator it = completedURLs.begin(); it != end; ++it) { WorkerScriptLoader scriptLoader; - scriptLoader.loadSynchronously(scriptExecutionContext(), *it, AllowDifferentRedirectOrigin); + scriptLoader.loadSynchronously(scriptExecutionContext(), *it, AllowCrossOriginRedirect); // If the fetching attempt failed, throw a NETWORK_ERR exception and abort all these steps. if (scriptLoader.failed()) { diff --git a/WebCore/workers/WorkerScriptLoader.cpp b/WebCore/workers/WorkerScriptLoader.cpp index 4679ded..8737b88 100644 --- a/WebCore/workers/WorkerScriptLoader.cpp +++ b/WebCore/workers/WorkerScriptLoader.cpp @@ -47,16 +47,16 @@ WorkerScriptLoader::WorkerScriptLoader() { } -void WorkerScriptLoader::loadSynchronously(ScriptExecutionContext* scriptExecutionContext, const String& url, RedirectOriginCheck redirectOriginCheck) +void WorkerScriptLoader::loadSynchronously(ScriptExecutionContext* scriptExecutionContext, const String& url, CrossOriginRedirectPolicy crossOriginRedirectPolicy) { ResourceRequest request(url); request.setHTTPMethod("GET"); ASSERT(scriptExecutionContext->isWorkerContext()); - WorkerThreadableLoader::loadResourceSynchronously(static_cast(scriptExecutionContext), request, *this, AllowStoredCredentials, redirectOriginCheck); + WorkerThreadableLoader::loadResourceSynchronously(static_cast(scriptExecutionContext), request, *this, AllowStoredCredentials, crossOriginRedirectPolicy); } -void WorkerScriptLoader::loadAsynchronously(ScriptExecutionContext* scriptExecutionContext, const String& url, RedirectOriginCheck redirectOriginCheck, WorkerScriptLoaderClient* client) +void WorkerScriptLoader::loadAsynchronously(ScriptExecutionContext* scriptExecutionContext, const String& url, CrossOriginRedirectPolicy crossOriginRedirectPolicy, WorkerScriptLoaderClient* client) { ASSERT(client); m_client = client; @@ -64,7 +64,7 @@ void WorkerScriptLoader::loadAsynchronously(ScriptExecutionContext* scriptExecut ResourceRequest request(url); request.setHTTPMethod("GET"); - m_threadableLoader = ThreadableLoader::create(scriptExecutionContext, this, request, DoNotSendLoadCallbacks, DoNotSniffContent, AllowStoredCredentials, redirectOriginCheck); + m_threadableLoader = ThreadableLoader::create(scriptExecutionContext, this, request, DoNotSendLoadCallbacks, DoNotSniffContent, AllowStoredCredentials, crossOriginRedirectPolicy); } void WorkerScriptLoader::didReceiveResponse(const ResourceResponse& response) diff --git a/WebCore/workers/WorkerScriptLoader.h b/WebCore/workers/WorkerScriptLoader.h index 9f2eb9c..e3a9663 100644 --- a/WebCore/workers/WorkerScriptLoader.h +++ b/WebCore/workers/WorkerScriptLoader.h @@ -45,8 +45,8 @@ namespace WebCore { public: WorkerScriptLoader(); - void loadSynchronously(ScriptExecutionContext*, const String& url, RedirectOriginCheck); - void loadAsynchronously(ScriptExecutionContext*, const String& url, RedirectOriginCheck, WorkerScriptLoaderClient*); + void loadSynchronously(ScriptExecutionContext*, const String& url, CrossOriginRedirectPolicy); + void loadAsynchronously(ScriptExecutionContext*, const String& url, CrossOriginRedirectPolicy, WorkerScriptLoaderClient*); const String& script() const { return m_script; } bool failed() const { return m_failed; } diff --git a/WebCore/xml/XMLHttpRequest.cpp b/WebCore/xml/XMLHttpRequest.cpp index 76ee048..59cacbd 100644 --- a/WebCore/xml/XMLHttpRequest.cpp +++ b/WebCore/xml/XMLHttpRequest.cpp @@ -674,7 +674,7 @@ void XMLHttpRequest::loadRequestAsynchronously(ResourceRequest& request) if (m_upload) request.setReportUploadProgress(true); - m_loader = ThreadableLoader::create(scriptExecutionContext(), this, request, callbacks, DoNotSniffContent, storedCredentials, RequireSameRedirectOrigin); + m_loader = ThreadableLoader::create(scriptExecutionContext(), this, request, callbacks, DoNotSniffContent, storedCredentials, DenyCrossOriginRedirect); if (m_loader) { // Neither this object nor the JavaScript wrapper should be deleted while -- 1.8.3.1