Improve preload related priorities

third_party/WebKit/Source/platform/loader/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
@@ skipping 139 matching lines @@
   return ResourceLoadPriorityUnresolved;
 }
 
 }  // namespace
 
 ResourceLoadPriority ResourceFetcher::computeLoadPriority(
     Resource::Type type,
     const ResourceRequest& resourceRequest,
     ResourcePriority::VisibilityStatus visibility,
     FetchRequest::DeferOption deferOption,
-    bool speculativePreload) {
+    bool isSpeculativePreload,
+    bool isLinkPreload) {
   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)
+  if (type == Resource::Image && !isLinkPreload)
     m_imageFetched = true;
 
+  // A preloaded font should not take precedence over critical CSS or
+  // parser-blocking scripts.
+  if (type == Resource::Font && isLinkPreload)
+    priority = ResourceLoadPriorityHigh;
+
   if (FetchRequest::IdleLoad == deferOption) {
     priority = ResourceLoadPriorityVeryLow;
   } else if (type == Resource::Script) {
     // 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 (FetchRequest::LazyLoad == deferOption) {
       priority = ResourceLoadPriorityLow;
-    } else if (speculativePreload && m_imageFetched) {
+    } else if (isSpeculativePreload && m_imageFetched) {
       // Speculative preload is used as a signal for scripts at the bottom of
       // the document.
       priority = ResourceLoadPriorityMedium;
     }
   } else if (FetchRequest::LazyLoad == deferOption) {
     priority = ResourceLoadPriorityVeryLow;
   }
 
   // A manually set priority acts as a floor. This is used to ensure that
   // synchronous requests are always given the highest possible priority, as
@@ skipping 277 matching lines @@
 
   context().populateResourceRequest(
       factory.type(), request.clientHintsPreferences(),
       request.getResourceWidth(), resourceRequest);
 
   if (!request.url().isValid())
     return Abort;
 
   resourceRequest.setPriority(computeLoadPriority(
       factory.type(), request.resourceRequest(), ResourcePriority::NotVisible,
-      request.defer(), request.isSpeculativePreload()));
+      request.defer(), request.isSpeculativePreload(),
+      request.isLinkPreload()));
   initializeResourceRequest(resourceRequest, factory.type(), request.defer());
   network_instrumentation::resourcePrioritySet(identifier,
                                                resourceRequest.priority());
 
   blockedReason = context().canRequest(
       factory.type(), resourceRequest,
       MemoryCache::removeFragmentIdentifierIfNeeded(request.url()),
       request.options(),
       /* Don't send security violation reports for speculative preloads */
       request.isSpeculativePreload()
@@ skipping 1052 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