Replace character vectors with StringBuilders in the WebVTT tokenizer

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 22 matching lines @@
 #include "core/html/track/vtt/VTTTokenizer.h"
 
 #include "core/xml/parser/MarkupTokenizerInlines.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);
+}
+
 VTTTokenizer::VTTTokenizer()
     : m_inputStreamPreprocessor(this)
 {
     reset();
 }
 
-template <typename CharacterType>
-inline bool vectorEqualsString(const Vector<CharacterType, 32>& vector, const String& string)
-{
-    if (vector.size() != string.length())
-        return false;
-
-    if (!string.length())
-        return true;
-
-    return equal(string.impl(), vector.data(), vector.size());
-}
-
 void VTTTokenizer::reset()
 {
     m_token = 0;
     m_buffer.clear();
 }
 
 bool VTTTokenizer::nextToken(SegmentedString& source, 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 || token.type() == VTTTokenTypes::Uninitialized);
     m_token = &token;
 
     if (source.isEmpty() || !m_inputStreamPreprocessor.peek(source))
         return haveBufferedCharacterToken();
 
     UChar cc = m_inputStreamPreprocessor.nextInputCharacter();
 
     m_state = VTTTokenizerState::DataState;
 
     // 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));
                 WEBVTT_ADVANCE_TO(EscapeState);
             } else if (cc == '<') {
-                // FIXME: the explicit Vector conversion copies into a temporary
-                // and is wasteful.
-                if (m_token->type() == VTTTokenTypes::Uninitialized
-                    || vectorEqualsString<UChar>(Vector<UChar, 32>(m_token->characters()), emptyString())) {
+                if (m_token->type() == VTTTokenTypes::Uninitialized || m_token->characters().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);
                 }
             } else if (cc == kEndOfFileMarker) {
                 return emitToken(VTTTokenTypes::Character);
             } else {
                 bufferCharacter(cc);
                 WEBVTT_ADVANCE_TO(DataState);
             }
         }
         END_STATE()
 
         WEBVTT_BEGIN_STATE(EscapeState) {
             if (cc == ';') {
-                if (vectorEqualsString(m_buffer, "&amp")) {
+                if (equalLiteral(m_buffer, "&amp")) {
                     bufferCharacter('&');
-                } else if (vectorEqualsString(m_buffer, "&lt")) {
+                } else if (equalLiteral(m_buffer, "&lt")) {
                     bufferCharacter('<');
-                } else if (vectorEqualsString(m_buffer, "&gt")) {
+                } else if (equalLiteral(m_buffer, "&gt")) {
                     bufferCharacter('>');
-                } else if (vectorEqualsString(m_buffer, "&lrm")) {
+                } else if (equalLiteral(m_buffer, "&lrm")) {
                     bufferCharacter(leftToRightMark);
-                } else if (vectorEqualsString(m_buffer, "&rlm")) {
+                } else if (equalLiteral(m_buffer, "&rlm")) {
                     bufferCharacter(rightToLeftMark);
-                } else if (vectorEqualsString(m_buffer, "&nbsp")) {
+                } else if (equalLiteral(m_buffer, "&nbsp")) {
                     bufferCharacter(noBreakSpace);
                 } else {
                     m_buffer.append(static_cast<LChar>(cc));
                     m_token->appendToCharacter(m_buffer);
                 }
                 m_buffer.clear();
                 WEBVTT_ADVANCE_TO(DataState);
             } else if (isASCIIAlphanumeric(cc)) {
                 m_buffer.append(static_cast<LChar>(cc));
                 WEBVTT_ADVANCE_TO(EscapeState);
             } else if (cc == kEndOfFileMarker) {
                 m_token->appendToCharacter(m_buffer);
                 return emitToken(VTTTokenTypes::Character);
             } else {
-                if (!vectorEqualsString(m_buffer, "&"))
+                if (!equalLiteral(m_buffer, "&"))
                     m_token->appendToCharacter(m_buffer);
                 m_buffer.clear();
                 WEBVTT_ADVANCE_TO(DataState);
             }
         }
         END_STATE()
 
         WEBVTT_BEGIN_STATE(TagState) {
             if (isTokenizerWhitespace(cc)) {
                 m_token->beginEmptyStartTag();
@@ skipping 85 matching lines @@
         END_STATE()
 
     }
 
     ASSERT_NOT_REACHED();
     return false;
 }
 
 }