Preload tokens even if a <meta> csp tag is found

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 102 matching lines @@
     , m_reentryPermit(HTMLParserReentryPermit::create())
     , m_token(syncPolicy == ForceSynchronousParsing ? wrapUnique(new HTMLToken) : nullptr)
     , m_tokenizer(syncPolicy == ForceSynchronousParsing ? HTMLTokenizer::create(m_options) : nullptr)
     , m_loadingTaskRunner(TaskRunnerHelper::get(TaskType::Networking, &document)->clone())
     , m_parserScheduler(syncPolicy == AllowAsynchronousParsing ? HTMLParserScheduler::create(this, m_loadingTaskRunner.get()) : nullptr)
     , m_xssAuditorDelegate(&document)
     , m_weakFactory(this)
     , m_preloader(HTMLResourcePreloader::create(document))
     , m_tokenizedChunkQueue(TokenizedChunkQueue::create())
     , m_evaluator(DocumentWriteEvaluator::create(document))
+    , m_pendingCSPMetaToken(nullptr)
     , m_shouldUseThreading(syncPolicy == AllowAsynchronousParsing)
     , m_endWasDelayed(false)
     , m_haveBackgroundParser(false)
     , m_tasksWereSuspended(false)
     , m_pumpSessionNestingLevel(0)
     , m_pumpSpeculationsSessionNestingLevel(0)
     , m_isParsingAtLineNumber(false)
     , m_triedLoadingLinkHeaders(false)
 {
     ASSERT(shouldUseThreading() || (m_token && m_tokenizer));
@@ skipping 174 matching lines @@
     // 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 (!m_triedLoadingLinkHeaders && document()->loader() && !pendingChunks.isEmpty()) {
         // Note that on commit, the loader dispatched preloads for all the
         // non-media links.
         document()->loader()->dispatchLinkHeaderPreloads(&pendingChunks.first()->viewport, LinkLoader::OnlyLoadMedia);
         m_triedLoadingLinkHeaders = true;
     }
 
-    if (!document()->documentElement()) {
+    // Defer preloads if any of the chunks contains a <meta> csp tag.
+    for (auto& chunk : pendingChunks) {

[kouhei (in TOK), 2016/08/22 05:34:03]

Can we skip this if(m_pendingCSPToken)? or do we need to update to the next meta
tag?

[Charlie Harrison, 2016/08/22 14:08:05]

I chose to be conservative in this patch and always update the CSP tag. This
ensures that any token after any <meta> csp tag is guaranteed to have its
policies applied.

If we wanted to be looser, we would need to have multiple defer lists.

+        if (chunk->pendingCSPMetaTokenIndex.has_value()) {
+            m_pendingCSPMetaToken = &chunk->tokens->at(chunk->pendingCSPMetaTokenIndex.value());
+        }
+    }
+
+    if (m_pendingCSPMetaToken || !document()->documentElement()) {
         PreloadRequestStream linkRelPreloads;
         for (auto& chunk : pendingChunks) {
             for (auto& request : chunk->preloads) {
-                if (request->isLinkRelPreload())
+                // Link rel preloads don't need to wait for AppCache but they
+                // should probably wait for CSP.
+                if (!m_pendingCSPMetaToken && 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());
             }
         }
@@ skipping 80 matching lines @@
     m_weakFactory.revokeAll();
 
     size_t discardedTokenCount = 0;
     for (const auto& speculation : m_speculations) {
         discardedTokenCount += speculation->tokens->size();
     }
     DEFINE_STATIC_LOCAL(CustomCountHistogram, discardedTokenCountHistogram, ("Parser.DiscardedTokenCount", 1, 100000, 50));
     discardedTokenCountHistogram.count(discardedTokenCount);
 
     m_speculations.clear();
+    m_pendingCSPMetaToken = nullptr;
+    m_queuedPreloads.clear();
 
     std::unique_ptr<BackgroundHTMLParser::Checkpoint> checkpoint = wrapUnique(new BackgroundHTMLParser::Checkpoint);
     checkpoint->parser = m_weakFactory.createWeakPtr();
     checkpoint->token = std::move(token);
     checkpoint->tokenizer = std::move(tokenizer);
     checkpoint->treeBuilderState = HTMLTreeBuilderSimulator::stateFor(m_treeBuilder.get());
     checkpoint->inputCheckpoint = lastChunkBeforeScript->inputCheckpoint;
     checkpoint->preloadScannerCheckpoint = lastChunkBeforeScript->preloadScannerCheckpoint;
     checkpoint->unparsedInput = m_input.current().toString().isolatedCopy();
     m_input.current().clear(); // FIXME: This should be passed in instead of cleared.
@@ skipping 50 matching lines @@
             break;
         }
 
         m_textPosition = it->textPosition();
 
         constructTreeFromCompactHTMLToken(*it);
 
         if (isStopped())
             break;
 
+        // Preloads were queued if there was a <meta> csp token in a tokenized
+        // chunk.
+        if (m_pendingCSPMetaToken && it == m_pendingCSPMetaToken) {
+            m_pendingCSPMetaToken = nullptr;
+            fetchQueuedPreloads();
+        }
+
         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) {
             ASSERT(it + 1 == tokens->end()); // The EOF is assumed to be the last token of this bunch.
             ASSERT(m_speculations.isEmpty()); // There should never be any chunks after the EOF.
@@ skipping 590 matching lines @@
     DecodedDataDocumentParser::setDecoder(std::move(decoder));
 
     if (m_haveBackgroundParser)
         postTaskToLookaheadParser(Asynchronous, &BackgroundHTMLParser::setDecoder, m_backgroundParser, passed(takeDecoder()));
 }
 
 void HTMLDocumentParser::documentElementAvailable()
 {
     TRACE_EVENT0("blink,loader", "HTMLDocumentParser::documentElementAvailable");
     DCHECK(document()->documentElement());
-    if (!m_queuedPreloads.isEmpty())
-        m_preloader->takeAndPreload(m_queuedPreloads);
-
-    for (const String& scriptSource : m_queuedDocumentWriteScripts) {
-        evaluateAndPreloadScriptForDocumentWrite(scriptSource);
-    }
-
-    m_queuedDocumentWriteScripts.clear();
+    fetchQueuedPreloads();
 }
 
 std::unique_ptr<HTMLPreloadScanner> HTMLDocumentParser::createPreloadScanner()
 {
     return HTMLPreloadScanner::create(
         m_options,
         document()->url(),
         CachedDocumentParameters::create(document()),
         MediaValuesCached::MediaValuesCachedData(*document()));
 }
 
+void HTMLDocumentParser::fetchQueuedPreloads()
+{
+    if (m_pendingCSPMetaToken || !document()->documentElement())
+        return;
+
+    if (!m_queuedPreloads.isEmpty())
+        m_preloader->takeAndPreload(m_queuedPreloads);
+
+    for (const String& scriptSource : m_queuedDocumentWriteScripts) {
+        evaluateAndPreloadScriptForDocumentWrite(scriptSource);
+    }
+
+    m_queuedDocumentWriteScripts.clear();
+}
+
 void HTMLDocumentParser::evaluateAndPreloadScriptForDocumentWrite(const String& source)
 {
     if (!m_evaluator->shouldEvaluate(source))
         return;
     document()->loader()->didObserveLoadingBehavior(WebLoadingBehaviorFlag::WebLoadingBehaviorDocumentWriteEvaluator);
     if (!RuntimeEnabledFeatures::documentWriteEvaluatorEnabled())
         return;
     TRACE_EVENT0("blink", "HTMLDocumentParser::evaluateAndPreloadScriptForDocumentWrite");
 
     double initializeStartTime = monotonicallyIncreasingTimeMS();
@@ skipping 41 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