Move multipart resource handling to core/fetch (2/2)

third_party/WebKit/Source/core/fetch/ResourceLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2007 Graham Dennis (graham.dennis@gmail.com)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 51 matching lines @@
 {
     ResourceLoader* loader = new ResourceLoader(fetcher, resource, options);
     loader->init(request);
     return loader;
 }
 
 ResourceLoader::ResourceLoader(ResourceFetcher* fetcher, Resource* resource, const ResourceLoaderOptions& options)
     : m_fetcher(fetcher)
     , m_notifiedLoadComplete(false)
     , m_defersLoading(fetcher->defersLoading())
-    , m_loadingMultipartContent(false)
     , m_options(options)
     , m_resource(resource)
     , m_state(Initialized)
     , m_connectionState(ConnectionStateNew)
 {
     ASSERT(m_resource);
     ASSERT(m_fetcher);
 }
 
 ResourceLoader::~ResourceLoader()
@@ skipping 112 matching lines @@
     ASSERT(m_state != Terminated);
     RELEASE_ASSERT(m_connectionState == ConnectionStateReceivedResponse);
     m_fetcher->didDownloadData(m_resource.get(), length, encodedDataLength);
     if (m_state == Terminated)
         return;
     m_resource->didDownloadData(length);
 }
 
 void ResourceLoader::didFinishLoadingOnePart(double finishTime, int64_t encodedDataLength)
 {
-    // If load has been cancelled after finishing (which could happen with a
-    // JavaScript that changes the window location), do nothing.
+    ASSERT(m_state != Terminated);

[Nate Chapin, 2016/03/01 19:02:15]

This means we both ASSERT and early-exit for this case. Can we do just one or
the other?

[yhirano, 2016/03/01 19:43:23]

Calling subresourceLoaderFinishedLoadingOnePar may change the state.

[Nate Chapin, 2016/03/01 19:56:45]

...of course. Never mind :)

+    if (m_state != Finishing) {
+        // When loading a multipart resource, make the loader non-block when
+        // finishing loading the first part.
+        m_fetcher->subresourceLoaderFinishedLoadingOnePart(this);
+    }
+
     if (m_state == Terminated)
         return;
 
     if (m_notifiedLoadComplete)
         return;
     m_notifiedLoadComplete = true;
     m_fetcher->didFinishLoading(m_resource.get(), finishTime, encodedDataLength);
 }
 
 void ResourceLoader::didChangePriority(ResourceLoadPriority loadPriority, int intraPriorityValue)
@@ skipping 98 matching lines @@
     return m_options.corsEnabled == IsCORSEnabled;
 }
 
 void ResourceLoader::didReceiveResponse(WebURLLoader*, const WebURLResponse& response, WebDataConsumerHandle* rawHandle)
 {
     ASSERT(!response.isNull());
     ASSERT(m_state == Initialized);
     // |rawHandle|'s ownership is transferred to the callee.
     OwnPtr<WebDataConsumerHandle> handle = adoptPtr(rawHandle);
 
-    bool isMultipartPayload = response.isMultipartPayload();
     bool isValidStateTransition = (m_connectionState == ConnectionStateStarted || m_connectionState == ConnectionStateReceivedResponse);
-    // In the case of multipart loads, calls to didReceiveData & didReceiveResponse can be interleaved.
-    RELEASE_ASSERT(isMultipartPayload || isValidStateTransition);
+    RELEASE_ASSERT(isValidStateTransition);
     m_connectionState = ConnectionStateReceivedResponse;
 
     const ResourceResponse& resourceResponse = response.toResourceResponse();
 
     if (responseNeedsAccessControlCheck()) {
         if (response.wasFetchedViaServiceWorker()) {
             if (response.wasFallbackRequiredByServiceWorker()) {
                 m_loader->cancel();
                 m_loader.clear();
                 m_connectionState = ConnectionStateStarted;
@@ skipping 17 matching lines @@
     }
 
     m_resource->responseReceived(resourceResponse, handle.release());
     if (m_state == Terminated)
         return;
 
     m_fetcher->didReceiveResponse(m_resource.get(), resourceResponse);
     if (m_state == Terminated)
         return;
 
-    if (response.toResourceResponse().isMultipart()) {
-        // We only support multipart for images, though the image may be loaded
-        // as a main resource that we end up displaying through an ImageDocument.
-        if (!m_resource->isImage() && m_resource->getType() != Resource::MainResource) {
-            cancel();
-            return;
-        }
-        m_loadingMultipartContent = true;
-    } else if (isMultipartPayload) {
-        // Since a subresource loader does not load multipart sections progressively, data was delivered to the loader all at once.
-        // After the first multipart section is complete, signal to delegates that this load is "finished"
-        m_fetcher->subresourceLoaderFinishedLoadingOnePart(this);
-        didFinishLoadingOnePart(0, WebURLLoaderClient::kUnknownEncodedDataLength);
-    }
-    if (m_state == Terminated)
-        return;
-
     if (m_resource->response().httpStatusCode() < 400 || m_resource->shouldIgnoreHTTPStatusCodeErrors())
         return;
     m_state = Finishing;
 
     if (!m_notifiedLoadComplete) {
         m_notifiedLoadComplete = true;
         m_fetcher->didFailLoading(m_resource.get(), ResourceError::cancelledError(m_request.url()));
     }
 
     ASSERT(m_state != Terminated);
@@ skipping 128 matching lines @@
     didFinishLoading(0, monotonicallyIncreasingTime(), encodedDataLength);
 }
 
 ResourceRequest& ResourceLoader::applyOptions(ResourceRequest& request) const
 {
     request.setAllowStoredCredentials(m_options.allowCredentials == AllowStoredCredentials);
     return request;
 }
 
 } // namespace blink