Move ThreadableLoader to Oilpan heap (2/3)

third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp

 /*
  * Copyright (C) 2009, 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 173 matching lines @@
     RefPtr<WaitableEventWithTasks> m_eventWithTasks;
 };
 
 WorkerThreadableLoader::WorkerThreadableLoader(
     WorkerGlobalScope& workerGlobalScope,
     ThreadableLoaderClient* client,
     const ThreadableLoaderOptions& options,
     const ResourceLoaderOptions& resourceLoaderOptions,
     BlockingBehavior blockingBehavior)
     : m_workerGlobalScope(&workerGlobalScope)
-    , m_workerClientWrapper(new ThreadableLoaderClientWrapper(workerGlobalScope, client))
-    , m_bridge(new Bridge(m_workerClientWrapper, workerGlobalScope.thread()->workerLoaderProxy(), options, resourceLoaderOptions, blockingBehavior))
+    , m_workerLoaderProxy(workerGlobalScope.thread()->workerLoaderProxy())
+    , m_client(client)
+    , m_threadableLoaderOptions(options)
+    , m_resourceLoaderOptions(resourceLoaderOptions)
+    , m_blockingBehavior(blockingBehavior)
 {
+    DCHECK(client);
 }
 
 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);
+    (new WorkerThreadableLoader(workerGlobalScope, &client, options, resourceLoaderOptions, LoadSynchronously))->start(request);
 }
 
 WorkerThreadableLoader::~WorkerThreadableLoader()
 {
-    DCHECK(m_workerClientWrapper->done());
-    m_bridge->destroy();
+    DCHECK(!m_peer);
+    DCHECK(!m_client);
 }
 
-void WorkerThreadableLoader::start(const ResourceRequest& request)
+void WorkerThreadableLoader::start(const ResourceRequest& originalRequest)
 {
-    ResourceRequest requestToPass(request);
-    if (!requestToPass.didSetHTTPReferrer())
-        requestToPass.setHTTPReferrer(SecurityPolicy::generateReferrer(m_workerGlobalScope->getReferrerPolicy(), request.url(), m_workerGlobalScope->outgoingReferrer()));
-    m_bridge->start(requestToPass, *m_workerGlobalScope);
-}
+    ResourceRequest request(originalRequest);
+    if (!request.didSetHTTPReferrer())
+        request.setHTTPReferrer(SecurityPolicy::generateReferrer(m_workerGlobalScope->getReferrerPolicy(), request.url(), m_workerGlobalScope->outgoingReferrer()));
 
-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(!isMainThread());
-}
-
-WorkerThreadableLoader::Bridge::~Bridge()
-{
-    DCHECK(!isMainThread());
-    DCHECK(!m_peer);
-}
-
-void WorkerThreadableLoader::Bridge::start(const ResourceRequest& request, const WorkerGlobalScope& workerGlobalScope)
-{
     DCHECK(!isMainThread());
     RefPtr<WaitableEventWithTasks> eventWithTasks;
     if (m_blockingBehavior == LoadSynchronously)
         eventWithTasks = WaitableEventWithTasks::create();
 
-    m_loaderProxy->postTaskToLoader(createCrossThreadTask(
+    m_workerLoaderProxy->postTaskToLoader(createCrossThreadTask(
         &Peer::createAndStart,
         wrapCrossThreadPersistent(this),
-        m_loaderProxy,
-        wrapCrossThreadPersistent(workerGlobalScope.thread()->getWorkerThreadLifecycleContext()),
+        m_workerLoaderProxy,
+        wrapCrossThreadPersistent(m_workerGlobalScope->thread()->getWorkerThreadLifecycleContext()),
         request,
         m_threadableLoaderOptions,
         m_resourceLoaderOptions,
         eventWithTasks));
 
     if (m_blockingBehavior == LoadAsynchronously)
         return;
 
     {
         SafePointScope scope(BlinkGC::HeapPointersOnStack);
         eventWithTasks->wait();
     }
 
     if (eventWithTasks->isAborted()) {
         // This thread is going to terminate.
         cancel();
         return;
     }
 
     for (const auto& task : eventWithTasks->take()) {
         // m_clientTask contains only CallClosureTasks. So, it's ok to pass
         // the nullptr.
         task->performTask(nullptr);
     }
 }
 
-void WorkerThreadableLoader::Bridge::overrideTimeout(unsigned long timeoutMilliseconds)
+void WorkerThreadableLoader::overrideTimeout(unsigned long timeoutMilliseconds)
 {
     DCHECK(!isMainThread());
     if (!m_peer)
         return;
-    m_loaderProxy->postTaskToLoader(createCrossThreadTask(&Peer::overrideTimeout, m_peer, timeoutMilliseconds));
+    m_workerLoaderProxy->postTaskToLoader(createCrossThreadTask(&Peer::overrideTimeout, m_peer, timeoutMilliseconds));
 }
 
-void WorkerThreadableLoader::Bridge::cancel()
+void WorkerThreadableLoader::cancel()
 {
     DCHECK(!isMainThread());
-    cancelPeer();
+    if (m_peer) {
+        m_workerLoaderProxy->postTaskToLoader(createCrossThreadTask(&Peer::cancel, m_peer));
+        m_peer = nullptr;
+    }
 
-    if (m_clientWrapper->done())
+    if (!m_client)
         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);
-    m_clientWrapper->didFail(error);
-    m_clientWrapper->clearClient();
+    didFail(error);
+    DCHECK(!m_client);
 }
 
-void WorkerThreadableLoader::Bridge::destroy()
-{
-    DCHECK(!isMainThread());
-    cancelPeer();
-    m_clientWrapper->clearClient();
-}
-
-void WorkerThreadableLoader::Bridge::didStart(Peer* peer)
+void WorkerThreadableLoader::didStart(Peer* peer)
 {
     DCHECK(!isMainThread());
     DCHECK(!m_peer);
     DCHECK(peer);
-    if (m_clientWrapper->done()) {
+    if (!m_client) {
         // The loading is already cancelled.
         return;
     }
 
     m_peer = peer;
 }
 
-DEFINE_TRACE(WorkerThreadableLoader::Bridge)
+void WorkerThreadableLoader::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
 {
-    visitor->trace(m_clientWrapper);
+    DCHECK(!isMainThread());
+    if (!m_client)
+        return;
+    m_client->didSendData(bytesSent, totalBytesToBeSent);
 }
 
-void WorkerThreadableLoader::Bridge::cancelPeer()
+void WorkerThreadableLoader::didReceiveResponse(unsigned long identifier, std::unique_ptr<CrossThreadResourceResponseData> responseData, std::unique_ptr<WebDataConsumerHandle> handle)
 {
     DCHECK(!isMainThread());
-    if (!m_peer)
+    if (!m_client)
         return;
-    m_loaderProxy->postTaskToLoader(createCrossThreadTask(&Peer::cancel, m_peer));
+    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;
     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(
-    Bridge* bridge,
+    WorkerThreadableLoader* workerLoader,
     PassRefPtr<WorkerLoaderProxy> passLoaderProxy,
     WorkerThreadLifecycleContext* workerThreadLifecycleContext,
     std::unique_ptr<CrossThreadResourceRequestData> request,
     const ThreadableLoaderOptions& options,
     const ResourceLoaderOptions& resourceLoaderOptions,
     PassRefPtr<WaitableEventWithTasks> eventWithTasks,
     ExecutionContext* executionContext)
 {
     DCHECK(isMainThread());
     TaskForwarder* forwarder;
     RefPtr<WorkerLoaderProxy> loaderProxy = passLoaderProxy;
     if (eventWithTasks)
         forwarder = new SyncTaskForwarder(eventWithTasks);
     else
         forwarder = new AsyncTaskForwarder(loaderProxy);
 
     Peer* peer = new Peer(forwarder, workerThreadLifecycleContext);
     if (peer->wasContextDestroyedBeforeObserverCreation()) {
         // The thread is already terminating.
         forwarder->abort();
         peer->m_forwarder = nullptr;
         return;
     }
-    peer->m_clientWrapper = bridge->clientWrapper();
+    peer->m_workerLoader = workerLoader;
     peer->start(*toDocument(executionContext), std::move(request), options, resourceLoaderOptions);
-    forwarder->forwardTask(createCrossThreadTask(&Bridge::didStart, wrapCrossThreadPersistent(bridge), wrapCrossThreadPersistent(peer)));
+    forwarder->forwardTask(createCrossThreadTask(&WorkerThreadableLoader::didStart, wrapCrossThreadPersistent(workerLoader), wrapCrossThreadPersistent(peer)));
 }
 
 WorkerThreadableLoader::Peer::~Peer()
 {
     DCHECK(isMainThread());

[haraken, 2016/07/29 14:52:51]

Can we add DCHECK(!m_workerLoader)?

[yhirano, 2016/08/01 06:20:06]

Done.

-    DCHECK(!m_mainThreadLoader);

[haraken, 2016/07/29 14:52:51]

Why do we need to remove the DCHECK?

[yhirano, 2016/08/01 06:20:06]

Generally I don't like to enforce clearing Member pointers manually. Before this
CL m_mainThreadLoader is a unique pointer and clearing it in the destructor has
a behavior impact. Now it's a Member pointer and I don't see a necessity to
check the nullity.

We need to check the loading in m_mainThreadLoader is completed, which is
checked in DocumentThreadableLoader's destructor.

 }
 
 void WorkerThreadableLoader::Peer::overrideTimeout(unsigned long timeoutMilliseconds)
 {
     DCHECK(isMainThread());
     if (!m_mainThreadLoader)
         return;
     m_mainThreadLoader->overrideTimeout(timeoutMilliseconds);
 }
 
 void WorkerThreadableLoader::Peer::cancel()
 {
     DCHECK(isMainThread());
     if (!m_mainThreadLoader)
         return;
     m_mainThreadLoader->cancel();
     m_mainThreadLoader = nullptr;
 }
 
 void WorkerThreadableLoader::Peer::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
 {
     DCHECK(isMainThread());
-    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
-    if (!clientWrapper || !m_forwarder)
+    CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
+    if (!workerLoader || !m_forwarder)
         return;
-    m_forwarder->forwardTask(createCrossThreadTask(&ThreadableLoaderClientWrapper::didSendData, clientWrapper, bytesSent, totalBytesToBeSent));
+    m_forwarder->forwardTask(createCrossThreadTask(&WorkerThreadableLoader::didSendData, workerLoader, bytesSent, totalBytesToBeSent));
 }
 
 void WorkerThreadableLoader::Peer::didReceiveResponse(unsigned long identifier, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle)
 {
     DCHECK(isMainThread());
-    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
-    if (!clientWrapper || !m_forwarder)
+    CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
+    if (!workerLoader || !m_forwarder)
         return;
-    m_forwarder->forwardTask(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveResponse, clientWrapper, identifier, response, passed(std::move(handle))));
+    m_forwarder->forwardTask(createCrossThreadTask(&WorkerThreadableLoader::didReceiveResponse, workerLoader, identifier, response, passed(std::move(handle))));
 }
 
 void WorkerThreadableLoader::Peer::didReceiveData(const char* data, unsigned dataLength)
 {
     DCHECK(isMainThread());
-    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
-    if (!clientWrapper || !m_forwarder)
+    CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
+    if (!workerLoader || !m_forwarder)
         return;
-    m_forwarder->forwardTask(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveData, clientWrapper, passed(createVectorFromMemoryRegion(data, dataLength))));
+    m_forwarder->forwardTask(createCrossThreadTask(&WorkerThreadableLoader::didReceiveData, workerLoader, passed(createVectorFromMemoryRegion(data, dataLength))));
 }
 
 void WorkerThreadableLoader::Peer::didDownloadData(int dataLength)
 {
     DCHECK(isMainThread());
-    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
-    if (!clientWrapper || !m_forwarder)
+    CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
+    if (!workerLoader || !m_forwarder)
         return;
-    m_forwarder->forwardTask(createCrossThreadTask(&ThreadableLoaderClientWrapper::didDownloadData, clientWrapper, dataLength));
+    m_forwarder->forwardTask(createCrossThreadTask(&WorkerThreadableLoader::didDownloadData, workerLoader, dataLength));
 }
 
 void WorkerThreadableLoader::Peer::didReceiveCachedMetadata(const char* data, int dataLength)
 {
     DCHECK(isMainThread());
-    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
-    if (!clientWrapper || !m_forwarder)
+    CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
+    if (!workerLoader || !m_forwarder)
         return;
-    m_forwarder->forwardTask(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveCachedMetadata, clientWrapper, passed(createVectorFromMemoryRegion(data, dataLength))));
+    m_forwarder->forwardTask(createCrossThreadTask(&WorkerThreadableLoader::didReceiveCachedMetadata, workerLoader, passed(createVectorFromMemoryRegion(data, dataLength))));
 }
 
 void WorkerThreadableLoader::Peer::didFinishLoading(unsigned long identifier, double finishTime)
 {
     DCHECK(isMainThread());
-    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
-    if (!clientWrapper || !m_forwarder)
+    CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
+    if (!workerLoader || !m_forwarder)
         return;
-    m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFinishLoading, clientWrapper, identifier, finishTime));
+    m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&WorkerThreadableLoader::didFinishLoading, workerLoader, identifier, finishTime));
     m_forwarder = nullptr;
 }
 
 void WorkerThreadableLoader::Peer::didFail(const ResourceError& error)
 {
     DCHECK(isMainThread());
-    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
-    if (!clientWrapper || !m_forwarder)
+    CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
+    if (!workerLoader || !m_forwarder)
         return;
-    m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFail, clientWrapper, error));
+    m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&WorkerThreadableLoader::didFail, workerLoader, error));
     m_forwarder = nullptr;
 }
 
 void WorkerThreadableLoader::Peer::didFailAccessControlCheck(const ResourceError& error)
 {
     DCHECK(isMainThread());
-    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
-    if (!clientWrapper || !m_forwarder)
+    CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
+    if (!workerLoader || !m_forwarder)
         return;
-    m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFailAccessControlCheck, clientWrapper, error));
+    m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&WorkerThreadableLoader::didFailAccessControlCheck, workerLoader, error));
     m_forwarder = nullptr;
 }
 
 void WorkerThreadableLoader::Peer::didFailRedirectCheck()
 {
     DCHECK(isMainThread());
-    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
-    if (!clientWrapper || !m_forwarder)
+    CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
+    if (!workerLoader || !m_forwarder)
         return;
-    m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&ThreadableLoaderClientWrapper::didFailRedirectCheck, clientWrapper));
+    m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&WorkerThreadableLoader::didFailRedirectCheck, workerLoader));
     m_forwarder = nullptr;
 }
 
 void WorkerThreadableLoader::Peer::didReceiveResourceTiming(const ResourceTimingInfo& info)
 {
     DCHECK(isMainThread());
-    CrossThreadPersistent<ThreadableLoaderClientWrapper> clientWrapper = m_clientWrapper.get();
-    if (!clientWrapper || !m_forwarder)
+    CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
+    if (!workerLoader || !m_forwarder)
         return;
-    m_forwarder->forwardTask(createCrossThreadTask(&ThreadableLoaderClientWrapper::didReceiveResourceTiming, clientWrapper, info));
+    m_forwarder->forwardTask(createCrossThreadTask(&WorkerThreadableLoader::didReceiveResourceTiming, workerLoader, info));
 }
 
 void WorkerThreadableLoader::Peer::contextDestroyed()
 {
     DCHECK(isMainThread());
     if (m_forwarder) {
         m_forwarder->abort();
         m_forwarder = nullptr;
     }
-    m_clientWrapper = nullptr;
+    m_workerLoader = nullptr;
     cancel();
 }
 
 DEFINE_TRACE(WorkerThreadableLoader::Peer)
 {
     visitor->trace(m_forwarder);
+    visitor->trace(m_mainThreadLoader);
     WorkerThreadLifecycleObserver::trace(visitor);
 }
 
 WorkerThreadableLoader::Peer::Peer(TaskForwarder* forwarder, WorkerThreadLifecycleContext* context)
     : WorkerThreadLifecycleObserver(context)
     , m_forwarder(forwarder)
 {
     DCHECK(isMainThread());
 }
 
 void WorkerThreadableLoader::Peer::start(
     Document& document,
     std::unique_ptr<CrossThreadResourceRequestData> request,
     const ThreadableLoaderOptions& options,
     const ResourceLoaderOptions& originalResourceLoaderOptions)
 {
     DCHECK(isMainThread());
     ResourceLoaderOptions resourceLoaderOptions = originalResourceLoaderOptions;
     resourceLoaderOptions.requestInitiatorContext = WorkerContext;
     m_mainThreadLoader = DocumentThreadableLoader::create(document, this, options, resourceLoaderOptions);
     m_mainThreadLoader->start(ResourceRequest(request.get()));
 }
 
 } // namespace blink