The Tor Browser: parser/html/nsHtml5Parser.cpp@8bccb770b82d (annotated)

parser/html/nsHtml5Parser.cpp@8bccb770b82d (annotated)

parser/html/nsHtml5Parser.cpp

Wed, 31 Dec 2014 13:27:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 13:27:57 +0100
branch: TOR_BUG_3246
changeset 6: 8bccb770b82d
permissions: -rw-r--r--

Ignore runtime configuration files generated during quality assurance.

 /* -*- 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.Assign("view");
 }
 NS_IMETHODIMP_(void)
 nsHtml5Parser::SetCommand(const char* aCommand)
 {
   NS_ASSERTION(!strcmp(aCommand, "view") ||
                !strcmp(aCommand, "view-source") ||
                !strcmp(aCommand, "external-resource") ||
                !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;
 }
 NS_IMETHODIMP
 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.
   nsRefPtr<nsHtml5StreamParser> streamKungFuDeathGrip(GetStreamParser());
   nsRefPtr<nsHtml5TreeOpExecutor> treeOpKungFuDeathGrip(mExecutor);
   if (!mExecutor->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
     mExecutor->SetParser(this);
     mTreeBuilder->setScriptingEnabled(mExecutor->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();
     mExecutor->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 = mExecutor->WillBuildModel(eDTDMode_unknown);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   // Return early if the parser has processed EOF
   if (mExecutor->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.
   nsRefPtr<nsHtml5OwningUTF16Buffer> prevSearchBuf;
   nsRefPtr<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();
       }
       mLastWasCR = mTokenizer->tokenizeBuffer(&stackBuffer);
       if (inRootContext) {
         mRootContextLineNumber = mTokenizer->getLineNumber();
       } else {
         mTokenizer->setLineNumber(lineNumberSave);
       }
       if (mTreeBuilder->HasScript()) {
         mTreeBuilder->Flush(); // Move ops to the executor
         rv = mExecutor->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 (mExecutor->IsComplete()) {
           return NS_OK;
         }
       }
       // Ignore suspension requests
     }
   }
   nsRefPtr<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 mExecutor->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 = mExecutor->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, mExecutor->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()) {
         mDocWriteSpeculativeLastWasCR =
             mDocWriteSpeculativeTokenizer->tokenizeBuffer(&stackBuffer);
       }
     }
     mDocWriteSpeculativeTreeBuilder->Flush();
     mDocWriteSpeculativeTreeBuilder->DropHandles();
     mExecutor->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);
   nsRefPtr<nsHtml5StreamParser> streamKungFuDeathGrip(GetStreamParser());
   nsRefPtr<nsHtml5TreeOpExecutor> treeOpKungFuDeathGrip(mExecutor);
   if (GetStreamParser()) {
     GetStreamParser()->Terminate();
   }
   return mExecutor->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::CanInterrupt()
 {
   // nsContentSink needs this to let nsContentSink::DidProcessATokenImpl
   // interrupt.
   return true;
 }
 bool
 nsHtml5Parser::IsInsertionPointDefined()
 {
   return !mExecutor->IsFlushing() &&
     (!GetStreamParser() || mParserInsertedScriptsBeingEvaluated);
 }
 void
 nsHtml5Parser::BeginEvaluatingParserInsertedScript()
 {
   ++mParserInsertedScriptsBeingEvaluated;
 }
 void
 nsHtml5Parser::EndEvaluatingParserInsertedScript()
 {
   --mParserInsertedScriptsBeingEvaluated;
 }
 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"),
                  "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) {
           NS_ASSERTION(!GetStreamParser(),
                        "This should only happen with script-created parser.");
           mTokenizer->eof();
           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 NS_OK;
         }
         // 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);
       }
       mLastWasCR = mTokenizer->tokenizeBuffer(mFirstBuffer);
       if (inRootContext) {
         mRootContextLineNumber = mTokenizer->getLineNumber();
       }
       if (mTreeBuilder->HasScript()) {
         mTreeBuilder->Flush();
         nsresult 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();
 }

The Tor Browser / annotate

parser/html/nsHtml5Parser.cpp@8bccb770b82d (annotated)

parser/html/nsHtml5Parser.cpp