Use TextResourceDecoder for the WebVTTParser

Source/core/html/track/WebVTTParser.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 26 matching lines @@
 #include "core/html/track/WebVTTElement.h"
 #include "platform/text/SegmentedString.h"
 #include "wtf/text/WTFString.h"
 
 namespace WebCore {
 
 const double secondsPerHour = 3600;
 const double secondsPerMinute = 60;
 const double secondsPerMillisecond = 0.001;
 const double malformedTime = -1;
-const unsigned bomLength = 3;
 const unsigned fileIdentifierLength = 6;
 
 String WebVTTParser::collectDigits(const String& input, unsigned* position)
 {
     StringBuilder digits;
     while (*position < input.length() && isASCIIDigit(input[*position]))
         digits.append(input[(*position)++]);
     return digits.toString();
 }
 
@@ skipping 49 matching lines @@
     bool isSecondValueValid;
     float secondCoord = parseFloatPercentageValue(value.substring(delimiterOffset + 1, value.length() - 1), isSecondValueValid);
 
     isValidSetting = isFirstValueValid && isSecondValueValid;
     return FloatPoint(firstCoord, secondCoord);
 }
 
 WebVTTParser::WebVTTParser(WebVTTParserClient* client, Document& document)
     : m_document(&document)
     , m_state(Initial)
+    , m_decoder(TextResourceDecoder::create("text/plain", UTF8Encoding()))
     , m_currentStartTime(0)
     , m_currentEndTime(0)
     , m_tokenizer(WebVTTTokenizer::create())
     , m_client(client)
 {
 }
 
 void WebVTTParser::getNewCues(Vector<RefPtr<TextTrackCue> >& outputCues)
 {
     outputCues = m_cuelist;
     m_cuelist.clear();
 }
 
 void WebVTTParser::getNewRegions(Vector<RefPtr<TextTrackRegion> >& outputRegions)
 {
     outputRegions = m_regionList;
     m_regionList.clear();
 }
 
 void WebVTTParser::parseBytes(const char* data, unsigned length)
 {
+    String textData = m_decoder->decode(data, length);
+
     // 4.8.10.13.3 WHATWG WebVTT Parser algorithm.
     // 1-3 - Initial setup.
     unsigned position = 0;
 
-    while (position < length) {
-        String line = collectNextLine(data, length, &position);
+    while (position < textData.length()) {
+        String line = collectNextLine(textData, &position);
 
         switch (m_state) {
         case Initial:
-            // Buffer up at least 9 bytes before proceeding with checking for the file identifier.
-            m_identifierData.append(data, length);
-            if (m_identifierData.size() < bomLength + fileIdentifierLength)
-                return;
-
-            // 4-12 - Collect the first line and check for "WEBVTT".
-            if (!hasRequiredFileIdentifier()) {
+            // 4-12 - Check for a valid WebVTT signature.
+            if (!hasRequiredFileIdentifier(line)) {
                 if (m_client)
                     m_client->fileFailedToParse();
                 return;
             }
 
             m_state = Header;
-            m_identifierData.clear();
             break;
 
         case Header:
             collectMetadataHeader(line);
 
             // 13-18 - Allow a header (comment area) under the WEBVTT line.
             if (line.isEmpty()) {
                 if (m_client && m_regionList.size())
                     m_client->newRegionsParsed();
 
@@ skipping 13 matching lines @@
             m_state = collectCueId(line);
             break;
 
         case TimingsAndSettings:
             // 40 - Collect cue timings and settings.
             m_state = collectTimingsAndSettings(line);
             break;
 
         case CueText:
             // 41-53 - Collect the cue text, create a cue, and add it to the output.
-            m_state = collectCueText(line, length, position);
+            m_state = collectCueText(line, position >= textData.length());
             break;
 
         case BadCue:
             // 54-62 - Collect and discard the remaining cue.
             m_state = ignoreBadCue(line);
             break;
         }
     }
 }
 
-bool WebVTTParser::hasRequiredFileIdentifier()
+bool WebVTTParser::hasRequiredFileIdentifier(const String& line)
 {
     // A WebVTT file identifier consists of an optional BOM character,
     // the string "WEBVTT" followed by an optional space or tab character,
     // and any number of characters that are not line terminators ...
-    unsigned position = 0;
-    if (m_identifierData.size() >= bomLength && m_identifierData[0] == '\xEF' && m_identifierData[1] == '\xBB' && m_identifierData[2] == '\xBF')
-        position += bomLength;
-    String line = collectNextLine(m_identifierData.data(), m_identifierData.size(), &position);
-
-    if (line.length() < fileIdentifierLength)
+    if (!line.startsWith("WEBVTT", fileIdentifierLength))
         return false;
-    if (line.substring(0, fileIdentifierLength) != "WEBVTT")
-        return false;
-    if (line.length() > fileIdentifierLength && line[fileIdentifierLength] != ' ' && line[fileIdentifierLength] != '\t')
+    if (line.length() > fileIdentifierLength && !isASpace(line[fileIdentifierLength]))
         return false;
 
     return true;
 }
 
 void WebVTTParser::collectMetadataHeader(const String& line)
 {
     // 4.1 Extension of WebVTT header parsing (11 - 15)
     DEFINE_STATIC_LOCAL(const AtomicString, regionHeaderName, ("Region", AtomicString::ConstructFromLiteral));
 
@@ skipping 51 matching lines @@
     m_currentEndTime = collectTimeStamp(line, &position);
     if (m_currentEndTime == malformedTime)
         return BadCue;
     skipWhiteSpace(line, &position);
 
     // 12 - Parse the WebVTT settings for the cue (conducted in TextTrackCue).
     m_currentSettings = line.substring(position, line.length()-1);
     return CueText;
 }
 
-WebVTTParser::ParseState WebVTTParser::collectCueText(const String& line, unsigned length, unsigned position)
+WebVTTParser::ParseState WebVTTParser::collectCueText(const String& line, bool isAtEnd)
 {
     if (line.isEmpty()) {
         createNewCue();
         return Id;
     }
     if (!m_currentContent.isEmpty())
         m_currentContent.append("\n");
     m_currentContent.append(line);
 
-    if (position >= length)
+    if (isAtEnd)
         createNewCue();
 
     return CueText;
 }
 
 WebVTTParser::ParseState WebVTTParser::ignoreBadCue(const String& line)
 {
     if (!line.isEmpty())
         return BadCue;
     return Id;
@@ skipping 213 matching lines @@
     }
     m_token.clear();
 }
 
 void WebVTTParser::skipWhiteSpace(const String& line, unsigned* position)
 {
     while (*position < line.length() && isASpace(line[*position]))
         (*position)++;
 }
 
-void WebVTTParser::skipLineTerminator(const char* data, unsigned length, unsigned* position)
+void WebVTTParser::skipLineTerminator(const String& data, unsigned* position)
 {
-    if (*position >= length)
+    if (*position >= data.length())
         return;
     if (data[*position] == '\r')
         (*position)++;
-    if (*position >= length)
+    if (*position >= data.length())
         return;
     if (data[*position] == '\n')
         (*position)++;
 }
 
-String WebVTTParser::collectNextLine(const char* data, unsigned length, unsigned* position)
+String WebVTTParser::collectNextLine(const String& data, unsigned* position)
 {
     unsigned oldPosition = *position;
-    while (*position < length && data[*position] != '\r' && data[*position] != '\n')
+    while (*position < data.length() && data[*position] != '\r' && data[*position] != '\n')
         (*position)++;
-    String line = String::fromUTF8(data + oldPosition, *position - oldPosition);
-    skipLineTerminator(data, length, position);
+    String line = data.substring(oldPosition, *position - oldPosition);
+    skipLineTerminator(data, position);
     return line;
 }
 
 }