Add m-esr52 at 52.6.0

1 files changed, 1600 insertions, 0 deletions

diff --git a/parser/htmlparser/nsParser.cpp b/parser/htmlparser/nsParser.cpp
new file mode 100644
index 000000000..dd140c553
--- /dev/null
+++ b/parser/htmlparser/nsParser.cpp
@@ -0,0 +1,1600 @@
+/* -*- 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 "nsIAtom.h"
+#include "nsParser.h"
+#include "nsString.h"
+#include "nsCRT.h"
+#include "nsScanner.h"
+#include "plstr.h"
+#include "nsIStringStream.h"
+#include "nsIChannel.h"
+#include "nsICachingChannel.h"
+#include "nsIInputStream.h"
+#include "CNavDTD.h"
+#include "prenv.h"
+#include "prlock.h"
+#include "prcvar.h"
+#include "nsParserCIID.h"
+#include "nsReadableUtils.h"
+#include "nsCOMPtr.h"
+#include "nsExpatDriver.h"
+#include "nsIServiceManager.h"
+#include "nsICategoryManager.h"
+#include "nsISupportsPrimitives.h"
+#include "nsIFragmentContentSink.h"
+#include "nsStreamUtils.h"
+#include "nsHTMLTokenizer.h"
+#include "nsScriptLoader.h"
+#include "nsDataHashtable.h"
+#include "nsXPCOMCIDInternal.h"
+#include "nsMimeTypes.h"
+#include "mozilla/CondVar.h"
+#include "mozilla/Mutex.h"
+#include "nsParserConstants.h"
+#include "nsCharsetSource.h"
+#include "nsContentUtils.h"
+#include "nsThreadUtils.h"
+#include "nsIHTMLContentSink.h"
+
+#include "mozilla/dom/EncodingUtils.h"
+#include "mozilla/BinarySearch.h"
+
+using namespace mozilla;
+using mozilla::dom::EncodingUtils;
+
+#define NS_PARSER_FLAG_PARSER_ENABLED         0x00000002
+#define NS_PARSER_FLAG_OBSERVERS_ENABLED      0x00000004
+#define NS_PARSER_FLAG_PENDING_CONTINUE_EVENT 0x00000008
+#define NS_PARSER_FLAG_FLUSH_TOKENS           0x00000020
+#define NS_PARSER_FLAG_CAN_TOKENIZE           0x00000040
+
+//-------------- Begin ParseContinue Event Definition ------------------------
+/*
+The parser can be explicitly interrupted by passing a return value of
+NS_ERROR_HTMLPARSER_INTERRUPTED from BuildModel on the DTD. This will cause
+the parser to stop processing and allow the application to return to the event
+loop. The data which was left at the time of interruption will be processed
+the next time OnDataAvailable is called. If the parser has received its final
+chunk of data then OnDataAvailable will no longer be called by the networking
+module, so the parser will schedule a nsParserContinueEvent which will call
+the parser to process the remaining data after returning to the event loop.
+If the parser is interrupted while processing the remaining data it will
+schedule another ParseContinueEvent. The processing of data followed by
+scheduling of the continue events will proceed until either:
+
+  1) All of the remaining data can be processed without interrupting
+  2) The parser has been cancelled.
+
+
+This capability is currently used in CNavDTD and nsHTMLContentSink. The
+nsHTMLContentSink is notified by CNavDTD when a chunk of tokens is going to be
+processed and when each token is processed. The nsHTML content sink records
+the time when the chunk has started processing and will return
+NS_ERROR_HTMLPARSER_INTERRUPTED if the token processing time has exceeded a
+threshold called max tokenizing processing time. This allows the content sink
+to limit how much data is processed in a single chunk which in turn gates how
+much time is spent away from the event loop. Processing smaller chunks of data
+also reduces the time spent in subsequent reflows.
+
+This capability is most apparent when loading large documents. If the maximum
+token processing time is set small enough the application will remain
+responsive during document load.
+
+A side-effect of this capability is that document load is not complete when
+the last chunk of data is passed to OnDataAvailable since  the parser may have
+been interrupted when the last chunk of data arrived. The document is complete
+when all of the document has been tokenized and there aren't any pending
+nsParserContinueEvents. This can cause problems if the application assumes
+that it can monitor the load requests to determine when the document load has
+been completed. This is what happens in Mozilla. The document is considered
+completely loaded when all of the load requests have been satisfied. To delay
+the document load until all of the parsing has been completed the
+nsHTMLContentSink adds a dummy parser load request which is not removed until
+the nsHTMLContentSink's DidBuildModel is called. The CNavDTD will not call
+DidBuildModel until the final chunk of data has been passed to the parser
+through the OnDataAvailable and there aren't any pending
+nsParserContineEvents.
+
+Currently the parser is ignores requests to be interrupted during the
+processing of script.  This is because a document.write followed by JavaScript
+calls to manipulate the DOM may fail if the parser was interrupted during the
+document.write.
+
+For more details @see bugzilla bug 76722
+*/
+
+
+class nsParserContinueEvent : public Runnable
+{
+public:
+  RefPtr<nsParser> mParser;
+
+  explicit nsParserContinueEvent(nsParser* aParser)
+    : mParser(aParser)
+  {}
+
+  NS_IMETHOD Run() override
+  {
+    mParser->HandleParserContinueEvent(this);
+    return NS_OK;
+  }
+};
+
+//-------------- End ParseContinue Event Definition ------------------------
+
+/**
+ *  default constructor
+ */
+nsParser::nsParser()
+{
+  Initialize(true);
+}
+
+nsParser::~nsParser()
+{
+  Cleanup();
+}
+
+void
+nsParser::Initialize(bool aConstructor)
+{
+  if (aConstructor) {
+    // Raw pointer
+    mParserContext = 0;
+  }
+  else {
+    // nsCOMPtrs
+    mObserver = nullptr;
+    mUnusedInput.Truncate();
+  }
+
+  mContinueEvent = nullptr;
+  mCharsetSource = kCharsetUninitialized;
+  mCharset.AssignLiteral("ISO-8859-1");
+  mInternalState = NS_OK;
+  mStreamStatus = NS_OK;
+  mCommand = eViewNormal;
+  mFlags = NS_PARSER_FLAG_OBSERVERS_ENABLED |
+           NS_PARSER_FLAG_PARSER_ENABLED |
+           NS_PARSER_FLAG_CAN_TOKENIZE;
+
+  mProcessingNetworkData = false;
+  mIsAboutBlank = false;
+}
+
+void
+nsParser::Cleanup()
+{
+#ifdef DEBUG
+  if (mParserContext && mParserContext->mPrevContext) {
+    NS_WARNING("Extra parser contexts still on the parser stack");
+  }
+#endif
+
+  while (mParserContext) {
+    CParserContext *pc = mParserContext->mPrevContext;
+    delete mParserContext;
+    mParserContext = pc;
+  }
+
+  // It should not be possible for this flag to be set when we are getting
+  // destroyed since this flag implies a pending nsParserContinueEvent, which
+  // has an owning reference to |this|.
+  NS_ASSERTION(!(mFlags & NS_PARSER_FLAG_PENDING_CONTINUE_EVENT), "bad");
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsParser)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsParser)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mDTD)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mSink)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mObserver)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsParser)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDTD)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSink)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mObserver)
+  CParserContext *pc = tmp->mParserContext;
+  while (pc) {
+    cb.NoteXPCOMChild(pc->mTokenizer);
+    pc = pc->mPrevContext;
+  }
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsParser)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsParser)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsParser)
+  NS_INTERFACE_MAP_ENTRY(nsIStreamListener)
+  NS_INTERFACE_MAP_ENTRY(nsIParser)
+  NS_INTERFACE_MAP_ENTRY(nsIRequestObserver)
+  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIParser)
+NS_INTERFACE_MAP_END
+
+// The parser continue event is posted only if
+// all of the data to parse has been passed to ::OnDataAvailable
+// and the parser has been interrupted by the content sink
+// because the processing of tokens took too long.
+
+nsresult
+nsParser::PostContinueEvent()
+{
+  if (!(mFlags & NS_PARSER_FLAG_PENDING_CONTINUE_EVENT)) {
+    // If this flag isn't set, then there shouldn't be a live continue event!
+    NS_ASSERTION(!mContinueEvent, "bad");
+
+    // This creates a reference cycle between this and the event that is
+    // broken when the event fires.
+    nsCOMPtr<nsIRunnable> event = new nsParserContinueEvent(this);
+    if (NS_FAILED(NS_DispatchToCurrentThread(event))) {
+        NS_WARNING("failed to dispatch parser continuation event");
+    } else {
+        mFlags |= NS_PARSER_FLAG_PENDING_CONTINUE_EVENT;
+        mContinueEvent = event;
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP_(void)
+nsParser::GetCommand(nsCString& aCommand)
+{
+  aCommand = mCommandStr;
+}
+
+/**
+ *  Call this method once you've created a parser, and want to instruct it
+ *  about the command which caused the parser to be constructed. For example,
+ *  this allows us to select a DTD which can do, say, view-source.
+ *
+ *  @param   aCommand the command string to set
+ */
+NS_IMETHODIMP_(void)
+nsParser::SetCommand(const char* aCommand)
+{
+  mCommandStr.Assign(aCommand);
+  if (mCommandStr.EqualsLiteral("view-source")) {
+    mCommand = eViewSource;
+  } else if (mCommandStr.EqualsLiteral("view-fragment")) {
+    mCommand = eViewFragment;
+  } else {
+    mCommand = eViewNormal;
+  }
+}
+
+/**
+ *  Call this method once you've created a parser, and want to instruct it
+ *  about the command which caused the parser to be constructed. For example,
+ *  this allows us to select a DTD which can do, say, view-source.
+ *
+ *  @param   aParserCommand the command to set
+ */
+NS_IMETHODIMP_(void)
+nsParser::SetCommand(eParserCommands aParserCommand)
+{
+  mCommand = aParserCommand;
+}
+
+/**
+ *  Call this method once you've created a parser, and want to instruct it
+ *  about what charset to load
+ *
+ *  @param   aCharset- the charset of a document
+ *  @param   aCharsetSource- the source of the charset
+ */
+NS_IMETHODIMP_(void)
+nsParser::SetDocumentCharset(const nsACString& aCharset, int32_t aCharsetSource)
+{
+  mCharset = aCharset;
+  mCharsetSource = aCharsetSource;
+  if (mParserContext && mParserContext->mScanner) {
+     mParserContext->mScanner->SetDocumentCharset(aCharset, aCharsetSource);
+  }
+}
+
+void
+nsParser::SetSinkCharset(nsACString& aCharset)
+{
+  if (mSink) {
+    mSink->SetDocumentCharset(aCharset);
+  }
+}
+
+/**
+ *  This method gets called in order to set the content
+ *  sink for this parser to dump nodes to.
+ *
+ *  @param   nsIContentSink interface for node receiver
+ */
+NS_IMETHODIMP_(void)
+nsParser::SetContentSink(nsIContentSink* aSink)
+{
+  NS_PRECONDITION(aSink, "sink cannot be null!");
+  mSink = aSink;
+
+  if (mSink) {
+    mSink->SetParser(this);
+    nsCOMPtr<nsIHTMLContentSink> htmlSink = do_QueryInterface(mSink);
+    if (htmlSink) {
+      mIsAboutBlank = true;
+    }
+  }
+}
+
+/**
+ * retrieve the sink set into the parser
+ * @return  current sink
+ */
+NS_IMETHODIMP_(nsIContentSink*)
+nsParser::GetContentSink()
+{
+  return mSink;
+}
+
+static nsIDTD*
+FindSuitableDTD(CParserContext& aParserContext)
+{
+  // We always find a DTD.
+  aParserContext.mAutoDetectStatus = ePrimaryDetect;
+
+  // Quick check for view source.
+  MOZ_ASSERT(aParserContext.mParserCommand != eViewSource,
+             "The old parser is not supposed to be used for View Source "
+             "anymore.");
+
+  // Now see if we're parsing HTML (which, as far as we're concerned, simply
+  // means "not XML").
+  if (aParserContext.mDocType != eXML) {
+    return new CNavDTD();
+  }
+
+  // If we're here, then we'd better be parsing XML.
+  NS_ASSERTION(aParserContext.mDocType == eXML, "What are you trying to send me, here?");
+  return new nsExpatDriver();
+}
+
+NS_IMETHODIMP
+nsParser::CancelParsingEvents()
+{
+  if (mFlags & NS_PARSER_FLAG_PENDING_CONTINUE_EVENT) {
+    NS_ASSERTION(mContinueEvent, "mContinueEvent is null");
+    // Revoke the pending continue parsing event
+    mContinueEvent = nullptr;
+    mFlags &= ~NS_PARSER_FLAG_PENDING_CONTINUE_EVENT;
+  }
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+
+/**
+ * Evalutes EXPR1 and EXPR2 exactly once each, in that order.  Stores the value
+ * of EXPR2 in RV is EXPR2 fails, otherwise RV contains the result of EXPR1
+ * (which could be success or failure).
+ *
+ * To understand the motivation for this construct, consider these example
+ * methods:
+ *
+ *   nsresult nsSomething::DoThatThing(nsIWhatever* obj) {
+ *     nsresult rv = NS_OK;
+ *     ...
+ *     return obj->DoThatThing();
+ *     NS_ENSURE_SUCCESS(rv, rv);
+ *     ...
+ *     return rv;
+ *   }
+ *
+ *   void nsCaller::MakeThingsHappen() {
+ *     return mSomething->DoThatThing(mWhatever);
+ *   }
+ *
+ * Suppose, for whatever reason*, we want to shift responsibility for calling
+ * mWhatever->DoThatThing() from nsSomething::DoThatThing up to
+ * nsCaller::MakeThingsHappen.  We might rewrite the two methods as follows:
+ *
+ *   nsresult nsSomething::DoThatThing() {
+ *     nsresult rv = NS_OK;
+ *     ...
+ *     ...
+ *     return rv;
+ *   }
+ *
+ *   void nsCaller::MakeThingsHappen() {
+ *     nsresult rv;
+ *     PREFER_LATTER_ERROR_CODE(mSomething->DoThatThing(),
+ *                              mWhatever->DoThatThing(),
+ *                              rv);
+ *     return rv;
+ *   }
+ *
+ * *Possible reasons include: nsCaller doesn't want to give mSomething access
+ * to mWhatever, nsCaller wants to guarantee that mWhatever->DoThatThing() will
+ * be called regardless of how nsSomething::DoThatThing behaves, &c.
+ */
+#define PREFER_LATTER_ERROR_CODE(EXPR1, EXPR2, RV) {                          \
+  nsresult RV##__temp = EXPR1;                                                \
+  RV = EXPR2;                                                                 \
+  if (NS_FAILED(RV)) {                                                        \
+    RV = RV##__temp;                                                          \
+  }                                                                           \
+}
+
+/**
+ * This gets called just prior to the model actually
+ * being constructed. It's important to make this the
+ * last thing that happens right before parsing, so we
+ * can delay until the last moment the resolution of
+ * which DTD to use (unless of course we're assigned one).
+ */
+nsresult
+nsParser::WillBuildModel(nsString& aFilename)
+{
+  if (!mParserContext)
+    return kInvalidParserContext;
+
+  if (eUnknownDetect != mParserContext->mAutoDetectStatus)
+    return NS_OK;
+
+  if (eDTDMode_unknown == mParserContext->mDTDMode ||
+      eDTDMode_autodetect == mParserContext->mDTDMode) {
+    if (mIsAboutBlank) {
+      mParserContext->mDTDMode = eDTDMode_quirks;
+      mParserContext->mDocType = eHTML_Quirks;
+    } else {
+      mParserContext->mDTDMode = eDTDMode_full_standards;
+      mParserContext->mDocType = eXML;
+    }
+  } // else XML fragment with nested parser context
+
+  NS_ASSERTION(!mDTD || !mParserContext->mPrevContext,
+               "Clobbering DTD for non-root parser context!");
+  mDTD = FindSuitableDTD(*mParserContext);
+  NS_ENSURE_TRUE(mDTD, NS_ERROR_OUT_OF_MEMORY);
+
+  nsITokenizer* tokenizer;
+  nsresult rv = mParserContext->GetTokenizer(mDTD, mSink, tokenizer);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mDTD->WillBuildModel(*mParserContext, tokenizer, mSink);
+  nsresult sinkResult = mSink->WillBuildModel(mDTD->GetMode());
+  // nsIDTD::WillBuildModel used to be responsible for calling
+  // nsIContentSink::WillBuildModel, but that obligation isn't expressible
+  // in the nsIDTD interface itself, so it's sounder and simpler to give that
+  // responsibility back to the parser. The former behavior of the DTD was to
+  // NS_ENSURE_SUCCESS the sink WillBuildModel call, so if the sink returns
+  // failure we should use sinkResult instead of rv, to preserve the old error
+  // handling behavior of the DTD:
+  return NS_FAILED(sinkResult) ? sinkResult : rv;
+}
+
+/**
+ * This gets called when the parser is done with its input.
+ * Note that the parser may have been called recursively, so we
+ * have to check for a prev. context before closing out the DTD/sink.
+ */
+nsresult
+nsParser::DidBuildModel(nsresult anErrorCode)
+{
+  nsresult result = anErrorCode;
+
+  if (IsComplete()) {
+    if (mParserContext && !mParserContext->mPrevContext) {
+      // Let sink know if we're about to end load because we've been terminated.
+      // In that case we don't want it to run deferred scripts.
+      bool terminated = mInternalState == NS_ERROR_HTMLPARSER_STOPPARSING;
+      if (mDTD && mSink) {
+        nsresult dtdResult =  mDTD->DidBuildModel(anErrorCode),
+                sinkResult = mSink->DidBuildModel(terminated);
+        // nsIDTD::DidBuildModel used to be responsible for calling
+        // nsIContentSink::DidBuildModel, but that obligation isn't expressible
+        // in the nsIDTD interface itself, so it's sounder and simpler to give
+        // that responsibility back to the parser. The former behavior of the
+        // DTD was to NS_ENSURE_SUCCESS the sink DidBuildModel call, so if the
+        // sink returns failure we should use sinkResult instead of dtdResult,
+        // to preserve the old error handling behavior of the DTD:
+        result = NS_FAILED(sinkResult) ? sinkResult : dtdResult;
+      }
+
+      //Ref. to bug 61462.
+      mParserContext->mRequest = nullptr;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * This method adds a new parser context to the list,
+ * pushing the current one to the next position.
+ *
+ * @param   ptr to new context
+ */
+void
+nsParser::PushContext(CParserContext& aContext)
+{
+  NS_ASSERTION(aContext.mPrevContext == mParserContext,
+               "Trying to push a context whose previous context differs from "
+               "the current parser context.");
+  mParserContext = &aContext;
+}
+
+/**
+ * This method pops the topmost context off the stack,
+ * returning it to the user. The next context  (if any)
+ * becomes the current context.
+ * @update	gess7/22/98
+ * @return  prev. context
+ */
+CParserContext*
+nsParser::PopContext()
+{
+  CParserContext* oldContext = mParserContext;
+  if (oldContext) {
+    mParserContext = oldContext->mPrevContext;
+    if (mParserContext) {
+      // If the old context was blocked, propagate the blocked state
+      // back to the new one. Also, propagate the stream listener state
+      // but don't override onStop state to guarantee the call to DidBuildModel().
+      if (mParserContext->mStreamListenerState != eOnStop) {
+        mParserContext->mStreamListenerState = oldContext->mStreamListenerState;
+      }
+    }
+  }
+  return oldContext;
+}
+
+/**
+ *  Call this when you want control whether or not the parser will parse
+ *  and tokenize input (TRUE), or whether it just caches input to be
+ *  parsed later (FALSE).
+ *
+ *  @param   aState determines whether we parse/tokenize or just cache.
+ *  @return  current state
+ */
+void
+nsParser::SetUnusedInput(nsString& aBuffer)
+{
+  mUnusedInput = aBuffer;
+}
+
+/**
+ *  Call this when you want to *force* the parser to terminate the
+ *  parsing process altogether. This is binary -- so once you terminate
+ *  you can't resume without restarting altogether.
+ */
+NS_IMETHODIMP
+nsParser::Terminate(void)
+{
+  // We should only call DidBuildModel once, so don't do anything if this is
+  // the second time that Terminate has been called.
+  if (mInternalState == NS_ERROR_HTMLPARSER_STOPPARSING) {
+    return NS_OK;
+  }
+
+  nsresult result = 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);
+  mInternalState = result = NS_ERROR_HTMLPARSER_STOPPARSING;
+
+  // CancelParsingEvents must be called to avoid leaking the nsParser object
+  // @see bug 108049
+  // If NS_PARSER_FLAG_PENDING_CONTINUE_EVENT is set then CancelParsingEvents
+  // will reset it so DidBuildModel will call DidBuildModel on the DTD. Note:
+  // The IsComplete() call inside of DidBuildModel looks at the pendingContinueEvents flag.
+  CancelParsingEvents();
+
+  // If we got interrupted in the middle of a document.write, then we might
+  // have more than one parser context on our parsercontext stack. This has
+  // the effect of making DidBuildModel a no-op, meaning that we never call
+  // our sink's DidBuildModel and break the reference cycle, causing a leak.
+  // Since we're getting terminated, we manually clean up our context stack.
+  while (mParserContext && mParserContext->mPrevContext) {
+    CParserContext *prev = mParserContext->mPrevContext;
+    delete mParserContext;
+    mParserContext = prev;
+  }
+
+  if (mDTD) {
+    mDTD->Terminate();
+    DidBuildModel(result);
+  } else if (mSink) {
+    // We have no parser context or no DTD yet (so we got terminated before we
+    // got any data).  Manually break the reference cycle with the sink.
+    result = mSink->DidBuildModel(true);
+    NS_ENSURE_SUCCESS(result, result);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsParser::ContinueInterruptedParsing()
+{
+  // If there are scripts executing, then the content sink is jumping the gun
+  // (probably due to a synchronous XMLHttpRequest) and will re-enable us
+  // later, see bug 460706.
+  if (!IsOkToProcessNetworkData()) {
+    return NS_OK;
+  }
+
+  // If the stream has already finished, there's a good chance
+  // that we might start closing things down when the parser
+  // is reenabled. To make sure that we're not deleted across
+  // the reenabling process, hold a reference to ourselves.
+  nsresult result=NS_OK;
+  nsCOMPtr<nsIParser> kungFuDeathGrip(this);
+  nsCOMPtr<nsIContentSink> sinkDeathGrip(mSink);
+
+#ifdef DEBUG
+  if (!(mFlags & NS_PARSER_FLAG_PARSER_ENABLED)) {
+    NS_WARNING("Don't call ContinueInterruptedParsing on a blocked parser.");
+  }
+#endif
+
+  bool isFinalChunk = mParserContext &&
+                        mParserContext->mStreamListenerState == eOnStop;
+
+  mProcessingNetworkData = true;
+  if (sinkDeathGrip) {
+    sinkDeathGrip->WillParse();
+  }
+  result = ResumeParse(true, isFinalChunk); // Ref. bug 57999
+  mProcessingNetworkData = false;
+
+  if (result != NS_OK) {
+    result=mInternalState;
+  }
+
+  return result;
+}
+
+/**
+ *  Stops parsing temporarily. That's it will prevent the
+ *  parser from building up content model.
+ */
+NS_IMETHODIMP_(void)
+nsParser::BlockParser()
+{
+  mFlags &= ~NS_PARSER_FLAG_PARSER_ENABLED;
+}
+
+/**
+ *  Open up the parser for tokenization, building up content
+ *  model..etc. However, this method does not resume parsing
+ *  automatically. It's the callers' responsibility to restart
+ *  the parsing engine.
+ */
+NS_IMETHODIMP_(void)
+nsParser::UnblockParser()
+{
+  if (!(mFlags & NS_PARSER_FLAG_PARSER_ENABLED)) {
+    mFlags |= NS_PARSER_FLAG_PARSER_ENABLED;
+  } else {
+    NS_WARNING("Trying to unblock an unblocked parser.");
+  }
+}
+
+NS_IMETHODIMP_(void)
+nsParser::ContinueInterruptedParsingAsync()
+{
+  mSink->ContinueInterruptedParsingAsync();
+}
+
+/**
+ * Call this to query whether the parser is enabled or not.
+ */
+NS_IMETHODIMP_(bool)
+nsParser::IsParserEnabled()
+{
+  return (mFlags & NS_PARSER_FLAG_PARSER_ENABLED) != 0;
+}
+
+/**
+ * Call this to query whether the parser thinks it's done with parsing.
+ */
+NS_IMETHODIMP_(bool)
+nsParser::IsComplete()
+{
+  return !(mFlags & NS_PARSER_FLAG_PENDING_CONTINUE_EVENT);
+}
+
+
+void nsParser::HandleParserContinueEvent(nsParserContinueEvent *ev)
+{
+  // Ignore any revoked continue events...
+  if (mContinueEvent != ev)
+    return;
+
+  mFlags &= ~NS_PARSER_FLAG_PENDING_CONTINUE_EVENT;
+  mContinueEvent = nullptr;
+
+  NS_ASSERTION(IsOkToProcessNetworkData(),
+               "Interrupted in the middle of a script?");
+  ContinueInterruptedParsing();
+}
+
+bool
+nsParser::IsInsertionPointDefined()
+{
+  return false;
+}
+
+void
+nsParser::PushDefinedInsertionPoint()
+{
+}
+
+void
+nsParser::PopDefinedInsertionPoint()
+{
+}
+
+void
+nsParser::MarkAsNotScriptCreated(const char* aCommand)
+{
+}
+
+bool
+nsParser::IsScriptCreated()
+{
+  return false;
+}
+
+/**
+ *  This is the main controlling routine in the parsing process.
+ *  Note that it may get called multiple times for the same scanner,
+ *  since this is a pushed based system, and all the tokens may
+ *  not have been consumed by the scanner during a given invocation
+ *  of this method.
+ */
+NS_IMETHODIMP
+nsParser::Parse(nsIURI* aURL,
+                nsIRequestObserver* aListener,
+                void* aKey,
+                nsDTDMode aMode)
+{
+
+  NS_PRECONDITION(aURL, "Error: Null URL given");
+
+  nsresult result=kBadURL;
+  mObserver = aListener;
+
+  if (aURL) {
+    nsAutoCString spec;
+    nsresult rv = aURL->GetSpec(spec);
+    if (rv != NS_OK) {
+      return rv;
+    }
+    NS_ConvertUTF8toUTF16 theName(spec);
+
+    nsScanner* theScanner = new nsScanner(theName, false);
+    CParserContext* pc = new CParserContext(mParserContext, theScanner, aKey,
+                                            mCommand, aListener);
+    if (pc && theScanner) {
+      pc->mMultipart = true;
+      pc->mContextType = CParserContext::eCTURL;
+      pc->mDTDMode = aMode;
+      PushContext(*pc);
+
+      result = NS_OK;
+    } else {
+      result = mInternalState = NS_ERROR_HTMLPARSER_BADCONTEXT;
+    }
+  }
+  return result;
+}
+
+/**
+ * Used by XML fragment parsing below.
+ *
+ * @param   aSourceBuffer contains a string-full of real content
+ */
+nsresult
+nsParser::Parse(const nsAString& aSourceBuffer,
+                void* aKey,
+                bool aLastCall)
+{
+  nsresult result = NS_OK;
+
+  // Don't bother if we're never going to parse this.
+  if (mInternalState == NS_ERROR_HTMLPARSER_STOPPARSING) {
+    return result;
+  }
+
+  if (!aLastCall && aSourceBuffer.IsEmpty()) {
+    // Nothing is being passed to the parser so return
+    // immediately. mUnusedInput will get processed when
+    // some data is actually passed in.
+    // But if this is the last call, make sure to finish up
+    // stuff correctly.
+    return result;
+  }
+
+  // Maintain a reference to ourselves so we don't go away
+  // till we're completely done.
+  nsCOMPtr<nsIParser> kungFuDeathGrip(this);
+
+  if (aLastCall || !aSourceBuffer.IsEmpty() || !mUnusedInput.IsEmpty()) {
+    // Note: The following code will always find the parser context associated
+    // with the given key, even if that context has been suspended (e.g., for
+    // another document.write call). This doesn't appear to be exactly what IE
+    // does in the case where this happens, but this makes more sense.
+    CParserContext* pc = mParserContext;
+    while (pc && pc->mKey != aKey) {
+      pc = pc->mPrevContext;
+    }
+
+    if (!pc) {
+      // Only make a new context if we don't have one, OR if we do, but has a
+      // different context key.
+      nsScanner* theScanner = new nsScanner(mUnusedInput);
+      NS_ENSURE_TRUE(theScanner, NS_ERROR_OUT_OF_MEMORY);
+
+      eAutoDetectResult theStatus = eUnknownDetect;
+
+      if (mParserContext &&
+          mParserContext->mMimeType.EqualsLiteral("application/xml")) {
+        // Ref. Bug 90379
+        NS_ASSERTION(mDTD, "How come the DTD is null?");
+
+        if (mParserContext) {
+          theStatus = mParserContext->mAutoDetectStatus;
+          // Added this to fix bug 32022.
+        }
+      }
+
+      pc = new CParserContext(mParserContext, theScanner, aKey, mCommand,
+                              0, theStatus, aLastCall);
+      NS_ENSURE_TRUE(pc, NS_ERROR_OUT_OF_MEMORY);
+
+      PushContext(*pc);
+
+      pc->mMultipart = !aLastCall; // By default
+      if (pc->mPrevContext) {
+        pc->mMultipart |= pc->mPrevContext->mMultipart;
+      }
+
+      // Start fix bug 40143
+      if (pc->mMultipart) {
+        pc->mStreamListenerState = eOnDataAvail;
+        if (pc->mScanner) {
+          pc->mScanner->SetIncremental(true);
+        }
+      } else {
+        pc->mStreamListenerState = eOnStop;
+        if (pc->mScanner) {
+          pc->mScanner->SetIncremental(false);
+        }
+      }
+      // end fix for 40143
+
+      pc->mContextType=CParserContext::eCTString;
+      pc->SetMimeType(NS_LITERAL_CSTRING("application/xml"));
+      pc->mDTDMode = eDTDMode_full_standards;
+
+      mUnusedInput.Truncate();
+
+      pc->mScanner->Append(aSourceBuffer);
+      // Do not interrupt document.write() - bug 95487
+      result = ResumeParse(false, false, false);
+    } else {
+      pc->mScanner->Append(aSourceBuffer);
+      if (!pc->mPrevContext) {
+        // Set stream listener state to eOnStop, on the final context - Fix 68160,
+        // to guarantee DidBuildModel() call - Fix 36148
+        if (aLastCall) {
+          pc->mStreamListenerState = eOnStop;
+          pc->mScanner->SetIncremental(false);
+        }
+
+        if (pc == mParserContext) {
+          // If pc is not mParserContext, then this call to ResumeParse would
+          // do the wrong thing and try to continue parsing using
+          // mParserContext. We need to wait to actually resume parsing on pc.
+          ResumeParse(false, false, false);
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+NS_IMETHODIMP
+nsParser::ParseFragment(const nsAString& aSourceBuffer,
+                        nsTArray<nsString>& aTagStack)
+{
+  nsresult result = NS_OK;
+  nsAutoString  theContext;
+  uint32_t theCount = aTagStack.Length();
+  uint32_t theIndex = 0;
+
+  // Disable observers for fragments
+  mFlags &= ~NS_PARSER_FLAG_OBSERVERS_ENABLED;
+
+  for (theIndex = 0; theIndex < theCount; theIndex++) {
+    theContext.Append('<');
+    theContext.Append(aTagStack[theCount - theIndex - 1]);
+    theContext.Append('>');
+  }
+
+  if (theCount == 0) {
+    // Ensure that the buffer is not empty. Because none of the DTDs care
+    // about leading whitespace, this doesn't change the result.
+    theContext.Assign(' ');
+  }
+
+  // First, parse the context to build up the DTD's tag stack. Note that we
+  // pass false for the aLastCall parameter.
+  result = Parse(theContext,
+                 (void*)&theContext,
+                 false);
+  if (NS_FAILED(result)) {
+    mFlags |= NS_PARSER_FLAG_OBSERVERS_ENABLED;
+    return result;
+  }
+
+  if (!mSink) {
+    // Parse must have failed in the XML case and so the sink was killed.
+    return NS_ERROR_HTMLPARSER_STOPPARSING;
+  }
+
+  nsCOMPtr<nsIFragmentContentSink> fragSink = do_QueryInterface(mSink);
+  NS_ASSERTION(fragSink, "ParseFragment requires a fragment content sink");
+
+  fragSink->WillBuildContent();
+  // Now, parse the actual content. Note that this is the last call
+  // for HTML content, but for XML, we will want to build and parse
+  // the end tags.  However, if tagStack is empty, it's the last call
+  // for XML as well.
+  if (theCount == 0) {
+    result = Parse(aSourceBuffer,
+                   &theContext,
+                   true);
+    fragSink->DidBuildContent();
+  } else {
+    // Add an end tag chunk, so expat will read the whole source buffer,
+    // and not worry about ']]' etc.
+    result = Parse(aSourceBuffer + NS_LITERAL_STRING("</"),
+                   &theContext,
+                   false);
+    fragSink->DidBuildContent();
+
+    if (NS_SUCCEEDED(result)) {
+      nsAutoString endContext;
+      for (theIndex = 0; theIndex < theCount; theIndex++) {
+         // we already added an end tag chunk above
+        if (theIndex > 0) {
+          endContext.AppendLiteral("</");
+        }
+
+        nsString& thisTag = aTagStack[theIndex];
+        // was there an xmlns=?
+        int32_t endOfTag = thisTag.FindChar(char16_t(' '));
+        if (endOfTag == -1) {
+          endContext.Append(thisTag);
+        } else {
+          endContext.Append(Substring(thisTag,0,endOfTag));
+        }
+
+        endContext.Append('>');
+      }
+
+      result = Parse(endContext,
+                     &theContext,
+                     true);
+    }
+  }
+
+  mFlags |= NS_PARSER_FLAG_OBSERVERS_ENABLED;
+
+  return result;
+}
+
+/**
+ *  This routine is called to cause the parser to continue parsing its
+ *  underlying stream.  This call allows the parse process to happen in
+ *  chunks, such as when the content is push based, and we need to parse in
+ *  pieces.
+ *
+ *  An interesting change in how the parser gets used has led us to add extra
+ *  processing to this method.  The case occurs when the parser is blocked in
+ *  one context, and gets a parse(string) call in another context.  In this
+ *  case, the parserContexts are linked. No problem.
+ *
+ *  The problem is that Parse(string) assumes that it can proceed unabated,
+ *  but if the parser is already blocked that assumption is false. So we
+ *  needed to add a mechanism here to allow the parser to continue to process
+ *  (the pop and free) contexts until 1) it get's blocked again; 2) it runs
+ *  out of contexts.
+ *
+ *
+ *  @param   allowItertion : set to true if non-script resumption is requested
+ *  @param   aIsFinalChunk : tells us when the last chunk of data is provided.
+ *  @return  error code -- 0 if ok, non-zero if error.
+ */
+nsresult
+nsParser::ResumeParse(bool allowIteration, bool aIsFinalChunk,
+                      bool aCanInterrupt)
+{
+  nsresult result = NS_OK;
+
+  if ((mFlags & NS_PARSER_FLAG_PARSER_ENABLED) &&
+      mInternalState != NS_ERROR_HTMLPARSER_STOPPARSING) {
+
+    result = WillBuildModel(mParserContext->mScanner->GetFilename());
+    if (NS_FAILED(result)) {
+      mFlags &= ~NS_PARSER_FLAG_CAN_TOKENIZE;
+      return result;
+    }
+
+    if (mDTD) {
+      mSink->WillResume();
+      bool theIterationIsOk = true;
+
+      while (result == NS_OK && theIterationIsOk) {
+        if (!mUnusedInput.IsEmpty() && mParserContext->mScanner) {
+          // -- Ref: Bug# 22485 --
+          // Insert the unused input into the source buffer
+          // as if it was read from the input stream.
+          // Adding UngetReadable() per vidur!!
+          mParserContext->mScanner->UngetReadable(mUnusedInput);
+          mUnusedInput.Truncate(0);
+        }
+
+        // Only allow parsing to be interrupted in the subsequent call to
+        // build model.
+        nsresult theTokenizerResult = (mFlags & NS_PARSER_FLAG_CAN_TOKENIZE)
+                                      ? Tokenize(aIsFinalChunk)
+                                      : NS_OK;
+        result = BuildModel();
+
+        if (result == NS_ERROR_HTMLPARSER_INTERRUPTED && aIsFinalChunk) {
+          PostContinueEvent();
+        }
+
+        theIterationIsOk = theTokenizerResult != kEOF &&
+                           result != NS_ERROR_HTMLPARSER_INTERRUPTED;
+
+        // Make sure not to stop parsing too early. Therefore, before shutting
+        // down the parser, it's important to check whether the input buffer
+        // has been scanned to completion (theTokenizerResult should be kEOF).
+        // kEOF -> End of buffer.
+
+        // If we're told to block the parser, we disable all further parsing
+        // (and cache any data coming in) until the parser is re-enabled.
+        if (NS_ERROR_HTMLPARSER_BLOCK == result) {
+          mSink->WillInterrupt();
+          if (mFlags & NS_PARSER_FLAG_PARSER_ENABLED) {
+            // If we were blocked by a recursive invocation, don't re-block.
+            BlockParser();
+          }
+          return NS_OK;
+        }
+        if (NS_ERROR_HTMLPARSER_STOPPARSING == result) {
+          // Note: Parser Terminate() calls DidBuildModel.
+          if (mInternalState != NS_ERROR_HTMLPARSER_STOPPARSING) {
+            DidBuildModel(mStreamStatus);
+            mInternalState = result;
+          }
+
+          return NS_OK;
+        }
+        if ((NS_OK == result && theTokenizerResult == kEOF) ||
+             result == NS_ERROR_HTMLPARSER_INTERRUPTED) {
+          bool theContextIsStringBased =
+            CParserContext::eCTString == mParserContext->mContextType;
+
+          if (mParserContext->mStreamListenerState == eOnStop ||
+              !mParserContext->mMultipart || theContextIsStringBased) {
+            if (!mParserContext->mPrevContext) {
+              if (mParserContext->mStreamListenerState == eOnStop) {
+                DidBuildModel(mStreamStatus);
+                return NS_OK;
+              }
+            } else {
+              CParserContext* theContext = PopContext();
+              if (theContext) {
+                theIterationIsOk = allowIteration && theContextIsStringBased;
+                if (theContext->mCopyUnused) {
+                  if (!theContext->mScanner->CopyUnusedData(mUnusedInput)) {
+                    mInternalState = NS_ERROR_OUT_OF_MEMORY;
+                  }
+                }
+
+                delete theContext;
+              }
+
+              result = mInternalState;
+              aIsFinalChunk = mParserContext &&
+                              mParserContext->mStreamListenerState == eOnStop;
+              // ...then intentionally fall through to mSink->WillInterrupt()...
+            }
+          }
+        }
+
+        if (theTokenizerResult == kEOF ||
+            result == NS_ERROR_HTMLPARSER_INTERRUPTED) {
+          result = (result == NS_ERROR_HTMLPARSER_INTERRUPTED) ? NS_OK : result;
+          mSink->WillInterrupt();
+        }
+      }
+    } else {
+      mInternalState = result = NS_ERROR_HTMLPARSER_UNRESOLVEDDTD;
+    }
+  }
+
+  return (result == NS_ERROR_HTMLPARSER_INTERRUPTED) ? NS_OK : result;
+}
+
+/**
+ *  This is where we loop over the tokens created in the
+ *  tokenization phase, and try to make sense out of them.
+ */
+nsresult
+nsParser::BuildModel()
+{
+  nsITokenizer* theTokenizer = nullptr;
+
+  nsresult result = NS_OK;
+  if (mParserContext) {
+    result = mParserContext->GetTokenizer(mDTD, mSink, theTokenizer);
+  }
+
+  if (NS_SUCCEEDED(result)) {
+    if (mDTD) {
+      result = mDTD->BuildModel(theTokenizer, mSink);
+    }
+  } else {
+    mInternalState = result = NS_ERROR_HTMLPARSER_BADTOKENIZER;
+  }
+  return result;
+}
+
+/*******************************************************************
+  These methods are used to talk to the netlib system...
+ *******************************************************************/
+
+nsresult
+nsParser::OnStartRequest(nsIRequest *request, nsISupports* aContext)
+{
+  NS_PRECONDITION(eNone == mParserContext->mStreamListenerState,
+                  "Parser's nsIStreamListener API was not setup "
+                  "correctly in constructor.");
+  if (mObserver) {
+    mObserver->OnStartRequest(request, aContext);
+  }
+  mParserContext->mStreamListenerState = eOnStart;
+  mParserContext->mAutoDetectStatus = eUnknownDetect;
+  mParserContext->mRequest = request;
+
+  NS_ASSERTION(!mParserContext->mPrevContext,
+               "Clobbering DTD for non-root parser context!");
+  mDTD = nullptr;
+
+  nsresult rv;
+  nsAutoCString contentType;
+  nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
+  if (channel) {
+    rv = channel->GetContentType(contentType);
+    if (NS_SUCCEEDED(rv)) {
+      mParserContext->SetMimeType(contentType);
+    }
+  }
+
+  rv = NS_OK;
+
+  return rv;
+}
+
+static bool
+ExtractCharsetFromXmlDeclaration(const unsigned char* aBytes, int32_t aLen,
+                                 nsCString& oCharset)
+{
+  // This code is rather pointless to have. Might as well reuse expat as
+  // seen in nsHtml5StreamParser. -- hsivonen
+  oCharset.Truncate();
+  if ((aLen >= 5) &&
+      ('<' == aBytes[0]) &&
+      ('?' == aBytes[1]) &&
+      ('x' == aBytes[2]) &&
+      ('m' == aBytes[3]) &&
+      ('l' == aBytes[4])) {
+    int32_t i;
+    bool versionFound = false, encodingFound = false;
+    for (i = 6; i < aLen && !encodingFound; ++i) {
+      // end of XML declaration?
+      if ((((char*) aBytes)[i] == '?') &&
+          ((i + 1) < aLen) &&
+          (((char*) aBytes)[i + 1] == '>')) {
+        break;
+      }
+      // Version is required.
+      if (!versionFound) {
+        // Want to avoid string comparisons, hence looking for 'n'
+        // and only if found check the string leading to it. Not
+        // foolproof, but fast.
+        // The shortest string allowed before this is  (strlen==13):
+        // <?xml version
+        if ((((char*) aBytes)[i] == 'n') &&
+            (i >= 12) &&
+            (0 == PL_strncmp("versio", (char*) (aBytes + i - 6), 6))) {
+          // Fast forward through version
+          char q = 0;
+          for (++i; i < aLen; ++i) {
+            char qi = ((char*) aBytes)[i];
+            if (qi == '\'' || qi == '"') {
+              if (q && q == qi) {
+                //  ending quote
+                versionFound = true;
+                break;
+              } else {
+                // Starting quote
+                q = qi;
+              }
+            }
+          }
+        }
+      } else {
+        // encoding must follow version
+        // Want to avoid string comparisons, hence looking for 'g'
+        // and only if found check the string leading to it. Not
+        // foolproof, but fast.
+        // The shortest allowed string before this (strlen==26):
+        // <?xml version="1" encoding
+        if ((((char*) aBytes)[i] == 'g') && (i >= 25) && (0 == PL_strncmp(
+            "encodin", (char*) (aBytes + i - 7), 7))) {
+          int32_t encStart = 0;
+          char q = 0;
+          for (++i; i < aLen; ++i) {
+            char qi = ((char*) aBytes)[i];
+            if (qi == '\'' || qi == '"') {
+              if (q && q == qi) {
+                int32_t count = i - encStart;
+                // encoding value is invalid if it is UTF-16
+                if (count > 0 && PL_strncasecmp("UTF-16",
+                    (char*) (aBytes + encStart), count)) {
+                  oCharset.Assign((char*) (aBytes + encStart), count);
+                }
+                encodingFound = true;
+                break;
+              } else {
+                encStart = i + 1;
+                q = qi;
+              }
+            }
+          }
+        }
+      } // if (!versionFound)
+    } // for
+  }
+  return !oCharset.IsEmpty();
+}
+
+inline char
+GetNextChar(nsACString::const_iterator& aStart,
+            nsACString::const_iterator& aEnd)
+{
+  NS_ASSERTION(aStart != aEnd, "end of buffer");
+  return (++aStart != aEnd) ? *aStart : '\0';
+}
+
+static nsresult
+NoOpParserWriteFunc(nsIInputStream* in,
+                void* closure,
+                const char* fromRawSegment,
+                uint32_t toOffset,
+                uint32_t count,
+                uint32_t *writeCount)
+{
+  *writeCount = count;
+  return NS_OK;
+}
+
+typedef struct {
+  bool mNeedCharsetCheck;
+  nsParser* mParser;
+  nsScanner* mScanner;
+  nsIRequest* mRequest;
+} ParserWriteStruct;
+
+/*
+ * This function is invoked as a result of a call to a stream's
+ * ReadSegments() method. It is called for each contiguous buffer
+ * of data in the underlying stream or pipe. Using ReadSegments
+ * allows us to avoid copying data to read out of the stream.
+ */
+static nsresult
+ParserWriteFunc(nsIInputStream* in,
+                void* closure,
+                const char* fromRawSegment,
+                uint32_t toOffset,
+                uint32_t count,
+                uint32_t *writeCount)
+{
+  nsresult result;
+  ParserWriteStruct* pws = static_cast<ParserWriteStruct*>(closure);
+  const unsigned char* buf =
+    reinterpret_cast<const unsigned char*> (fromRawSegment);
+  uint32_t theNumRead = count;
+
+  if (!pws) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (pws->mNeedCharsetCheck) {
+    pws->mNeedCharsetCheck = false;
+    int32_t source;
+    nsAutoCString preferred;
+    nsAutoCString maybePrefer;
+    pws->mParser->GetDocumentCharset(preferred, source);
+
+    // This code was bogus when I found it. It expects the BOM or the XML
+    // declaration to be entirely in the first network buffer. -- hsivonen
+    if (nsContentUtils::CheckForBOM(buf, count, maybePrefer)) {
+      // The decoder will swallow the BOM. The UTF-16 will re-sniff for
+      // endianness. The value of preferred is now either "UTF-8" or "UTF-16".
+      preferred.Assign(maybePrefer);
+      source = kCharsetFromByteOrderMark;
+    } else if (source < kCharsetFromChannel) {
+      nsAutoCString declCharset;
+
+      if (ExtractCharsetFromXmlDeclaration(buf, count, declCharset)) {
+        if (EncodingUtils::FindEncodingForLabel(declCharset, maybePrefer)) {
+          preferred.Assign(maybePrefer);
+          source = kCharsetFromMetaTag;
+        }
+      }
+    }
+
+    pws->mParser->SetDocumentCharset(preferred, source);
+    pws->mParser->SetSinkCharset(preferred);
+
+  }
+
+  result = pws->mScanner->Append(fromRawSegment, theNumRead);
+  if (NS_SUCCEEDED(result)) {
+    *writeCount = count;
+  }
+
+  return result;
+}
+
+nsresult
+nsParser::OnDataAvailable(nsIRequest *request, nsISupports* aContext,
+                          nsIInputStream *pIStream, uint64_t sourceOffset,
+                          uint32_t aLength)
+{
+  NS_PRECONDITION((eOnStart == mParserContext->mStreamListenerState ||
+                   eOnDataAvail == mParserContext->mStreamListenerState),
+            "Error: OnStartRequest() must be called before OnDataAvailable()");
+  NS_PRECONDITION(NS_InputStreamIsBuffered(pIStream),
+                  "Must have a buffered input stream");
+
+  nsresult rv = NS_OK;
+
+  if (mIsAboutBlank) {
+    MOZ_ASSERT(false, "Must not get OnDataAvailable for about:blank");
+    // ... but if an extension tries to feed us data for about:blank in a
+    // release build, silently ignore the data.
+    uint32_t totalRead;
+    rv = pIStream->ReadSegments(NoOpParserWriteFunc,
+                                nullptr,
+                                aLength,
+                                &totalRead);
+    return rv;
+  }
+
+  CParserContext *theContext = mParserContext;
+
+  while (theContext && theContext->mRequest != request) {
+    theContext = theContext->mPrevContext;
+  }
+
+  if (theContext) {
+    theContext->mStreamListenerState = eOnDataAvail;
+
+    if (eInvalidDetect == theContext->mAutoDetectStatus) {
+      if (theContext->mScanner) {
+        nsScannerIterator iter;
+        theContext->mScanner->EndReading(iter);
+        theContext->mScanner->SetPosition(iter, true);
+      }
+    }
+
+    uint32_t totalRead;
+    ParserWriteStruct pws;
+    pws.mNeedCharsetCheck = true;
+    pws.mParser = this;
+    pws.mScanner = theContext->mScanner;
+    pws.mRequest = request;
+
+    rv = pIStream->ReadSegments(ParserWriteFunc, &pws, aLength, &totalRead);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+
+    if (IsOkToProcessNetworkData()) {
+      nsCOMPtr<nsIParser> kungFuDeathGrip(this);
+      nsCOMPtr<nsIContentSink> sinkDeathGrip(mSink);
+      mProcessingNetworkData = true;
+      if (sinkDeathGrip) {
+        sinkDeathGrip->WillParse();
+      }
+      rv = ResumeParse();
+      mProcessingNetworkData = false;
+    }
+  } else {
+    rv = NS_ERROR_UNEXPECTED;
+  }
+
+  return rv;
+}
+
+/**
+ *  This is called by the networking library once the last block of data
+ *  has been collected from the net.
+ */
+nsresult
+nsParser::OnStopRequest(nsIRequest *request, nsISupports* aContext,
+                        nsresult status)
+{
+  nsresult rv = NS_OK;
+
+  CParserContext *pc = mParserContext;
+  while (pc) {
+    if (pc->mRequest == request) {
+      pc->mStreamListenerState = eOnStop;
+      pc->mScanner->SetIncremental(false);
+      break;
+    }
+
+    pc = pc->mPrevContext;
+  }
+
+  mStreamStatus = status;
+
+  if (IsOkToProcessNetworkData() && NS_SUCCEEDED(rv)) {
+    mProcessingNetworkData = true;
+    if (mSink) {
+      mSink->WillParse();
+    }
+    rv = ResumeParse(true, true);
+    mProcessingNetworkData = false;
+  }
+
+  // If the parser isn't enabled, we don't finish parsing till
+  // it is reenabled.
+
+
+  // XXX Should we wait to notify our observers as well if the
+  // parser isn't yet enabled?
+  if (mObserver) {
+    mObserver->OnStopRequest(request, aContext, status);
+  }
+
+  return rv;
+}
+
+
+/*******************************************************************
+  Here come the tokenization methods...
+ *******************************************************************/
+
+
+/**
+ *  Part of the code sandwich, this gets called right before
+ *  the tokenization process begins. The main reason for
+ *  this call is to allow the delegate to do initialization.
+ */
+bool
+nsParser::WillTokenize(bool aIsFinalChunk)
+{
+  if (!mParserContext) {
+    return true;
+  }
+
+  nsITokenizer* theTokenizer;
+  nsresult result = mParserContext->GetTokenizer(mDTD, mSink, theTokenizer);
+  NS_ENSURE_SUCCESS(result, false);
+  return NS_SUCCEEDED(theTokenizer->WillTokenize(aIsFinalChunk));
+}
+
+
+/**
+ * This is the primary control routine to consume tokens.
+ * It iteratively consumes tokens until an error occurs or
+ * you run out of data.
+ */
+nsresult nsParser::Tokenize(bool aIsFinalChunk)
+{
+  nsITokenizer* theTokenizer;
+
+  nsresult result = NS_ERROR_NOT_AVAILABLE;
+  if (mParserContext) {
+    result = mParserContext->GetTokenizer(mDTD, mSink, theTokenizer);
+  }
+
+  if (NS_SUCCEEDED(result)) {
+    bool flushTokens = false;
+
+    bool killSink = false;
+
+    WillTokenize(aIsFinalChunk);
+    while (NS_SUCCEEDED(result)) {
+      mParserContext->mScanner->Mark();
+      result = theTokenizer->ConsumeToken(*mParserContext->mScanner,
+                                          flushTokens);
+      if (NS_FAILED(result)) {
+        mParserContext->mScanner->RewindToMark();
+        if (kEOF == result){
+          break;
+        }
+        if (NS_ERROR_HTMLPARSER_STOPPARSING == result) {
+          killSink = true;
+          result = Terminate();
+          break;
+        }
+      } else if (flushTokens && (mFlags & NS_PARSER_FLAG_OBSERVERS_ENABLED)) {
+        // I added the extra test of NS_PARSER_FLAG_OBSERVERS_ENABLED to fix Bug# 23931.
+        // Flush tokens on seeing </SCRIPT> -- Ref: Bug# 22485 --
+        // Also remember to update the marked position.
+        mFlags |= NS_PARSER_FLAG_FLUSH_TOKENS;
+        mParserContext->mScanner->Mark();
+        break;
+      }
+    }
+
+    if (killSink) {
+      mSink = nullptr;
+    }
+  } else {
+    result = mInternalState = NS_ERROR_HTMLPARSER_BADTOKENIZER;
+  }
+
+  return result;
+}
+
+/**
+ * Get the channel associated with this parser
+ *
+ * @param aChannel out param that will contain the result
+ * @return NS_OK if successful
+ */
+NS_IMETHODIMP
+nsParser::GetChannel(nsIChannel** aChannel)
+{
+  nsresult result = NS_ERROR_NOT_AVAILABLE;
+  if (mParserContext && mParserContext->mRequest) {
+    result = CallQueryInterface(mParserContext->mRequest, aChannel);
+  }
+  return result;
+}
+
+/**
+ * Get the DTD associated with this parser
+ */
+NS_IMETHODIMP
+nsParser::GetDTD(nsIDTD** aDTD)
+{
+  if (mParserContext) {
+    NS_IF_ADDREF(*aDTD = mDTD);
+  }
+
+  return NS_OK;
+}
+
+/**
+ * Get this as nsIStreamListener
+ */
+nsIStreamListener*
+nsParser::GetStreamListener()
+{
+  return this;
+}