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();
 
+    // An image fetch is used to distinguish between "early" and "late" scripts in a document
+    if (type == Resource::Image)
+        m_imageFetched = true;
+
+    // Runtime experiment that change how we prioritize resources.
+    // The toggles do not depend on each other and can be flipped individually
+    // though the cumulative result will depend on the interaction between them.
+    // Background doc: https://docs.google.com/document/d/1bCDuq9H1ih9iNjgzyAL0gpwNFiEP4TZS-YLRp_RuMlc/edit?usp=sharing
+    bool deferLateScripts = context().fetchDeferLateScripts();
+    bool increaseFontPriority = context().fetchIncreaseFontPriority();
+    bool increaseAsyncScriptPriority = context().fetchIncreaseAsyncScriptPriority();
+    // Increases the priorities for CSS, Scripts, Fonts and Images all by one level
+    // and parser-blocking scripts and visible images by 2.
+    // This is used in conjunction with logic on the Chrome side to raise the threshold
+    // of "layout-blocking" resources and provide a boost to resources that are needed
+    // as soon as possible for something currently on the screen.
+    bool increasePriorities = context().fetchIncreasePriorities();
+
     switch (type) {
     case Resource::MainResource:
         return context().isLowPriorityIframe() ? ResourceLoadPriorityVeryLow : ResourceLoadPriorityVeryHigh;
     case Resource::CSSStyleSheet:
-        return ResourceLoadPriorityHigh;
+        return increasePriorities ? ResourceLoadPriorityVeryHigh : 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.
+        // Async/Defer scripts.
         if (FetchRequest::LazyLoad == request.defer())
-            return ResourceLoadPriorityLow;
-        return ResourceLoadPriorityMedium;
+            return increaseAsyncScriptPriority ? ResourceLoadPriorityMedium : ResourceLoadPriorityLow;
+        // Reduce the priority of late-body scripts.
+        if (deferLateScripts && request.forPreload() && m_imageFetched)
+            return increasePriorities ? ResourceLoadPriorityMedium : ResourceLoadPriorityLow;
+        // Parser-blocking scripts.
+        if (increasePriorities && !request.forPreload())

[Bryan McQuade, 2015/08/11 13:05:12]

do you only want to elevate the priority of parser-blocking scripts if
increasePriorities is also true? if so, this can be simplified to:
if (increasePriorities && !request.forPreload())
    return  ResourceLoadPriorityVeryHigh;

[Pat Meenan, 2015/08/11 14:18:40]

I flipped it around to be consistent with the comment so ALL non-preload scripts
will trigger here.  It keeps the complexity of the different returns depending
on the state of increasePriorities but it will be cleaner than the other way
around when a decision is made.

+            return increasePriorities ? ResourceLoadPriorityVeryHigh : ResourceLoadPriorityMedium;
+        // Early scripts discovered by the preload scanner.

[Bryan McQuade, 2015/08/11 13:05:12]

note that since your if test above looks at both forPreload() *and*
increasePriorities, this means that non-preloaded scripts will fall through to
this case if increasePriorities is not true (is that your intended behavior?)
and thus this comment isn't universally correct: at this point you are handling
either early scripts discovered by the preload scanner, or parser-blocking
scripts when increasePriorities is false. maybe we can modify the logic
slightly, or the comments, to make this clearer.

[Pat Meenan, 2015/08/11 14:18:39]

Cleaned up the check above so only preload scanner scripts reach this point.  It
does still include late-body scripts if deferLateScripts isn't set though so I
also updated the comment (will reduce to only being early scripts when the
experiment is complete).

+        return increasePriorities ? ResourceLoadPriorityHigh : ResourceLoadPriorityMedium;
     case Resource::Font:
+        if (increaseFontPriority)
+            return increasePriorities ? ResourceLoadPriorityVeryHigh : ResourceLoadPriorityHigh;
+        return increasePriorities ? ResourceLoadPriorityHigh : ResourceLoadPriorityMedium;
     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;
+        // Default images to VeryLow, and promote when they become visible.
+        return increasePriorities ? ResourceLoadPriorityLow : 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;
     }
+
     ASSERT_NOT_REACHED();
     return ResourceLoadPriorityUnresolved;
 }
 
 static void populateResourceTiming(ResourceTimingInfo* info, Resource* resource, bool clearLoadTimings)
 {
     info->setInitialRequest(resource->resourceRequest());
     info->setFinalResponse(resource->response());
     if (clearLoadTimings) {
         info->clearLoadTimings();
@@ skipping 44 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 891 matching lines @@
 
 DEFINE_TRACE(ResourceFetcher)
 {
     visitor->trace(m_context);
     visitor->trace(m_archiveResourceCollection);
     visitor->trace(m_loaders);
     visitor->trace(m_nonBlockingLoaders);
 }
 
 }