Changeset 140569 in webkit


Ignore:
Timestamp:
Jan 23, 2013 12:13:00 PM (11 years ago)
Author:
eric@webkit.org
Message:

Remove DocType support from MarkupTokenBase now that NEW_XML is gone
​https://bugs.webkit.org/show_bug.cgi?id=107709

Reviewed by Adam Barth.

Just moving code out of MarkupTokenBase and into HTMLToken.
The test for this change is if it compiles. :) Which it does.

  • html/parser/HTMLToken.h:

(DoctypeData):
(WebCore::DoctypeData::DoctypeData):
(WebCore):
(WebCore::HTMLToken::appendToName):
(WebCore::HTMLToken::name):
(HTMLToken):
(WebCore::HTMLToken::beginDOCTYPE):
(WebCore::HTMLToken::publicIdentifier):
(WebCore::HTMLToken::systemIdentifier):
(WebCore::HTMLToken::setPublicIdentifierToEmptyString):
(WebCore::HTMLToken::setSystemIdentifierToEmptyString):
(WebCore::HTMLToken::appendToPublicIdentifier):
(WebCore::HTMLToken::appendToSystemIdentifier):
(WebCore::HTMLToken::releaseDoctypeData):
(WebCore::AtomicHTMLToken::AtomicHTMLToken):
(AtomicHTMLToken):

  • html/parser/HTMLTokenTypes.h:
  • xml/parser/MarkupTokenBase.h:

(WebCore):
(MarkupTokenBase):

Location:
trunk/Source/WebCore
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r140560 r140569  
     12013-01-23  Eric Seidel  <eric@webkit.org>
     2
     3        Remove DocType support from MarkupTokenBase now that NEW_XML is gone
     4        https://bugs.webkit.org/show_bug.cgi?id=107709
     5
     6        Reviewed by Adam Barth.
     7
     8        Just moving code out of MarkupTokenBase and into HTMLToken.
     9        The test for this change is if it compiles. :)  Which it does.
     10
     11        * html/parser/HTMLToken.h:
     12        (DoctypeData):
     13        (WebCore::DoctypeData::DoctypeData):
     14        (WebCore):
     15        (WebCore::HTMLToken::appendToName):
     16        (WebCore::HTMLToken::name):
     17        (HTMLToken):
     18        (WebCore::HTMLToken::beginDOCTYPE):
     19        (WebCore::HTMLToken::publicIdentifier):
     20        (WebCore::HTMLToken::systemIdentifier):
     21        (WebCore::HTMLToken::setPublicIdentifierToEmptyString):
     22        (WebCore::HTMLToken::setSystemIdentifierToEmptyString):
     23        (WebCore::HTMLToken::appendToPublicIdentifier):
     24        (WebCore::HTMLToken::appendToSystemIdentifier):
     25        (WebCore::HTMLToken::releaseDoctypeData):
     26        (WebCore::AtomicHTMLToken::AtomicHTMLToken):
     27        (AtomicHTMLToken):
     28        * html/parser/HTMLTokenTypes.h:
     29        * xml/parser/MarkupTokenBase.h:
     30        (WebCore):
     31        (MarkupTokenBase):
     32
    1332013-01-23  Alexis Menard  <alexis@webkit.org>
    234

  • trunk/Source/WebCore/html/parser/HTMLToken.h

    r140485 r140569  
    3535namespace WebCore {
    3636
    37 class HTMLToken : public MarkupTokenBase<HTMLTokenTypes, HTMLTokenTypes::DoctypeData> {
     37class DoctypeData {
     38    WTF_MAKE_NONCOPYABLE(DoctypeData);
     39public:
     40    DoctypeData()
     41        : m_hasPublicIdentifier(false)
     42        , m_hasSystemIdentifier(false)
     43        , m_forceQuirks(false)
     44    {
     45    }
     46
     47    // FIXME: This should use String instead of Vector<UChar>.
     48    bool m_hasPublicIdentifier;
     49    bool m_hasSystemIdentifier;
     50    WTF::Vector<UChar> m_publicIdentifier;
     51    WTF::Vector<UChar> m_systemIdentifier;
     52    bool m_forceQuirks;
     53};
     54
     55class HTMLToken : public MarkupTokenBase<HTMLTokenTypes> {
    3856public:
    3957    void appendToName(UChar character)
    4058    {
    4159        ASSERT(m_type == HTMLTokenTypes::StartTag || m_type == HTMLTokenTypes::EndTag || m_type == HTMLTokenTypes::DOCTYPE);
    42         MarkupTokenBase<HTMLTokenTypes, HTMLTokenTypes::DoctypeData>::appendToName(character);
     60        MarkupTokenBase<HTMLTokenTypes>::appendToName(character);
    4361    }
    4462
    … …  
    4664    {
    4765        ASSERT(m_type == HTMLTokenTypes::StartTag || m_type == HTMLTokenTypes::EndTag || m_type == HTMLTokenTypes::DOCTYPE);
    48         return MarkupTokenBase<HTMLTokenTypes, HTMLTokenTypes::DoctypeData>::name();
     66        return MarkupTokenBase<HTMLTokenTypes>::name();
    4967    }
    5068
    … …  
    6078        m_doctypeData->m_forceQuirks = true;
    6179    }
     80
     81    void beginDOCTYPE()
     82    {
     83        ASSERT(m_type == HTMLTokenTypes::Uninitialized);
     84        m_type = HTMLTokenTypes::DOCTYPE;
     85        m_doctypeData = adoptPtr(new DoctypeData);
     86    }
     87
     88    void beginDOCTYPE(UChar character)
     89    {
     90        ASSERT(character);
     91        beginDOCTYPE();
     92        m_data.append(character);
     93        m_orAllData |= character;
     94    }
     95
     96    // FIXME: Distinguish between a missing public identifer and an empty one.
     97    const WTF::Vector<UChar>& publicIdentifier() const
     98    {
     99        ASSERT(m_type == HTMLTokenTypes::DOCTYPE);
     100        return m_doctypeData->m_publicIdentifier;
     101    }
     102
     103    // FIXME: Distinguish between a missing system identifer and an empty one.
     104    const WTF::Vector<UChar>& systemIdentifier() const
     105    {
     106        ASSERT(m_type == HTMLTokenTypes::DOCTYPE);
     107        return m_doctypeData->m_systemIdentifier;
     108    }
     109
     110    void setPublicIdentifierToEmptyString()
     111    {
     112        ASSERT(m_type == HTMLTokenTypes::DOCTYPE);
     113        m_doctypeData->m_hasPublicIdentifier = true;
     114        m_doctypeData->m_publicIdentifier.clear();
     115    }
     116
     117    void setSystemIdentifierToEmptyString()
     118    {
     119        ASSERT(m_type == HTMLTokenTypes::DOCTYPE);
     120        m_doctypeData->m_hasSystemIdentifier = true;
     121        m_doctypeData->m_systemIdentifier.clear();
     122    }
     123
     124    void appendToPublicIdentifier(UChar character)
     125    {
     126        ASSERT(character);
     127        ASSERT(m_type == HTMLTokenTypes::DOCTYPE);
     128        ASSERT(m_doctypeData->m_hasPublicIdentifier);
     129        m_doctypeData->m_publicIdentifier.append(character);
     130    }
     131
     132    void appendToSystemIdentifier(UChar character)
     133    {
     134        ASSERT(character);
     135        ASSERT(m_type == HTMLTokenTypes::DOCTYPE);
     136        ASSERT(m_doctypeData->m_hasSystemIdentifier);
     137        m_doctypeData->m_systemIdentifier.append(character);
     138    }
     139
     140    PassOwnPtr<DoctypeData> releaseDoctypeData()
     141    {
     142        return m_doctypeData.release();
     143    }
     144
     145private:
     146    // For DOCTYPE
     147    OwnPtr<DoctypeData> m_doctypeData;
    62148};
    63149
    … …  
    220306        case HTMLTokenTypes::DOCTYPE:
    221307            m_name = token.data();
    222             m_doctypeData = adoptPtr(new HTMLToken::DoctypeData());
     308            m_doctypeData = adoptPtr(new DoctypeData());
    223309            m_doctypeData->m_hasPublicIdentifier = true;
    224310            m_doctypeData->m_publicIdentifier.append(token.publicIdentifier().characters(), token.publicIdentifier().length());
    … …  
    301387
    302388    // For DOCTYPE
    303     OwnPtr<HTMLTokenTypes::DoctypeData> m_doctypeData;
     389    OwnPtr<DoctypeData> m_doctypeData;
    304390
    305391    // For StartTag and EndTag

  • trunk/Source/WebCore/html/parser/HTMLTokenTypes.h

    r139533 r140569  
    4343        EndOfFile,
    4444    };
    45 
    46     class DoctypeData : public DoctypeDataBase {
    47         WTF_MAKE_NONCOPYABLE(DoctypeData);
    48     public:
    49         DoctypeData()
    50             : m_forceQuirks(false)
    51         {
    52         }
    53 
    54         bool m_forceQuirks;
    55     };
    5645};
    5746

  • trunk/Source/WebCore/xml/parser/MarkupTokenBase.h

    r140403 r140569  
    4646}
    4747
    48 class DoctypeDataBase {
    49     WTF_MAKE_NONCOPYABLE(DoctypeDataBase); WTF_MAKE_FAST_ALLOCATED;
    50 public:
    51     DoctypeDataBase()
    52         : m_hasPublicIdentifier(false)
    53         , m_hasSystemIdentifier(false)
    54     {
    55     }
    56 
    57     bool m_hasPublicIdentifier;
    58     bool m_hasSystemIdentifier;
    59     WTF::Vector<UChar> m_publicIdentifier;
    60     WTF::Vector<UChar> m_systemIdentifier;
    61 };
    62 
    6348class AttributeBase {
    6449public:
    … …  
    7560};
    7661
    77 template<typename TypeSet, typename DoctypeDataType = DoctypeDataBase, typename AttributeType = AttributeBase>
     62template<typename TypeSet, typename AttributeType = AttributeBase>
    7863class MarkupTokenBase {
    7964    WTF_MAKE_NONCOPYABLE(MarkupTokenBase);
    … …  
    8267    typedef TypeSet Type;
    8368    typedef AttributeType Attribute;
    84     typedef DoctypeDataType DoctypeData;
    8569
    8670    typedef WTF::Vector<Attribute, 10> AttributeList;
    … …  
    168152        ASSERT(m_type == TypeSet::Uninitialized);
    169153        m_type = TypeSet::Comment;
    170     }
    171 
    172     void beginDOCTYPE()
    173     {
    174         ASSERT(m_type == TypeSet::Uninitialized);
    175         m_type = TypeSet::DOCTYPE;
    176         m_doctypeData = adoptPtr(new DoctypeData);
    177     }
    178 
    179     void beginDOCTYPE(UChar character)
    180     {
    181         ASSERT(character);
    182         beginDOCTYPE();
    183         m_data.append(character);
    184         m_orAllData |= character;
    185154    }
    186155
    … …  
    332301    }
    333302
    334     // FIXME: Distinguish between a missing public identifer and an empty one.
    335     const WTF::Vector<UChar>& publicIdentifier() const
    336     {
    337         ASSERT(m_type == TypeSet::DOCTYPE);
    338         return m_doctypeData->m_publicIdentifier;
    339     }
    340 
    341     // FIXME: Distinguish between a missing system identifer and an empty one.
    342     const WTF::Vector<UChar>& systemIdentifier() const
    343     {
    344         ASSERT(m_type == TypeSet::DOCTYPE);
    345         return m_doctypeData->m_systemIdentifier;
    346     }
    347 
    348     void setPublicIdentifierToEmptyString()
    349     {
    350         ASSERT(m_type == TypeSet::DOCTYPE);
    351         m_doctypeData->m_hasPublicIdentifier = true;
    352         m_doctypeData->m_publicIdentifier.clear();
    353     }
    354 
    355     void setSystemIdentifierToEmptyString()
    356     {
    357         ASSERT(m_type == TypeSet::DOCTYPE);
    358         m_doctypeData->m_hasSystemIdentifier = true;
    359         m_doctypeData->m_systemIdentifier.clear();
    360     }
    361 
    362     void appendToPublicIdentifier(UChar character)
    363     {
    364         ASSERT(character);
    365         ASSERT(m_type == TypeSet::DOCTYPE);
    366         ASSERT(m_doctypeData->m_hasPublicIdentifier);
    367         m_doctypeData->m_publicIdentifier.append(character);
    368     }
    369 
    370     void appendToSystemIdentifier(UChar character)
    371     {
    372         ASSERT(character);
    373         ASSERT(m_type == TypeSet::DOCTYPE);
    374         ASSERT(m_doctypeData->m_hasSystemIdentifier);
    375         m_doctypeData->m_systemIdentifier.append(character);
    376     }
    377 
    378303    const DataVector& name() const
    379304    {
    … …  
    390315    }
    391316
    392     PassOwnPtr<DoctypeData> releaseDoctypeData()
    393     {
    394         return m_doctypeData.release();
    395     }
    396 
    397317protected:
    398318
    … …  
    419339    UChar m_orAllData;
    420340
    421     // For DOCTYPE
    422     OwnPtr<DoctypeData> m_doctypeData;
    423 
    424341    // For StartTag and EndTag
    425342    bool m_selfClosing;
Note: See TracChangeset for help on using the changeset viewer.