Don't lower priority for scripts inserted by doc.write

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 140 matching lines @@
   return kResourceLoadPriorityUnresolved;
 }
 
 }  // namespace
 
 ResourceLoadPriority ResourceFetcher::ComputeLoadPriority(
     Resource::Type type,
     const ResourceRequest& resource_request,
     ResourcePriority::VisibilityStatus visibility,
     FetchParameters::DeferOption defer_option,
-    bool is_speculative_preload,
+    FetchParameters::SpeculativePreloadType speculative_preload_type,
     bool is_link_preload) {
   ResourceLoadPriority priority = TypeToPriority(type);
 
   // Visible resources (images in practice) get a boost to High priority.
   if (visibility == ResourcePriority::kVisible)
     priority = kResourceLoadPriorityHigh;
 
   // 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
@@ skipping 10 matching lines @@
   if (FetchParameters::kIdleLoad == defer_option) {
     priority = kResourceLoadPriorityVeryLow;
   } else if (type == Resource::kScript) {
     // 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 (FetchParameters::kLazyLoad == defer_option) {
       priority = kResourceLoadPriorityLow;
-    } else if (is_speculative_preload && image_fetched_) {
+    } else if (speculative_preload_type ==
+                   FetchParameters::SpeculativePreloadType::kInDocument &&
+               image_fetched_) {
       // Speculative preload is used as a signal for scripts at the bottom of
       // the document.
       priority = kResourceLoadPriorityMedium;
     }
   } else if (FetchParameters::kLazyLoad == defer_option) {
     priority = kResourceLoadPriorityVeryLow;
   }
 
   // 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 300 matching lines @@
   Context().PopulateResourceRequest(
       factory.GetType(), params.GetClientHintsPreferences(),
       params.GetResourceWidth(), resource_request);
 
   if (!params.Url().IsValid())
     return kAbort;
 
   resource_request.SetPriority(ComputeLoadPriority(
       factory.GetType(), params.GetResourceRequest(),
       ResourcePriority::kNotVisible, params.Defer(),
-      params.IsSpeculativePreload(), params.IsLinkPreload()));
+      params.GetSpeculativePreloadType(), params.IsLinkPreload()));
   InitializeResourceRequest(resource_request, factory.GetType(),
                             params.Defer());
   network_instrumentation::resourcePrioritySet(identifier,
                                                resource_request.Priority());
 
   blocked_reason = Context().CanRequest(
       factory.GetType(), resource_request,
       MemoryCache::RemoveFragmentIdentifierIfNeeded(params.Url()),
       params.Options(),
       /* Don't send security violation reports for speculative preloads */
@@ skipping 1053 matching lines @@
   visitor->Trace(context_);
   visitor->Trace(archive_);
   visitor->Trace(loaders_);
   visitor->Trace(non_blocking_loaders_);
   visitor->Trace(document_resources_);
   visitor->Trace(preloads_);
   visitor->Trace(resource_timing_info_map_);
 }
 
 }  // namespace blink