Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(73)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp

Issue 2228433002: Revert of Move ThreadableLoader to Oilpan heap (2/3) (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@onheap-bridge-peer-in-worker-threadable-loader
Patch Set: Created 4 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « third_party/WebKit/Source/core/loader/WorkerThreadableLoader.h ('k') | third_party/WebKit/Source/core/page/EventSource.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
diff --git a/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp b/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
index ab02e4ffa3f5098da572d49e54d390c693cb83b4..19f24037ed37614081c54bad4e1f452ded5a2c7c 100644
--- a/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
+++ b/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
@@ -208,42 +208,74 @@
const ResourceLoaderOptions& resourceLoaderOptions,
BlockingBehavior blockingBehavior)
: m_workerGlobalScope(&workerGlobalScope)
- , m_workerLoaderProxy(workerGlobalScope.thread()->workerLoaderProxy())
- , m_client(client)
- , m_threadableLoaderOptions(options)
+ , m_workerClientWrapper(new ThreadableLoaderClientWrapper(workerGlobalScope, client))
+ , m_bridge(new Bridge(m_workerClientWrapper, workerGlobalScope.thread()->workerLoaderProxy(), options, resourceLoaderOptions, blockingBehavior))
+{
+}
+
+void WorkerThreadableLoader::loadResourceSynchronously(WorkerGlobalScope& workerGlobalScope, const ResourceRequest& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoaderOptions)
+{
+ std::unique_ptr<WorkerThreadableLoader> loader = wrapUnique(new WorkerThreadableLoader(workerGlobalScope, &client, options, resourceLoaderOptions, LoadSynchronously));
+ loader->start(request);
+}
+
+WorkerThreadableLoader::~WorkerThreadableLoader()
+{
+ DCHECK(m_workerClientWrapper->done());
+ m_bridge->destroy();
+}
+
+void WorkerThreadableLoader::start(const ResourceRequest& request)
+{
+ ResourceRequest requestToPass(request);
+ if (!requestToPass.didSetHTTPReferrer())
+ requestToPass.setHTTPReferrer(SecurityPolicy::generateReferrer(m_workerGlobalScope->getReferrerPolicy(), request.url(), m_workerGlobalScope->outgoingReferrer()));
+ m_bridge->start(requestToPass, *m_workerGlobalScope);
+}
+
+void WorkerThreadableLoader::overrideTimeout(unsigned long timeoutMilliseconds)
+{
+ m_bridge->overrideTimeout(timeoutMilliseconds);
+}
+
+void WorkerThreadableLoader::cancel()
+{
+ m_bridge->cancel();
+}
+
+WorkerThreadableLoader::Bridge::Bridge(
+ ThreadableLoaderClientWrapper* clientWrapper,
+ PassRefPtr<WorkerLoaderProxy> loaderProxy,
+ const ThreadableLoaderOptions& threadableLoaderOptions,
+ const ResourceLoaderOptions& resourceLoaderOptions,
+ BlockingBehavior blockingBehavior)
+ : m_clientWrapper(clientWrapper)
+ , m_loaderProxy(loaderProxy)
+ , m_threadableLoaderOptions(threadableLoaderOptions)
, m_resourceLoaderOptions(resourceLoaderOptions)
, m_blockingBehavior(blockingBehavior)
{
- DCHECK(client);
-}
-
-void WorkerThreadableLoader::loadResourceSynchronously(WorkerGlobalScope& workerGlobalScope, const ResourceRequest& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoaderOptions)
-{
- (new WorkerThreadableLoader(workerGlobalScope, &client, options, resourceLoaderOptions, LoadSynchronously))->start(request);
-}
-
-WorkerThreadableLoader::~WorkerThreadableLoader()
-{
+ DCHECK(!isMainThread());
+}
+
+WorkerThreadableLoader::Bridge::~Bridge()
+{
+ DCHECK(!isMainThread());
DCHECK(!m_peer);
- DCHECK(!m_client);
-}
-
-void WorkerThreadableLoader::start(const ResourceRequest& originalRequest)
-{
- ResourceRequest request(originalRequest);
- if (!request.didSetHTTPReferrer())
- request.setHTTPReferrer(SecurityPolicy::generateReferrer(m_workerGlobalScope->getReferrerPolicy(), request.url(), m_workerGlobalScope->outgoingReferrer()));
-
+}
+
+void WorkerThreadableLoader::Bridge::start(const ResourceRequest& request, const WorkerGlobalScope& workerGlobalScope)
+{
DCHECK(!isMainThread());
RefPtr<WaitableEventWithTasks> eventWithTasks;
if (m_blockingBehavior == LoadSynchronously)
eventWithTasks = WaitableEventWithTasks::create();
- m_workerLoaderProxy->postTaskToLoader(BLINK_FROM_HERE, createCrossThreadTask(
+ m_loaderProxy->postTaskToLoader(BLINK_FROM_HERE, createCrossThreadTask(
&Peer::createAndStart,
wrapCrossThreadPersistent(this),
- m_workerLoaderProxy,
- wrapCrossThreadPersistent(m_workerGlobalScope->thread()->getWorkerThreadLifecycleContext()),
+ m_loaderProxy,
+ wrapCrossThreadPersistent(workerGlobalScope.thread()->getWorkerThreadLifecycleContext()),
request,
m_threadableLoaderOptions,
m_resourceLoaderOptions,
@@ -275,41 +307,44 @@
}
}
-void WorkerThreadableLoader::overrideTimeout(unsigned long timeoutMilliseconds)
+void WorkerThreadableLoader::Bridge::overrideTimeout(unsigned long timeoutMilliseconds)
{
DCHECK(!isMainThread());
if (!m_peer)
return;
- m_workerLoaderProxy->postTaskToLoader(BLINK_FROM_HERE, createCrossThreadTask(&Peer::overrideTimeout, m_peer, timeoutMilliseconds));
-}
-
-void WorkerThreadableLoader::cancel()
-{
- DCHECK(!isMainThread());
- if (m_peer) {
- m_workerLoaderProxy->postTaskToLoader(BLINK_FROM_HERE, createCrossThreadTask(&Peer::cancel, m_peer));
- m_peer = nullptr;
- }
-
- if (!m_client)
- return;
-
+ m_loaderProxy->postTaskToLoader(BLINK_FROM_HERE, createCrossThreadTask(&Peer::overrideTimeout, m_peer, timeoutMilliseconds));
+}
+
+void WorkerThreadableLoader::Bridge::cancel()
+{
+ DCHECK(!isMainThread());
+ cancelPeer();
+
+ if (m_clientWrapper->done())
+ return;
// If the client hasn't reached a termination state, then transition it
// by sending a cancellation error.
// Note: no more client callbacks will be done after this method -- the
// clearClient() call ensures that.
ResourceError error(String(), 0, String(), String());
error.setIsCancellation(true);
- didFail(error);
- DCHECK(!m_client);
-}
-
-void WorkerThreadableLoader::didStart(Peer* peer)
+ m_clientWrapper->didFail(error);
+ m_clientWrapper->clearClient();
+}
+
+void WorkerThreadableLoader::Bridge::destroy()
+{
+ DCHECK(!isMainThread());
+ cancelPeer();
+ m_clientWrapper->clearClient();
+}
+
+void WorkerThreadableLoader::Bridge::didStart(Peer* peer)
{
DCHECK(!isMainThread());
DCHECK(!m_peer);
DCHECK(peer);
- if (!m_client) {
+ if (m_clientWrapper->done()) {
// The loading is already cancelled.
return;
}
@@ -317,110 +352,22 @@
m_peer = peer;
}
-void WorkerThreadableLoader::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
-{
- DCHECK(!isMainThread());
- if (!m_client)
- return;
- m_client->didSendData(bytesSent, totalBytesToBeSent);
-}
-
-void WorkerThreadableLoader::didReceiveResponse(unsigned long identifier, std::unique_ptr<CrossThreadResourceResponseData> responseData, std::unique_ptr<WebDataConsumerHandle> handle)
-{
- DCHECK(!isMainThread());
- if (!m_client)
- return;
- ResourceResponse response(responseData.get());
- m_client->didReceiveResponse(identifier, response, std::move(handle));
-}
-
-void WorkerThreadableLoader::didReceiveData(std::unique_ptr<Vector<char>> data)
-{
- DCHECK(!isMainThread());
- CHECK_LE(data->size(), std::numeric_limits<unsigned>::max());
- if (!m_client)
- return;
- m_client->didReceiveData(data->data(), data->size());
-}
-
-void WorkerThreadableLoader::didReceiveCachedMetadata(std::unique_ptr<Vector<char>> data)
-{
- DCHECK(!isMainThread());
- if (!m_client)
- return;
- m_client->didReceiveCachedMetadata(data->data(), data->size());
-}
-
-void WorkerThreadableLoader::didFinishLoading(unsigned long identifier, double finishTime)
-{
- DCHECK(!isMainThread());
- if (!m_client)
- return;
- auto* client = m_client;
- m_client = nullptr;
+DEFINE_TRACE(WorkerThreadableLoader::Bridge)
+{
+ visitor->trace(m_clientWrapper);
+}
+
+void WorkerThreadableLoader::Bridge::cancelPeer()
+{
+ DCHECK(!isMainThread());
+ if (!m_peer)
+ return;
+ m_loaderProxy->postTaskToLoader(BLINK_FROM_HERE, createCrossThreadTask(&Peer::cancel, m_peer));
m_peer = nullptr;
- client->didFinishLoading(identifier, finishTime);
-}
-
-void WorkerThreadableLoader::didFail(const ResourceError& error)
-{
- DCHECK(!isMainThread());
- if (!m_client)
- return;
- auto* client = m_client;
- m_client = nullptr;
- m_peer = nullptr;
- client->didFail(error);
-}
-
-void WorkerThreadableLoader::didFailAccessControlCheck(const ResourceError& error)
-{
- DCHECK(!isMainThread());
- if (!m_client)
- return;
- auto* client = m_client;
- m_client = nullptr;
- m_peer = nullptr;
- client->didFailAccessControlCheck(error);
-}
-
-void WorkerThreadableLoader::didFailRedirectCheck()
-{
- DCHECK(!isMainThread());
- if (!m_client)
- return;
- auto* client = m_client;
- m_client = nullptr;
- m_peer = nullptr;
- client->didFailRedirectCheck();
-}
-
-void WorkerThreadableLoader::didDownloadData(int dataLength)
-{
- DCHECK(!isMainThread());
- if (!m_client)
- return;
- m_client->didDownloadData(dataLength);
-}
-
-void WorkerThreadableLoader::didReceiveResourceTiming(std::unique_ptr<CrossThreadResourceTimingInfoData> timingData)
-{
- DCHECK(!isMainThread());
- if (!m_client)
- return;
- std::unique_ptr<ResourceTimingInfo> info(ResourceTimingInfo::adopt(std::move(timingData)));
- WorkerGlobalScopePerformance::performance(*m_workerGlobalScope)->addResourceTiming(*info);
- m_client->didReceiveResourceTiming(*info);
-}
-
-DEFINE_TRACE(WorkerThreadableLoader)
-{
- visitor->trace(m_workerGlobalScope);
- ThreadableLoader::trace(visitor);
}
void WorkerThreadableLoader::Peer::createAndStart(
- WorkerThreadableLoader* workerLoader,
+ Bridge* bridge,
PassRefPtr<WorkerLoaderProxy> passLoaderProxy,
WorkerThreadLifecycleContext* workerThreadLifecycleContext,
std::unique_ptr<CrossThreadResourceRequestData> request,
@@ -444,15 +391,15 @@
peer->m_forwarder = nullptr;
return;
}
- peer->m_workerLoader = workerLoader;
+ peer->m_clientWrapper = bridge->clientWrapper();
peer->start(*toDocument(executionContext), std::move(request), options, resourceLoaderOptions);
- forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didStart, wrapCrossThreadPersistent(workerLoader), wrapCrossThreadPersistent(peer)));
+ forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&Bridge::didStart, wrapCrossThreadPersistent(bridge), wrapCrossThreadPersistent(peer)));
}
WorkerThreadableLoader::Peer::~Peer()
{
DCHECK(isMainThread());
- DCHECK(!m_workerLoader);
+ DCHECK(!m_mainThreadLoader);
}
void WorkerThreadableLoader::Peer::overrideTimeout(unsigned long timeoutMilliseconds)
@@ -475,95 +422,95 @@
void WorkerThreadableLoader::Peer::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
{
DCHECK(isMainThread());
- CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
- if (!workerLoader || !m_forwarder)
- return;
- m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didSendData, workerLoader, bytesSent, totalBytesToBeSent));
+ CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+ if (!clientWrapper || !m_forwarder)
+ return;
+ m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&ThreadableLoaderClientWrapper::didSendData, clientWrapper, bytesSent, totalBytesToBeSent));
}
void WorkerThreadableLoader::Peer::didReceiveResponse(unsigned long identifier, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle)
{
DCHECK(isMainThread());
- CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
- if (!workerLoader || !m_forwarder)
- return;
- m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didReceiveResponse, workerLoader, identifier, response, passed(std::move(handle))));
+ CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+ if (!clientWrapper || !m_forwarder)
+ return;
+ m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveResponse, clientWrapper, identifier, response, passed(std::move(handle))));
}
void WorkerThreadableLoader::Peer::didReceiveData(const char* data, unsigned dataLength)
{
DCHECK(isMainThread());
- CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
- if (!workerLoader || !m_forwarder)
- return;
- m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didReceiveData, workerLoader, passed(createVectorFromMemoryRegion(data, dataLength))));
+ CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+ if (!clientWrapper || !m_forwarder)
+ return;
+ m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveData, clientWrapper, passed(createVectorFromMemoryRegion(data, dataLength))));
}
void WorkerThreadableLoader::Peer::didDownloadData(int dataLength)
{
DCHECK(isMainThread());
- CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
- if (!workerLoader || !m_forwarder)
- return;
- m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didDownloadData, workerLoader, dataLength));
+ CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+ if (!clientWrapper || !m_forwarder)
+ return;
+ m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&ThreadableLoaderClientWrapper::didDownloadData, clientWrapper, dataLength));
}
void WorkerThreadableLoader::Peer::didReceiveCachedMetadata(const char* data, int dataLength)
{
DCHECK(isMainThread());
- CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
- if (!workerLoader || !m_forwarder)
- return;
- m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didReceiveCachedMetadata, workerLoader, passed(createVectorFromMemoryRegion(data, dataLength))));
+ CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+ if (!clientWrapper || !m_forwarder)
+ return;
+ m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveCachedMetadata, clientWrapper, passed(createVectorFromMemoryRegion(data, dataLength))));
}
void WorkerThreadableLoader::Peer::didFinishLoading(unsigned long identifier, double finishTime)
{
DCHECK(isMainThread());
- CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
- if (!workerLoader || !m_forwarder)
- return;
- m_forwarder->forwardTaskWithDoneSignal(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didFinishLoading, workerLoader, identifier, finishTime));
+ CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+ if (!clientWrapper || !m_forwarder)
+ return;
+ m_forwarder->forwardTaskWithDoneSignal(BLINK_FROM_HERE, createCrossThreadTask(&ThreadableLoaderClientWrapper::didFinishLoading, clientWrapper, identifier, finishTime));
m_forwarder = nullptr;
}
void WorkerThreadableLoader::Peer::didFail(const ResourceError& error)
{
DCHECK(isMainThread());
- CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
- if (!workerLoader || !m_forwarder)
- return;
- m_forwarder->forwardTaskWithDoneSignal(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didFail, workerLoader, error));
+ CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+ if (!clientWrapper || !m_forwarder)
+ return;
+ m_forwarder->forwardTaskWithDoneSignal(BLINK_FROM_HERE, createCrossThreadTask(&ThreadableLoaderClientWrapper::didFail, clientWrapper, error));
m_forwarder = nullptr;
}
void WorkerThreadableLoader::Peer::didFailAccessControlCheck(const ResourceError& error)
{
DCHECK(isMainThread());
- CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
- if (!workerLoader || !m_forwarder)
- return;
- m_forwarder->forwardTaskWithDoneSignal(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didFailAccessControlCheck, workerLoader, error));
+ CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+ if (!clientWrapper || !m_forwarder)
+ return;
+ m_forwarder->forwardTaskWithDoneSignal(BLINK_FROM_HERE, createCrossThreadTask(&ThreadableLoaderClientWrapper::didFailAccessControlCheck, clientWrapper, error));
m_forwarder = nullptr;
}
void WorkerThreadableLoader::Peer::didFailRedirectCheck()
{
DCHECK(isMainThread());
- CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
- if (!workerLoader || !m_forwarder)
- return;
- m_forwarder->forwardTaskWithDoneSignal(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didFailRedirectCheck, workerLoader));
+ CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+ if (!clientWrapper || !m_forwarder)
+ return;
+ m_forwarder->forwardTaskWithDoneSignal(BLINK_FROM_HERE, createCrossThreadTask(&ThreadableLoaderClientWrapper::didFailRedirectCheck, clientWrapper));
m_forwarder = nullptr;
}
void WorkerThreadableLoader::Peer::didReceiveResourceTiming(const ResourceTimingInfo& info)
{
DCHECK(isMainThread());
- CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
- if (!workerLoader || !m_forwarder)
- return;
- m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didReceiveResourceTiming, workerLoader, info));
+ CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
+ if (!clientWrapper || !m_forwarder)
+ return;
+ m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveResourceTiming, clientWrapper, info));
}
void WorkerThreadableLoader::Peer::contextDestroyed()
@@ -573,14 +520,13 @@
m_forwarder->abort();
m_forwarder = nullptr;
}
- m_workerLoader = nullptr;
+ m_clientWrapper = nullptr;
cancel();
}
DEFINE_TRACE(WorkerThreadableLoader::Peer)
{
visitor->trace(m_forwarder);
- visitor->trace(m_mainThreadLoader);
WorkerThreadLifecycleObserver::trace(visitor);
}
« no previous file with comments | « third_party/WebKit/Source/core/loader/WorkerThreadableLoader.h ('k') | third_party/WebKit/Source/core/page/EventSource.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698