diff options
Diffstat (limited to 'parser/html/nsHtml5Parser.cpp')
| -rw-r--r-- | parser/html/nsHtml5Parser.cpp | 754 |
1 files changed, 754 insertions, 0 deletions
diff --git a/parser/html/nsHtml5Parser.cpp b/parser/html/nsHtml5Parser.cpp new file mode 100644 index 000000000..e8ca12f89 --- /dev/null +++ b/parser/html/nsHtml5Parser.cpp @@ -0,0 +1,754 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set sw=2 ts=2 et tw=79: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "nsHtml5Parser.h" + +#include "mozilla/AutoRestore.h" +#include "nsContentUtils.h" // for kLoadAsData +#include "nsHtml5Tokenizer.h" +#include "nsHtml5TreeBuilder.h" +#include "nsHtml5AtomTable.h" +#include "nsHtml5DependentUTF16Buffer.h" +#include "nsNetUtil.h" + +NS_INTERFACE_TABLE_HEAD(nsHtml5Parser) + NS_INTERFACE_TABLE(nsHtml5Parser, nsIParser, nsISupportsWeakReference) + NS_INTERFACE_TABLE_TO_MAP_SEGUE_CYCLE_COLLECTION(nsHtml5Parser) +NS_INTERFACE_MAP_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(nsHtml5Parser) +NS_IMPL_CYCLE_COLLECTING_RELEASE(nsHtml5Parser) + +NS_IMPL_CYCLE_COLLECTION_CLASS(nsHtml5Parser) + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsHtml5Parser) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mExecutor) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(GetStreamParser()) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsHtml5Parser) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mExecutor) + tmp->DropStreamParser(); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +nsHtml5Parser::nsHtml5Parser() + : mFirstBuffer(new nsHtml5OwningUTF16Buffer((void*)nullptr)) + , mLastBuffer(mFirstBuffer) + , mExecutor(new nsHtml5TreeOpExecutor()) + , mTreeBuilder(new nsHtml5TreeBuilder(mExecutor, nullptr)) + , mTokenizer(new nsHtml5Tokenizer(mTreeBuilder, false)) + , mRootContextLineNumber(1) +{ + mTokenizer->setInterner(&mAtomTable); + // There's a zeroing operator new for everything else +} + +nsHtml5Parser::~nsHtml5Parser() +{ + mTokenizer->end(); + if (mDocWriteSpeculativeTokenizer) { + mDocWriteSpeculativeTokenizer->end(); + } +} + +NS_IMETHODIMP_(void) +nsHtml5Parser::SetContentSink(nsIContentSink* aSink) +{ + NS_ASSERTION(aSink == static_cast<nsIContentSink*> (mExecutor), + "Attempt to set a foreign sink."); +} + +NS_IMETHODIMP_(nsIContentSink*) +nsHtml5Parser::GetContentSink() +{ + return static_cast<nsIContentSink*> (mExecutor); +} + +NS_IMETHODIMP_(void) +nsHtml5Parser::GetCommand(nsCString& aCommand) +{ + aCommand.AssignLiteral("view"); +} + +NS_IMETHODIMP_(void) +nsHtml5Parser::SetCommand(const char* aCommand) +{ + NS_ASSERTION(!strcmp(aCommand, "view") || + !strcmp(aCommand, "view-source") || + !strcmp(aCommand, "external-resource") || + !strcmp(aCommand, "import") || + !strcmp(aCommand, kLoadAsData), + "Unsupported parser command"); +} + +NS_IMETHODIMP_(void) +nsHtml5Parser::SetCommand(eParserCommands aParserCommand) +{ + NS_ASSERTION(aParserCommand == eViewNormal, + "Parser command was not eViewNormal."); +} + +NS_IMETHODIMP_(void) +nsHtml5Parser::SetDocumentCharset(const nsACString& aCharset, + int32_t aCharsetSource) +{ + NS_PRECONDITION(!mExecutor->HasStarted(), + "Document charset set too late."); + NS_PRECONDITION(GetStreamParser(), "Setting charset on a script-only parser."); + nsAutoCString trimmed; + trimmed.Assign(aCharset); + trimmed.Trim(" \t\r\n\f"); + GetStreamParser()->SetDocumentCharset(trimmed, aCharsetSource); + mExecutor->SetDocumentCharsetAndSource(trimmed, + aCharsetSource); +} + +NS_IMETHODIMP +nsHtml5Parser::GetChannel(nsIChannel** aChannel) +{ + if (GetStreamParser()) { + return GetStreamParser()->GetChannel(aChannel); + } else { + return NS_ERROR_NOT_AVAILABLE; + } +} + +NS_IMETHODIMP +nsHtml5Parser::GetDTD(nsIDTD** aDTD) +{ + *aDTD = nullptr; + return NS_OK; +} + +nsIStreamListener* +nsHtml5Parser::GetStreamListener() +{ + return mStreamListener; +} + +NS_IMETHODIMP +nsHtml5Parser::ContinueInterruptedParsing() +{ + NS_NOTREACHED("Don't call. For interface compat only."); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP_(void) +nsHtml5Parser::BlockParser() +{ + mBlocked = true; +} + +NS_IMETHODIMP_(void) +nsHtml5Parser::UnblockParser() +{ + mBlocked = false; + mExecutor->ContinueInterruptedParsingAsync(); +} + +NS_IMETHODIMP_(void) +nsHtml5Parser::ContinueInterruptedParsingAsync() +{ + mExecutor->ContinueInterruptedParsingAsync(); +} + +NS_IMETHODIMP_(bool) +nsHtml5Parser::IsParserEnabled() +{ + return !mBlocked; +} + +NS_IMETHODIMP_(bool) +nsHtml5Parser::IsComplete() +{ + return mExecutor->IsComplete(); +} + +NS_IMETHODIMP +nsHtml5Parser::Parse(nsIURI* aURL, + nsIRequestObserver* aObserver, + void* aKey, // legacy; ignored + nsDTDMode aMode) // legacy; ignored +{ + /* + * Do NOT cause WillBuildModel to be called synchronously from here! + * The document won't be ready for it until OnStartRequest! + */ + NS_PRECONDITION(!mExecutor->HasStarted(), + "Tried to start parse without initializing the parser."); + NS_PRECONDITION(GetStreamParser(), + "Can't call this Parse() variant on script-created parser"); + GetStreamParser()->SetObserver(aObserver); + GetStreamParser()->SetViewSourceTitle(aURL); // In case we're viewing source + mExecutor->SetStreamParser(GetStreamParser()); + mExecutor->SetParser(this); + return NS_OK; +} + +nsresult +nsHtml5Parser::Parse(const nsAString& aSourceBuffer, + void* aKey, + const nsACString& aContentType, + bool aLastCall, + nsDTDMode aMode) // ignored +{ + nsresult rv; + if (NS_FAILED(rv = mExecutor->IsBroken())) { + return rv; + } + if (aSourceBuffer.Length() > INT32_MAX) { + return mExecutor->MarkAsBroken(NS_ERROR_OUT_OF_MEMORY); + } + + // Maintain a reference to ourselves so we don't go away + // till we're completely done. The old parser grips itself in this method. + nsCOMPtr<nsIParser> kungFuDeathGrip(this); + + // Gripping the other objects just in case, since the other old grip + // required grips to these, too. + RefPtr<nsHtml5StreamParser> streamKungFuDeathGrip(GetStreamParser()); + mozilla::Unused << streamKungFuDeathGrip; // Not used within function + RefPtr<nsHtml5TreeOpExecutor> executor(mExecutor); + + if (!executor->HasStarted()) { + NS_ASSERTION(!GetStreamParser(), + "Had stream parser but document.write started life cycle."); + // This is the first document.write() on a document.open()ed document + executor->SetParser(this); + mTreeBuilder->setScriptingEnabled(executor->IsScriptEnabled()); + + bool isSrcdoc = false; + nsCOMPtr<nsIChannel> channel; + rv = GetChannel(getter_AddRefs(channel)); + if (NS_SUCCEEDED(rv)) { + isSrcdoc = NS_IsSrcdocChannel(channel); + } + mTreeBuilder->setIsSrcdocDocument(isSrcdoc); + + mTokenizer->start(); + executor->Start(); + if (!aContentType.EqualsLiteral("text/html")) { + mTreeBuilder->StartPlainText(); + mTokenizer->StartPlainText(); + } + /* + * If you move the following line, be very careful not to cause + * WillBuildModel to be called before the document has had its + * script global object set. + */ + rv = executor->WillBuildModel(eDTDMode_unknown); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Return early if the parser has processed EOF + if (executor->IsComplete()) { + return NS_OK; + } + + if (aLastCall && aSourceBuffer.IsEmpty() && !aKey) { + // document.close() + NS_ASSERTION(!GetStreamParser(), + "Had stream parser but got document.close()."); + if (mDocumentClosed) { + // already closed + return NS_OK; + } + mDocumentClosed = true; + if (!mBlocked && !mInDocumentWrite) { + return ParseUntilBlocked(); + } + return NS_OK; + } + + // If we got this far, we are dealing with a document.write or + // document.writeln call--not document.close(). + + NS_ASSERTION(IsInsertionPointDefined(), + "Doc.write reached parser with undefined insertion point."); + + NS_ASSERTION(!(GetStreamParser() && !aKey), + "Got a null key in a non-script-created parser"); + + // XXX is this optimization bogus? + if (aSourceBuffer.IsEmpty()) { + return NS_OK; + } + + // This guard is here to prevent document.close from tokenizing synchronously + // while a document.write (that wrote the script that called document.close!) + // is still on the call stack. + mozilla::AutoRestore<bool> guard(mInDocumentWrite); + mInDocumentWrite = true; + + // The script is identified by aKey. If there's nothing in the buffer + // chain for that key, we'll insert at the head of the queue. + // When the script leaves something in the queue, a zero-length + // key-holder "buffer" is inserted in the queue. If the same script + // leaves something in the chain again, it will be inserted immediately + // before the old key holder belonging to the same script. + // + // We don't do the actual data insertion yet in the hope that the data gets + // tokenized and there no data or less data to copy to the heap after + // tokenization. Also, this way, we avoid inserting one empty data buffer + // per document.write, which matters for performance when the parser isn't + // blocked and a badly-authored script calls document.write() once per + // input character. (As seen in a benchmark!) + // + // The insertion into the input stream happens conceptually before anything + // gets tokenized. To make sure multi-level document.write works right, + // it's necessary to establish the location of our parser key up front + // in case this is the first write with this key. + // + // In a document.open() case, the first write level has a null key, so that + // case is handled separately, because normal buffers containing data + // have null keys. + + // These don't need to be owning references, because they always point to + // the buffer queue and buffers can't be removed from the buffer queue + // before document.write() returns. The buffer queue clean-up happens the + // next time ParseUntilBlocked() is called. + // However, they are made owning just in case the reasoning above is flawed + // and a flaw would lead to worse problems with plain pointers. If this + // turns out to be a perf problem, it's worthwhile to consider making + // prevSearchbuf a plain pointer again. + RefPtr<nsHtml5OwningUTF16Buffer> prevSearchBuf; + RefPtr<nsHtml5OwningUTF16Buffer> firstLevelMarker; + + if (aKey) { + if (mFirstBuffer == mLastBuffer) { + nsHtml5OwningUTF16Buffer* keyHolder = new nsHtml5OwningUTF16Buffer(aKey); + keyHolder->next = mLastBuffer; + mFirstBuffer = keyHolder; + } else if (mFirstBuffer->key != aKey) { + prevSearchBuf = mFirstBuffer; + for (;;) { + if (prevSearchBuf->next == mLastBuffer) { + // key was not found + nsHtml5OwningUTF16Buffer* keyHolder = + new nsHtml5OwningUTF16Buffer(aKey); + keyHolder->next = mFirstBuffer; + mFirstBuffer = keyHolder; + prevSearchBuf = nullptr; + break; + } + if (prevSearchBuf->next->key == aKey) { + // found a key holder + break; + } + prevSearchBuf = prevSearchBuf->next; + } + } // else mFirstBuffer is the keyholder + + // prevSearchBuf is the previous buffer before the keyholder or null if + // there isn't one. + } else { + // We have a first-level write in the document.open() case. We insert before + // mLastBuffer, effectively, by making mLastBuffer be a new sentinel object + // and redesignating the previous mLastBuffer as our firstLevelMarker. We + // need to put a marker there, because otherwise additional document.writes + // from nested event loops would insert in the wrong place. Sigh. + mLastBuffer->next = new nsHtml5OwningUTF16Buffer((void*)nullptr); + firstLevelMarker = mLastBuffer; + mLastBuffer = mLastBuffer->next; + } + + nsHtml5DependentUTF16Buffer stackBuffer(aSourceBuffer); + + while (!mBlocked && stackBuffer.hasMore()) { + stackBuffer.adjust(mLastWasCR); + mLastWasCR = false; + if (stackBuffer.hasMore()) { + int32_t lineNumberSave; + bool inRootContext = (!GetStreamParser() && !aKey); + if (inRootContext) { + mTokenizer->setLineNumber(mRootContextLineNumber); + } else { + // we aren't the root context, so save the line number on the + // *stack* so that we can restore it. + lineNumberSave = mTokenizer->getLineNumber(); + } + + if (!mTokenizer->EnsureBufferSpace(stackBuffer.getLength())) { + return executor->MarkAsBroken(NS_ERROR_OUT_OF_MEMORY); + } + mLastWasCR = mTokenizer->tokenizeBuffer(&stackBuffer); + if (NS_FAILED((rv = mTreeBuilder->IsBroken()))) { + return executor->MarkAsBroken(rv); + } + + if (inRootContext) { + mRootContextLineNumber = mTokenizer->getLineNumber(); + } else { + mTokenizer->setLineNumber(lineNumberSave); + } + + if (mTreeBuilder->HasScript()) { + mTreeBuilder->Flush(); // Move ops to the executor + rv = executor->FlushDocumentWrite(); // run the ops + NS_ENSURE_SUCCESS(rv, rv); + // Flushing tree ops can cause all sorts of things. + // Return early if the parser got terminated. + if (executor->IsComplete()) { + return NS_OK; + } + } + // Ignore suspension requests + } + } + + RefPtr<nsHtml5OwningUTF16Buffer> heapBuffer; + if (stackBuffer.hasMore()) { + // The buffer wasn't tokenized to completion. Create a copy of the tail + // on the heap. + heapBuffer = stackBuffer.FalliblyCopyAsOwningBuffer(); + if (!heapBuffer) { + // Allocation failed. The parser is now broken. + return executor->MarkAsBroken(NS_ERROR_OUT_OF_MEMORY); + } + } + + if (heapBuffer) { + // We have something to insert before the keyholder holding in the non-null + // aKey case and we have something to swap into firstLevelMarker in the + // null aKey case. + if (aKey) { + NS_ASSERTION(mFirstBuffer != mLastBuffer, + "Where's the keyholder?"); + // the key holder is still somewhere further down the list from + // prevSearchBuf (which may be null) + if (mFirstBuffer->key == aKey) { + NS_ASSERTION(!prevSearchBuf, + "Non-null prevSearchBuf when mFirstBuffer is the key holder?"); + heapBuffer->next = mFirstBuffer; + mFirstBuffer = heapBuffer; + } else { + if (!prevSearchBuf) { + prevSearchBuf = mFirstBuffer; + } + // We created a key holder earlier, so we will find it without walking + // past the end of the list. + while (prevSearchBuf->next->key != aKey) { + prevSearchBuf = prevSearchBuf->next; + } + heapBuffer->next = prevSearchBuf->next; + prevSearchBuf->next = heapBuffer; + } + } else { + NS_ASSERTION(firstLevelMarker, "How come we don't have a marker."); + firstLevelMarker->Swap(heapBuffer); + } + } + + if (!mBlocked) { // buffer was tokenized to completion + NS_ASSERTION(!stackBuffer.hasMore(), + "Buffer wasn't tokenized to completion?"); + // Scripting semantics require a forced tree builder flush here + mTreeBuilder->Flush(); // Move ops to the executor + rv = executor->FlushDocumentWrite(); // run the ops + NS_ENSURE_SUCCESS(rv, rv); + } else if (stackBuffer.hasMore()) { + // The buffer wasn't tokenized to completion. Tokenize the untokenized + // content in order to preload stuff. This content will be retokenized + // later for normal parsing. + if (!mDocWriteSpeculatorActive) { + mDocWriteSpeculatorActive = true; + if (!mDocWriteSpeculativeTreeBuilder) { + // Lazily initialize if uninitialized + mDocWriteSpeculativeTreeBuilder = + new nsHtml5TreeBuilder(nullptr, executor->GetStage()); + mDocWriteSpeculativeTreeBuilder->setScriptingEnabled( + mTreeBuilder->isScriptingEnabled()); + mDocWriteSpeculativeTokenizer = + new nsHtml5Tokenizer(mDocWriteSpeculativeTreeBuilder, false); + mDocWriteSpeculativeTokenizer->setInterner(&mAtomTable); + mDocWriteSpeculativeTokenizer->start(); + } + mDocWriteSpeculativeTokenizer->resetToDataState(); + mDocWriteSpeculativeTreeBuilder->loadState(mTreeBuilder, &mAtomTable); + mDocWriteSpeculativeLastWasCR = false; + } + + // Note that with multilevel document.write if we didn't just activate the + // speculator, it's possible that the speculator is now in the wrong state. + // That's OK for the sake of simplicity. The worst that can happen is + // that the speculative loads aren't exactly right. The content will be + // reparsed anyway for non-preload purposes. + + // The buffer position for subsequent non-speculative parsing now lives + // in heapBuffer, so it's ok to let the buffer position of stackBuffer + // to be overwritten and not restored below. + while (stackBuffer.hasMore()) { + stackBuffer.adjust(mDocWriteSpeculativeLastWasCR); + if (stackBuffer.hasMore()) { + if (!mDocWriteSpeculativeTokenizer->EnsureBufferSpace( + stackBuffer.getLength())) { + return executor->MarkAsBroken(NS_ERROR_OUT_OF_MEMORY); + } + mDocWriteSpeculativeLastWasCR = + mDocWriteSpeculativeTokenizer->tokenizeBuffer(&stackBuffer); + nsresult rv; + if (NS_FAILED((rv = mDocWriteSpeculativeTreeBuilder->IsBroken()))) { + return executor->MarkAsBroken(rv); + } + } + } + + mDocWriteSpeculativeTreeBuilder->Flush(); + mDocWriteSpeculativeTreeBuilder->DropHandles(); + executor->FlushSpeculativeLoads(); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsHtml5Parser::Terminate() +{ + // We should only call DidBuildModel once, so don't do anything if this is + // the second time that Terminate has been called. + if (mExecutor->IsComplete()) { + return NS_OK; + } + // XXX - [ until we figure out a way to break parser-sink circularity ] + // Hack - Hold a reference until we are completely done... + nsCOMPtr<nsIParser> kungFuDeathGrip(this); + RefPtr<nsHtml5StreamParser> streamParser(GetStreamParser()); + RefPtr<nsHtml5TreeOpExecutor> executor(mExecutor); + if (streamParser) { + streamParser->Terminate(); + } + return executor->DidBuildModel(true); +} + +NS_IMETHODIMP +nsHtml5Parser::ParseFragment(const nsAString& aSourceBuffer, + nsTArray<nsString>& aTagStack) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsHtml5Parser::BuildModel() +{ + NS_NOTREACHED("Don't call this!"); + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsHtml5Parser::CancelParsingEvents() +{ + NS_NOTREACHED("Don't call this!"); + return NS_ERROR_NOT_IMPLEMENTED; +} + +void +nsHtml5Parser::Reset() +{ + NS_NOTREACHED("Don't call this!"); +} + +bool +nsHtml5Parser::IsInsertionPointDefined() +{ + return !mExecutor->IsFlushing() && + (!GetStreamParser() || mInsertionPointPushLevel); +} + +void +nsHtml5Parser::PushDefinedInsertionPoint() +{ + ++mInsertionPointPushLevel; +} + +void +nsHtml5Parser::PopDefinedInsertionPoint() +{ + --mInsertionPointPushLevel; +} + +void +nsHtml5Parser::MarkAsNotScriptCreated(const char* aCommand) +{ + NS_PRECONDITION(!mStreamListener, "Must not call this twice."); + eParserMode mode = NORMAL; + if (!nsCRT::strcmp(aCommand, "view-source")) { + mode = VIEW_SOURCE_HTML; + } else if (!nsCRT::strcmp(aCommand, "view-source-xml")) { + mode = VIEW_SOURCE_XML; + } else if (!nsCRT::strcmp(aCommand, "view-source-plain")) { + mode = VIEW_SOURCE_PLAIN; + } else if (!nsCRT::strcmp(aCommand, "plain-text")) { + mode = PLAIN_TEXT; + } else if (!nsCRT::strcmp(aCommand, kLoadAsData)) { + mode = LOAD_AS_DATA; + } +#ifdef DEBUG + else { + NS_ASSERTION(!nsCRT::strcmp(aCommand, "view") || + !nsCRT::strcmp(aCommand, "external-resource") || + !nsCRT::strcmp(aCommand, "import"), + "Unsupported parser command!"); + } +#endif + mStreamListener = + new nsHtml5StreamListener(new nsHtml5StreamParser(mExecutor, this, mode)); +} + +bool +nsHtml5Parser::IsScriptCreated() +{ + return !GetStreamParser(); +} + +/* End nsIParser */ + +// not from interface +nsresult +nsHtml5Parser::ParseUntilBlocked() +{ + nsresult rv = mExecutor->IsBroken(); + NS_ENSURE_SUCCESS(rv, rv); + if (mBlocked || mExecutor->IsComplete()) { + return NS_OK; + } + NS_ASSERTION(mExecutor->HasStarted(), "Bad life cycle."); + NS_ASSERTION(!mInDocumentWrite, + "ParseUntilBlocked entered while in doc.write!"); + + mDocWriteSpeculatorActive = false; + + for (;;) { + if (!mFirstBuffer->hasMore()) { + if (mFirstBuffer == mLastBuffer) { + if (mExecutor->IsComplete()) { + // something like cache manisfests stopped the parse in mid-flight + return NS_OK; + } + if (mDocumentClosed) { + nsresult rv; + NS_ASSERTION(!GetStreamParser(), + "This should only happen with script-created parser."); + if (NS_SUCCEEDED((rv = mExecutor->IsBroken()))) { + mTokenizer->eof(); + if (NS_FAILED((rv = mTreeBuilder->IsBroken()))) { + mExecutor->MarkAsBroken(rv); + } else { + mTreeBuilder->StreamEnded(); + } + } + mTreeBuilder->Flush(); + mExecutor->FlushDocumentWrite(); + // The below call does memory cleanup, so call it even if the + // parser has been marked as broken. + mTokenizer->end(); + return rv; + } + // never release the last buffer. + NS_ASSERTION(!mLastBuffer->getStart() && !mLastBuffer->getEnd(), + "Sentinel buffer had its indeces changed."); + if (GetStreamParser()) { + if (mReturnToStreamParserPermitted && + !mExecutor->IsScriptExecuting()) { + mTreeBuilder->Flush(); + mReturnToStreamParserPermitted = false; + GetStreamParser()->ContinueAfterScripts(mTokenizer, + mTreeBuilder, + mLastWasCR); + } + } else { + // Script-created parser + mTreeBuilder->Flush(); + // No need to flush the executor, because the executor is already + // in a flush + NS_ASSERTION(mExecutor->IsInFlushLoop(), + "How did we come here without being in the flush loop?"); + } + return NS_OK; // no more data for now but expecting more + } + mFirstBuffer = mFirstBuffer->next; + continue; + } + + if (mBlocked || mExecutor->IsComplete()) { + return NS_OK; + } + + // now we have a non-empty buffer + mFirstBuffer->adjust(mLastWasCR); + mLastWasCR = false; + if (mFirstBuffer->hasMore()) { + bool inRootContext = (!GetStreamParser() && !mFirstBuffer->key); + if (inRootContext) { + mTokenizer->setLineNumber(mRootContextLineNumber); + } + if (!mTokenizer->EnsureBufferSpace(mFirstBuffer->getLength())) { + return mExecutor->MarkAsBroken(NS_ERROR_OUT_OF_MEMORY); + } + mLastWasCR = mTokenizer->tokenizeBuffer(mFirstBuffer); + nsresult rv; + if (NS_FAILED((rv = mTreeBuilder->IsBroken()))) { + return mExecutor->MarkAsBroken(rv); + } + if (inRootContext) { + mRootContextLineNumber = mTokenizer->getLineNumber(); + } + if (mTreeBuilder->HasScript()) { + mTreeBuilder->Flush(); + rv = mExecutor->FlushDocumentWrite(); + NS_ENSURE_SUCCESS(rv, rv); + } + if (mBlocked) { + return NS_OK; + } + } + continue; + } +} + +nsresult +nsHtml5Parser::Initialize(nsIDocument* aDoc, + nsIURI* aURI, + nsISupports* aContainer, + nsIChannel* aChannel) +{ + return mExecutor->Init(aDoc, aURI, aContainer, aChannel); +} + +void +nsHtml5Parser::StartTokenizer(bool aScriptingEnabled) { + + bool isSrcdoc = false; + nsCOMPtr<nsIChannel> channel; + nsresult rv = GetChannel(getter_AddRefs(channel)); + if (NS_SUCCEEDED(rv)) { + isSrcdoc = NS_IsSrcdocChannel(channel); + } + mTreeBuilder->setIsSrcdocDocument(isSrcdoc); + + mTreeBuilder->SetPreventScriptExecution(!aScriptingEnabled); + mTreeBuilder->setScriptingEnabled(aScriptingEnabled); + mTokenizer->start(); +} + +void +nsHtml5Parser::InitializeDocWriteParserState(nsAHtml5TreeBuilderState* aState, + int32_t aLine) +{ + mTokenizer->resetToDataState(); + mTokenizer->setLineNumber(aLine); + mTreeBuilder->loadState(aState, &mAtomTable); + mLastWasCR = false; + mReturnToStreamParserPermitted = true; +} + +void +nsHtml5Parser::ContinueAfterFailedCharsetSwitch() +{ + NS_PRECONDITION(GetStreamParser(), + "Tried to continue after failed charset switch without a stream parser"); + GetStreamParser()->ContinueAfterFailedCharsetSwitch(); +} + |