Home | History | Annotate | Download | only in parser 
      1 /*
      2  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
      3  * Copyright (C) 2011 Apple Inc. All rights reserved.
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions
      7  * are met:
      8  * 1. Redistributions of source code must retain the above copyright
      9  *    notice, this list of conditions and the following disclaimer.
     10  * 2. Redistributions in binary form must reproduce the above copyright
     11  *    notice, this list of conditions and the following disclaimer in the
     12  *    documentation and/or other materials provided with the distribution.
     13  *
     14  * THIS SOFTWARE IS PROVIDED BY GOOGLE INC. ``AS IS'' AND ANY
     15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL GOOGLE INC. OR
     18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     25  */
     26 
     27 #ifndef HTMLTreeBuilder_h
     28 #define HTMLTreeBuilder_h
     29 
     30 #include "core/html/parser/HTMLConstructionSite.h"
     31 #include "core/html/parser/HTMLElementStack.h"
     32 #include "core/html/parser/HTMLParserOptions.h"
     33 #include "platform/heap/Handle.h"
     34 #include "wtf/Noncopyable.h"
     35 #include "wtf/PassOwnPtr.h"
     36 #include "wtf/PassRefPtr.h"
     37 #include "wtf/RefPtr.h"
     38 #include "wtf/Vector.h"
     39 #include "wtf/text/StringBuilder.h"
     40 #include "wtf/text/TextPosition.h"
     41 
     42 namespace blink {
     43 
     44 class AtomicHTMLToken;
     45 class Document;
     46 class DocumentFragment;
     47 class Element;
     48 class LocalFrame;
     49 class HTMLToken;
     50 class HTMLDocument;
     51 class Node;
     52 class HTMLDocumentParser;
     53 
     54 class HTMLTreeBuilder FINAL : public NoBaseWillBeGarbageCollectedFinalized<HTMLTreeBuilder> {
     55     WTF_MAKE_NONCOPYABLE(HTMLTreeBuilder); WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
     56 public:
     57     static PassOwnPtrWillBeRawPtr<HTMLTreeBuilder> create(HTMLDocumentParser* parser, HTMLDocument* document, ParserContentPolicy parserContentPolicy, bool reportErrors, const HTMLParserOptions& options)
     58     {
     59         return adoptPtrWillBeNoop(new HTMLTreeBuilder(parser, document, parserContentPolicy, reportErrors, options));
     60     }
     61     static PassOwnPtrWillBeRawPtr<HTMLTreeBuilder> create(HTMLDocumentParser* parser, DocumentFragment* fragment, Element* contextElement, ParserContentPolicy parserContentPolicy, const HTMLParserOptions& options)
     62     {
     63         return adoptPtrWillBeNoop(new HTMLTreeBuilder(parser, fragment, contextElement, parserContentPolicy, options));
     64     }
     65     ~HTMLTreeBuilder();
     66     void trace(Visitor*);
     67 
     68     const HTMLElementStack* openElements() const { return m_tree.openElements(); }
     69 
     70     bool isParsingFragment() const { return !!m_fragmentContext.fragment(); }
     71     bool isParsingTemplateContents() const { return m_tree.openElements()->hasTemplateInHTMLScope(); }
     72     bool isParsingFragmentOrTemplateContents() const { return isParsingFragment() || isParsingTemplateContents(); }
     73 
     74     void detach();
     75 
     76     void constructTree(AtomicHTMLToken*);
     77 
     78     bool hasParserBlockingScript() const { return !!m_scriptToProcess; }
     79     // Must be called to take the parser-blocking script before calling the parser again.
     80     PassRefPtrWillBeRawPtr<Element> takeScriptToProcess(TextPosition& scriptStartPosition);
     81 
     82     // Done, close any open tags, etc.
     83     void finished();
     84 
     85     // Synchronously flush pending text and queued tasks, possibly creating more DOM nodes.
     86     // Flushing pending text depends on |mode|.
     87     void flush(FlushMode mode) { m_tree.flush(mode); }
     88 
     89     void setShouldSkipLeadingNewline(bool shouldSkip) { m_shouldSkipLeadingNewline = shouldSkip; }
     90 
     91 private:
     92     class CharacterTokenBuffer;
     93     // Represents HTML5 "insertion mode"
     94     // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#insertion-mode
     95     enum InsertionMode {
     96         InitialMode,
     97         BeforeHTMLMode,
     98         BeforeHeadMode,
     99         InHeadMode,
    100         InHeadNoscriptMode,
    101         AfterHeadMode,
    102         TemplateContentsMode,
    103         InBodyMode,
    104         TextMode,
    105         InTableMode,
    106         InTableTextMode,
    107         InCaptionMode,
    108         InColumnGroupMode,
    109         InTableBodyMode,
    110         InRowMode,
    111         InCellMode,
    112         InSelectMode,
    113         InSelectInTableMode,
    114         AfterBodyMode,
    115         InFramesetMode,
    116         AfterFramesetMode,
    117         AfterAfterBodyMode,
    118         AfterAfterFramesetMode,
    119     };
    120 
    121     HTMLTreeBuilder(HTMLDocumentParser*, HTMLDocument*, ParserContentPolicy, bool reportErrors, const HTMLParserOptions&);
    122     HTMLTreeBuilder(HTMLDocumentParser*, DocumentFragment*, Element* contextElement, ParserContentPolicy, const HTMLParserOptions&);
    123 
    124     void processToken(AtomicHTMLToken*);
    125 
    126     void processDoctypeToken(AtomicHTMLToken*);
    127     void processStartTag(AtomicHTMLToken*);
    128     void processEndTag(AtomicHTMLToken*);
    129     void processComment(AtomicHTMLToken*);
    130     void processCharacter(AtomicHTMLToken*);
    131     void processEndOfFile(AtomicHTMLToken*);
    132 
    133     bool processStartTagForInHead(AtomicHTMLToken*);
    134     void processStartTagForInBody(AtomicHTMLToken*);
    135     void processStartTagForInTable(AtomicHTMLToken*);
    136     void processEndTagForInBody(AtomicHTMLToken*);
    137     void processEndTagForInTable(AtomicHTMLToken*);
    138     void processEndTagForInTableBody(AtomicHTMLToken*);
    139     void processEndTagForInRow(AtomicHTMLToken*);
    140     void processEndTagForInCell(AtomicHTMLToken*);
    141 
    142     void processIsindexStartTagForInBody(AtomicHTMLToken*);
    143     void processHtmlStartTagForInBody(AtomicHTMLToken*);
    144     bool processBodyEndTagForInBody(AtomicHTMLToken*);
    145     bool processTableEndTagForInTable();
    146     bool processCaptionEndTagForInCaption();
    147     bool processColgroupEndTagForInColumnGroup();
    148     bool processTrEndTagForInRow();
    149     // FIXME: This function should be inlined into its one call site or it
    150     // needs to assert which tokens it can be called with.
    151     void processAnyOtherEndTagForInBody(AtomicHTMLToken*);
    152 
    153     void processCharacterBuffer(CharacterTokenBuffer&);
    154     inline void processCharacterBufferForInBody(CharacterTokenBuffer&);
    155 
    156     void processFakeStartTag(const QualifiedName&, const Vector<Attribute>& attributes = Vector<Attribute>());
    157     void processFakeEndTag(const QualifiedName&);
    158     void processFakeEndTag(const AtomicString&);
    159     void processFakePEndTagIfPInButtonScope();
    160 
    161     void processGenericRCDATAStartTag(AtomicHTMLToken*);
    162     void processGenericRawTextStartTag(AtomicHTMLToken*);
    163     void processScriptStartTag(AtomicHTMLToken*);
    164 
    165     // Default processing for the different insertion modes.
    166     void defaultForInitial();
    167     void defaultForBeforeHTML();
    168     void defaultForBeforeHead();
    169     void defaultForInHead();
    170     void defaultForInHeadNoscript();
    171     void defaultForAfterHead();
    172     void defaultForInTableText();
    173 
    174     inline HTMLStackItem* adjustedCurrentStackItem() const;
    175     inline bool shouldProcessTokenInForeignContent(AtomicHTMLToken*);
    176     void processTokenInForeignContent(AtomicHTMLToken*);
    177 
    178     Vector<Attribute> attributesForIsindexInput(AtomicHTMLToken*);
    179 
    180     void callTheAdoptionAgency(AtomicHTMLToken*);
    181 
    182     void closeTheCell();
    183 
    184     template <bool shouldClose(const HTMLStackItem*)>
    185     void processCloseWhenNestedTag(AtomicHTMLToken*);
    186 
    187     void parseError(AtomicHTMLToken*);
    188 
    189     InsertionMode insertionMode() const { return m_insertionMode; }
    190     void setInsertionMode(InsertionMode mode) { m_insertionMode = mode; }
    191 
    192     void resetInsertionModeAppropriately();
    193 
    194     void processTemplateStartTag(AtomicHTMLToken*);
    195     bool processTemplateEndTag(AtomicHTMLToken*);
    196     bool processEndOfFileForInTemplateContents(AtomicHTMLToken*);
    197 
    198     class FragmentParsingContext {
    199         WTF_MAKE_NONCOPYABLE(FragmentParsingContext);
    200         DISALLOW_ALLOCATION();
    201     public:
    202         FragmentParsingContext();
    203         FragmentParsingContext(DocumentFragment*, Element* contextElement);
    204         ~FragmentParsingContext();
    205 
    206         DocumentFragment* fragment() const { return m_fragment; }
    207         Element* contextElement() const { ASSERT(m_fragment); return m_contextElementStackItem->element(); }
    208         HTMLStackItem* contextElementStackItem() const { ASSERT(m_fragment); return m_contextElementStackItem.get(); }
    209 
    210         void trace(Visitor*);
    211 
    212     private:
    213         RawPtrWillBeMember<DocumentFragment> m_fragment;
    214         RefPtrWillBeMember<HTMLStackItem> m_contextElementStackItem;
    215     };
    216 
    217     bool m_framesetOk;
    218 #if ENABLE(ASSERT)
    219     bool m_isAttached;
    220 #endif
    221     FragmentParsingContext m_fragmentContext;
    222     HTMLConstructionSite m_tree;
    223 
    224     // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#insertion-mode
    225     InsertionMode m_insertionMode;
    226 
    227     // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#original-insertion-mode
    228     InsertionMode m_originalInsertionMode;
    229 
    230     Vector<InsertionMode> m_templateInsertionModes;
    231 
    232     // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#pending-table-character-tokens
    233     StringBuilder m_pendingTableCharacters;
    234 
    235     bool m_shouldSkipLeadingNewline;
    236 
    237     // We access parser because HTML5 spec requires that we be able to change the state of the tokenizer
    238     // from within parser actions. We also need it to track the current position.
    239     RawPtrWillBeMember<HTMLDocumentParser> m_parser;
    240 
    241     RefPtrWillBeMember<Element> m_scriptToProcess; // <script> tag which needs processing before resuming the parser.
    242     TextPosition m_scriptToProcessStartPosition; // Starting line number of the script tag needing processing.
    243 
    244     HTMLParserOptions m_options;
    245 };
    246 
    247 }
    248 
    249 #endif
    250