Make ResourceLoadPriority calculation simpler

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 117 matching lines @@
     case Resource::LinkPrefetch:
         return ResourceLoadPriorityVeryLow;
     }
 
     ASSERT_NOT_REACHED();
     return ResourceLoadPriorityUnresolved;
 }
 
 ResourceLoadPriority ResourceFetcher::loadPriority(Resource::Type type, const FetchRequest& request, ResourcePriority::VisibilityStatus visibility)
 {
-    // TODO(yoav): Change it here so that priority can be changed even after it was resolved.
-    if (request.priority() != ResourceLoadPriorityUnresolved)
-        return request.priority();
-
-    // Synchronous requests should always be max priority, lest they hang the renderer.
-    if (request.options().synchronousPolicy == RequestSynchronously)
-        return ResourceLoadPriorityHighest;
-
     ResourceLoadPriority priority = typeToPriority(type);
 
     // Visible resources (images in practice) get a boost to High priority.
     if (visibility == ResourcePriority::Visible)
         priority = ResourceLoadPriorityHigh;
 
     // Resources before the first image are considered "early" in the document
     // and resources after the first image are "late" in the document.  Important to
     // note that this is based on when the preload scanner discovers a resource
     // for the most part so the main parser may not have reached the image element yet.
     if (type == Resource::Image)
         m_imageFetched = true;
 
     // Special handling for scripts.
     // Default/Parser-Blocking/Preload early in document: High (set in typeToPriority)
     // Async/Defer: Low Priority (applies to both preload and parser-inserted)
     // Preload late in document: Medium
     if (type == Resource::Script) {
         if (FetchRequest::LazyLoad == request.defer())
             priority = ResourceLoadPriorityLow;
         else if (request.forPreload() && m_imageFetched)
             priority = ResourceLoadPriorityMedium;
+    } else if (FetchRequest::LazyLoad == request.defer()) {
+        priority = ResourceLoadPriorityVeryLow;
     }
 
-    return context().modifyPriorityForExperiments(priority);
+    return std::max(context().modifyPriorityForExperiments(priority), request.resourceRequest().priority());

[kinuko, 2016/06/17 05:40:47]

Is the max here to cover synchronous load case?

[Nate Chapin, 2016/06/17 18:38:16]

That's half of it. Also, it covers the case where an image moves into the
viewport, then out of it, which would drop the priority this function reports.

[kinuko, 2016/06/20 04:28:31]

Ah I see, thanks. Would it make sense to add a brief comment about that? That
sounds helpful.

[Nate Chapin, 2016/06/20 19:44:31]

Done.

 }
 
 static void populateResourceTiming(ResourceTimingInfo* info, Resource* resource)
 {
     info->setInitialRequest(resource->resourceRequest());
     info->setFinalResponse(resource->response());
 }
 
 static WebURLRequest::RequestContext requestContextFromType(bool isMainFrame, Resource::Type type)
 {
@@ skipping 234 matching lines @@
 
     TRACE_EVENT1("blink", "ResourceFetcher::requestResource", "url", urlForTraceEvent(request.url()));
 
     if (!request.url().isValid())
         return nullptr;
 
     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());
+    request.mutableResourceRequest().setPriority(loadPriority(factory.type(), request, ResourcePriority::NotVisible));
     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
@@ skipping 55 matching lines @@
 
     if (policy != Use)
         resource->setIdentifier(identifier);
 
     if (!request.forPreload() || policy != Use) {
         // 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 (request.priority() > resource->resourceRequest().priority())
-            resource->didChangePriority(request.priority(), 0);
+        if (request.resourceRequest().priority() > resource->resourceRequest().priority())
+            resource->didChangePriority(request.resourceRequest().priority(), 0);
     }
 
     // If only the fragment identifiers differ, it is the same resource.
     DCHECK(equalIgnoringFragmentIdentifier(resource->url(), request.url()));
     requestLoadStarted(identifier, resource, request, policy == Use ? ResourceLoadingFromCache : ResourceLoadingFromNetwork, isStaticData);
     m_documentResources.set(MemoryCache::removeFragmentIdentifierIfNeeded(request.url()), resource);
 
     // Returns with an existing resource if the resource does not need to start
     // loading immediately.
     // If revalidation policy was determined as |Revalidate|, the resource was
@@ skipping 746 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