Turn VTTToken into an immutable object

Source/core/html/track/vtt/VTTTokenizer.cpp

 /*
  * Copyright (C) 2011 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #include "core/html/track/vtt/VTTTokenizer.h"
 
 #include "core/xml/parser/MarkupTokenizerInlines.h"
+#include "wtf/text/StringBuilder.h"
 #include "wtf/unicode/CharacterNames.h"
 
 namespace WebCore {
 
 #define WEBVTT_BEGIN_STATE(stateName) BEGIN_STATE(VTTTokenizerState, stateName)
 #define WEBVTT_ADVANCE_TO(stateName) ADVANCE_TO(VTTTokenizerState, stateName)
 
 template<unsigned charactersCount>
 ALWAYS_INLINE bool equalLiteral(const StringBuilder& s, const char (&characters)[charactersCount])
 {
     return WTF::equal(s, reinterpret_cast<const LChar*>(characters), charactersCount - 1);
 }
 
+static void addNewClass(StringBuilder& classes, const StringBuilder& newClass)
+{
+    if (!classes.isEmpty())
+        classes.append(' ');
+    classes.append(newClass);
+}
+
 VTTTokenizer::VTTTokenizer(const String& input)
     : m_input(input)
     , m_inputStreamPreprocessor(this)
 {
     reset();
 
     // Append a EOF marker and close the input "stream".
     ASSERT(!m_input.isClosed());
     m_input.append(SegmentedString(String(&kEndOfFileMarker, 1)));
     m_input.close();
 }
 
 void VTTTokenizer::reset()
 {
     m_token = 0;
-    m_buffer.clear();
 }
 
 bool VTTTokenizer::nextToken(VTTToken& token)
 {
     // If we have a token in progress, then we're supposed to be called back
     // with the same token so we can finish it.
     ASSERT(!m_token || m_token == &token);
     m_token = &token;
 
     if (m_input.isEmpty() || !m_inputStreamPreprocessor.peek(m_input))
         return haveBufferedCharacterToken();
 
     UChar cc = m_inputStreamPreprocessor.nextInputCharacter();
     if (cc == kEndOfFileMarker) {
         m_inputStreamPreprocessor.advance(m_input);
         return false;
     }
 
+    StringBuilder buffer;
+    StringBuilder result;
+    StringBuilder classes;
     m_state = VTTTokenizerState::DataState;
 
     // The ADVANCE_TO helper macros expect this name ('source') on the input variable.
     SegmentedString& source = m_input;
 
     // 4.8.10.13.4 WebVTT cue text tokenizer
     switch (m_state) {
         WEBVTT_BEGIN_STATE(DataState) {
             if (cc == '&') {
-                m_buffer.append(static_cast<LChar>(cc));
+                buffer.append(static_cast<LChar>(cc));
                 WEBVTT_ADVANCE_TO(EscapeState);
             } else if (cc == '<') {
-                if (m_token->characters().isEmpty()) {
+                if (result.isEmpty()) {
                     WEBVTT_ADVANCE_TO(TagState);
                 } else {
                     // We don't want to advance input or perform a state transition - just return a (new) token.
                     // (On the next call to nextToken we will see '<' again, but take the other branch in this if instead.)
-                    return emitToken(VTTTokenTypes::Character);
+                    return emitToken(VTTToken::StringToken(result.toString()));
                 }
             } else if (cc == kEndOfFileMarker) {
-                return advanceAndEmitToken(source, VTTTokenTypes::Character);
+                return advanceAndEmitToken(source, VTTToken::StringToken(result.toString()));
             } else {
-                m_token->appendToData(cc);
+                result.append(cc);
                 WEBVTT_ADVANCE_TO(DataState);
             }
         }
         END_STATE()
 
         WEBVTT_BEGIN_STATE(EscapeState) {
             if (cc == ';') {
-                if (equalLiteral(m_buffer, "&amp")) {
-                    m_token->appendToData('&');
-                } else if (equalLiteral(m_buffer, "&lt")) {
-                    m_token->appendToData('<');
-                } else if (equalLiteral(m_buffer, "&gt")) {
-                    m_token->appendToData('>');
-                } else if (equalLiteral(m_buffer, "&lrm")) {
-                    m_token->appendToData(leftToRightMark);
-                } else if (equalLiteral(m_buffer, "&rlm")) {
-                    m_token->appendToData(rightToLeftMark);
-                } else if (equalLiteral(m_buffer, "&nbsp")) {
-                    m_token->appendToData(noBreakSpace);
+                if (equalLiteral(buffer, "&amp")) {
+                    result.append('&');
+                } else if (equalLiteral(buffer, "&lt")) {
+                    result.append('<');
+                } else if (equalLiteral(buffer, "&gt")) {
+                    result.append('>');
+                } else if (equalLiteral(buffer, "&lrm")) {
+                    result.append(leftToRightMark);
+                } else if (equalLiteral(buffer, "&rlm")) {
+                    result.append(rightToLeftMark);
+                } else if (equalLiteral(buffer, "&nbsp")) {
+                    result.append(noBreakSpace);
                 } else {
-                    m_buffer.append(static_cast<LChar>(cc));
-                    m_token->appendToData(m_buffer);
+                    buffer.append(static_cast<LChar>(cc));
+                    result.append(buffer);
                 }
-                m_buffer.clear();
+                buffer.clear();
                 WEBVTT_ADVANCE_TO(DataState);
             } else if (isASCIIAlphanumeric(cc)) {
-                m_buffer.append(static_cast<LChar>(cc));
+                buffer.append(static_cast<LChar>(cc));
                 WEBVTT_ADVANCE_TO(EscapeState);
             } else if (cc == kEndOfFileMarker) {
-                m_token->appendToData(m_buffer);
-                return advanceAndEmitToken(source, VTTTokenTypes::Character);
+                result.append(buffer);
+                return advanceAndEmitToken(source, VTTToken::StringToken(result.toString()));
             } else {
-                if (!equalLiteral(m_buffer, "&"))
-                    m_token->appendToData(m_buffer);
-                m_buffer.clear();
+                if (!equalLiteral(buffer, "&"))
+                    result.append(buffer);
+                buffer.clear();
                 WEBVTT_ADVANCE_TO(DataState);
             }
         }
         END_STATE()
 
         WEBVTT_BEGIN_STATE(TagState) {
             if (isTokenizerWhitespace(cc)) {
-                ASSERT(m_token->name().isEmpty());
+                ASSERT(result.isEmpty());
                 WEBVTT_ADVANCE_TO(StartTagAnnotationState);
             } else if (cc == '.') {
-                ASSERT(m_token->name().isEmpty());
+                ASSERT(result.isEmpty());
                 WEBVTT_ADVANCE_TO(StartTagClassState);
             } else if (cc == '/') {
                 WEBVTT_ADVANCE_TO(EndTagState);
             } else if (WTF::isASCIIDigit(cc)) {
-                m_token->appendToData(cc);
+                result.append(cc);
                 WEBVTT_ADVANCE_TO(TimestampTagState);
             } else if (cc == '>' || cc == kEndOfFileMarker) {
-                ASSERT(m_token->name().isEmpty());
-                return advanceAndEmitToken(source, VTTTokenTypes::StartTag);
+                ASSERT(result.isEmpty());
+                return advanceAndEmitToken(source, VTTToken::StartTag(result.toString()));
             } else {
-                m_token->appendToData(cc);
+                result.append(cc);
                 WEBVTT_ADVANCE_TO(StartTagState);
             }
         }
         END_STATE()
 
         WEBVTT_BEGIN_STATE(StartTagState) {
             if (isTokenizerWhitespace(cc)) {
                 WEBVTT_ADVANCE_TO(StartTagAnnotationState);
             } else if (cc == '.') {
                 WEBVTT_ADVANCE_TO(StartTagClassState);
             } else if (cc == '>' || cc == kEndOfFileMarker) {
-                return advanceAndEmitToken(source, VTTTokenTypes::StartTag);
+                return advanceAndEmitToken(source, VTTToken::StartTag(result.toString()));
             } else {
-                m_token->appendToData(cc);
+                result.append(cc);
                 WEBVTT_ADVANCE_TO(StartTagState);
             }
         }
         END_STATE()
 
         WEBVTT_BEGIN_STATE(StartTagClassState) {
             if (isTokenizerWhitespace(cc)) {
-                m_token->addNewClass(m_buffer);
-                m_buffer.clear();
+                addNewClass(classes, buffer);
+                buffer.clear();
                 WEBVTT_ADVANCE_TO(StartTagAnnotationState);
             } else if (cc == '.') {
-                m_token->addNewClass(m_buffer);
-                m_buffer.clear();
+                addNewClass(classes, buffer);
+                buffer.clear();
                 WEBVTT_ADVANCE_TO(StartTagClassState);
             } else if (cc == '>' || cc == kEndOfFileMarker) {
-                m_token->addNewClass(m_buffer);
-                m_buffer.clear();
-                return advanceAndEmitToken(source, VTTTokenTypes::StartTag);
+                addNewClass(classes, buffer);
+                buffer.clear();
+                return advanceAndEmitToken(source, VTTToken::StartTag(result.toString(), classes.toAtomicString()));
             } else {
-                m_buffer.append(cc);
+                buffer.append(cc);
                 WEBVTT_ADVANCE_TO(StartTagClassState);
             }
         }
         END_STATE()
 
         WEBVTT_BEGIN_STATE(StartTagAnnotationState) {
             if (cc == '>' || cc == kEndOfFileMarker) {
-                m_token->addNewAnnotation(m_buffer);
-                m_buffer.clear();
-                return advanceAndEmitToken(source, VTTTokenTypes::StartTag);
+                return advanceAndEmitToken(source, VTTToken::StartTag(result.toString(), classes.toAtomicString(), buffer.toAtomicString()));
             }
-            m_buffer.append(cc);
+            buffer.append(cc);
             WEBVTT_ADVANCE_TO(StartTagAnnotationState);
         }
         END_STATE()
 
         WEBVTT_BEGIN_STATE(EndTagState) {
             if (cc == '>' || cc == kEndOfFileMarker)
-                return advanceAndEmitToken(source, VTTTokenTypes::EndTag);
-            m_token->appendToData(cc);
+                return advanceAndEmitToken(source, VTTToken::EndTag(result.toString()));
+            result.append(cc);
             WEBVTT_ADVANCE_TO(EndTagState);
         }
         END_STATE()
 
         WEBVTT_BEGIN_STATE(TimestampTagState) {
             if (cc == '>' || cc == kEndOfFileMarker)
-                return advanceAndEmitToken(source, VTTTokenTypes::TimestampTag);
-            m_token->appendToData(cc);
+                return advanceAndEmitToken(source, VTTToken::TimestampTag(result.toString()));
+            result.append(cc);
             WEBVTT_ADVANCE_TO(TimestampTagState);
         }
         END_STATE()
 
     }
 
     ASSERT_NOT_REACHED();
     return false;
 }
 
 }