Move ThreadableLoader to Oilpan heap (3/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 189 matching lines @@
     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(!m_peer);
+    DCHECK(!m_mainThreadLoaderHolder);
     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()));
 
     DCHECK(!isMainThread());
     RefPtr<WaitableEventWithTasks> eventWithTasks;
     if (m_blockingBehavior == LoadSynchronously)
         eventWithTasks = WaitableEventWithTasks::create();
 
     m_workerLoaderProxy->postTaskToLoader(createCrossThreadTask(
-        &Peer::createAndStart,
+        &MainThreadLoaderHolder::createAndStart,
         wrapCrossThreadPersistent(this),
         m_workerLoaderProxy,
         wrapCrossThreadPersistent(m_workerGlobalScope->thread()->getWorkerThreadLifecycleContext()),
         request,
         m_threadableLoaderOptions,
         m_resourceLoaderOptions,
         eventWithTasks));
 
     if (m_blockingBehavior == LoadAsynchronously)
         return;
@@ skipping 12 matching lines @@
     for (const auto& task : eventWithTasks->take()) {
         // m_clientTask contains only CallClosureTasks. So, it's ok to pass
         // the nullptr.
         task->performTask(nullptr);
     }
 }
 
 void WorkerThreadableLoader::overrideTimeout(unsigned long timeoutMilliseconds)
 {
     DCHECK(!isMainThread());
-    if (!m_peer)
+    if (!m_mainThreadLoaderHolder)
         return;
-    m_workerLoaderProxy->postTaskToLoader(createCrossThreadTask(&Peer::overrideTimeout, m_peer, timeoutMilliseconds));
+    m_workerLoaderProxy->postTaskToLoader(createCrossThreadTask(&MainThreadLoaderHolder::overrideTimeout, m_mainThreadLoaderHolder, timeoutMilliseconds));
 }
 
 void WorkerThreadableLoader::cancel()
 {
     DCHECK(!isMainThread());
-    if (m_peer) {
-        m_workerLoaderProxy->postTaskToLoader(createCrossThreadTask(&Peer::cancel, m_peer));
-        m_peer = nullptr;
+    if (m_mainThreadLoaderHolder) {
+        m_workerLoaderProxy->postTaskToLoader(createCrossThreadTask(&MainThreadLoaderHolder::cancel, m_mainThreadLoaderHolder));
+        m_mainThreadLoaderHolder = nullptr;
     }
 
     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);
     didFail(error);
     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)
 {
     DCHECK(!isMainThread());
     if (!m_client)
         return;
     m_client->didSendData(bytesSent, totalBytesToBeSent);
 }
 
@@ skipping 23 matching lines @@
     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;
+    m_mainThreadLoaderHolder = 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;
+    m_mainThreadLoaderHolder = 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;
+    m_mainThreadLoaderHolder = nullptr;
     client->didFailAccessControlCheck(error);
 }
 
 void WorkerThreadableLoader::didFailRedirectCheck()
 {
     DCHECK(!isMainThread());
     if (!m_client)
         return;
     auto* client = m_client;
     m_client = nullptr;
-    m_peer = nullptr;
+    m_mainThreadLoaderHolder = 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(
+void WorkerThreadableLoader::MainThreadLoaderHolder::createAndStart(
     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()) {
+    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(createCrossThreadTask(&WorkerThreadableLoader::didStart, wrapCrossThreadPersistent(workerLoader), wrapCrossThreadPersistent(peer)));
+    mainThreadLoaderHolder->m_workerLoader = workerLoader;
+    mainThreadLoaderHolder->start(*toDocument(executionContext), std::move(request), options, resourceLoaderOptions);
+    forwarder->forwardTask(createCrossThreadTask(&WorkerThreadableLoader::didStart, wrapCrossThreadPersistent(workerLoader), wrapCrossThreadPersistent(mainThreadLoaderHolder)));
 }
 
-WorkerThreadableLoader::Peer::~Peer()
+WorkerThreadableLoader::MainThreadLoaderHolder::~MainThreadLoaderHolder()
 {
     DCHECK(isMainThread());
 }
 
-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)
         return;
     m_mainThreadLoader->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();
     if (!workerLoader || !m_forwarder)
         return;
     m_forwarder->forwardTask(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();
     if (!workerLoader || !m_forwarder)
         return;
     m_forwarder->forwardTask(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();
     if (!workerLoader || !m_forwarder)
         return;
     m_forwarder->forwardTask(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();
     if (!workerLoader || !m_forwarder)
         return;
     m_forwarder->forwardTask(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();
     if (!workerLoader || !m_forwarder)
         return;
     m_forwarder->forwardTask(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();
     if (!workerLoader || !m_forwarder)
         return;
     m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&WorkerThreadableLoader::didFinishLoading, workerLoader, identifier, finishTime));
     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();
     if (!workerLoader || !m_forwarder)
         return;
     m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&WorkerThreadableLoader::didFail, workerLoader, 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();
     if (!workerLoader || !m_forwarder)
         return;
     m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&WorkerThreadableLoader::didFailAccessControlCheck, workerLoader, error));
     m_forwarder = nullptr;
 }
 
-void WorkerThreadableLoader::Peer::didFailRedirectCheck()
+void WorkerThreadableLoader::MainThreadLoaderHolder::didFailRedirectCheck()
 {
     DCHECK(isMainThread());
     CrossThreadPersistent<WorkerThreadableLoader> workerLoader = m_workerLoader.get();
     if (!workerLoader || !m_forwarder)
         return;
     m_forwarder->forwardTaskWithDoneSignal(createCrossThreadTask(&WorkerThreadableLoader::didFailRedirectCheck, workerLoader));
     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();
     if (!workerLoader || !m_forwarder)
         return;
     m_forwarder->forwardTask(createCrossThreadTask(&WorkerThreadableLoader::didReceiveResourceTiming, workerLoader, info));
 }
 
-void WorkerThreadableLoader::Peer::contextDestroyed()
+void WorkerThreadableLoader::MainThreadLoaderHolder::contextDestroyed()
 {
     DCHECK(isMainThread());
     if (m_forwarder) {
         m_forwarder->abort();
         m_forwarder = nullptr;
     }
     m_workerLoader = nullptr;
     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,
     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