The HTML parser synchronously creates custom elements

third_party/WebKit/Source/core/html/parser/HTMLScriptRunner.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 115 matching lines @@
     }
 
     // Use the URL of the currently active document for this frame.
     return document->frame()->document()->url();
 }
 
 } // namespace
 
 using namespace HTMLNames;
 
-HTMLScriptRunner::HTMLScriptRunner(Document* document, HTMLScriptRunnerHost* host)
-    : m_document(document)
+HTMLScriptRunner::HTMLScriptRunner(HTMLParserReentryPermit* reentryPermit, Document* document, HTMLScriptRunnerHost* host)
+    : m_reentryPermit(reentryPermit)
+    , m_document(document)
     , m_host(host)
     , m_parserBlockingScript(PendingScript::create(nullptr, nullptr))
-    , m_scriptNestingLevel(0)
     , m_hasScriptsWaitingForResources(false)
 {
     ASSERT(m_host);
     ThreadState::current()->registerPreFinalizer(this);
 }
 
 HTMLScriptRunner::~HTMLScriptRunner()
 {
     // Verify that detach() has been called.
     ASSERT(!m_document);
 }
 
 void HTMLScriptRunner::detach()
 {
     if (!m_document)
         return;
 
     m_parserBlockingScript->stopWatchingForLoad();
     m_parserBlockingScript->releaseElementAndClear();
 
     while (!m_scriptsToExecuteAfterParsing.isEmpty()) {
         PendingScript* pendingScript = m_scriptsToExecuteAfterParsing.takeFirst();
         pendingScript->stopWatchingForLoad();
         pendingScript->releaseElementAndClear();
     }
     m_document = nullptr;
+    // m_reentryPermit is not cleared here, because the script runner
+    // may continue to run pending scripts after the parser has
+    // detached.
 }
 
 bool HTMLScriptRunner::isPendingScriptReady(const PendingScript* script)
 {
     m_hasScriptsWaitingForResources = !m_document->isScriptExecutionReady();
     if (m_hasScriptsWaitingForResources)
         return false;
     return script->isReady();
 }
 
@@ skipping 24 matching lines @@
             if (m_hasScriptsWaitingForResources)
                 return;
         }
     }
 
     TextPosition scriptStartPosition = pendingScript->startingPosition();
     double scriptParserBlockingTime = pendingScript->parserBlockingLoadStartTime();
     // Clear the pending script before possible re-entrancy from executeScript()
     Element* element = pendingScript->releaseElementAndClear();
     if (ScriptLoader* scriptLoader = toScriptLoaderIfPossible(element)) {
-        NestingLevelIncrementer nestingLevelIncrementer(m_scriptNestingLevel);
+        HTMLParserReentryPermit::ScriptNestingLevelIncrementer nestingLevelIncrementer = m_reentryPermit->incrementScriptNestingLevel();
         IgnoreDestructiveWriteCountIncrementer ignoreDestructiveWriteCountIncrementer(m_document);
         if (errorOccurred) {
             TRACE_EVENT_WITH_FLOW1("blink", "HTMLScriptRunner ExecuteScriptFailed", element, TRACE_EVENT_FLAG_FLOW_IN,
                 "data", getTraceArgsForScriptElement(element, scriptStartPosition));
             scriptLoader->dispatchErrorEvent();
         } else {
             ASSERT(isExecutingScript());
             if (scriptParserBlockingTime > 0.0) {
                 DocumentParserTiming::from(*m_document).recordParserBlockedOnScriptLoadDuration(monotonicallyIncreasingTime() - scriptParserBlockingTime, scriptLoader->wasCreatedDuringDocumentWrite());
             }
@@ skipping 190 matching lines @@
         ASSERT(scriptLoader);
         if (!scriptLoader)
             return;
 
         ASSERT(scriptLoader->isParserInserted());
 
         if (!isExecutingScript())
             Microtask::performCheckpoint(V8PerIsolateData::mainThreadIsolate());
 
         InsertionPointRecord insertionPointRecord(m_host->inputStream());
-        NestingLevelIncrementer nestingLevelIncrementer(m_scriptNestingLevel);
+        HTMLParserReentryPermit::ScriptNestingLevelIncrementer nestingLevelIncrementer = m_reentryPermit->incrementScriptNestingLevel();
 
         scriptLoader->prepareScript(scriptStartPosition);
 
         if (!scriptLoader->willBeParserExecuted())
             return;
 
         if (scriptLoader->willExecuteWhenDocumentFinishedParsing()) {
             requestDeferredScript(script);
         } else if (scriptLoader->readyToBeParserExecuted()) {
-            if (m_scriptNestingLevel == 1) {
+            if (m_reentryPermit->scriptNestingLevel() == 1u) {
                 m_parserBlockingScript->setElement(script);
                 m_parserBlockingScript->setStartingPosition(scriptStartPosition);
             } else {
-                ASSERT(m_scriptNestingLevel > 1);
+                DCHECK_GT(m_reentryPermit->scriptNestingLevel(), 1u);
                 m_parserBlockingScript->releaseElementAndClear();
                 ScriptSourceCode sourceCode(script->textContent(), documentURLForScriptExecution(m_document), scriptStartPosition);
                 doExecuteScript(script, sourceCode, scriptStartPosition);
             }
         } else {
             requestParsingBlockingScript(script);
         }
     }
 }
 
 DEFINE_TRACE(HTMLScriptRunner)
 {
     visitor->trace(m_document);
     visitor->trace(m_host);
     visitor->trace(m_parserBlockingScript);
     visitor->trace(m_scriptsToExecuteAfterParsing);
     ScriptResourceClient::trace(visitor);
 }
 
 } // namespace blink