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

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 704 matching lines @@
 
   if (IsPaused()) {
     DCHECK_EQ(tokenizer_->GetState(), HTMLTokenizer::kDataState);
 
     DCHECK(preloader_);
     // TODO(kouhei): m_preloader should be always available for synchronous
     // parsing case, adding paranoia if for speculative crash fix for
     // crbug.com/465478
     if (preloader_) {
       if (!preload_scanner_) {
-        preload_scanner_ = CreatePreloadScanner();
+        preload_scanner_ = CreatePreloadScanner(
+            TokenPreloadScanner::ScannerType::kMainDocument);
         preload_scanner_->AppendToEnd(input_.Current());
       }
       ScanAndPreload(preload_scanner_.get());
     }
   }
 }
 
 void HTMLDocumentParser::ConstructTreeFromHTMLToken() {
   AtomicHTMLToken atomic_token(Token());
 
@@ skipping 54 matching lines @@
   }
 
   SegmentedString excluded_line_number_source(source);
   excluded_line_number_source.SetExcludeLineNumbers();
   input_.InsertAtCurrentInsertionPoint(excluded_line_number_source);
   PumpTokenizerIfPossible();
 
   if (IsPaused()) {
     // Check the document.write() output with a separate preload scanner as
     // the main scanner can't deal with insertions.
-    if (!insertion_preload_scanner_)
-      insertion_preload_scanner_ = CreatePreloadScanner();
+    if (!insertion_preload_scanner_) {
+      insertion_preload_scanner_ =
+          CreatePreloadScanner(TokenPreloadScanner::ScannerType::kInsertion);
+    }
     insertion_preload_scanner_->AppendToEnd(source);
     ScanAndPreload(insertion_preload_scanner_.get());
   }
 
   EndIfDelayed();
 }
 
 void HTMLDocumentParser::StartBackgroundParser() {
   DCHECK(!IsStopped());
   DCHECK(ShouldUseThreading());
@@ skipping 76 matching lines @@
 
   // We should never reach this point if we're using a parser thread, as
   // appendBytes() will directly ship the data to the thread.
   DCHECK(!ShouldUseThreading());
 
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.debug"),
                "HTMLDocumentParser::append", "size", input_source.length());
   const SegmentedString source(input_source);
 
   if (GetDocument()->IsPrefetchOnly()) {
-    if (!preload_scanner_)
-      preload_scanner_ = CreatePreloadScanner();
+    if (!preload_scanner_) {
+      preload_scanner_ =
+          CreatePreloadScanner(TokenPreloadScanner::ScannerType::kMainDocument);
+    }
 
     preload_scanner_->AppendToEnd(source);
     ScanAndPreload(preload_scanner_.get());
 
     // Return after the preload scanner, do not actually parse the document.
     return;
   }
 
   if (preload_scanner_) {
     if (input_.Current().IsEmpty() && !IsPaused()) {
@@ skipping 335 matching lines @@
                   WTF::Passed(TakeDecoder())));
   }
 }
 
 void HTMLDocumentParser::DocumentElementAvailable() {
   TRACE_EVENT0("blink,loader", "HTMLDocumentParser::documentElementAvailable");
   DCHECK(GetDocument()->documentElement());
   FetchQueuedPreloads();
 }
 
-std::unique_ptr<HTMLPreloadScanner> HTMLDocumentParser::CreatePreloadScanner() {
+std::unique_ptr<HTMLPreloadScanner> HTMLDocumentParser::CreatePreloadScanner(
+    TokenPreloadScanner::ScannerType scanner_type) {
   return HTMLPreloadScanner::Create(
       options_, GetDocument()->Url(),
       CachedDocumentParameters::Create(GetDocument()),
-      MediaValuesCached::MediaValuesCachedData(*GetDocument()));
+      MediaValuesCached::MediaValuesCachedData(*GetDocument()), scanner_type);
 }
 
 void HTMLDocumentParser::ScanAndPreload(HTMLPreloadScanner* scanner) {
   PreloadRequestStream requests =
       scanner->Scan(GetDocument()->ValidBaseElementURL(), nullptr);
   preloader_->TakeAndPreload(requests);
 }
 
 void HTMLDocumentParser::FetchQueuedPreloads() {
   if (pending_csp_meta_token_ || !GetDocument()->documentElement())
@@ skipping 25 matching lines @@
   double initialization_duration =
       MonotonicallyIncreasingTimeMS() - initialize_start_time;
 
   double start_time = MonotonicallyIncreasingTimeMS();
   String written_source = evaluator_->EvaluateAndEmitWrittenSource(source);
   double duration = MonotonicallyIncreasingTimeMS() - start_time;
 
   int current_preload_count =
       GetDocument()->Loader()->Fetcher()->CountPreloads();
 
-  std::unique_ptr<HTMLPreloadScanner> scanner = CreatePreloadScanner();
+  std::unique_ptr<HTMLPreloadScanner> scanner =
+      CreatePreloadScanner(TokenPreloadScanner::ScannerType::kInsertion);
   scanner->AppendToEnd(SegmentedString(written_source));
   ScanAndPreload(scanner.get());
 
   int num_preloads = GetDocument()->Loader()->Fetcher()->CountPreloads() -
                      current_preload_count;
 
   TRACE_EVENT_INSTANT2(
       "blink",
       "HTMLDocumentParser::evaluateAndPreloadScriptForDocumentWrite.data",
       TRACE_EVENT_SCOPE_THREAD, "numPreloads", num_preloads, "scriptLength",
@@ skipping 13 matching lines @@
     success_histogram.Count(duration);
   } else {
     DEFINE_STATIC_LOCAL(
         CustomCountHistogram, failure_histogram,
         ("PreloadScanner.DocumentWrite.ExecutionTime.Failure", 1, 10000, 50));
     failure_histogram.Count(duration);
   }
 }
 
 }  // namespace blink