Split the constructor of ThreadableLoader into two methods (ctor and start())

Source/core/loader/WorkerThreadableLoader.cpp

Index: Source/core/loader/WorkerThreadableLoader.cpp
diff --git a/Source/core/loader/WorkerThreadableLoader.cpp b/Source/core/loader/WorkerThreadableLoader.cpp
index eacf55c077d249ab1b862f7f1944af6533bf4b01..d409be321632f1a31e60a15c7155ae0e1fe8fd52 100644
--- a/Source/core/loader/WorkerThreadableLoader.cpp
+++ b/Source/core/loader/WorkerThreadableLoader.cpp
@@ -53,12 +53,11 @@
 
 namespace blink {
 
-WorkerThreadableLoader::WorkerThreadableLoader(WorkerGlobalScope& workerGlobalScope, PassRefPtr<ThreadableLoaderClientWrapper> clientWrapper, PassOwnPtr<ThreadableLoaderClient> clientBridge, const ResourceRequest& request, const ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoaderOptions)
+WorkerThreadableLoader::WorkerThreadableLoader(WorkerGlobalScope& workerGlobalScope, PassRefPtr<ThreadableLoaderClientWrapper> clientWrapper, PassOwnPtr<ThreadableLoaderClient> clientBridge, 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.referrerPolicy(), workerGlobalScope.url().strippedForUseAsReferrer())))
+    , m_bridge(*(new MainThreadBridge(m_workerClientWrapper, clientBridge, workerGlobalScope.thread()->workerLoaderProxy(), options, resourceLoaderOptions)))
 {
-    m_workerClientWrapper->setResourceTimingClient(this);
 }
 
 WorkerThreadableLoader::~WorkerThreadableLoader()
@@ -84,7 +83,8 @@ void WorkerThreadableLoader::loadResourceSynchronously(WorkerGlobalScope& worker
     // This must be valid while loader is around.
     WorkerLoaderClientBridgeSyncHelper* clientBridgePtr = clientBridge.get();
 
-    RefPtr<WorkerThreadableLoader> loader = WorkerThreadableLoader::create(workerGlobalScope, clientWrapper, clientBridge.release(), request, options, resourceLoaderOptions);
+    RefPtr<WorkerThreadableLoader> loader = WorkerThreadableLoader::create(workerGlobalScope, clientWrapper, clientBridge.release(), options, resourceLoaderOptions);
+    loader->start(request);
 
     WebWaitableEvent* signalled;
     {
@@ -99,6 +99,12 @@ void WorkerThreadableLoader::loadResourceSynchronously(WorkerGlobalScope& worker
     clientBridgePtr->run();
 }
 
+void WorkerThreadableLoader::start(const ResourceRequest& request)
+{
+    m_bridge.start(request, m_workerGlobalScope->referrerPolicy(), m_workerGlobalScope->url().strippedForUseAsReferrer());
+    m_workerClientWrapper->setResourceTimingClient(this);
+}
+
 void WorkerThreadableLoader::overrideTimeout(unsigned long timeoutMilliseconds)
 {
     m_bridge.overrideTimeout(timeoutMilliseconds);
@@ -118,11 +124,8 @@ WorkerThreadableLoader::MainThreadBridge::MainThreadBridge(
     PassRefPtr<ThreadableLoaderClientWrapper> workerClientWrapper,
     PassOwnPtr<ThreadableLoaderClient> clientBridge,
     PassRefPtr<WorkerLoaderProxy> loaderProxy,
-    const ResourceRequest& request,
     const ThreadableLoaderOptions& options,
-    const ResourceLoaderOptions& resourceLoaderOptions,
-    const ReferrerPolicy referrerPolicy,
-    const String& outgoingReferrer)
+    const ResourceLoaderOptions& resourceLoaderOptions)
     : m_clientBridge(clientBridge)
     , m_workerClientWrapper(workerClientWrapper)
     , m_loaderProxy(loaderProxy)
@@ -130,26 +133,40 @@ WorkerThreadableLoader::MainThreadBridge::MainThreadBridge(
     ASSERT(m_workerClientWrapper.get());
     ASSERT(m_clientBridge.get());
     m_loaderProxy->postTaskToLoader(
-        createCrossThreadTask(&MainThreadBridge::mainThreadCreateLoader, this, request, options, resourceLoaderOptions, referrerPolicy, outgoingReferrer));
+        createCrossThreadTask(&MainThreadBridge::mainThreadCreateLoader, this, options, resourceLoaderOptions));
 }
 
 WorkerThreadableLoader::MainThreadBridge::~MainThreadBridge()
 {
 }
 
-void WorkerThreadableLoader::MainThreadBridge::mainThreadCreateLoader(PassOwnPtr<CrossThreadResourceRequestData> requestData, ThreadableLoaderOptions options, ResourceLoaderOptions resourceLoaderOptions, const ReferrerPolicy referrerPolicy, const String& outgoingReferrer, ExecutionContext* context)
+void WorkerThreadableLoader::MainThreadBridge::mainThreadCreateLoader(ThreadableLoaderOptions options, ResourceLoaderOptions resourceLoaderOptions, ExecutionContext* context)
 {
     ASSERT(isMainThread());
     Document* document = toDocument(context);
 
+    resourceLoaderOptions.requestInitiatorContext = WorkerContext;
+    m_mainThreadLoader = DocumentThreadableLoader::create(*document, this, options, resourceLoaderOptions);
+    ASSERT(m_mainThreadLoader);
+}
+
+void WorkerThreadableLoader::MainThreadBridge::mainThreadStart(PassOwnPtr<CrossThreadResourceRequestData> requestData, const ReferrerPolicy referrerPolicy, const String& outgoingReferrer)
+{
+    ASSERT(isMainThread());
+
+    if (!m_mainThreadLoader)

[hiroshige, 2015/07/30 12:07:21]

When can |m_mainThreadLoader| be null? Please add a comment.

[tyoshino (SeeGerritForStatus), 2015/07/31 08:00:42]

Good point. As we require start() to be always called after create(), we can
make this ASSERT.

+        return;
+
     OwnPtr<ResourceRequest> request(ResourceRequest::adopt(requestData));
     request->setHTTPReferrer(SecurityPolicy::generateReferrer(referrerPolicy, request->url(), outgoingReferrer));
-    resourceLoaderOptions.requestInitiatorContext = WorkerContext;
-    m_mainThreadLoader = DocumentThreadableLoader::create(*document, this, *request, options, resourceLoaderOptions);
-    if (!m_mainThreadLoader) {
-        // DocumentThreadableLoader::create may return 0 when the document loader has been already changed.
-        didFail(ResourceError(errorDomainBlinkInternal, 0, request->url().string(), "Can't create DocumentThreadableLoader"));
-    }
+
+    m_mainThreadLoader->start(*request);
+}
+
+void WorkerThreadableLoader::MainThreadBridge::start(const ResourceRequest& request, const ReferrerPolicy referrerPolicy, const String& outgoingReferrer)
+{
+    m_loaderProxy->postTaskToLoader(
+        createCrossThreadTask(&MainThreadBridge::mainThreadStart, this, request, referrerPolicy, outgoingReferrer));
 }
 
 void WorkerThreadableLoader::MainThreadBridge::mainThreadDestroy(ExecutionContext* context)