Changeset 61914 in webkit


Ignore:
Timestamp:
Jun 25, 2010 4:32:11 PM (14 years ago)
Author:
abarth@webkit.org
Message:

2010-06-25 Adam Barth <​abarth@webkit.org>

Reviewed by Darin Adler.

Tree builder doesn't need to return a Node
​https://bugs.webkit.org/show_bug.cgi?id=41225

The old tree builder returned the newly inserted Node, but the new tree
builder doesn't need to do that as far as I can tell. Removing the
return value cuts down on a bunch of accounting.

  • html/HTMLTreeBuilder.cpp: (WebCore::HTMLTreeBuilder::passTokenToLegacyParser): (WebCore::HTMLTreeBuilder::constructTreeFromToken): (WebCore::HTMLTreeBuilder::processToken): (WebCore::HTMLTreeBuilder::insertDoctype): (WebCore::HTMLTreeBuilder::insertComment): (WebCore::HTMLTreeBuilder::insertGenericRCDATAElement): (WebCore::HTMLTreeBuilder::insertGenericRawTextElement): (WebCore::HTMLTreeBuilder::insertScriptElement):
  • html/HTMLTreeBuilder.h:
Location:
trunk/WebCore
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r61913 r61914  
     12010-06-25  Adam Barth  <abarth@webkit.org>
     2
     3        Reviewed by Darin Adler.
     4
     5        Tree builder doesn't need to return a Node
     6        https://bugs.webkit.org/show_bug.cgi?id=41225
     7
     8        The old tree builder returned the newly inserted Node, but the new tree
     9        builder doesn't need to do that as far as I can tell.  Removing the
     10        return value cuts down on a bunch of accounting.
     11
     12        * html/HTMLTreeBuilder.cpp:
     13        (WebCore::HTMLTreeBuilder::passTokenToLegacyParser):
     14        (WebCore::HTMLTreeBuilder::constructTreeFromToken):
     15        (WebCore::HTMLTreeBuilder::processToken):
     16        (WebCore::HTMLTreeBuilder::insertDoctype):
     17        (WebCore::HTMLTreeBuilder::insertComment):
     18        (WebCore::HTMLTreeBuilder::insertGenericRCDATAElement):
     19        (WebCore::HTMLTreeBuilder::insertGenericRawTextElement):
     20        (WebCore::HTMLTreeBuilder::insertScriptElement):
     21        * html/HTMLTreeBuilder.h:
     22
    1232010-06-25  Zhenyao Mo  <zmo@google.com>
    224

  • trunk/WebCore/html/HTMLTreeBuilder.cpp

    r61825 r61914  
    167167}
    168168
    169 PassRefPtr<Node> HTMLTreeBuilder::passTokenToLegacyParser(HTMLToken& token)
     169void HTMLTreeBuilder::passTokenToLegacyParser(HTMLToken& token)
    170170{
    171171    if (token.type() == HTMLToken::DOCTYPE) {
    … …  
    177177
    178178        m_legacyTreeBuilder->parseDoctypeToken(&doctypeToken);
    179         return 0;
     179        return;
    180180    }
    181181
    … …  
    215215            setInsertionMode(AfterFramesetMode);
    216216    }
    217     return result.release();
    218 }
    219 
    220 PassRefPtr<Node> HTMLTreeBuilder::constructTreeFromToken(HTMLToken& rawToken)
     217}
     218
     219void HTMLTreeBuilder::constructTreeFromToken(HTMLToken& rawToken)
    221220{
    222221    // Make MSVC ignore our unreachable code for now.
    223     if (true)
    224         return passTokenToLegacyParser(rawToken);
     222    if (true) {
     223        passTokenToLegacyParser(rawToken);
     224        return;
     225    }
    225226
    226227    AtomicHTMLToken token(rawToken);
    … …  
    235236        for (unsigned i = 0; i < characters->length(); ++i)
    236237            processToken(token, (*characters)[i]);
    237         return 0; // FIXME: Should we be returning the Text node?
     238        return;
    238239    }
    239240    return processToken(token);
    240241}
    241242
    242 PassRefPtr<Node> HTMLTreeBuilder::processToken(AtomicHTMLToken& token, UChar cc)
     243void HTMLTreeBuilder::processToken(AtomicHTMLToken& token, UChar cc)
    243244{
    244245reprocessToken:
    … …  
    250251            break;
    251252        case HTMLToken::DOCTYPE:
    252             return insertDoctype(token);
     253            insertDoctype(token);
     254            return;
    253255        case HTMLToken::Comment:
    254             return insertComment(token);
     256            insertComment(token);
     257            return;
    255258        case HTMLToken::Character:
    256259            if (isTreeBuilderWhiteSpace(cc))
    257                 return 0;
     260                return;
    258261            break;
    259262        case HTMLToken::StartTag:
    … …  
    274277        case HTMLToken::DOCTYPE:
    275278            parseError(token);
    276             return 0;
     279            return;
    277280        case HTMLToken::Comment:
    278             return insertComment(token);
     281            insertComment(token);
     282            return;
    279283        case HTMLToken::Character:
    280284            if (isTreeBuilderWhiteSpace(cc))
    281                 return 0;
     285                return;
    282286            break;
    283287        case HTMLToken::StartTag:
    … …  
    285289                notImplemented();
    286290                setInsertionMode(BeforeHeadMode);
    287                 return 0;
     291                return;
    288292            }
    289293            break;
    … …  
    292296                break;
    293297            parseError(token);
    294             return 0;
     298            return;
    295299        case HTMLToken::EndOfFile:
    296300            break;
    … …  
    307311        case HTMLToken::Character:
    308312            if (isTreeBuilderWhiteSpace(cc))
    309                 return 0;
     313                return;
    310314            break;
    311315        case HTMLToken::Comment:
    312             return insertComment(token);
     316            insertComment(token);
     317            return;
    313318        case HTMLToken::DOCTYPE:
    314319            parseError(token);
    315             return 0;
     320            return;
    316321        case HTMLToken::StartTag:
    317322            if (token.name() == htmlTag) {
    318323                notImplemented();
    319                 return 0;
     324                return;
    320325            }
    321326            if (token.name() == headTag) {
    322327                m_headElement = insertElement(token);
    323328                setInsertionMode(InHeadMode);
    324                 return m_headElement;
     329                return;
    325330            }
    326331            break;
    … …  
    332337            }
    333338            parseError(token);
    334             return 0;
     339            return;
    335340        case HTMLToken::EndOfFile:
    336341            break;
    … …  
    347352        case HTMLToken::Character:
    348353            insertCharacter(cc);
    349             break;
     354            return;
    350355        case HTMLToken::Comment:
    351             return insertComment(token);
     356            insertComment(token);
     357            return;
    352358        case HTMLToken::DOCTYPE:
    353359            parseError(token);
    354             return 0;
     360            return;
    355361        case HTMLToken::StartTag:
    356362            if (token.name() == htmlTag) {
    357363                notImplemented();
    358                 return 0;
     364                return;
    359365            }
    360366            // FIXME: Atomize "command".
    361367            if (token.name() == baseTag || token.name() == "command" || token.name() == linkTag) {
    362                 PassRefPtr<Node> node = insertElement(token);
     368                insertElement(token);
    363369                m_openElements.pop();
    364370                notImplemented();
    365                 return node;
    366371            }
    367372            if (token.name() == metaTag) {
    368                 PassRefPtr<Node> node = insertElement(token);
     373                insertElement(token);
    369374                m_openElements.pop();
    370375                notImplemented();
    371                 return node;
    372             }
    373             if (token.name() == titleTag)
    374                 return insertGenericRCDATAElement(token);
     376            }
     377            if (token.name() == titleTag) {
     378                insertGenericRCDATAElement(token);
     379                return;
     380            }
    375381            if (token.name() == noscriptTag) {
    376                 if (isScriptingFlagEnabled(m_document->frame()))
    377                     return insertGenericRawTextElement(token);
    378                 PassRefPtr<Node> node = insertElement(token);
     382                if (isScriptingFlagEnabled(m_document->frame())) {
     383                    insertGenericRawTextElement(token);
     384                    return;
     385                }
     386                insertElement(token);
    379387                setInsertionMode(InHeadNoscriptMode);
    380                 return node;
    381             }
    382             if (token.name() == noframesTag || token.name() == styleTag)
    383                 return insertGenericRawTextElement(token);
    384             if (token.name() == scriptTag)
    385                 return insertScriptElement(token);
     388            }
     389            if (token.name() == noframesTag || token.name() == styleTag) {
     390                insertGenericRawTextElement(token);
     391                return;
     392            }
     393            if (token.name() == scriptTag) {
     394                insertScriptElement(token);
     395                return;
     396            }
    386397            if (token.name() == headTag) {
    387398                notImplemented();
    388                 return 0;
     399                return;
    389400            }
    390401            break;
    … …  
    394405                m_openElements.pop();
    395406                setInsertionMode(AfterHeadMode);
    396                 return 0;
     407                return;
    397408            }
    398409            if (token.name() == bodyTag || token.name() == htmlTag || token.name() == brTag)
    399410                break;
    400411            parseError(token);
    401             return 0;
     412            return;
    402413            break;
    403414        case HTMLToken::EndOfFile:
    … …  
    415426        case HTMLToken::DOCTYPE:
    416427            parseError(token);
    417             return 0;
     428            return;
    418429        case HTMLToken::StartTag:
    419430            if (token.name() == htmlTag) {
    420431                notImplemented();
    421                 return 0;
     432                return;
    422433            }
    423434            if (token.name() == linkTag || token.name() == metaTag || token.name() == noframesTag || token.name() == styleTag) {
    424435                notImplemented();
    425                 return 0;
     436                return;
    426437            }
    427438            if (token.name() == htmlTag || token.name() == noscriptTag) {
    428439                parseError(token);
    429                 return 0;
     440                return;
    430441            }
    431442            break;
    … …  
    436447                ASSERT(m_openElements.top()->tagQName() == headTag);
    437448                setInsertionMode(InHeadMode);
    438                 return 0;
     449                return;
    439450            }
    440451            if (token.name() == brTag)
    441452                break;
    442453            parseError(token);
    443             return 0;
     454            return;
    444455        case HTMLToken::Character:
    445456            notImplemented();
    … …  
    447458        case HTMLToken::Comment:
    448459            notImplemented();
    449             return 0;
     460            return;
    450461        case HTMLToken::EndOfFile:
    451462            break;
    … …  
    463474            if (isTreeBuilderWhiteSpace(cc)) {
    464475                insertCharacter(cc);
    465                 return 0;
     476                return;
    466477            }
    467478            break;
    468479        case HTMLToken::Comment:
    469             return insertComment(token);
     480            insertComment(token);
     481            return;
    470482        case HTMLToken::DOCTYPE:
    471483            parseError(token);
    472             return 0;
     484            return;
    473485        case HTMLToken::StartTag:
    474486            if (token.name() == htmlTag) {
    475487                notImplemented();
    476                 return 0;
     488                return;
    477489            }
    478490            if (token.name() == bodyTag) {
    479491                m_framesetOk = false;
    480                 return insertElement(token);
     492                insertElement(token);
     493                return;
    481494            }
    482495            if (token.name() == framesetTag) {
    483                 PassRefPtr<Node> node = insertElement(token);
     496                insertElement(token);
    484497                setInsertionMode(InFramesetMode);
    485                 return node;
     498                return;
    486499            }
    487500            if (token.name() == baseTag || token.name() == linkTag || token.name() == metaTag || token.name() == noframesTag || token.name() == scriptTag || token.name() == styleTag || token.name() == titleTag) {
    … …  
    491504                notImplemented();
    492505                m_openElements.remove(m_headElement.get());
     506                return;
    493507            }
    494508            if (token.name() == headTag) {
    495509                parseError(token);
    496                 return 0;
     510                return;
    497511            }
    498512            break;
    … …  
    501515                break;
    502516            parseError(token);
    503             return 0;
     517            return;
    504518        case HTMLToken::EndOfFile:
    505519            break;
    … …  
    527541    case AfterAfterBodyMode:
    528542    case AfterAfterFramesetMode:
     543        notImplemented();
    529544        ASSERT_NOT_REACHED();
    530545    }
    531 
    532     // Implementation coming in the next patch.
    533     return 0;
    534 }
    535 
    536 PassRefPtr<Node> HTMLTreeBuilder::insertDoctype(AtomicHTMLToken& token)
     546    ASSERT_NOT_REACHED();
     547}
     548
     549void HTMLTreeBuilder::insertDoctype(AtomicHTMLToken& token)
    537550{
    538551    ASSERT_UNUSED(token, token.type() == HTMLToken::DOCTYPE);
    539     return 0;
    540 }
    541 
    542 PassRefPtr<Node> HTMLTreeBuilder::insertComment(AtomicHTMLToken& token)
     552}
     553
     554void HTMLTreeBuilder::insertComment(AtomicHTMLToken& token)
    543555{
    544556    ASSERT_UNUSED(token, token.type() == HTMLToken::Comment);
    545     return 0;
    546557}
    547558
    … …  
    557568}
    558569
    559 PassRefPtr<Node> HTMLTreeBuilder::insertGenericRCDATAElement(AtomicHTMLToken& token)
     570void HTMLTreeBuilder::insertGenericRCDATAElement(AtomicHTMLToken& token)
    560571{
    561572    ASSERT_UNUSED(token, token.type() == HTMLToken::StartTag);
    562     return 0;
    563 }
    564 
    565 PassRefPtr<Node> HTMLTreeBuilder::insertGenericRawTextElement(AtomicHTMLToken& token)
     573}
     574
     575void HTMLTreeBuilder::insertGenericRawTextElement(AtomicHTMLToken& token)
    566576{
    567577    ASSERT_UNUSED(token, token.type() == HTMLToken::StartTag);
    568     return 0;
    569 }
    570 
    571 PassRefPtr<Node> HTMLTreeBuilder::insertScriptElement(AtomicHTMLToken& token)
     578}
     579
     580void HTMLTreeBuilder::insertScriptElement(AtomicHTMLToken& token)
    572581{
    573582    ASSERT_UNUSED(token, token.type() == HTMLToken::StartTag);
    574     return 0;
    575583}
    576584

  • trunk/WebCore/html/HTMLTreeBuilder.h

    r61825 r61914  
    5858
    5959    // The token really should be passed as a const& since it's never modified.
    60     PassRefPtr<Node> constructTreeFromToken(HTMLToken&);
     60    void constructTreeFromToken(HTMLToken&);
    6161    // Must be called when parser is paused before calling the parser again.
    6262    PassRefPtr<Element> takeScriptToProcess(int& scriptStartLine);
    … …  
    108108    };
    109109
    110     PassRefPtr<Node> passTokenToLegacyParser(HTMLToken&);
    111     PassRefPtr<Node> processToken(AtomicHTMLToken&, UChar cc = 0);
     110    void passTokenToLegacyParser(HTMLToken&);
     111    void processToken(AtomicHTMLToken&, UChar cc = 0);
    112112
    113     PassRefPtr<Node> insertDoctype(AtomicHTMLToken&);
    114     PassRefPtr<Node> insertComment(AtomicHTMLToken&);
     113    void insertDoctype(AtomicHTMLToken&);
     114    void insertComment(AtomicHTMLToken&);
    115115    PassRefPtr<Element> insertElement(AtomicHTMLToken&);
    116116    void insertCharacter(UChar cc);
    117     PassRefPtr<Node> insertGenericRCDATAElement(AtomicHTMLToken&);
    118     PassRefPtr<Node> insertGenericRawTextElement(AtomicHTMLToken&);
    119     PassRefPtr<Node> insertScriptElement(AtomicHTMLToken&);
     117    void insertGenericRCDATAElement(AtomicHTMLToken&);
     118    void insertGenericRawTextElement(AtomicHTMLToken&);
     119    void insertScriptElement(AtomicHTMLToken&);
    120120
    121121    RefPtr<Element> m_headElement;
Note: See TracChangeset for help on using the changeset viewer.