Allow multiple dart <script> tags in .sky files

sky/engine/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 141 matching lines @@
     ASSERT(m_haveBackgroundParser);
     pumpPendingChunks();
 }
 
 void HTMLDocumentParser::runScriptsForPausedTreeBuilder()
 {
     if (m_isFragment)
         return;
     TextPosition scriptStartPosition = TextPosition::belowRangePosition();
     RefPtr<Element> scriptToProcess = m_treeBuilder->takeScriptToProcess(scriptStartPosition);
-    m_scriptRunner.runScript(toHTMLScriptElement(scriptToProcess.get()), scriptStartPosition);
+
+    // Sending the script to dart may find additional 'import' declarations
+    // which need to load before the script can execute.  HTMLScriptRunner
+    // always calls scriptExecutionCompleted regardless of success/failure.
+    m_scriptRunner = HTMLScriptRunner::createForScript(
+        toHTMLScriptElement(scriptToProcess.get()), scriptStartPosition, this);
+    m_scriptRunner->start();
 }
 
 void HTMLDocumentParser::didReceiveParsedChunkFromBackgroundParser(PassOwnPtr<ParsedChunk> chunk)
 {
     TRACE_EVENT0("blink", "HTMLDocumentParser::didReceiveParsedChunkFromBackgroundParser");
     // Sky should not need nested parsers.
     ASSERT(document()->activeParserCount() == 0);
 
-    if (isWaitingForScripts() || !m_pendingChunks.isEmpty() || document()->activeParserCount() > 0 || !document()->haveImportsLoaded()) {
+    if (isWaitingForScripts() || !m_pendingChunks.isEmpty() ||
+        document()->activeParserCount() > 0) {
         m_pendingChunks.append(chunk);
         return;
     }
 
     // processParsedChunkFromBackgroundParser can cause this parser to be detached from the Document,
     // but we need to ensure it isn't deleted yet.
     RefPtr<HTMLDocumentParser> protect(this);
 
     ASSERT(m_pendingChunks.isEmpty());
     m_pendingChunks.append(chunk);
@@ skipping 11 matching lines @@
     ASSERT(!isStopped());
 
     // ASSERT that this object is both attached to the Document and protected.
     ASSERT(refCount() >= 2);
 
     ActiveParserSession session(contextForParsingSession());
 
     OwnPtr<ParsedChunk> chunk(popChunk);
     OwnPtr<CompactHTMLTokenStream> tokens = chunk->tokens.release();
 
-    for (Vector<CompactHTMLToken>::const_iterator it = tokens->begin(); it != tokens->end(); ++it) {
-        ASSERT(!isWaitingForScripts());
+    Vector<CompactHTMLToken>::const_iterator it;
+    for (it = tokens->begin(); it != tokens->end(); ++it) {
+      // A chunk can issue import loads causing us to be isWaitingForScripts
+      // but we don't stop processing in that case.
+      ASSERT(!m_treeBuilder->hasParserBlockingScript());
+      ASSERT(!m_scriptRunner);
 
         m_textPosition = it->textPosition();
 
         constructTreeFromCompactHTMLToken(*it);
 
         if (isStopped())
             break;
 
-        if (isWaitingForScripts()) {
-            ASSERT(it + 1 == tokens->end()); // The </script> is assumed to be the last token of this bunch.
+        if (m_treeBuilder->hasParserBlockingScript()) {
+            ++it; // Make it == end() during non-stopped termination.
+            ASSERT(it == tokens->end());  // The </script> is assumed to be the
+                                          // last token of this bunch.
             runScriptsForPausedTreeBuilder();
             break;
         }
 
         if (it->type() == HTMLToken::EndOfFile) {
-            ASSERT(it + 1 == tokens->end()); // The EOF is assumed to be the last token of this bunch.
+            ++it; // Make it == end() during non-stopped termination.
+            ASSERT(it == tokens->end());  // The EOF is assumed to be the
+                                          // last token of this bunch.
             ASSERT(m_pendingChunks.isEmpty()); // There should never be any chunks after the EOF.
             prepareToStopParsing();
             break;
         }
     }
 
+    // Either we aborted due to stopping or we processed all tokens.
+    ASSERT(isStopped() || it == tokens->end());
+
     // Make sure any pending text nodes are emitted before returning.
     if (!isStopped())
         m_treeBuilder->flush();
 }
 
 void HTMLDocumentParser::pumpPendingChunks()
 {
     // FIXME: Share this constant with the parser scheduler.
     const double parserTimeLimit = 0.500;
 
     // ASSERT that this object is both attached to the Document and protected.
     ASSERT(refCount() >= 2);
     ASSERT(!isWaitingForScripts());
     ASSERT(!isStopped());
-    ASSERT(document()->haveImportsLoaded());
 
     double startTime = currentTime();
 
     while (!m_pendingChunks.isEmpty()) {
         processParsedChunkFromBackgroundParser(m_pendingChunks.takeFirst());
 
         // Always check isStopped first as m_document may be null.
-        if (isStopped() || isWaitingForScripts() || !document()->haveImportsLoaded())
+        if (isStopped() || isWaitingForScripts())
             break;
 
         if (currentTime() - startTime > parserTimeLimit && !m_pendingChunks.isEmpty()) {
             m_parserScheduler->scheduleForResume();
             break;
         }
     }
 }
 
 Document* HTMLDocumentParser::contextForParsingSession()
@@ skipping 86 matching lines @@
 
     if (!m_endWasDelayed || shouldDelayEnd())
         return;
 
     m_endWasDelayed = false;
     prepareToStopParsing();
 }
 
 bool HTMLDocumentParser::isExecutingScript() const
 {
-    return m_scriptRunner.isExecutingScript();
+    // TODO(eseidel): Callers may need updates now that scripts can be async.
+    return m_scriptRunner && m_scriptRunner->isExecutingScript();
 }
 
 OrdinalNumber HTMLDocumentParser::lineNumber() const
 {
     ASSERT(m_haveBackgroundParser);
     return m_textPosition.m_line;
 }
 
 TextPosition HTMLDocumentParser::textPosition() const
 {
     ASSERT(m_haveBackgroundParser);
     return m_textPosition;
 }
 
 bool HTMLDocumentParser::isWaitingForScripts() const
 {
-    return m_treeBuilder->hasParserBlockingScript();
+  return m_treeBuilder->hasParserBlockingScript() || m_scriptRunner ||
+         !document()->haveImportsLoaded();
 }
 
 void HTMLDocumentParser::resumeAfterWaitingForImports()
 {
     RefPtr<HTMLDocumentParser> protect(this);
-    ASSERT(!isExecutingScript());
     ASSERT(!isWaitingForScripts());
     if (m_pendingChunks.isEmpty())
         return;
     ASSERT(m_haveBackgroundParser);
     pumpPendingChunks();
 }
 
+// HTMLScriptRunner has finished executing a script.
+// Just call resumeAfterWaitingForImports since it happens to do what we need.
+void HTMLDocumentParser::scriptExecutionCompleted() {
+  ASSERT(m_scriptRunner);
+  m_scriptRunner.clear();
+  // To avoid re-entering the parser for synchronous scripts, we use a postTask.
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&HTMLDocumentParser::resumeAfterWaitingForImports,
+                            m_weakFactory.GetWeakPtr()));
 }
+}