1 files changed, 114 insertions, 23 deletions

diff --git a/WebCore/html/HTML5Token.h b/WebCore/html/HTML5Token.h
index 1918589..b4188d3 100644
--- a/WebCore/html/HTML5Token.h
+++ b/WebCore/html/HTML5Token.h
@@ -51,6 +51,7 @@ public:
     };
 
     typedef WTF::Vector<Attribute> AttributeList;
+    typedef WTF::Vector<UChar, 1024> DataVector;
 
     HTML5Token() { clear(); }
 
@@ -63,10 +64,10 @@ public:
     {
         ASSERT(m_type == Uninitialized);
         m_type = StartTag;
-        m_data.clear();
-        m_dataString = AtomicString();
+        clearData();
         m_selfClosing = false;
         m_currentAttribute = 0;
+        m_attributes.clear();
 
         m_data.append(character);
     }
@@ -76,10 +77,10 @@ public:
     {
         ASSERT(m_type == Uninitialized);
         m_type = EndTag;
-        m_data.clear();
-        m_dataString = AtomicString();
+        clearData();
         m_selfClosing = false;
         m_currentAttribute = 0;
+        m_attributes.clear();
 
         m_data.append(characters);
     }
@@ -88,8 +89,7 @@ public:
     {
         ASSERT(m_type == Uninitialized);
         m_type = Character;
-        m_data.clear();
-        m_dataString = AtomicString();
+        clearData();
         m_data.append(character);
     }
 
@@ -97,8 +97,21 @@ public:
     {
         ASSERT(m_type == Uninitialized);
         m_type = Comment;
-        m_data.clear();
-        m_dataString = AtomicString();
+        clearData();
+    }
+
+    void beginDOCTYPE()
+    {
+        ASSERT(m_type == Uninitialized);
+        m_type = DOCTYPE;
+        clearData();
+        m_doctypeData.set(new DoctypeData());
+    }
+
+    void beginDOCTYPE(UChar character)
+    {
+        beginDOCTYPE();
+        m_data.append(character);
     }
 
     void appendToName(UChar character)
@@ -156,27 +169,108 @@ public:
     AtomicString name()
     {
         ASSERT(m_type == StartTag || m_type == EndTag || m_type == DOCTYPE);
-        return dataString();
+        if (!m_data.isEmpty() && m_dataAsNameAtom.isEmpty())
+            m_dataAsNameAtom = AtomicString(adoptDataAsStringImpl());
+        return m_dataAsNameAtom;
+    }
+
+    PassRefPtr<StringImpl> adoptDataAsStringImpl()
+    {
+        ASSERT(!m_dataAsNameAtom); // An attempt to make sure this isn't called twice.
+        return StringImpl::adopt(m_data);
+    }
+
+    const DataVector& characters()
+    {
+        ASSERT(m_type == Character);
+        ASSERT(!m_dataAsNameAtom);
+        return m_data;
+    }
+
+    const DataVector& comment()
+    {
+        ASSERT(m_type == Comment);
+        ASSERT(!m_dataAsNameAtom);
+        return m_data;
     }
 
-    AtomicString characters()
+    // FIXME: Should be removed once we stop using the old parser.
+    String takeCharacters()
     {
         ASSERT(m_type == Character);
-        return dataString();
+        return String(adoptDataAsStringImpl());
     }
 
-    AtomicString data()
+    // FIXME: Should be removed once we stop using the old parser.
+    String takeComment()
     {
         ASSERT(m_type == Comment);
-        return dataString();
+        return String(adoptDataAsStringImpl());
+    }
+
+    // FIXME: Distinguish between a missing public identifer and an empty one.
+    const WTF::Vector<UChar>& publicIdentifier()
+    {
+        ASSERT(m_type == DOCTYPE);
+        return m_doctypeData->m_publicIdentifier;
+    }
+
+    // FIXME: Distinguish between a missing system identifer and an empty one.
+    const WTF::Vector<UChar>& systemIdentifier()
+    {
+        ASSERT(m_type == DOCTYPE);
+        return m_doctypeData->m_systemIdentifier;
+    }
+
+    void setPublicIdentifierToEmptyString()
+    {
+        ASSERT(m_type == DOCTYPE);
+        m_doctypeData->m_hasPublicIdentifier = true;
+        m_doctypeData->m_publicIdentifier.clear();
+    }
+
+    void setSystemIdentifierToEmptyString()
+    {
+        ASSERT(m_type == DOCTYPE);
+        m_doctypeData->m_hasSystemIdentifier = true;
+        m_doctypeData->m_systemIdentifier.clear();
+    }
+
+    void appendToPublicIdentifier(UChar character)
+    {
+        ASSERT(m_type == DOCTYPE);
+        ASSERT(m_doctypeData->m_hasPublicIdentifier);
+        m_doctypeData->m_publicIdentifier.append(character);
+    }
+
+    void appendToSystemIdentifier(UChar character)
+    {
+        ASSERT(m_type == DOCTYPE);
+        ASSERT(m_doctypeData->m_hasSystemIdentifier);
+        m_doctypeData->m_systemIdentifier.append(character);
     }
 
 private:
-    AtomicString dataString()
+    class DoctypeData {
+    public:
+        DoctypeData()
+            : m_hasPublicIdentifier(false)
+            , m_hasSystemIdentifier(false)
+            , m_forceQuirks(false)
+        {
+        }
+
+        bool m_hasPublicIdentifier;
+        bool m_hasSystemIdentifier;
+        bool m_forceQuirks;
+        WTF::Vector<UChar> m_publicIdentifier;
+        WTF::Vector<UChar> m_systemIdentifier;
+    };
+
+    void clearData()
     {
-        if (!m_data.isEmpty() && m_dataString.isEmpty())
-            m_dataString = AtomicString(StringImpl::adopt(m_data));
-        return m_dataString;
+        m_data.clear();
+        m_dataAsNameAtom = AtomicString();
     }
 
     Type m_type;
@@ -184,12 +278,11 @@ private:
     // "name" for DOCTYPE, StartTag, and EndTag
     // "characters" for Character
     // "data" for Comment
-    WTF::Vector<UChar, 1024> m_data;
+    DataVector m_data;
+    AtomicString m_dataAsNameAtom;
 
     // For DOCTYPE
-    String m_publicIdentifier;
-    String m_systemIdentifier;
-    bool m_forceQuirks;
+    OwnPtr<DoctypeData> m_doctypeData;
 
     // For StartTag and EndTag
     bool m_selfClosing;
@@ -197,8 +290,6 @@ private:
 
     // A pointer into m_attributes used during lexing.
     Attribute* m_currentAttribute;
-
-    AtomicString m_dataString;
 };
 
 }