Update tokenizer to match spec

sky/engine/core/html/parser/HTMLTokenizer.h

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * 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.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 29 matching lines @@
 public:
     static PassOwnPtr<HTMLTokenizer> create() { return adoptPtr(new HTMLTokenizer()); }
     ~HTMLTokenizer();
 
     void reset();
 
     enum State {
         DataState,
         CharacterReferenceInDataState,
         CharacterReferenceInAttributeValueState,
-        RAWTEXTState,
+        RawDataState,
+        RawDataLessThanSignState,
+        RawDataEndTagOpenState,
+        RawDataEndTagNameState,
         TagOpenState,
         CloseTagState,
         TagNameState,
-        RAWTEXTLessThanSignState,
-        RAWTEXTEndTagOpenState,
-        RAWTEXTEndTagNameState,
         BeforeAttributeNameState,
         AttributeNameState,
         AfterAttributeNameState,
         BeforeAttributeValueState,
         AttributeValueDoubleQuotedState,
         AttributeValueSingleQuotedState,
         AttributeValueUnquotedState,
-        AfterAttributeValueQuotedState,
-        SelfClosingStartTagState,
+        VoidTagState,
         CommentStart1State,
         CommentStart2State,
         CommentState,
         CommentEnd1State,
         CommentEnd2State,
     };
 
     // This function returns true if it emits a token. Otherwise, callers
     // must provide the same (in progress) token on the next call (unless
     // they call reset() first).
     bool nextToken(SegmentedString&, HTMLToken&);
 
     State state() const { return m_state; }
+
     void setState(State state) { m_state = state; }
 
 private:
     HTMLTokenizer();
 
     inline void parseError();
 
     inline void bufferCharacter(UChar character)
     {
         ASSERT(character != kEndOfFileMarker);
@@ skipping 25 matching lines @@
         m_token->clear();
         m_token->makeEndOfFile();
         return true;
     }
 
     inline bool flushEmitAndResumeIn(SegmentedString&, State);
 
     // Return whether we need to emit a character token before dealing with
     // the buffered end tag.
     inline bool flushBufferedEndTag(SegmentedString&);
-    inline bool temporaryBufferIs(const String&);
-
-    // Sometimes we speculatively consume input characters and we don't
-    // know whether they represent end tags or RCDATA, etc. These
-    // functions help manage these state.
-    inline void addToPossibleEndTag(LChar cc);
 
     inline void saveEndTagNameIfNeeded()
     {
         ASSERT(m_token->type() != HTMLToken::Uninitialized);
         if (m_token->type() == HTMLToken::StartTag)
             m_appropriateEndTagName = m_token->name();
     }
     inline bool isAppropriateEndTag();
 
-
     inline bool haveBufferedCharacterToken()
     {
         return m_token->type() == HTMLToken::Character;
     }
 
     State m_state;
 
     // m_token is owned by the caller. If nextToken is not on the stack,
     // this member might be pointing to unallocated memory.
     HTMLToken* m_token;
 
     State m_returnState;
 
     // http://www.whatwg.org/specs/web-apps/current-work/#preprocessing-the-input-stream
     InputStreamPreprocessor<HTMLTokenizer> m_inputStreamPreprocessor;
     HTMLEntityParser m_entityParser;
 
     Vector<UChar, 32> m_appropriateEndTagName;
 
     // http://www.whatwg.org/specs/web-apps/current-work/#temporary-buffer
     Vector<LChar, 32> m_temporaryBuffer;
-
-    // We occationally want to emit both a character token and an end tag
-    // token (e.g., when lexing script). We buffer the name of the end tag
-    // token here so we remember it next time we re-enter the tokenizer.
-    Vector<LChar, 32> m_bufferedEndTagName;
 };
 
 }
 
 #endif