Clean up ResourceLoader finish more, remove ConnectionState enum

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

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
     Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
@@ skipping 796 matching lines @@
 }
 
 void ResourceFetcher::reloadImagesIfNotDeferred()
 {
     for (Resource* resource : m_documentResources.values()) {
         if (resource->getType() == Resource::Image && resource->stillNeedsLoad() && !shouldDeferImageLoad(resource->url()))
             const_cast<Resource*>(resource)->load(this);
     }
 }
 
-void ResourceFetcher::didLoadResource(Resource* resource)
-{
-    context().didLoadResource(resource);
-}
-
 int ResourceFetcher::requestCount() const
 {
     return m_loaders ? m_loaders->size() : 0;
 }
 
 void ResourceFetcher::preloadStarted(Resource* resource)
 {
     if (m_preloads && m_preloads->contains(resource))
         return;
     TRACE_EVENT_ASYNC_STEP_INTO0("blink.net", "Resource", resource, "Preload");
@@ skipping 38 matching lines @@
 
 ArchiveResource* ResourceFetcher::createArchive(Resource* resource)
 {
     // Only the top-frame can load MHTML.
     if (!context().isMainFrame())
         return nullptr;
     m_archive = MHTMLArchive::create(resource->url(), resource->resourceBuffer());
     return m_archive ? m_archive->mainResource() : nullptr;
 }
 
-void ResourceFetcher::didFinishLoading(Resource* resource, double finishTime, int64_t encodedDataLength)
+void ResourceFetcher::didFinishLoading(Resource* resource, double finishTime, int64_t encodedDataLength, DidFinishLoadingReason finishReason)
 {
     TRACE_EVENT_ASYNC_END0("blink.net", "Resource", resource);
-    // The ResourceLoader might be in |m_nonBlockingLoaders| for multipart responses.
-    ASSERT(resource);
-    ASSERT(!(m_loaders && m_loaders->contains(resource->loader())));
+    DCHECK(resource);
+
+    // When loading a multipart resource, make the loader non-block when
+    // finishing loading the first part.
+    if (finishReason == DidFinishFirstPartInMultipart)
+        moveResourceLoaderToNonBlocking(resource->loader());
+    else
+        removeResourceLoader(resource->loader());
+    DCHECK(!m_loaders || !m_loaders->contains(resource->loader()));
+    DCHECK(finishReason == DidFinishFirstPartInMultipart || !m_nonBlockingLoaders || !m_nonBlockingLoaders->contains(resource->loader()));
 
     if (OwnPtr<ResourceTimingInfo> info = m_resourceTimingInfoMap.take(resource)) {
         if (resource->response().isHTTP() && resource->response().httpStatusCode() < 400) {
             populateResourceTiming(info.get(), resource);
             info->setLoadFinishTime(finishTime);
             if (resource->options().requestInitiatorContext == DocumentContext)
                 context().addResourceTiming(*info);
             resource->reportResourceTimingToClients(*info);
         }
     }
     context().dispatchDidFinishLoading(resource->identifier(), finishTime, encodedDataLength);
+    if (finishReason == DidFinishLoading)
+        resource->finish(finishTime);
+    context().didLoadResource(resource);
 }
 
-void ResourceFetcher::didFailLoading(const Resource* resource, const ResourceError& error)
+void ResourceFetcher::didFailLoading(Resource* resource, const ResourceError& error)
 {
     TRACE_EVENT_ASYNC_END0("blink.net", "Resource", resource);
     removeResourceLoader(resource->loader());
     m_resourceTimingInfoMap.take(const_cast<Resource*>(resource));
     bool isInternalRequest = resource->options().initiatorInfo.name == FetchInitiatorTypeNames::internal;
     context().dispatchDidFail(resource->identifier(), error, isInternalRequest);
+    resource->error(error);
+    context().didLoadResource(resource);
 }
 
 void ResourceFetcher::didReceiveResponse(Resource* resource, const ResourceResponse& response)
 {
     // If the response is fetched via ServiceWorker, the original URL of the response could be different from the URL of the request.
     // We check the URL not to load the resources which are forbidden by the page CSP.
     // https://w3c.github.io/webappsec-csp/#should-block-response
     if (response.wasFetchedViaServiceWorker()) {
         const KURL& originalURL = response.originalURLViaServiceWorker();
         if (!originalURL.isEmpty() && !context().allowResponse(resource->getType(), resource->resourceRequest(), originalURL, resource->options())) {
@@ skipping 248 matching lines @@
     visitor->trace(m_context);
     visitor->trace(m_archive);
     visitor->trace(m_loaders);
     visitor->trace(m_nonBlockingLoaders);
     visitor->trace(m_documentResources);
     visitor->trace(m_preloads);
     visitor->trace(m_resourceTimingInfoMap);
 }
 
 } // namespace blink