diff options
Diffstat (limited to 'chromium/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp')
| -rw-r--r-- | chromium/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp | 156 |
1 files changed, 59 insertions, 97 deletions
diff --git a/chromium/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp b/chromium/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp index ad16a0f36d0..b4ee50843c9 100644 --- a/chromium/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp +++ b/chromium/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp @@ -35,26 +35,26 @@ #include "core/dom/CrossThreadTask.h" #include "core/dom/Document.h" #include "core/loader/DocumentThreadableLoader.h" +#include "core/loader/WorkerLoaderClientBridgeSyncHelper.h" #include "core/workers/WorkerGlobalScope.h" #include "core/workers/WorkerLoaderProxy.h" #include "core/workers/WorkerThread.h" #include "platform/network/ResourceError.h" #include "platform/network/ResourceRequest.h" #include "platform/network/ResourceResponse.h" +#include "platform/weborigin/Referrer.h" +#include "public/platform/Platform.h" +#include "public/platform/WebWaitableEvent.h" #include "wtf/MainThread.h" #include "wtf/OwnPtr.h" #include "wtf/Vector.h" -using namespace std; - namespace WebCore { -static const char loadResourceSynchronouslyMode[] = "loadResourceSynchronouslyMode"; - -WorkerThreadableLoader::WorkerThreadableLoader(WorkerGlobalScope* workerGlobalScope, ThreadableLoaderClient* client, const String& taskMode, const ResourceRequest& request, const ThreadableLoaderOptions& options) - : m_workerGlobalScope(workerGlobalScope) - , m_workerClientWrapper(ThreadableLoaderClientWrapper::create(client)) - , m_bridge(*(new MainThreadBridge(m_workerClientWrapper, m_workerGlobalScope->thread()->workerLoaderProxy(), taskMode, request, options, workerGlobalScope->url().strippedForUseAsReferrer()))) +WorkerThreadableLoader::WorkerThreadableLoader(WorkerGlobalScope& workerGlobalScope, PassRefPtr<ThreadableLoaderClientWrapper> clientWrapper, PassOwnPtr<ThreadableLoaderClient> clientBridge, const ResourceRequest& request, const ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoaderOptions) + : m_workerGlobalScope(&workerGlobalScope) + , m_workerClientWrapper(clientWrapper) + , m_bridge(*(new MainThreadBridge(m_workerClientWrapper, clientBridge, workerGlobalScope.thread()->workerLoaderProxy(), request, options, resourceLoaderOptions, workerGlobalScope.url().strippedForUseAsReferrer()))) { } @@ -63,21 +63,36 @@ WorkerThreadableLoader::~WorkerThreadableLoader() m_bridge.destroy(); } -void WorkerThreadableLoader::loadResourceSynchronously(WorkerGlobalScope* workerGlobalScope, const ResourceRequest& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options) +void WorkerThreadableLoader::loadResourceSynchronously(WorkerGlobalScope& workerGlobalScope, const ResourceRequest& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoaderOptions) { - WorkerRunLoop& runLoop = workerGlobalScope->thread()->runLoop(); + blink::WebWaitableEvent* shutdownEvent = + workerGlobalScope.thread()->shutdownEvent(); + OwnPtr<blink::WebWaitableEvent> loaderDone = + adoptPtr(blink::Platform::current()->createWaitableEvent()); + + Vector<blink::WebWaitableEvent*> events; + events.append(shutdownEvent); + events.append(loaderDone.get()); - // Create a unique mode just for this synchronous resource load. - String mode = loadResourceSynchronouslyMode; - mode.append(String::number(runLoop.createUniqueId())); + RefPtr<ThreadableLoaderClientWrapper> clientWrapper(ThreadableLoaderClientWrapper::create(&client)); + OwnPtr<WorkerLoaderClientBridgeSyncHelper> clientBridge(WorkerLoaderClientBridgeSyncHelper::create(client, loaderDone.release())); - RefPtr<WorkerThreadableLoader> loader = WorkerThreadableLoader::create(workerGlobalScope, &client, mode, request, options); - MessageQueueWaitResult result = MessageQueueMessageReceived; - while (!loader->done() && result != MessageQueueTerminated) - result = runLoop.runInMode(workerGlobalScope, mode); + // This must be valid while loader is around. + WorkerLoaderClientBridgeSyncHelper* clientBridgePtr = clientBridge.get(); - if (!loader->done() && result == MessageQueueTerminated) + RefPtr<WorkerThreadableLoader> loader = WorkerThreadableLoader::create(workerGlobalScope, clientWrapper, clientBridge.release(), request, options, resourceLoaderOptions); + + blink::WebWaitableEvent* signalled; + { + ThreadState::SafePointScope scope(ThreadState::HeapPointersOnStack); + signalled = blink::Platform::current()->waitMultipleEvents(events); + } + if (signalled == shutdownEvent) { loader->cancel(); + return; + } + + clientBridgePtr->run(); } void WorkerThreadableLoader::cancel() @@ -85,31 +100,37 @@ void WorkerThreadableLoader::cancel() m_bridge.cancel(); } -WorkerThreadableLoader::MainThreadBridge::MainThreadBridge(PassRefPtr<ThreadableLoaderClientWrapper> workerClientWrapper, WorkerLoaderProxy& loaderProxy, const String& taskMode, - const ResourceRequest& request, const ThreadableLoaderOptions& options, const String& outgoingReferrer) - : m_workerClientWrapper(workerClientWrapper) +WorkerThreadableLoader::MainThreadBridge::MainThreadBridge( + PassRefPtr<ThreadableLoaderClientWrapper> workerClientWrapper, + PassOwnPtr<ThreadableLoaderClient> clientBridge, + WorkerLoaderProxy& loaderProxy, + const ResourceRequest& request, + const ThreadableLoaderOptions& options, + const ResourceLoaderOptions& resourceLoaderOptions, + const String& outgoingReferrer) + : m_clientBridge(clientBridge) + , m_workerClientWrapper(workerClientWrapper) , m_loaderProxy(loaderProxy) - , m_taskMode(taskMode.isolatedCopy()) { ASSERT(m_workerClientWrapper.get()); + ASSERT(m_clientBridge.get()); m_loaderProxy.postTaskToLoader( - createCallbackTask(&MainThreadBridge::mainThreadCreateLoader, - AllowCrossThreadAccess(this), request, options, outgoingReferrer)); + createCallbackTask(&MainThreadBridge::mainThreadCreateLoader, AllowCrossThreadAccess(this), request, options, resourceLoaderOptions, outgoingReferrer)); } WorkerThreadableLoader::MainThreadBridge::~MainThreadBridge() { } -void WorkerThreadableLoader::MainThreadBridge::mainThreadCreateLoader(ExecutionContext* context, MainThreadBridge* thisPtr, PassOwnPtr<CrossThreadResourceRequestData> requestData, ThreadableLoaderOptions options, const String& outgoingReferrer) +void WorkerThreadableLoader::MainThreadBridge::mainThreadCreateLoader(ExecutionContext* context, MainThreadBridge* thisPtr, PassOwnPtr<CrossThreadResourceRequestData> requestData, ThreadableLoaderOptions options, ResourceLoaderOptions resourceLoaderOptions, const String& outgoingReferrer) { ASSERT(isMainThread()); Document* document = toDocument(context); OwnPtr<ResourceRequest> request(ResourceRequest::adopt(requestData)); - request->setHTTPReferrer(outgoingReferrer); - options.requestInitiatorContext = WorkerContext; - thisPtr->m_mainThreadLoader = DocumentThreadableLoader::create(document, thisPtr, *request, options); + request->setHTTPReferrer(Referrer(outgoingReferrer, ReferrerPolicyDefault)); + resourceLoaderOptions.requestInitiatorContext = WorkerContext; + thisPtr->m_mainThreadLoader = DocumentThreadableLoader::create(*document, thisPtr, *request, options, resourceLoaderOptions); if (!thisPtr->m_mainThreadLoader) { // DocumentThreadableLoader::create may return 0 when the document loader has been already changed. thisPtr->didFail(ResourceError(errorDomainBlinkInternal, 0, request->url().string(), "Can't create DocumentThreadableLoader")); @@ -141,7 +162,7 @@ void WorkerThreadableLoader::MainThreadBridge::mainThreadCancel(ExecutionContext if (!thisPtr->m_mainThreadLoader) return; thisPtr->m_mainThreadLoader->cancel(); - thisPtr->m_mainThreadLoader = 0; + thisPtr->m_mainThreadLoader = nullptr; } void WorkerThreadableLoader::MainThreadBridge::cancel() @@ -164,108 +185,49 @@ void WorkerThreadableLoader::MainThreadBridge::clearClientWrapper() m_workerClientWrapper->clearClient(); } -static void workerGlobalScopeDidSendData(ExecutionContext* context, PassRefPtr<ThreadableLoaderClientWrapper> workerClientWrapper, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) -{ - ASSERT_UNUSED(context, context->isWorkerGlobalScope()); - workerClientWrapper->didSendData(bytesSent, totalBytesToBeSent); -} - void WorkerThreadableLoader::MainThreadBridge::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) { - m_loaderProxy.postTaskForModeToWorkerGlobalScope(createCallbackTask(&workerGlobalScopeDidSendData, m_workerClientWrapper, bytesSent, totalBytesToBeSent), m_taskMode); -} - -static void workerGlobalScopeDidReceiveResponse(ExecutionContext* context, PassRefPtr<ThreadableLoaderClientWrapper> workerClientWrapper, unsigned long identifier, PassOwnPtr<CrossThreadResourceResponseData> responseData) -{ - ASSERT_UNUSED(context, context->isWorkerGlobalScope()); - OwnPtr<ResourceResponse> response(ResourceResponse::adopt(responseData)); - workerClientWrapper->didReceiveResponse(identifier, *response); + m_clientBridge->didSendData(bytesSent, totalBytesToBeSent); } void WorkerThreadableLoader::MainThreadBridge::didReceiveResponse(unsigned long identifier, const ResourceResponse& response) { - m_loaderProxy.postTaskForModeToWorkerGlobalScope(createCallbackTask(&workerGlobalScopeDidReceiveResponse, m_workerClientWrapper, identifier, response), m_taskMode); -} - -static void workerGlobalScopeDidReceiveData(ExecutionContext* context, PassRefPtr<ThreadableLoaderClientWrapper> workerClientWrapper, PassOwnPtr<Vector<char> > vectorData) -{ - ASSERT_UNUSED(context, context->isWorkerGlobalScope()); - workerClientWrapper->didReceiveData(vectorData->data(), vectorData->size()); + m_clientBridge->didReceiveResponse(identifier, response); } void WorkerThreadableLoader::MainThreadBridge::didReceiveData(const char* data, int dataLength) { - OwnPtr<Vector<char> > vector = adoptPtr(new Vector<char>(dataLength)); // needs to be an OwnPtr for usage with createCallbackTask. - memcpy(vector->data(), data, dataLength); - m_loaderProxy.postTaskForModeToWorkerGlobalScope(createCallbackTask(&workerGlobalScopeDidReceiveData, m_workerClientWrapper, vector.release()), m_taskMode); -} - -static void workerGlobalScopeDidDownloadData(ExecutionContext* context, PassRefPtr<ThreadableLoaderClientWrapper> workerClientWrapper, int dataLength) -{ - ASSERT_UNUSED(context, context->isWorkerGlobalScope()); - workerClientWrapper->didDownloadData(dataLength); + m_clientBridge->didReceiveData(data, dataLength); } void WorkerThreadableLoader::MainThreadBridge::didDownloadData(int dataLength) { - m_loaderProxy.postTaskForModeToWorkerGlobalScope(createCallbackTask(&workerGlobalScopeDidDownloadData, m_workerClientWrapper, dataLength), m_taskMode); -} - -static void workerGlobalScopeDidReceiveCachedMetadata(ExecutionContext* context, PassRefPtr<ThreadableLoaderClientWrapper> workerClientWrapper, PassOwnPtr<Vector<char> > vectorData) -{ - ASSERT_UNUSED(context, context->isWorkerGlobalScope()); - workerClientWrapper->didReceiveCachedMetadata(vectorData->data(), vectorData->size()); + m_clientBridge->didDownloadData(dataLength); } void WorkerThreadableLoader::MainThreadBridge::didReceiveCachedMetadata(const char* data, int dataLength) { - OwnPtr<Vector<char> > vector = adoptPtr(new Vector<char>(dataLength)); // needs to be an OwnPtr for usage with createCallbackTask. - memcpy(vector->data(), data, dataLength); - m_loaderProxy.postTaskForModeToWorkerGlobalScope(createCallbackTask(&workerGlobalScopeDidReceiveCachedMetadata, m_workerClientWrapper, vector.release()), m_taskMode); -} - -static void workerGlobalScopeDidFinishLoading(ExecutionContext* context, PassRefPtr<ThreadableLoaderClientWrapper> workerClientWrapper, unsigned long identifier, double finishTime) -{ - ASSERT_UNUSED(context, context->isWorkerGlobalScope()); - workerClientWrapper->didFinishLoading(identifier, finishTime); + m_clientBridge->didReceiveCachedMetadata(data, dataLength); } void WorkerThreadableLoader::MainThreadBridge::didFinishLoading(unsigned long identifier, double finishTime) { - m_loaderProxy.postTaskForModeToWorkerGlobalScope(createCallbackTask(&workerGlobalScopeDidFinishLoading, m_workerClientWrapper, identifier, finishTime), m_taskMode); -} - -static void workerGlobalScopeDidFail(ExecutionContext* context, PassRefPtr<ThreadableLoaderClientWrapper> workerClientWrapper, const ResourceError& error) -{ - ASSERT_UNUSED(context, context->isWorkerGlobalScope()); - workerClientWrapper->didFail(error); + m_clientBridge->didFinishLoading(identifier, finishTime); } void WorkerThreadableLoader::MainThreadBridge::didFail(const ResourceError& error) { - m_loaderProxy.postTaskForModeToWorkerGlobalScope(createCallbackTask(&workerGlobalScopeDidFail, m_workerClientWrapper, error), m_taskMode); -} - -static void workerGlobalScopeDidFailAccessControlCheck(ExecutionContext* context, PassRefPtr<ThreadableLoaderClientWrapper> workerClientWrapper, const ResourceError& error) -{ - ASSERT_UNUSED(context, context->isWorkerGlobalScope()); - workerClientWrapper->didFailAccessControlCheck(error); + m_clientBridge->didFail(error); } void WorkerThreadableLoader::MainThreadBridge::didFailAccessControlCheck(const ResourceError& error) { - m_loaderProxy.postTaskForModeToWorkerGlobalScope(createCallbackTask(&workerGlobalScopeDidFailAccessControlCheck, m_workerClientWrapper, error), m_taskMode); -} - -static void workerGlobalScopeDidFailRedirectCheck(ExecutionContext* context, PassRefPtr<ThreadableLoaderClientWrapper> workerClientWrapper) -{ - ASSERT_UNUSED(context, context->isWorkerGlobalScope()); - workerClientWrapper->didFailRedirectCheck(); + m_clientBridge->didFailAccessControlCheck(error); } void WorkerThreadableLoader::MainThreadBridge::didFailRedirectCheck() { - m_loaderProxy.postTaskForModeToWorkerGlobalScope(createCallbackTask(&workerGlobalScopeDidFailRedirectCheck, m_workerClientWrapper), m_taskMode); + m_clientBridge->didFailRedirectCheck(); } } // namespace WebCore |