[Script Spec Annotation] Annotate and refactor script element's flags

third_party/WebKit/Source/core/dom/ScriptLoader.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2008 Nikolas Zimmermann <zimmermann@kde.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 48 matching lines @@
 #include "wtf/text/StringHash.h"
 
 namespace blink {
 
 ScriptLoader::ScriptLoader(Element* element,
                            bool parserInserted,
                            bool alreadyStarted,
                            bool createdDuringDocumentWrite)
     : m_element(element),
       m_startLineNumber(WTF::OrdinalNumber::beforeFirst()),
+
+      // https://html.spec.whatwg.org/#already-started
+      // "Initially, script elements must have this flag unset"
+      // "The cloning steps for script elements must set the "already started"
+      //  flag on the copy if it is set on the element being cloned."

[kouhei (in TOK), 2017/02/13 21:31:08]

My understanding is that cloning steps are implemented in
{HTML,SVG}ScriptElement::cloneElementWithoutAttributesAndChildren (yes. duped
logic)

[hiroshige, 2017/02/13 21:46:52]

Agree. Added TODO.

+      m_alreadyStarted(alreadyStarted),
+
+      // https://html.spec.whatwg.org/#parser-inserted
+      // "Initially, script elements must have this flag unset."
+      // "It is set by the HTML parser and the XML parser on script elements
+      //  they insert"
       m_parserInserted(parserInserted),
+
+      // https://html.spec.whatwg.org/#non-blocking
+      // "Initially, script elements must have this flag set."
+      // "It is unset by the HTML parser and the XML parser on script
+      // elements they insert.
+      m_nonBlocking(!parserInserted),
+
       m_isExternalScript(false),
-      m_alreadyStarted(alreadyStarted),
       m_haveFiredLoad(false),
       m_willBeParserExecuted(false),
-      m_readyToBeParserExecuted(false),
       m_willExecuteWhenDocumentFinishedParsing(false),
-      m_forceAsync(!parserInserted),
       m_createdDuringDocumentWrite(createdDuringDocumentWrite),
       m_asyncExecType(ScriptRunner::None),
       m_documentWriteIntervention(
           DocumentWriteIntervention::DocumentWriteInterventionNone) {
   DCHECK(m_element);
   if (parserInserted && element->document().scriptableDocumentParser() &&
       !element->document().isInDocumentWrite())
     m_startLineNumber =
         element->document().scriptableDocumentParser()->lineNumber();
 }
@@ skipping 24 matching lines @@
 }
 
 void ScriptLoader::handleSourceAttribute(const String& sourceUrl) {
   if (ignoresLoadRequest() || sourceUrl.isEmpty())
     return;
 
   prepareScript();  // FIXME: Provide a real starting line number here.
 }
 
 void ScriptLoader::handleAsyncAttribute() {
-  m_forceAsync = false;
+  // https://html.spec.whatwg.org/#non-blocking
+  // "In addition, whenever a script element whose "non-blocking" flag is set
+  //  has an async content attribute added, the element's "non-blocking" flag
+  //  must be unset."
+  m_nonBlocking = false;
 }
 
 void ScriptLoader::detach() {
   if (!m_pendingScript)
     return;
   m_pendingScript->dispose();
   m_pendingScript = nullptr;
 }
 
 static bool isLegacySupportedJavaScriptLanguage(const String& language) {
@@ skipping 77 matching lines @@
 
   bool wasParserInserted;
   if (m_parserInserted) {
     wasParserInserted = true;
     m_parserInserted = false;
   } else {
     wasParserInserted = false;
   }
 
   if (wasParserInserted && !client->asyncAttributeValue())
-    m_forceAsync = true;
+    m_nonBlocking = true;
 
   // FIXME: HTML5 spec says we should check that all children are either
   // comments or empty text nodes.
   if (!client->hasSourceAttribute() && !m_element->hasChildren())
     return false;
 
   if (!m_element->isConnected())
     return false;
 
   if (!isScriptTypeSupported(supportLegacyTypes))
     return false;
 
   if (wasParserInserted) {
     m_parserInserted = true;
-    m_forceAsync = false;
+    m_nonBlocking = false;
   }
 
   m_alreadyStarted = true;
 
   // FIXME: If script is parser inserted, verify it's still in the original
   // document.
   Document& elementDocument = m_element->document();
   Document* contextDocument = elementDocument.contextDocument();
 
   if (!contextDocument || !contextDocument->allowExecutingScripts(m_element))
@@ skipping 35 matching lines @@
     m_willExecuteWhenDocumentFinishedParsing = true;
     m_willBeParserExecuted = true;
   } else if (client->hasSourceAttribute() && m_parserInserted &&
              !client->asyncAttributeValue()) {
     m_willBeParserExecuted = true;
   } else if (!client->hasSourceAttribute() && m_parserInserted &&
              !elementDocument.isScriptExecutionReady()) {
     m_willBeParserExecuted = true;
     m_readyToBeParserExecuted = true;
   } else if (client->hasSourceAttribute() && !client->asyncAttributeValue() &&
-             !m_forceAsync) {
+             !m_nonBlocking) {
     m_pendingScript = PendingScript::create(m_element, m_resource.get());
     m_asyncExecType = ScriptRunner::InOrder;
     contextDocument->scriptRunner()->queueScriptForExecution(this,
                                                              m_asyncExecType);
     // Note that watchForLoad can immediately call pendingScriptFinished.
     m_pendingScript->watchForLoad(this);
   } else if (client->hasSourceAttribute()) {
     m_pendingScript = PendingScript::create(m_element, m_resource.get());
     m_asyncExecType = ScriptRunner::Async;
     LocalFrame* frame = m_element->document().frame();
@@ skipping 343 matching lines @@
   if (isHTMLScriptLoader(element))
     return toHTMLScriptElement(element)->loader();
 
   if (isSVGScriptLoader(element))
     return toSVGScriptElement(element)->loader();
 
   return 0;
 }
 
 }  // namespace blink