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

Source/modules/fetch/FetchBlobDataConsumerHandle.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "modules/fetch/FetchBlobDataConsumerHandle.h"
 
 #include "core/dom/ActiveDOMObject.h"
 #include "core/dom/CrossThreadTask.h"
 #include "core/dom/ExecutionContext.h"
@@ skipping 226 matching lines @@
             m_loader->cancel();
             m_loader.clear();
         }
     }
 
     void start(ExecutionContext* executionContext) override
     {
         ASSERT(executionContext->isContextThread());
         ASSERT(!m_loader);
 
+        KURL url = BlobURL::createPublicURL(executionContext->securityOrigin());
+        if (url.isEmpty()) {

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

Please call m_updater->update(createUnexpectedErrorDataConsumerHandle()); here.

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

Good catch! Done

+            return;
+        }
+        BlobRegistry::registerPublicBlobURL(executionContext->securityOrigin(), url, m_blobDataHandle);
+
         m_loader = createLoader(executionContext, this);

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

Please add ASSERT(m_loader) here.

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

Done.

-        if (!m_loader)
-            m_updater->update(createUnexpectedErrorDataConsumerHandle());
+
+        ResourceRequest request(url);
+        request.setRequestContext(WebURLRequest::RequestContextInternal);
+        request.setUseStreamOnResponse(true);
+        m_loader->start(request);
     }
 
 private:
     PassRefPtr<ThreadableLoader> createLoader(ExecutionContext* executionContext, ThreadableLoaderClient* client) const
     {
-        KURL url = BlobURL::createPublicURL(executionContext->securityOrigin());
-        if (url.isEmpty()) {
-            return nullptr;
-        }
-        BlobRegistry::registerPublicBlobURL(executionContext->securityOrigin(), url, m_blobDataHandle);
-
-        ResourceRequest request(url);
-        request.setRequestContext(WebURLRequest::RequestContextInternal);
-        request.setUseStreamOnResponse(true);
-
         ThreadableLoaderOptions options;
         options.preflightPolicy = ConsiderPreflight;
         options.crossOriginRequestPolicy = DenyCrossOriginRequests;
         options.contentSecurityPolicyEnforcement = DoNotEnforceContentSecurityPolicy;
         options.initiator = FetchInitiatorTypeNames::internal;
 
         ResourceLoaderOptions resourceLoaderOptions;
         resourceLoaderOptions.dataBufferingPolicy = DoNotBufferData;
 
-        return m_loaderFactory->create(*executionContext, client, request, options, resourceLoaderOptions);
+        return m_loaderFactory->create(*executionContext, client, options, resourceLoaderOptions);
     }
 
     // ThreadableLoaderClient
     void didReceiveResponse(unsigned long, const ResourceResponse&, PassOwnPtr<WebDataConsumerHandle> handle) override
     {
         ASSERT(!m_receivedResponse);
         m_receivedResponse = true;
         if (!handle) {
             // Here we assume WebURLLoader must return the response body as
             // |WebDataConsumerHandle| since we call
@@ skipping 29 matching lines @@
     RefPtr<ThreadableLoader> m_loader;
 
     bool m_receivedResponse;
 };
 
 class DefaultLoaderFactory final : public FetchBlobDataConsumerHandle::LoaderFactory {
 public:
     PassRefPtr<ThreadableLoader> create(
         ExecutionContext& executionContext,
         ThreadableLoaderClient* client,
-        const ResourceRequest& request,
         const ThreadableLoaderOptions& options,
         const ResourceLoaderOptions& resourceLoaderOptions) override
     {
-        return ThreadableLoader::create(executionContext, client, request, options, resourceLoaderOptions);
+        return ThreadableLoader::create(executionContext, client, options, resourceLoaderOptions);
     }
 };
 
 } // namespace
 
 // ReaderContext is referenced from FetchBlobDataConsumerHandle and
 // ReaderContext::ReaderImpl.
 // All functions/members must be called/accessed only on the reader thread,
 // except for constructor, destructor, and obtainReader().
 class FetchBlobDataConsumerHandle::ReaderContext final : public ThreadSafeRefCounted<ReaderContext> {
@@ skipping 121 matching lines @@
 
     return adoptPtr(new FetchBlobDataConsumerHandle(executionContext, blobDataHandle, new DefaultLoaderFactory));
 }
 
 FetchDataConsumerHandle::Reader* FetchBlobDataConsumerHandle::obtainReaderInternal(Client* client)
 {
     return m_readerContext->obtainReader(client).leakPtr();
 }
 
 } // namespace blink