Link prefetch fetches deferred until onload

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 244 matching lines @@
       // loadingTaskRunner() is null in tests that use the null fetch context.
       m_resourceTimingReportTimer(
           context().loadingTaskRunner()
               ? context().loadingTaskRunner()
               : Platform::current()->currentThread()->getWebTaskRunner(),
           this,
           &ResourceFetcher::resourceTimingReportTimerFired),
       m_autoLoadImages(true),
       m_imagesEnabled(true),
       m_allowStaleResources(false),
-      m_imageFetched(false) {}
+      m_imageFetched(false),
+      m_onloadDeferredResourcesLoaded(false) {}
 
 ResourceFetcher::~ResourceFetcher() {}
 
 Resource* ResourceFetcher::cachedResource(const KURL& resourceURL) const {
   KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(resourceURL);
   const WeakMember<Resource>& resource = m_documentResources.at(url);
   return resource.get();
 }
 
 bool ResourceFetcher::isControlledByServiceWorker() const {
   return context().isControlledByServiceWorker();
 }
 
 bool ResourceFetcher::resourceNeedsLoad(Resource* resource,
                                         const FetchRequest& request,
                                         RevalidationPolicy policy) {
   // Defer a font load until it is actually needed unless this is a link
   // preload.
   if (resource->getType() == Resource::Font && !request.isLinkPreload())
     return false;
   if (resource->isImage() && shouldDeferImageLoad(resource->url()))
     return false;
+  if (resource->getType() == Resource::LinkPrefetch &&
+      !m_onloadDeferredResourcesLoaded) {
+    if (!m_onloadDeferredResources)
+      m_onloadDeferredResources = new HeapVector<Member<Resource>>;
+    m_onloadDeferredResources->push_back(resource);
+    return false;
+  }
   return policy != Use || resource->stillNeedsLoad();
 }
 
 // Limit the number of URLs in m_validatedURLs to avoid memory bloat.
 // http://crbug.com/52411
 static const int kMaxValidatedURLsSize = 10000;
 
 void ResourceFetcher::requestLoadStarted(unsigned long identifier,
                                          Resource* resource,
                                          const FetchRequest& request,
@@ skipping 744 matching lines @@
 }
 
 void ResourceFetcher::reloadImagesIfNotDeferred() {
   for (Resource* resource : m_documentResources.values()) {
     if (resource->getType() == Resource::Image && resource->stillNeedsLoad() &&
         !shouldDeferImageLoad(resource->url()))
       startLoad(resource);
   }
 }
 
+void ResourceFetcher::loadOnloadDeferredResources() {
+  if (!m_onloadDeferredResources)
+    return;
+  for (auto& resource : *m_onloadDeferredResources) {
+    if (resource->stillNeedsLoad())
+      startLoad(resource);
+  }
+  m_onloadDeferredResources->clear();
+  m_onloadDeferredResourcesLoaded = true;
+}
+
 void ResourceFetcher::clearContext() {
   clearPreloads(ResourceFetcher::ClearAllPreloads);
   m_context.clear();
 }
 
 int ResourceFetcher::requestCount() const {
   return m_loaders.size();
 }
 
 bool ResourceFetcher::hasPendingRequest() const {
@@ skipping 480 matching lines @@
   }
 }
 
 DEFINE_TRACE(ResourceFetcher) {
   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_onloadDeferredResources);
   visitor->trace(m_resourceTimingInfoMap);
 }
 
 }  // namespace blink