Fix Resource Priorities and Scheduling (Blink Side)

Source/core/fetch/ResourceFetcher.cpp

Index: Source/core/fetch/ResourceFetcher.cpp
diff --git a/Source/core/fetch/ResourceFetcher.cpp b/Source/core/fetch/ResourceFetcher.cpp
index e0874bc6d37e800dba7348467b4605dc261321b8..8cef48eb18251e4b00ff9726c2feed07f6ba3024 100644
--- a/Source/core/fetch/ResourceFetcher.cpp
+++ b/Source/core/fetch/ResourceFetcher.cpp
@@ -63,40 +63,130 @@ ResourceLoadPriority ResourceFetcher::loadPriority(Resource::Type type, const Fe
     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;
@@ -162,6 +252,7 @@ ResourceFetcher::ResourceFetcher(FetchContext* context)
     , m_autoLoadImages(true)
     , m_imagesEnabled(true)
     , m_allowStaleResources(false)
+    , m_imageFetched(false)
 {
 }