Remove the concept of pendingScripts from HTMLScriptRunner

sky/engine/core/html/parser/BackgroundHTMLParser.cpp

 /*
  * Copyright (C) 2013 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 95 matching lines @@
     pumpTokenizer();
 }
 
 void BackgroundHTMLParser::markEndOfFile()
 {
     ASSERT(!m_input.isClosed());
     m_input.append(SegmentedString(String(&kEndOfFileMarker, 1)));
     m_input.close();
 }
 
-bool BackgroundHTMLParser::updateTokenizerState(const CompactHTMLToken& token)
+BackgroundHTMLParser::ContinueBehavior BackgroundHTMLParser::updateTokenizerState(const CompactHTMLToken& lastToken)
 {
-    if (token.type() == HTMLToken::StartTag) {
-        const String& tagName = token.data();
+    if (lastToken.type() == HTMLToken::StartTag) {
+        const String& tagName = lastToken.data();
 
         if (threadSafeMatch(tagName, HTMLNames::scriptTag) || threadSafeMatch(tagName, HTMLNames::styleTag))
             m_tokenizer->setState(HTMLTokenizer::RawDataState);
 
         if (threadSafeMatch(tagName, HTMLNames::importTag)) {
             m_state = DidSeeImportState;
-            return true;
+            return ContinueParsing;
         }
 
         if (m_state == InitialState)
-            return true;
+            return ContinueParsing;
 
+        // If we hit a start tag which is not an <import> tag while in the
+        // have-seen-import state, we need to send all but the last token.
+        // This lets the main thread see all import tags in one chunk.
+        // TODO(eseidel): We could replace this with a preloader and then
+        // simply yield after every </import> regardless.
         m_state = InitialState;
-        return false;
+        return SendTokensExceptingLast;
     }
 
-    return token.type() != HTMLToken::EndTag || !threadSafeMatch(token.data(), HTMLNames::scriptTag);
+    // We send all tokens at the end of every </script>
+    if (lastToken.type() == HTMLToken::EndTag && threadSafeMatch(lastToken.data(), HTMLNames::scriptTag))
+        return SendTokensIncludingLast;
+
+    return ContinueParsing;
 }
 
 void BackgroundHTMLParser::pumpTokenizer()
 {
     while (true) {
         if (!m_tokenizer->nextToken(m_input, *m_token)) {
             // We've reached the end of our current input.
             sendTokensToMainThread();
             break;
         }
 
+        ContinueBehavior result;
         {
             CompactHTMLToken token(m_token.get(), TextPosition(m_input.currentLine(), m_input.currentColumn()));
+            result = updateTokenizerState(token);
+            if (result ==  SendTokensExceptingLast)
+                sendTokensToMainThread();
+
             m_pendingTokens->append(token);
         }
 
         m_token->clear();
 
-        if (!updateTokenizerState(m_pendingTokens->last()) || m_pendingTokens->size() >= pendingTokenLimit)
+        if (result == SendTokensIncludingLast || m_pendingTokens->size() >= pendingTokenLimit)
             sendTokensToMainThread();
     }
 }
 
 void BackgroundHTMLParser::sendTokensToMainThread()
 {
     if (m_pendingTokens->isEmpty())
         return;
 
 #if ENABLE(ASSERT)
     checkThatTokensAreSafeToSendToAnotherThread(m_pendingTokens.get());
 #endif
 
     OwnPtr<HTMLDocumentParser::ParsedChunk> chunk = adoptPtr(new HTMLDocumentParser::ParsedChunk);
     chunk->tokens = m_pendingTokens.release();
     Platform::current()->mainThreadTaskRunner()->PostTask(FROM_HERE,
         base::Bind(&HTMLDocumentParser::didReceiveParsedChunkFromBackgroundParser, m_parser, chunk.release()));
 
     m_pendingTokens = adoptPtr(new CompactHTMLTokenStream);
 }
 
 }