Refactoring starting a resource load

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 186 matching lines @@
     , m_imagesEnabled(true)
     , m_allowStaleResources(false)
 {
     ThreadState::current()->registerPreFinalizer(this);
 }
 
 ResourceFetcher::~ResourceFetcher()
 {
 }
 
-WebTaskRunner* ResourceFetcher::loadingTaskRunner()
-{
-    if (!m_context)
-        return nullptr;
-
-    return m_context->loadingTaskRunner();
-}
-
 Resource* ResourceFetcher::cachedResource(const KURL& resourceURL) const
 {
     KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(resourceURL);
     const WeakMember<Resource>& resource = m_documentResources.get(url);
     return resource.get();
 }
 
 bool ResourceFetcher::canAccessResource(Resource* resource, SecurityOrigin* sourceOrigin, const KURL& url, AccessControlLoggingDecision logErrorsDecision) const
 {
     // Redirects can change the response URL different from one of request.
@@ skipping 31 matching lines @@
         return false;
     if (resource->isImage() && shouldDeferImageLoad(resource->url()))
         return false;
     return policy != Use || resource->stillNeedsLoad();
 }
 
 // Limit the number of URLs in m_validatedURLs to avoid memory bloat.
 // http://crbug.com/52411
 static const int kMaxValidatedURLsSize = 10000;
 
-void ResourceFetcher::requestLoadStarted(Resource* resource, const FetchRequest& request, ResourceLoadStartType type, bool isStaticData)
+void ResourceFetcher::requestLoadStarted(unsigned long identifier, Resource* resource, const FetchRequest& request, ResourceLoadStartType type, bool isStaticData)
 {
     if (type == ResourceLoadingFromCache && resource->getStatus() == Resource::Cached && !m_validatedURLs.contains(resource->url()))
-        context().dispatchDidLoadResourceFromMemoryCache(resource, request.resourceRequest().frameType(), request.resourceRequest().requestContext());
+        context().dispatchDidLoadResourceFromMemoryCache(identifier, resource, request.resourceRequest().frameType(), request.resourceRequest().requestContext());
 
     if (isStaticData)
         return;
 
     if (type == ResourceLoadingFromCache && !resource->stillNeedsLoad() && !m_validatedURLs.contains(request.resourceRequest().url())) {
         // Resources loaded from memory cache should be reported the first time they're used.
         OwnPtr<ResourceTimingInfo> info = ResourceTimingInfo::create(request.options().initiatorInfo.name, monotonicallyIncreasingTime(), resource->getType() == Resource::MainResource);
         populateResourceTiming(info.get(), resource);
         info->clearLoadTimings();
         info->setLoadFinishTime(info->initialTime());
@@ skipping 110 matching lines @@
 }
 
 Resource* ResourceFetcher::requestResource(FetchRequest& request, const ResourceFactory& factory, const SubstituteData& substituteData)
 {
     ASSERT(request.options().synchronousPolicy == RequestAsynchronously || factory.type() == Resource::Raw || factory.type() == Resource::XSLStyleSheet);
 
     context().upgradeInsecureRequest(request);
     context().addClientHintsIfNecessary(request);
     context().addCSPHeaderIfNecessary(factory.type(), request);
 
-    KURL url = request.resourceRequest().url();
-    KURL urlWithoutFragment = MemoryCache::removeFragmentIdentifierIfNeeded(url);
-    TRACE_EVENT1("blink", "ResourceFetcher::requestResource", "url", urlForTraceEvent(url));
+    TRACE_EVENT1("blink", "ResourceFetcher::requestResource", "url", urlForTraceEvent(request.url()));
 
-    WTF_LOG(ResourceLoading, "ResourceFetcher::requestResource '%s', charset '%s', priority=%d, forPreload=%u, type=%s", url.elidedString().latin1().data(), request.charset().latin1().data(), request.priority(), request.forPreload(), Resource::resourceTypeName(factory.type()));
-
-    if (!url.isValid())
+    if (!request.url().isValid())
         return nullptr;
 
-    if (!context().canRequest(factory.type(), request.resourceRequest(), urlWithoutFragment, request.options(), request.forPreload(), request.getOriginRestriction()))
+    if (!context().canRequest(factory.type(), request.resourceRequest(), MemoryCache::removeFragmentIdentifierIfNeeded(request.url()), request.options(), request.forPreload(), request.getOriginRestriction()))
+        return nullptr;
+
+    unsigned long identifier = createUniqueIdentifier();
+    request.setPriority(loadPriority(factory.type(), request, ResourcePriority::NotVisible));
+    request.mutableResourceRequest().setPriority(request.priority());
+    initializeResourceRequest(request.mutableResourceRequest(), factory.type(), request.defer());
+    context().willStartLoadingResource(identifier, request.mutableResourceRequest(), factory.type());
+    if (!request.url().isValid())
         return nullptr;
 
     if (!request.forPreload()) {
         V8DOMActivityLogger* activityLogger = nullptr;
         if (request.options().initiatorInfo.name == FetchInitiatorTypeNames::xmlhttprequest)
             activityLogger = V8DOMActivityLogger::currentActivityLogger();
         else
             activityLogger = V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
 
         if (activityLogger) {
             Vector<String> argv;
             argv.append(Resource::resourceTypeToString(factory.type(), request.options().initiatorInfo));
-            argv.append(url);
+            argv.append(request.url());
             activityLogger->logEvent("blinkRequestResource", argv.size(), argv.data());
         }
     }
 
     bool isStaticData = request.resourceRequest().url().protocolIsData() || substituteData.isValid() || m_archive;
     Resource* resource(nullptr);
     if (isStaticData)
         resource = resourceForStaticData(request, factory, substituteData);
     if (!resource)
-        resource = memoryCache()->resourceForURL(url, getCacheIdentifier());
+        resource = memoryCache()->resourceForURL(request.url(), getCacheIdentifier());
 
     // See if we can use an existing resource from the cache. If so, we need to move it to be load blocking.
     moveCachedNonBlockingResourceToBlocking(resource, request);
 
     const RevalidationPolicy policy = determineRevalidationPolicy(factory.type(), request, resource, isStaticData);
 
     updateMemoryCacheStats(resource, policy, request, factory, isStaticData);
 
-    initializeResourceRequest(request.mutableResourceRequest(), factory.type(), request.defer());
+    if (policy != Use)
+        willSendRequest(identifier, request.mutableResourceRequest(), ResourceResponse(), request.options());
+
     switch (policy) {
     case Reload:
         memoryCache()->remove(resource);
         // Fall through
     case Load:
         resource = createResourceForLoading(request, request.charset(), factory);
         break;
     case Revalidate:
         initializeRevalidation(request, resource);
         break;
     case Use:
         memoryCache()->updateForAccess(resource);
         break;
     }
 
     if (!resource)
         return nullptr;
     if (resource->getType() != factory.type()) {
         ASSERT(request.forPreload());
         return nullptr;
     }
 
     if (!resource->hasClientsOrObservers())
         m_deadStatsRecorder.update(policy);
 
     if (policy != Use)
-        resource->setIdentifier(createUniqueIdentifier());
+        resource->setIdentifier(identifier);
 
     if (!request.forPreload() || policy != Use) {
-        ResourceLoadPriority priority = loadPriority(factory.type(), request, ResourcePriority::NotVisible);
         // When issuing another request for a resource that is already in-flight make
         // sure to not demote the priority of the in-flight request. If the new request
         // isn't at the same priority as the in-flight request, only allow promotions.
         // This can happen when a visible image's priority is increased and then another
         // reference to the image is parsed (which would be at a lower priority).
-        if (priority > resource->resourceRequest().priority())
-            resource->didChangePriority(priority, 0);
+        if (request.priority() > resource->resourceRequest().priority())
+            resource->didChangePriority(request.priority(), 0);
     }
 
     // If only the fragment identifiers differ, it is the same resource.
-    ASSERT(equalIgnoringFragmentIdentifier(resource->url(), url));
-    requestLoadStarted(resource, request, policy == Use ? ResourceLoadingFromCache : ResourceLoadingFromNetwork, isStaticData);
-    m_documentResources.set(urlWithoutFragment, resource);
+    DCHECK(equalIgnoringFragmentIdentifier(resource->url(), request.url()));
+    requestLoadStarted(identifier, resource, request, policy == Use ? ResourceLoadingFromCache : ResourceLoadingFromNetwork, isStaticData);
+    m_documentResources.set(MemoryCache::removeFragmentIdentifierIfNeeded(request.url()), resource);
 
     if (!resourceNeedsLoad(resource, request, policy))
         return resource;
 
-    if (!context().shouldLoadNewResource(factory.type())) {
-        if (memoryCache()->contains(resource))
-            memoryCache()->remove(resource);
+    if (!startLoad(resource))
         return nullptr;
-    }
-
-    resource->load(this);
     ASSERT(!resource->errorOccurred() || request.options().synchronousPolicy == RequestSynchronously);
     return resource;
 }
 
 void ResourceFetcher::resourceTimingReportTimerFired(Timer<ResourceFetcher>* timer)
 {
     ASSERT_UNUSED(timer, timer == &m_resourceTimingReportTimer);
     Vector<OwnPtr<ResourceTimingInfo>> timingReports;
     timingReports.swap(m_scheduledResourceTimingReports);
     for (const auto& timingInfo : timingReports)
@@ skipping 16 matching lines @@
     if (request.getCachePolicy() == WebCachePolicy::UseProtocolCachePolicy)
         request.setCachePolicy(context().resourceRequestCachePolicy(request, type, defer));
     if (request.requestContext() == WebURLRequest::RequestContextUnspecified)
         determineRequestContext(request, type);
     if (type == Resource::LinkPrefetch)
         request.setHTTPHeaderField(HTTPNames::Purpose, "prefetch");
 
     context().addAdditionalRequestHeaders(request, (type == Resource::MainResource) ? FetchMainResource : FetchSubresource);
 }
 
-void ResourceFetcher::initializeRevalidation(const FetchRequest& request, Resource* resource)
+void ResourceFetcher::initializeRevalidation(FetchRequest& request, Resource* resource)
 {
     ASSERT(resource);
     ASSERT(memoryCache()->contains(resource));
     ASSERT(resource->isLoaded());
     ASSERT(resource->canUseCacheValidator());
     ASSERT(!resource->isCacheValidator());
     ASSERT(!context().isControlledByServiceWorker());
 
-    ResourceRequest revalidatingRequest(resource->resourceRequest());
+    ResourceRequest& revalidatingRequest = request.mutableResourceRequest();
     revalidatingRequest.clearHTTPReferrer();
     initializeResourceRequest(revalidatingRequest, resource->getType(), request.defer());
 
     const AtomicString& lastModified = resource->response().httpHeaderField(HTTPNames::Last_Modified);
     const AtomicString& eTag = resource->response().httpHeaderField(HTTPNames::ETag);
     if (!lastModified.isEmpty() || !eTag.isEmpty()) {
         ASSERT(context().getCachePolicy() != CachePolicyReload);
         if (context().getCachePolicy() == CachePolicyRevalidate)
             revalidatingRequest.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=0");
     }
@@ skipping 129 matching lines @@
         return Reload;
 
     // Don't try to reuse an in-progress async request for a new sync request.
     if (fetchRequest.options().synchronousPolicy == RequestSynchronously && existingResource->isLoading())
         return Reload;
 
     // Don't reload resources while pasting.
     if (m_allowStaleResources)
         return Use;
 
-    if (request.getCachePolicy() == WebCachePolicy::BypassingCache)
-        return Reload;
-
     if (!fetchRequest.options().canReuseRequest(existingResource->options()))
         return Reload;
 
     // Always use preloads.
     if (existingResource->isPreloaded())
         return Use;
 
     // CachePolicyHistoryBuffer uses the cache no matter what.
     CachePolicy cachePolicy = context().getCachePolicy();
     if (cachePolicy == CachePolicyHistoryBuffer)
@@ skipping 21 matching lines @@
     // We also group loads of the same resource together.
     // Raw resources are exempted, as XHRs fall into this category and may have user-set Cache-Control:
     // headers or other factors that require separate requests.
     if (type != Resource::Raw) {
         if (!context().isLoadComplete() && m_validatedURLs.contains(existingResource->url()))
             return Use;
         if (existingResource->isLoading())
             return Use;
     }
 
+    if (request.getCachePolicy() == WebCachePolicy::BypassingCache)

[Nate Chapin, 2016/05/18 23:56:05]

Turns out initializeResourceRequest() is called too late on trunk, and the cache
policy doesn't fallback to FetchContext::resourceRequestCachePolicy() until
*after* we call determineRevalidationPolicy(). Moving
initializeResourceRequest() to its proper earlier time means that this clause
needs to move to a lower priority: it was blocking even a preload from being
reused, which is not good. This makes it equivalent priority to
CachePolicyReload, which is a very similar concept.

+        return Reload;
+
     // CachePolicyReload always reloads
     if (cachePolicy == CachePolicyReload) {
         WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicy reloading due to CachePolicyReload.");
         return Reload;
     }
 
     // We'll try to reload the resource if it failed last time.
     if (existingResource->errorOccurred()) {
         WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicye reloading due to resource being in the error state");
         return Reload;
@@ skipping 58 matching lines @@
 
 bool ResourceFetcher::shouldDeferImageLoad(const KURL& url) const
 {
     return !context().allowImage(m_imagesEnabled, url) || !m_autoLoadImages;
 }
 
 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);
+            startLoad(resource);
     }
 }
 
 int ResourceFetcher::requestCount() const
 {
     return m_loaders ? m_loaders->size() : 0;
 }
 
 void ResourceFetcher::preloadStarted(Resource* resource)
 {
@@ skipping 121 matching lines @@
 }
 
 void ResourceFetcher::moveResourceLoaderToNonBlocking(ResourceLoader* loader)
 {
     if (!m_nonBlockingLoaders)
         m_nonBlockingLoaders = ResourceLoaderSet::create();
     m_nonBlockingLoaders->add(loader);
     m_loaders->remove(loader);
 }
 
-void ResourceFetcher::willStartLoadingResource(Resource* resource, ResourceLoader* loader, ResourceRequest& request)
+bool ResourceFetcher::startLoad(Resource* resource)
 {
+    DCHECK(resource && resource->stillNeedsLoad());
+    if (!context().shouldLoadNewResource(resource->getType())) {
+        memoryCache()->remove(resource);
+        return false;
+    }
+
+    ResourceLoader* loader = ResourceLoader::create(this, resource);
     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);
     }
 
-    context().willStartLoadingResource(resource, request);
     storeResourceTimingInitiatorInformation(resource);
-
-    context().dispatchWillSendRequest(resource->identifier(), request, ResourceResponse(), resource->options().initiatorInfo);
+    resource->setFetcherSecurityOrigin(context().getSecurityOrigin());
+    loader->start(resource->requestForLoadStart(), context().loadingTaskRunner(), context().defersLoading());
+    return true;
 }
 
 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);
     else
         ASSERT_NOT_REACHED();
@@ skipping 48 matching lines @@
                 return false;
             }
         }
         if (resource->getType() == Resource::Image && shouldDeferImageLoad(newRequest.url()))
             return false;
     }
 
     ResourceTimingInfoMap::iterator it = m_resourceTimingInfoMap.find(resource);
     if (it != m_resourceTimingInfoMap.end())
         it->value->addRedirect(redirectResponse);
-    context().dispatchWillSendRequest(resource->identifier(), newRequest, redirectResponse, resource->options().initiatorInfo);
+    willSendRequest(resource->identifier(), newRequest, redirectResponse, resource->options());
     return true;
 }
 
+void ResourceFetcher::willSendRequest(unsigned long identifier, ResourceRequest& newRequest, const ResourceResponse& redirectResponse, const ResourceLoaderOptions& options)
+{
+    newRequest.setAllowStoredCredentials(options.allowCredentials == AllowStoredCredentials);
+    context().dispatchWillSendRequest(identifier, newRequest, redirectResponse, options.initiatorInfo);
+}
+
 void ResourceFetcher::updateAllImageResourcePriorities()
 {
     TRACE_EVENT0("blink", "ResourceLoadPriorityOptimizer::updateAllImageResourcePriorities");
     for (const auto& documentResource : m_documentResources) {
         Resource* resource = documentResource.value.get();
         if (!resource || !resource->isImage() || !resource->isLoading())
             continue;
 
         ResourcePriority resourcePriority = resource->priorityFromObservers();
         ResourceLoadPriority resourceLoadPriority = loadPriority(Resource::Image, FetchRequest(resource->resourceRequest(), FetchInitiatorInfo()), resourcePriority.visibility);
@@ skipping 118 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