Cleanup ResourceLoadPriority setting

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 39 matching lines @@
 #include "public/platform/WebURLRequest.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/WTFString.h"
 
 #define PRELOAD_DEBUG 0
 
 using blink::WebURLRequest;
 
 namespace blink {
 
+static ResourceLoadPriority typeToPriority(Resource::Type type)
+{
+    switch (type) {
+    case Resource::MainResource:
+        return ResourceLoadPriorityVeryHigh;
+    case Resource::XSLStyleSheet:
+        ASSERT(RuntimeEnabledFeatures::xsltEnabled());
+    case Resource::CSSStyleSheet:
+        return ResourceLoadPriorityHigh;
+    case Resource::Raw:
+    case Resource::Script:
+    case Resource::Font:
+    case Resource::ImportResource:
+        return ResourceLoadPriorityMedium;
+    case Resource::LinkSubresource:
+    case Resource::TextTrack:
+    case Resource::Media:
+    case Resource::SVGDocument:
+        return ResourceLoadPriorityLow;
+    case Resource::Image:
+    case Resource::LinkPrefetch:
+    case Resource::LinkPreload:
+        return ResourceLoadPriorityVeryLow;
+    }
+
+    ASSERT_NOT_REACHED();
+    return ResourceLoadPriorityUnresolved;
+}
+
 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;
+    // Synchronous requests should always be max priority, lest they hang the renderer.
+    if (request.options().synchronousPolicy == RequestSynchronously)
+        return ResourceLoadPriorityHighest;
 
-    // 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 increasePriorities ? ResourceLoadPriorityVeryHigh : ResourceLoadPriorityHigh;
-    case Resource::Raw:
-        return request.options().synchronousPolicy == RequestSynchronously ? ResourceLoadPriorityVeryHigh : ResourceLoadPriorityMedium;
-    case Resource::Script:
-        // Async/Defer scripts.
-        if (FetchRequest::LazyLoad == request.defer())
-            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 (!request.forPreload())
-            return increasePriorities ? ResourceLoadPriorityVeryHigh : ResourceLoadPriorityMedium;
-        // Non-async/defer scripts discovered by the preload scanner (only early scripts if deferLateScripts is active).
-        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 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;
+    return context().modifyPriorityForExperiments(typeToPriority(type), type, request);
 }
 
 static void populateResourceTiming(ResourceTimingInfo* info, Resource* resource, bool clearLoadTimings)
 {
     info->setInitialRequest(resource->resourceRequest());
     info->setFinalResponse(resource->response());
     if (clearLoadTimings) {
         info->clearLoadTimings();
         info->setLoadFinishTime(info->initialTime());
     } else {
@@ skipping 42 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)
 {
 #if ENABLE(OILPAN)
     ThreadState::current()->registerPreFinalizer(this);
 #endif
 }
 
 ResourceFetcher::~ResourceFetcher()
 {
 #if !ENABLE(OILPAN)
     clearPreloads();
@@ skipping 929 matching lines @@
     visitor->trace(m_archiveResourceCollection);
     visitor->trace(m_loaders);
     visitor->trace(m_nonBlockingLoaders);
 #if ENABLE(OILPAN)
     visitor->trace(m_preloads);
     visitor->trace(m_resourceTimingInfoMap);
 #endif
 }
 
 }