Don't wait for AppCache for link rel preloads

third_party/WebKit/Source/core/html/parser/HTMLDocumentParser.cpp

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 280 matching lines @@
     ASSERT(m_parsedChunkQueue);
 
     Vector<std::unique_ptr<ParsedChunk>> pendingChunks;
     m_parsedChunkQueue->takeAll(pendingChunks);
 
     if (!isParsing())
         return;
 
     // ApplicationCache needs to be initialized before issuing preloads.
     // We suspend preload until HTMLHTMLElement is inserted and
-    // ApplicationCache is initialized.
+    // ApplicationCache is initialized. Note: link rel preloads don't follow
+    // this policy per the spec. These directives should initiate a fetch as
+    // fast as possible.
     if (!document()->documentElement()) {
+        PreloadRequestStream linkRelPreloads;
         for (auto& chunk : pendingChunks) {
-            for (auto& request : chunk->preloads)
-                m_queuedPreloads.append(std::move(request));
+            for (auto& request : chunk->preloads) {

[Yoav Weiss, 2016/07/22 08:43:28]

I don't understand why this waiting is necessary for *any* resource. The
preloadScanner bails out from preloading if AppCache is present. So AFAIUI if we
have preloads here, there's no AppCache.

[Charlie Harrison, 2016/07/22 14:03:22]

My understanding is that the preload scanner just looks for the manifest
attribute on the html element, but I think you can have appcache enabled even
without that check. Looking over the code right now
(WebApplicationCacheHostImpl::selectCacheWithoutManifest) it looks like this
might only happen if the document you loaded was loaded via appcache? Kouhei, do
you have more context for this?

+                if (request->isLinkRelPreload())
+                    linkRelPreloads.append(std::move(request));
+                else
+                    m_queuedPreloads.append(std::move(request));
+            }
             for (auto& index : chunk->likelyDocumentWriteScriptIndices) {
                 const CompactHTMLToken& token = chunk->tokens->at(index);
                 ASSERT(token.type() == HTMLToken::TokenType::Character);
                 m_queuedDocumentWriteScripts.append(token.data());
             }
         }
+        m_preloader->takeAndPreload(linkRelPreloads);
     } else {
         // We can safely assume that there are no queued preloads request after
         // the document element is available, as we empty the queue immediately
         // after the document element is created in documentElementAvailable().
         ASSERT(m_queuedPreloads.isEmpty());
         ASSERT(m_queuedDocumentWriteScripts.isEmpty());
         // Loop through the chunks to generate preloads before any
         // document.write script evaluation takes place. Preloading these
         // scripts is valuable and comparably cheap, while evaluating JS can be
         // expensive.
@@ skipping 140 matching lines @@
         }
 
         m_textPosition = it->textPosition();
 
         constructTreeFromCompactHTMLToken(*it);
 
         if (isStopped())
             break;
 
         if (!m_triedLoadingLinkHeaders && document()->loader()) {
-            String linkHeader = document()->loader()->response().httpHeaderField(HTTPNames::Link);
-            if (!linkHeader.isEmpty()) {
-                ASSERT(chunk);
-                LinkLoader::loadLinksFromHeader(linkHeader, document()->loader()->response().url(),
-                    document(), NetworkHintsInterfaceImpl(), LinkLoader::OnlyLoadResources, &(chunk->viewport));
-                m_triedLoadingLinkHeaders = true;
-            }
+            DCHECK(chunk);
+            // Note that on commit, the loader dispatched preloads for all the
+            // non-media links.
+            document()->loader()->dispatchLinkHeaderPreloads(&chunk->viewport, LinkLoader::OnlyLoadMedia);
+            m_triedLoadingLinkHeaders = true;
         }
 
         if (isWaitingForScripts()) {
             ASSERT(it + 1 == tokens->end()); // The </script> is assumed to be the last token of this bunch.
             runScriptsForPausedTreeBuilder();
             validateSpeculations(std::move(chunk));
             break;
         }
 
         if (it->type() == HTMLToken::EndOfFile) {
@@ skipping 661 matching lines @@
         (*WTF::bind(function, std::forward<Ps>(parameters)...))();
         return;
     case Asynchronous:
         m_loadingTaskRunner->postTask(BLINK_FROM_HERE, WTF::bind(function, std::forward<Ps>(parameters)...));
         return;
     }
     NOTREACHED();
 }
 
 } // namespace blink