Possibly merge consecutive script fragments to reduce execution overhead

third_party/WebKit/Source/core/html/parser/HTMLTokenizer.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2009 Torch Mobile, Inc. http://www.torchmobile.com/
  * 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.
@@ skipping 212 matching lines @@
       else if (cc == kEndOfFileMarker)
         return emitEndOfFile(source);
       else {
         bufferCharacter(cc);
         HTML_ADVANCE_TO(RAWTEXTState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(ScriptDataState) {
-      if (cc == '<')
-        HTML_ADVANCE_TO(ScriptDataLessThanSignState);
+      if (cc == '<') {
+        if (checkIfMergeScripts(source))
+          HTML_ADVANCE_TO(ScriptDataState);
+        else
+          HTML_ADVANCE_TO(ScriptDataLessThanSignState);
+      }
       else if (cc == kEndOfFileMarker)
         return emitEndOfFile(source);
       else {
         bufferCharacter(cc);
         HTML_ADVANCE_TO(ScriptDataState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(PLAINTEXTState) {
@@ skipping 51 matching lines @@
         HTML_RECONSUME_IN(BogusCommentState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(TagNameState) {
       if (isTokenizerWhitespace(cc))
         HTML_ADVANCE_TO(BeforeAttributeNameState);
       else if (cc == '/')
         HTML_ADVANCE_TO(SelfClosingStartTagState);
-      else if (cc == '>')
+      else if (cc == '>') {
+        if ((m_token->type() == HTMLToken::StartTag) && threadSafeMatch(attemptStaticStringCreation(m_token->name(), Likely8Bit), scriptTag))
+          reserveAttributeForCheck();
         return emitAndResumeIn(source, HTMLTokenizer::DataState);
-      else if (isASCIIUpper(cc)) {
+      } else if (isASCIIUpper(cc)) {
         m_token->appendToName(toLowerCase(cc));
         HTML_ADVANCE_TO(TagNameState);
       } else if (cc == kEndOfFileMarker) {
         parseError();
         HTML_RECONSUME_IN(DataState);
       } else {
         m_token->appendToName(cc);
         HTML_ADVANCE_TO(TagNameState);
       }
     }
@@ skipping 479 matching lines @@
         m_token->endAttributeName(source.numberOfCharactersConsumed());
         HTML_ADVANCE_TO(AfterAttributeNameState);
       } else if (cc == '/') {
         m_token->endAttributeName(source.numberOfCharactersConsumed());
         HTML_ADVANCE_TO(SelfClosingStartTagState);
       } else if (cc == '=') {
         m_token->endAttributeName(source.numberOfCharactersConsumed());
         HTML_ADVANCE_TO(BeforeAttributeValueState);
       } else if (cc == '>') {
         m_token->endAttributeName(source.numberOfCharactersConsumed());
+        if ((m_token->type() == HTMLToken::StartTag) && threadSafeMatch(attemptStaticStringCreation(m_token->name(), Likely8Bit), scriptTag))
+          reserveAttributeForCheck();
         return emitAndResumeIn(source, HTMLTokenizer::DataState);
       } else if (isASCIIUpper(cc)) {
         m_token->appendToAttributeName(toLowerCase(cc));
         HTML_ADVANCE_TO(AttributeNameState);
       } else if (cc == kEndOfFileMarker) {
         parseError();
         m_token->endAttributeName(source.numberOfCharactersConsumed());
         HTML_RECONSUME_IN(DataState);
       } else {
         if (cc == '"' || cc == '\'' || cc == '<' || cc == '=')
@@ skipping 147 matching lines @@
       else
         ASSERT_NOT_REACHED();
     }
     END_STATE()
 
     HTML_BEGIN_STATE(AfterAttributeValueQuotedState) {
       if (isTokenizerWhitespace(cc))
         HTML_ADVANCE_TO(BeforeAttributeNameState);
       else if (cc == '/')
         HTML_ADVANCE_TO(SelfClosingStartTagState);
-      else if (cc == '>')
+      else if (cc == '>') {
+        if ((m_token->type() == HTMLToken::StartTag) && threadSafeMatch(attemptStaticStringCreation(m_token->name(), Likely8Bit), scriptTag))
+          reserveAttributeForCheck();
         return emitAndResumeIn(source, HTMLTokenizer::DataState);
-      else if (cc == kEndOfFileMarker) {
+      } else if (cc == kEndOfFileMarker) {
         parseError();
         HTML_RECONSUME_IN(DataState);
       } else {
         parseError();
         HTML_RECONSUME_IN(BeforeAttributeNameState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(SelfClosingStartTagState) {
@@ skipping 562 matching lines @@
     setState(HTMLTokenizer::ScriptDataState);
   else if (threadSafeMatch(tagName, styleTag) ||
            threadSafeMatch(tagName, iframeTag) ||
            threadSafeMatch(tagName, xmpTag) ||
            (threadSafeMatch(tagName, noembedTag) && m_options.pluginsEnabled) ||
            threadSafeMatch(tagName, noframesTag) ||
            (threadSafeMatch(tagName, noscriptTag) && m_options.scriptEnabled))
     setState(HTMLTokenizer::RAWTEXTState);
 }
 
+void HTMLTokenizer::reserveAttributeForCheck() {
+    m_temporaryAttributeList = m_token->attributes();
+}
+
+bool HTMLTokenizer::checkIfMergeScripts(SegmentedString& source) {
+  unsigned scriptEndTagLength = 9;
+  unsigned scriptStartTagLength = 7;
+  String currentSubstring = source.getCurrentSubstring(scriptEndTagLength);
+  if (source.isEqualToScriptEndTagTemplate(currentSubstring)) {
+    unsigned index = scriptEndTagLength - 1;
+    while (true) {
+      UChar cc = source.getCurrentString().getCharByIndex(++index);
+      if (isTokenizerWhitespace(cc))
+        continue;
+      if (cc == '<') {
+        currentSubstring = source.getCurrentSubstring(index, scriptStartTagLength);
+        if (source.isEqualToScriptStartTagTemplate(currentSubstring)) {
+          index += scriptStartTagLength;
+          cc = source.getCurrentString().getCharByIndex(index);
+          if (cc == '>' && m_temporaryAttributeList.isEmpty()) {
+            //Merge <script> ... </script> <script>
+            for (unsigned it = 0; it < index; it++)
+              source.advanceAndUpdateLineNumber();
+            return true;
+          } else if (cc != '>' && !m_temporaryAttributeList.isEmpty()) {
+            // parse attribute name and value
+            if (compareAttribute(source, index)) {
+              for (unsigned it = 0; it < index; it++)
+                source.advanceAndUpdateLineNumber();
+              m_temporaryAttributeValueBuffer.clear();
+              return true;
+            } else {
+              m_temporaryAttributeList.clear();
+              m_temporaryAttributeValueBuffer.clear();
+              return false;
+            }
+          } else
+            break;
+        }
+        break;
+      }
+      break;
+    }
+    m_temporaryAttributeList.clear();
+  }
+  return false;
+}
+
+bool HTMLTokenizer::compareAttribute(SegmentedString& source, unsigned& index) {
+  UChar cc;
+  String currentSubstring;
+  unsigned attributeCount = 0;
+
+  while (true) {
+    cc = source.getCurrentString().getCharByIndex(++index);
+    if (isTokenizerWhitespace(cc))
+      continue;
+    if (isASCIIUpper(cc))
+      toLowerCase(cc);
+    if (isASCIILower(cc)) {
+      // 'src' attribute, shouldn't merge scripts if exists
+      if (cc == 's') {
+        currentSubstring = source.getCurrentSubstring(index, srcAttr.localName().length());
+        if (getAttributeFromList(srcAttr) || threadSafeMatch(currentSubstring, srcAttr)) {
+          return false;
+        }
+      } else if (cc == 't') {
+        // 'type' attribute
+        currentSubstring = source.getCurrentSubstring(index, typeAttr.localName().length());
+        if (getAttributeFromList(typeAttr) && threadSafeMatch(currentSubstring, typeAttr)) {
+          ++attributeCount;
+          index += typeAttr.localName().length() - 1;
+          if (compareAttributeValue(source, index, typeAttr))
+            continue;
+          else
+            return false;
+        } else
+          return false;
+      } else if (cc == 'c') {
+        // 'charset' attribute
+        currentSubstring = source.getCurrentSubstring(index, charsetAttr.localName().length());
+        if (getAttributeFromList(charsetAttr) && threadSafeMatch(currentSubstring, charsetAttr)) {
+          ++attributeCount;
+          index += charsetAttr.localName().length() - 1;
+          if (compareAttributeValue(source, index, charsetAttr))
+            continue;
+          else
+            return false;
+        } else
+          return false;
+      } else if (cc == 'l') {
+        // 'language' attribute
+        currentSubstring = source.getCurrentSubstring(index, languageAttr.localName().length());
+        if (getAttributeFromList(languageAttr) && threadSafeMatch(currentSubstring, languageAttr)) {
+          ++attributeCount;
+          index += languageAttr.localName().length() - 1;
+          if (compareAttributeValue(source, index, languageAttr))
+            continue;
+          else
+            return false;
+        } else
+          return false;
+      } else
+        return false;
+    }
+    if (cc == '>') {
+      if (m_temporaryAttributeList.size() > attributeCount)
+        return false;
+      break;
+    }
+  }
+  return true;
+}
+
+bool HTMLTokenizer::compareAttributeValue(SegmentedString& source, unsigned& index, const QualifiedName& qName) {
+  UChar cc;
+  bool singleQuotedAttributeValueStarts = false;
+  bool doubleQuotedAttributeValueStarts = false;
+  m_temporaryAttributeValueBuffer.clear();
+
+  while (true) {
+    cc = source.getCurrentString().getCharByIndex(++index);
+    if (singleQuotedAttributeValueStarts || doubleQuotedAttributeValueStarts) {
+      if (cc == '"' || cc == '\'')
+        break;
+      else if (isASCIIUpper(cc))
+        toLowerCase(cc);
+      m_temporaryAttributeValueBuffer.append(cc);
+    } else if (isTokenizerWhitespace(cc) || cc == '=')
+      continue;
+    else if ( cc == '\'' && !singleQuotedAttributeValueStarts) {
+      singleQuotedAttributeValueStarts = true;
+      continue;
+    } else if ( cc == '"' && !doubleQuotedAttributeValueStarts) {
+      doubleQuotedAttributeValueStarts = true;
+      continue;
+    } else
+      break;
+  }
+  const HTMLToken::Attribute* comparedAttribute = getAttributeFromList(qName);
+  String comparedAttributeValue(comparedAttribute->value());
+  return equalIgnoringCase(comparedAttributeValue, String(m_temporaryAttributeValueBuffer));
+}
+
 inline bool HTMLTokenizer::temporaryBufferIs(const String& expectedString) {
   return vectorEqualsString(m_temporaryBuffer, expectedString);
 }
 
 inline void HTMLTokenizer::addToPossibleEndTag(LChar cc) {
   ASSERT(isEndTagBufferingState(m_state));
   m_bufferedEndTagName.append(cc);
 }
 
 inline bool HTMLTokenizer::isAppropriateEndTag() {
   if (m_bufferedEndTagName.size() != m_appropriateEndTagName.size())
     return false;
 
   size_t numCharacters = m_bufferedEndTagName.size();
 
   for (size_t i = 0; i < numCharacters; i++) {
     if (m_bufferedEndTagName[i] != m_appropriateEndTagName[i])
       return false;
   }
 
   return true;
 }
 
 inline void HTMLTokenizer::parseError() {
   DVLOG(1) << "Not implemented.";
 }
 
 }  // namespace blink