Turn ResourceLoaderSet into a part object.

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 341 matching lines @@
     if (!substituteData.isValid())
         memoryCache()->add(resource);
 
     return resource;
 }
 
 void ResourceFetcher::moveCachedNonBlockingResourceToBlocking(Resource* resource, const FetchRequest& request)
 {
     // TODO(yoav): Test that non-blocking resources (video/audio/track) continue to not-block even after being preloaded and discovered.
     if (resource && resource->loader() && resource->isLoadEventBlockingResourceType() && resource->isLinkPreload() && !request.forPreload()) {
-        if (m_nonBlockingLoaders)
-            m_nonBlockingLoaders->remove(resource->loader());
-        if (!m_loaders)
-            m_loaders = ResourceLoaderSet::create();
-        m_loaders->add(resource->loader());
+        m_nonBlockingLoaders.remove(resource->loader());
+        m_loaders.add(resource->loader());
     }
 }
 
 void ResourceFetcher::updateMemoryCacheStats(Resource* resource, RevalidationPolicy policy, const FetchRequest& request,  const ResourceFactory& factory, bool isStaticData) const
 {
     if (isStaticData)
         return;
 
     if (request.forPreload()) {
         DEFINE_RESOURCE_HISTOGRAM("Preload.");
@@ skipping 434 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);
     }
 }
 
 int ResourceFetcher::requestCount() const
 {
-    return m_loaders ? m_loaders->size() : 0;
+    return m_loaders.size();
 }
 
 void ResourceFetcher::preloadStarted(Resource* resource)
 {
     if (m_preloads && m_preloads->contains(resource))
         return;
     TRACE_EVENT_ASYNC_STEP_INTO0("blink.net", "Resource", resource, "Preload");
     resource->increasePreloadCount();
 
     if (!m_preloads)
@@ skipping 41 matching lines @@
 {
     TRACE_EVENT_ASYNC_END0("blink.net", "Resource", resource);
     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()));
+    DCHECK(!m_loaders.contains(resource->loader()));
+    DCHECK(finishReason == DidFinishFirstPartInMultipart || !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);
         }
     }
@@ skipping 41 matching lines @@
     context().dispatchDidDownloadData(resource->identifier(), dataLength, encodedDataLength);
 }
 
 void ResourceFetcher::acceptDataFromThreadedReceiver(unsigned long identifier, const char* data, int dataLength, int encodedDataLength)
 {
     context().dispatchDidReceiveData(identifier, data, dataLength, encodedDataLength);
 }
 
 void ResourceFetcher::moveResourceLoaderToNonBlocking(ResourceLoader* loader)
 {
-    if (!m_nonBlockingLoaders)
-        m_nonBlockingLoaders = ResourceLoaderSet::create();
-    m_nonBlockingLoaders->add(loader);
-    m_loaders->remove(loader);
+    m_nonBlockingLoaders.add(loader);
+    m_loaders.remove(loader);
 }
 
 void ResourceFetcher::willStartLoadingResource(Resource* resource, ResourceLoader* loader, ResourceRequest& request)
 {
-    if (resource->shouldBlockLoadEvent()) {
-        if (!m_loaders)
-            m_loaders = ResourceLoaderSet::create();
-        m_loaders->add(loader);
-    } else {
-        if (!m_nonBlockingLoaders)
-            m_nonBlockingLoaders = ResourceLoaderSet::create();
-        m_nonBlockingLoaders->add(loader);
-    }
+    if (resource->shouldBlockLoadEvent())
+        m_loaders.add(loader);
+    else
+        m_nonBlockingLoaders.add(loader);
 
     context().willStartLoadingResource(resource, request);
     storeResourceTimingInitiatorInformation(resource);
 
     context().dispatchWillSendRequest(resource->identifier(), request, ResourceResponse(), resource->options().initiatorInfo);
 }
 
 void ResourceFetcher::removeResourceLoader(ResourceLoader* loader)
 {
-    if (m_loaders && m_loaders->contains(loader))
-        m_loaders->remove(loader);
-    else if (m_nonBlockingLoaders && m_nonBlockingLoaders->contains(loader))
-        m_nonBlockingLoaders->remove(loader);
+    if (m_loaders.contains(loader))
+        m_loaders.remove(loader);
+    else if (m_nonBlockingLoaders.contains(loader))
+        m_nonBlockingLoaders.remove(loader);
     else
         ASSERT_NOT_REACHED();
 }
 
 void ResourceFetcher::stopFetching()
 {
-    if (m_nonBlockingLoaders)
-        m_nonBlockingLoaders->cancelAll();
-    if (m_loaders)
-        m_loaders->cancelAll();
+    m_nonBlockingLoaders.cancelAll();
+    m_loaders.cancelAll();
 }
 
 bool ResourceFetcher::isFetching() const
 {
-    return m_loaders && !m_loaders->isEmpty();
+    return !m_loaders.isEmpty();
 }
 
 void ResourceFetcher::setDefersLoading(bool defers)
 {
-    if (m_loaders)
-        m_loaders->setAllDefersLoading(defers);
-    if (m_nonBlockingLoaders)
-        m_nonBlockingLoaders->setAllDefersLoading(defers);
+    m_loaders.setAllDefersLoading(defers);
+    m_nonBlockingLoaders.setAllDefersLoading(defers);
 }
 
 bool ResourceFetcher::defersLoading() const
 {
     return context().defersLoading();
 }
 
 static bool isManualRedirectFetchRequest(const ResourceRequest& request)
 {
     return request.fetchRedirectMode() == WebURLRequest::FetchRedirectModeManual && request.requestContext() == WebURLRequest::RequestContextFetch;
@@ skipping 221 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