Fix Resource Priorities and Scheduling (Blink Side)

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 45 matching lines @@
 using blink::WebURLRequest;
 
 namespace blink {
 
 ResourceLoadPriority ResourceFetcher::loadPriority(Resource::Type type, const FetchRequest& request)
 {
     // TODO(yoav): Change it here so that priority can be changed even after it was resolved.
     if (request.priority() != ResourceLoadPriorityUnresolved)
         return request.priority();
 
-    switch (type) {
-    case Resource::MainResource:
-        return context().isLowPriorityIframe() ? ResourceLoadPriorityVeryLow : ResourceLoadPriorityVeryHigh;
-    case Resource::CSSStyleSheet:
-        return ResourceLoadPriorityHigh;
-    case Resource::Raw:
-        return request.options().synchronousPolicy == RequestSynchronously ? ResourceLoadPriorityVeryHigh : ResourceLoadPriorityMedium;
-    case Resource::Script:
-        // Async scripts do not block the parser so they get the lowest priority and can be
-        // loaded in parser order with images.
-        if (FetchRequest::LazyLoad == request.defer())
+    // An image fetch is used to distinguish between "early" and "late" scripts in a document

[Bryan McQuade, 2015/07/22 17:51:06]

this means that if a doc contains no images we'll get this heuristic wrong,
right? not necessarily a blocker - just want to make sure i understand. though
would be nice to have a better way to identify late body scripts.

[Pat Meenan, 2015/07/28 16:55:15]

Correct though the failure when it doesn't detect just reverts to the current
behavior anyway and it's exceedingly rare to not have any images on a page so it
works pretty well in practice.

By using the image fetches as a deliniation it also keeps all of the code inside
of the fetch logic and we don't have to pass information from the parser through
(particularly when processing preload requests).

Document position is a bit complicated since we parse as it arrives and we don't
necessarily know how long it is (to know if we are near the top or bottom).  We
could potentially use other non-script tokens as a deliniation in the parser as
well but that will also have a bunch of edge cases.

+    if (type == Resource::Image)
+        m_imageFetched = true;
+
+    int fetchMode = context().resourceFetchMode();
+
+    if (fetchMode == 0) {

[Bryan McQuade, 2015/07/22 17:51:06]

this code flow is getting pretty complex. how do you feel about having 3 helper
methods one for each fetch mode, something like:

switch (fetchMode) {
case 0: return getLoadPriorityForOriginalFetchMode();
case 1: return getLoadPriorityForAltFetchMode1();
case 2: return getLoadPriorityForAltFetchMode2();
default: ASSERT(...);
}

[Pat Meenan, 2015/07/28 16:55:15]

I changed the code and folded them all back into a single switch so it's easier
to see the individual differences.

+        switch (type) {
+        case Resource::MainResource:
+            return context().isLowPriorityIframe() ? ResourceLoadPriorityVeryLow : ResourceLoadPriorityVeryHigh;
+        case Resource::CSSStyleSheet:
+            return ResourceLoadPriorityHigh;
+        case Resource::Raw:
+            return request.options().synchronousPolicy == RequestSynchronously ? ResourceLoadPriorityVeryHigh : ResourceLoadPriorityMedium;
+        case Resource::Script:
+            // Async scripts do not block the parser so they get the lowest priority and can be
+            // loaded in parser order with images.
+            if (FetchRequest::LazyLoad == request.defer())
+                return ResourceLoadPriorityLow;
+            return ResourceLoadPriorityMedium;
+        case Resource::Font:
+        case Resource::ImportResource:
+            return ResourceLoadPriorityMedium;
+        case Resource::Image:
+            // Default images to VeryLow, and promote whatever is visible. This improves
+            // speed-index by ~5% on average, ~14% at the 99th percentile.
+            return ResourceLoadPriorityVeryLow;
+        case Resource::Media:
             return ResourceLoadPriorityLow;
-        return ResourceLoadPriorityMedium;
-    case Resource::Font:
-    case Resource::ImportResource:
-        return ResourceLoadPriorityMedium;
-    case Resource::Image:
-        // Default images to VeryLow, and promote whatever is visible. This improves
-        // speed-index by ~5% on average, ~14% at the 99th percentile.
-        return ResourceLoadPriorityVeryLow;
-    case Resource::Media:
-        return ResourceLoadPriorityLow;
-    case Resource::XSLStyleSheet:
-        ASSERT(RuntimeEnabledFeatures::xsltEnabled());
-        return ResourceLoadPriorityHigh;
-    case Resource::SVGDocument:
-        return ResourceLoadPriorityLow;
-    case Resource::LinkPrefetch:
-    case Resource::LinkPreload:
-        return ResourceLoadPriorityVeryLow;
-    case Resource::LinkSubresource:
-        return ResourceLoadPriorityLow;
-    case Resource::TextTrack:
-        return ResourceLoadPriorityLow;
+        case Resource::XSLStyleSheet:
+            ASSERT(RuntimeEnabledFeatures::xsltEnabled());
+            return ResourceLoadPriorityHigh;
+        case Resource::SVGDocument:
+            return ResourceLoadPriorityLow;
+        case Resource::LinkPrefetch:
+        case Resource::LinkPreload:
+            return ResourceLoadPriorityVeryLow;
+        case Resource::LinkSubresource:
+            return ResourceLoadPriorityLow;
+        case Resource::TextTrack:
+            return ResourceLoadPriorityLow;
+        }
+    } else if (fetchMode == 1) {
+        // lower priority for late-body scripts
+        switch (type) {
+        case Resource::MainResource:
+            return context().isLowPriorityIframe() ? ResourceLoadPriorityVeryLow : ResourceLoadPriorityVeryHigh;
+        case Resource::CSSStyleSheet:
+            return ResourceLoadPriorityHigh;
+        case Resource::Raw:
+            return request.options().synchronousPolicy == RequestSynchronously ? ResourceLoadPriorityVeryHigh : ResourceLoadPriorityMedium;
+        case Resource::Script:
+            // Async scripts do not block the parser so they get the lowest priority and can be
+            // loaded in parser order with images.
+            if (FetchRequest::LazyLoad == request.defer())
+                return ResourceLoadPriorityLow;
+            if (!request.forPreload())
+                return ResourceLoadPriorityMedium;
+            return m_imageFetched ? ResourceLoadPriorityLow : ResourceLoadPriorityMedium;
+        case Resource::Font:
+        case Resource::ImportResource:
+            return ResourceLoadPriorityMedium;
+        case Resource::Image:
+            // Default images to VeryLow, and promote whatever is visible. This improves
+            // speed-index by ~5% on average, ~14% at the 99th percentile.
+            return ResourceLoadPriorityVeryLow;
+        case Resource::Media:
+            return ResourceLoadPriorityLow;
+        case Resource::XSLStyleSheet:
+            ASSERT(RuntimeEnabledFeatures::xsltEnabled());
+            return ResourceLoadPriorityHigh;
+        case Resource::SVGDocument:
+            return ResourceLoadPriorityLow;
+        case Resource::LinkPrefetch:
+        case Resource::LinkPreload:
+            return ResourceLoadPriorityVeryLow;
+        case Resource::LinkSubresource:
+            return ResourceLoadPriorityLow;
+        case Resource::TextTrack:
+            return ResourceLoadPriorityLow;
+        }
+    } else if (fetchMode == 2) {
+        // Increased CSS, script and image priorities and lowered late-body script priorities
+        switch (type) {
+        case Resource::MainResource:
+            return context().isLowPriorityIframe() ? ResourceLoadPriorityVeryLow : ResourceLoadPriorityVeryHigh;
+        case Resource::CSSStyleSheet:
+            return ResourceLoadPriorityVeryHigh;
+        case Resource::Raw:
+            return request.options().synchronousPolicy == RequestSynchronously ? ResourceLoadPriorityVeryHigh : ResourceLoadPriorityMedium;
+        case Resource::Script:
+            // Async scripts do not block the parser so they get the lowest priority and can be
+            // loaded in parser order with images.
+            if (FetchRequest::LazyLoad == request.defer())
+                return ResourceLoadPriorityMedium;
+            // Parser=blocking scripts need to be loaded at a high priority
+            if (!request.forPreload())
+                return ResourceLoadPriorityHigh;
+            // Early scripts (before the first image) get a higher priority as they are
+            // likely render-blocking.
+            return m_imageFetched ? ResourceLoadPriorityMedium : ResourceLoadPriorityHigh;
+        case Resource::Font:
+            return ResourceLoadPriorityVeryHigh;
+        case Resource::ImportResource:
+            return ResourceLoadPriorityMedium;
+        case Resource::Image:
+            // Default images to VeryLow, and promote whatever is visible. This improves
+            // speed-index by ~5% on average, ~14% at the 99th percentile.
+            return ResourceLoadPriorityLow;
+        case Resource::Media:
+            return ResourceLoadPriorityLow;
+        case Resource::XSLStyleSheet:
+            ASSERT(RuntimeEnabledFeatures::xsltEnabled());
+            return ResourceLoadPriorityHigh;
+        case Resource::SVGDocument:
+            return ResourceLoadPriorityLow;
+        case Resource::LinkPrefetch:
+        case Resource::LinkPreload:
+            return ResourceLoadPriorityVeryLow;
+        case Resource::LinkSubresource:
+            return ResourceLoadPriorityLow;
+        case Resource::TextTrack:
+            return ResourceLoadPriorityLow;
+        }
     }
     ASSERT_NOT_REACHED();
     return ResourceLoadPriorityUnresolved;
 }
 
 static void populateResourceTiming(ResourceTimingInfo* info, Resource* resource, bool clearLoadTimings)
 {
     info->setInitialRequest(resource->resourceRequest());
     info->setFinalResponse(resource->response());
     if (clearLoadTimings) {
@@ skipping 45 matching lines @@
     return WebURLRequest::RequestContextSubresource;
 }
 
 ResourceFetcher::ResourceFetcher(FetchContext* context)
     : m_context(context)
     , m_garbageCollectDocumentResourcesTimer(this, &ResourceFetcher::garbageCollectDocumentResourcesTimerFired)
     , m_resourceTimingReportTimer(this, &ResourceFetcher::resourceTimingReportTimerFired)
     , m_autoLoadImages(true)
     , m_imagesEnabled(true)
     , m_allowStaleResources(false)
+    , m_imageFetched(false)
 {
 }
 
 ResourceFetcher::~ResourceFetcher()
 {
     clearPreloads();
 }
 
 Resource* ResourceFetcher::cachedResource(const KURL& resourceURL) const
 {
@@ skipping 869 matching lines @@
 
 DEFINE_TRACE(ResourceFetcher)
 {
     visitor->trace(m_context);
     visitor->trace(m_archiveResourceCollection);
     visitor->trace(m_loaders);
     visitor->trace(m_nonBlockingLoaders);
 }
 
 }