Skip to content

Commit

Permalink
Move ThreadableLoader to Oilpan heap (3/3)
Browse files Browse the repository at this point in the history 
This CL is a refactoring and does not change the behavior.

BUG=587663

Review-Url: https://codereview.chromium.org/2193683004
Cr-Commit-Position: refs/heads/master@{#409961}
  • Loading branch information
@yutakahirano
yutakahirano authored and Commit bot committed Aug 5, 2016
1 parent 9bc477c commit 2ec047e
Show file tree
Hide file tree
Showing 4 changed files with 75 additions and 75 deletions.
4 changes: 2 additions & 2 deletions third_party/WebKit/Source/core/loader/DocumentThreadableLoader.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -341,7 +341,7 @@ void DocumentThreadableLoader::makeCrossOriginAccessRequest(const ResourceReques
DocumentThreadableLoader::~DocumentThreadableLoader()
{
CHECK(!m_client);
DCHECK(!m_resource);
DCHECK(!resource());
}

void DocumentThreadableLoader::overrideTimeout(unsigned long timeoutMilliseconds)
Expand Down Expand Up @@ -971,9 +971,9 @@ Document& DocumentThreadableLoader::document() const

DEFINE_TRACE(DocumentThreadableLoader)
{
visitor->trace(m_resource);
visitor->trace(m_document);
ThreadableLoader::trace(visitor);
ResourceOwner<RawResource>::trace(visitor);
}

} // namespace blink
26 changes: 2 additions & 24 deletions third_party/WebKit/Source/core/loader/DocumentThreadableLoader.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -54,7 +54,8 @@ class ResourceRequest;
class SecurityOrigin;
class ThreadableLoaderClient;

class CORE_EXPORT DocumentThreadableLoader final : public ThreadableLoader, private RawResourceClient {
class CORE_EXPORT DocumentThreadableLoader final : public ThreadableLoader, private ResourceOwner<RawResource> {
USING_GARBAGE_COLLECTED_MIXIN(DocumentThreadableLoader);
public:
static void loadResourceSynchronously(Document&, const ResourceRequest&, ThreadableLoaderClient&, const ThreadableLoaderOptions&, const ResourceLoaderOptions&);
static DocumentThreadableLoader* create(Document&, ThreadableLoaderClient*, const ThreadableLoaderOptions&, const ResourceLoaderOptions&);
Expand Down Expand Up @@ -150,29 +151,6 @@ class CORE_EXPORT DocumentThreadableLoader final : public ThreadableLoader, priv
// returns allowCredentials value of m_resourceLoaderOptions.
StoredCredentials effectiveAllowCredentials() const;

// TODO(oilpan): DocumentThreadableLoader used to be a ResourceOwner,
// but ResourceOwner was moved onto the oilpan heap before
// DocumentThreadableLoader was ready. When DocumentThreadableLoader
// moves onto the oilpan heap, make it a ResourceOwner again and remove
// this re-implementation of ResourceOwner.
RawResource* resource() const { return m_resource.get(); }
void clearResource() { setResource(nullptr); }
void setResource(RawResource* newResource)
{
if (newResource == m_resource)
return;

if (RawResource* oldResource = m_resource.release())
oldResource->removeClient(this);

if (newResource) {
m_resource = newResource;
m_resource->addClient(this);
}
}
Member<RawResource> m_resource;
// End of ResourceOwner re-implementation, see above.

SecurityOrigin* getSecurityOrigin() const;
Document& document() const;

Expand Down
78 changes: 39 additions & 39 deletions third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -224,7 +224,7 @@ void WorkerThreadableLoader::loadResourceSynchronously(WorkerGlobalScope& worker

WorkerThreadableLoader::~WorkerThreadableLoader()
{
DCHECK(!m_peer);
DCHECK(!m_mainThreadLoaderHolder);
DCHECK(!m_client);
}

Expand All @@ -240,7 +240,7 @@ void WorkerThreadableLoader::start(const ResourceRequest& originalRequest)
eventWithTasks = WaitableEventWithTasks::create();

m_workerLoaderProxy->postTaskToLoader(BLINK_FROM_HERE, createCrossThreadTask(
&Peer::createAndStart,
&MainThreadLoaderHolder::createAndStart,
wrapCrossThreadPersistent(this),
m_workerLoaderProxy,
wrapCrossThreadPersistent(m_workerGlobalScope->thread()->getWorkerThreadLifecycleContext()),
Expand Down Expand Up @@ -278,17 +278,17 @@ void WorkerThreadableLoader::start(const ResourceRequest& originalRequest)
void WorkerThreadableLoader::overrideTimeout(unsigned long timeoutMilliseconds)
{
DCHECK(!isMainThread());
if (!m_peer)
if (!m_mainThreadLoaderHolder)
return;
m_workerLoaderProxy->postTaskToLoader(BLINK_FROM_HERE, createCrossThreadTask(&Peer::overrideTimeout, m_peer, timeoutMilliseconds));
m_workerLoaderProxy->postTaskToLoader(BLINK_FROM_HERE, createCrossThreadTask(&MainThreadLoaderHolder::overrideTimeout, m_mainThreadLoaderHolder, 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_mainThreadLoaderHolder) {
m_workerLoaderProxy->postTaskToLoader(BLINK_FROM_HERE, createCrossThreadTask(&MainThreadLoaderHolder::cancel, m_mainThreadLoaderHolder));
m_mainThreadLoaderHolder = nullptr;
}

if (!m_client)
Expand All @@ -304,17 +304,17 @@ void WorkerThreadableLoader::cancel()
DCHECK(!m_client);
}

void WorkerThreadableLoader::didStart(Peer* peer)
void WorkerThreadableLoader::didStart(MainThreadLoaderHolder* mainThreadLoaderHolder)
{
DCHECK(!isMainThread());
DCHECK(!m_peer);
DCHECK(peer);
DCHECK(!m_mainThreadLoaderHolder);
DCHECK(mainThreadLoaderHolder);
if (!m_client) {
// The loading is already cancelled.
return;
}

m_peer = peer;
m_mainThreadLoaderHolder = mainThreadLoaderHolder;
}

void WorkerThreadableLoader::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
Expand Down Expand Up @@ -358,7 +358,7 @@ void WorkerThreadableLoader::didFinishLoading(unsigned long identifier, double f
return;
auto* client = m_client;
m_client = nullptr;
m_peer = nullptr;
m_mainThreadLoaderHolder = nullptr;
client->didFinishLoading(identifier, finishTime);
}

Expand All @@ -369,7 +369,7 @@ void WorkerThreadableLoader::didFail(const ResourceError& error)
return;
auto* client = m_client;
m_client = nullptr;
m_peer = nullptr;
m_mainThreadLoaderHolder = nullptr;
client->didFail(error);
}

Expand All @@ -380,7 +380,7 @@ void WorkerThreadableLoader::didFailAccessControlCheck(const ResourceError& erro
return;
auto* client = m_client;
m_client = nullptr;
m_peer = nullptr;
m_mainThreadLoaderHolder = nullptr;
client->didFailAccessControlCheck(error);
}

Expand All @@ -391,7 +391,7 @@ void WorkerThreadableLoader::didFailRedirectCheck()
return;
auto* client = m_client;
m_client = nullptr;
m_peer = nullptr;
m_mainThreadLoaderHolder = nullptr;
client->didFailRedirectCheck();
}

Expand Down Expand Up @@ -419,7 +419,7 @@ DEFINE_TRACE(WorkerThreadableLoader)
ThreadableLoader::trace(visitor);
}

void WorkerThreadableLoader::Peer::createAndStart(
void WorkerThreadableLoader::MainThreadLoaderHolder::createAndStart(
WorkerThreadableLoader* workerLoader,
PassRefPtr<WorkerLoaderProxy> passLoaderProxy,
WorkerThreadLifecycleContext* workerThreadLifecycleContext,
Expand All @@ -437,33 +437,33 @@ void WorkerThreadableLoader::Peer::createAndStart(
else
forwarder = new AsyncTaskForwarder(loaderProxy);

Peer* peer = new Peer(forwarder, workerThreadLifecycleContext);
if (peer->wasContextDestroyedBeforeObserverCreation()) {
MainThreadLoaderHolder* mainThreadLoaderHolder = new MainThreadLoaderHolder(forwarder, workerThreadLifecycleContext);
if (mainThreadLoaderHolder->wasContextDestroyedBeforeObserverCreation()) {
// The thread is already terminating.
forwarder->abort();
peer->m_forwarder = nullptr;
mainThreadLoaderHolder->m_forwarder = nullptr;
return;
}
peer->m_workerLoader = workerLoader;
peer->start(*toDocument(executionContext), std::move(request), options, resourceLoaderOptions);
forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didStart, wrapCrossThreadPersistent(workerLoader), wrapCrossThreadPersistent(peer)));
mainThreadLoaderHolder->m_workerLoader = workerLoader;
mainThreadLoaderHolder->start(*toDocument(executionContext), std::move(request), options, resourceLoaderOptions);
forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didStart, wrapCrossThreadPersistent(workerLoader), wrapCrossThreadPersistent(mainThreadLoaderHolder)));
}

WorkerThreadableLoader::Peer::~Peer()
WorkerThreadableLoader::MainThreadLoaderHolder::~MainThreadLoaderHolder()
{
DCHECK(isMainThread());
DCHECK(!m_workerLoader);
}

void WorkerThreadableLoader::Peer::overrideTimeout(unsigned long timeoutMilliseconds)
void WorkerThreadableLoader::MainThreadLoaderHolder::overrideTimeout(unsigned long timeoutMilliseconds)
{
DCHECK(isMainThread());
if (!m_mainThreadLoader)
return;
m_mainThreadLoader->overrideTimeout(timeoutMilliseconds);
}

void WorkerThreadableLoader::Peer::cancel()
void WorkerThreadableLoader::MainThreadLoaderHolder::cancel()
{
DCHECK(isMainThread());
if (!m_mainThreadLoader)
Expand All @@ -472,7 +472,7 @@ void WorkerThreadableLoader::Peer::cancel()
m_mainThreadLoader = nullptr;
}

void WorkerThreadableLoader::Peer::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
void WorkerThreadableLoader::MainThreadLoaderHolder::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
{
DCHECK(isMainThread());
CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
Expand All @@ -481,7 +481,7 @@ void WorkerThreadableLoader::Peer::didSendData(unsigned long long bytesSent, uns
m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didSendData, workerLoader, bytesSent, totalBytesToBeSent));
}

void WorkerThreadableLoader::Peer::didReceiveResponse(unsigned long identifier, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle)
void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveResponse(unsigned long identifier, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle)
{
DCHECK(isMainThread());
CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
Expand All @@ -490,7 +490,7 @@ void WorkerThreadableLoader::Peer::didReceiveResponse(unsigned long identifier,
m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didReceiveResponse, workerLoader, identifier, response, passed(std::move(handle))));
}

void WorkerThreadableLoader::Peer::didReceiveData(const char* data, unsigned dataLength)
void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveData(const char* data, unsigned dataLength)
{
DCHECK(isMainThread());
CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
Expand All @@ -499,7 +499,7 @@ void WorkerThreadableLoader::Peer::didReceiveData(const char* data, unsigned dat
m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didReceiveData, workerLoader, passed(createVectorFromMemoryRegion(data, dataLength))));
}

void WorkerThreadableLoader::Peer::didDownloadData(int dataLength)
void WorkerThreadableLoader::MainThreadLoaderHolder::didDownloadData(int dataLength)
{
DCHECK(isMainThread());
CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
Expand All @@ -508,7 +508,7 @@ void WorkerThreadableLoader::Peer::didDownloadData(int dataLength)
m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didDownloadData, workerLoader, dataLength));
}

void WorkerThreadableLoader::Peer::didReceiveCachedMetadata(const char* data, int dataLength)
void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveCachedMetadata(const char* data, int dataLength)
{
DCHECK(isMainThread());
CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
Expand All @@ -517,7 +517,7 @@ void WorkerThreadableLoader::Peer::didReceiveCachedMetadata(const char* data, in
m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didReceiveCachedMetadata, workerLoader, passed(createVectorFromMemoryRegion(data, dataLength))));
}

void WorkerThreadableLoader::Peer::didFinishLoading(unsigned long identifier, double finishTime)
void WorkerThreadableLoader::MainThreadLoaderHolder::didFinishLoading(unsigned long identifier, double finishTime)
{
DCHECK(isMainThread());
CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
Expand All @@ -527,7 +527,7 @@ void WorkerThreadableLoader::Peer::didFinishLoading(unsigned long identifier, do
m_forwarder = nullptr;
}

void WorkerThreadableLoader::Peer::didFail(const ResourceError& error)
void WorkerThreadableLoader::MainThreadLoaderHolder::didFail(const ResourceError& error)
{
DCHECK(isMainThread());
CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
Expand All @@ -537,7 +537,7 @@ void WorkerThreadableLoader::Peer::didFail(const ResourceError& error)
m_forwarder = nullptr;
}

void WorkerThreadableLoader::Peer::didFailAccessControlCheck(const ResourceError& error)
void WorkerThreadableLoader::MainThreadLoaderHolder::didFailAccessControlCheck(const ResourceError& error)
{
DCHECK(isMainThread());
CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
Expand All @@ -547,7 +547,7 @@ void WorkerThreadableLoader::Peer::didFailAccessControlCheck(const ResourceError
m_forwarder = nullptr;
}

void WorkerThreadableLoader::Peer::didFailRedirectCheck()
void WorkerThreadableLoader::MainThreadLoaderHolder::didFailRedirectCheck()
{
DCHECK(isMainThread());
CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
Expand All @@ -557,7 +557,7 @@ void WorkerThreadableLoader::Peer::didFailRedirectCheck()
m_forwarder = nullptr;
}

void WorkerThreadableLoader::Peer::didReceiveResourceTiming(const ResourceTimingInfo& info)
void WorkerThreadableLoader::MainThreadLoaderHolder::didReceiveResourceTiming(const ResourceTimingInfo& info)
{
DCHECK(isMainThread());
CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
Expand All @@ -566,7 +566,7 @@ void WorkerThreadableLoader::Peer::didReceiveResourceTiming(const ResourceTiming
m_forwarder->forwardTask(BLINK_FROM_HERE, createCrossThreadTask(&WorkerThreadableLoader::didReceiveResourceTiming, workerLoader, info));
}

void WorkerThreadableLoader::Peer::contextDestroyed()
void WorkerThreadableLoader::MainThreadLoaderHolder::contextDestroyed()
{
DCHECK(isMainThread());
if (m_forwarder) {
Expand All @@ -577,21 +577,21 @@ void WorkerThreadableLoader::Peer::contextDestroyed()
cancel();
}

DEFINE_TRACE(WorkerThreadableLoader::Peer)
DEFINE_TRACE(WorkerThreadableLoader::MainThreadLoaderHolder)
{
visitor->trace(m_forwarder);
visitor->trace(m_mainThreadLoader);
WorkerThreadLifecycleObserver::trace(visitor);
}

WorkerThreadableLoader::Peer::Peer(TaskForwarder* forwarder, WorkerThreadLifecycleContext* context)
WorkerThreadableLoader::MainThreadLoaderHolder::MainThreadLoaderHolder(TaskForwarder* forwarder, WorkerThreadLifecycleContext* context)
: WorkerThreadLifecycleObserver(context)
, m_forwarder(forwarder)
{
DCHECK(isMainThread());
}

void WorkerThreadableLoader::Peer::start(
void WorkerThreadableLoader::MainThreadLoaderHolder::start(
Document& document,
std::unique_ptr<CrossThreadResourceRequestData> request,
const ThreadableLoaderOptions& options,
Expand Down
Loading

0 comments on commit 2ec047e

Please sign in to comment.