/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* 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/. */

/**

 * This file is near-OBSOLETE. It is used for about:blank only and for the

 * HTML element factory.

 * Don't bother adding new stuff in this file.

 */

#include "mozilla/ArrayUtils.h"

#include "nsContentSink.h"

#include "nsCOMPtr.h"

#include "nsHTMLTags.h"

#include "nsReadableUtils.h"

#include "nsUnicharUtils.h"

#include "nsIHTMLContentSink.h"

#include "nsIInterfaceRequestor.h"

#include "nsIInterfaceRequestorUtils.h"

#include "nsIURI.h"

#include "nsIContentViewer.h"

#include "mozilla/dom/NodeInfo.h"

#include "mozilla/dom/ScriptLoader.h"

#include "nsIAppShell.h"

#include "nsCRT.h"

#include "prtime.h"

#include "mozilla/Logging.h"

#include "nsNodeUtils.h"

#include "nsIContent.h"

#include "mozilla/dom/CustomElementRegistry.h"

#include "mozilla/dom/Element.h"

#include "mozilla/Preferences.h"

#include "nsGenericHTMLElement.h"

#include "nsIScriptElement.h"

#include "nsIComponentManager.h"

#include "nsIServiceManager.h"

#include "nsGkAtoms.h"

#include "nsContentUtils.h"

#include "nsIChannel.h"

#include "nsIHttpChannel.h"

#include "nsIDocShell.h"

#include "nsIDocument.h"

#include "nsStubDocumentObserver.h"

#include "nsIHTMLDocument.h"

#include "nsICookieService.h"

#include "nsTArray.h"

#include "nsIScriptSecurityManager.h"

#include "nsIPrincipal.h"

#include "nsTextFragment.h"

#include "nsIScriptGlobalObject.h"

#include "nsNameSpaceManager.h"

#include "nsIStyleSheetLinkingElement.h"

#include "nsITimer.h"

#include "nsError.h"

#include "nsContentPolicyUtils.h"

#include "nsIScriptContext.h"

#include "nsStyleLinkElement.h"

#include "nsWeakReference.h" // nsHTMLElementFactory supports weak references

#include "nsIPrompt.h"

#include "nsLayoutCID.h"

#include "nsIDocShellTreeItem.h"

#include "nsEscape.h"

#include "nsNodeInfoManager.h"

#include "nsContentCreatorFunctions.h"

#include "mozAutoDocUpdate.h"

#include "nsTextNode.h"

using namespace mozilla;

using namespace mozilla::dom;

//----------------------------------------------------------------------

nsGenericHTMLElement*

NS_NewHTMLNOTUSEDElement(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,

                         FromParser aFromParser)

{

  MOZ_ASSERT_UNREACHABLE("The element ctor should never be called");

  return nullptr;

}

#define HTML_TAG(_tag, _classname, _interfacename) NS_NewHTML##_classname##Element,

#define HTML_OTHER(_tag) NS_NewHTMLNOTUSEDElement,

static const HTMLContentCreatorFunction sHTMLContentCreatorFunctions[] = {

  NS_NewHTMLUnknownElement,

#include "nsHTMLTagList.h"

#undef HTML_TAG

#undef HTML_OTHER

  NS_NewHTMLUnknownElement

};

class SinkContext;

class HTMLContentSink;

/**

 * This class is near-OBSOLETE. It is used for about:blank only.

 * Don't bother adding new stuff in this file.

 */

class HTMLContentSink : public nsContentSink,

                        public nsIHTMLContentSink

{

public:

  friend class SinkContext;

  HTMLContentSink();

  nsresult Init(nsIDocument* aDoc, nsIURI* aURI, nsISupports* aContainer,

                nsIChannel* aChannel);

  // nsISupports

  NS_DECL_ISUPPORTS_INHERITED

  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(HTMLContentSink, nsContentSink)

  // nsIContentSink

  NS_IMETHOD WillParse(void) override;

  NS_IMETHOD WillBuildModel(nsDTDMode aDTDMode) override;

  NS_IMETHOD DidBuildModel(bool aTerminated) override;

  NS_IMETHOD WillInterrupt(void) override;

  NS_IMETHOD WillResume(void) override;

  NS_IMETHOD SetParser(nsParserBase* aParser) override;

  virtual void FlushPendingNotifications(FlushType aType) override;

  virtual void SetDocumentCharset(NotNull<const Encoding*> aEncoding) override;

  virtual nsISupports *GetTarget() override;

  virtual bool IsScriptExecuting() override;

  virtual void ContinueInterruptedParsingAsync() override;

  // nsIHTMLContentSink

  NS_IMETHOD OpenContainer(ElementType aNodeType) override;

  NS_IMETHOD CloseContainer(ElementType aTag) override;

protected:

  virtual ~HTMLContentSink();

  nsCOMPtr<nsIHTMLDocument> mHTMLDocument;

  // The maximum length of a text run

  int32_t mMaxTextRun;

  RefPtr<nsGenericHTMLElement> mRoot;

  RefPtr<nsGenericHTMLElement> mBody;

  RefPtr<nsGenericHTMLElement> mHead;

  AutoTArray<SinkContext*, 8> mContextStack;

  SinkContext* mCurrentContext;

  SinkContext* mHeadContext;

  // Boolean indicating whether we've seen a <head> tag that might have had

  // attributes once already.

  bool mHaveSeenHead;

  // Boolean indicating whether we've notified insertion of our root content

  // yet.  We want to make sure to only do this once.

  bool mNotifiedRootInsertion;

  nsresult FlushTags() override;

  // Routines for tags that require special handling

  nsresult CloseHTML();

  nsresult OpenBody();

  nsresult CloseBody();

  void CloseHeadContext();

  // nsContentSink overrides

  void UpdateChildCounts() override;

  void NotifyInsert(nsIContent* aContent,

                    nsIContent* aChildContent);

  void NotifyRootInsertion();

private:

  void ContinueInterruptedParsingIfEnabled();

};

class SinkContext

{

public:

  explicit SinkContext(HTMLContentSink* aSink);

  ~SinkContext();

  nsresult Begin(nsHTMLTag aNodeType, nsGenericHTMLElement* aRoot,

                 uint32_t aNumFlushed, int32_t aInsertionPoint);

  nsresult OpenBody();

  nsresult CloseBody();

  nsresult End();

  nsresult GrowStack();

  nsresult FlushTags();

  bool     IsCurrentContainer(nsHTMLTag mType);

  void DidAddContent(nsIContent* aContent);

  void UpdateChildCounts();

private:

  // Function to check whether we've notified for the current content.

  // What this actually does is check whether we've notified for all

  // of the parent's kids.

  bool HaveNotifiedForCurrentContent() const;

public:

  HTMLContentSink* mSink;

  int32_t mNotifyLevel;

  struct Node {

    nsHTMLTag mType;

    nsGenericHTMLElement* mContent;

    uint32_t mNumFlushed;

    int32_t mInsertionPoint;

    nsIContent *Add(nsIContent *child);

  };

  Node* mStack;

  int32_t mStackSize;

  int32_t mStackPos;

};

nsresult

NS_NewHTMLElement(Element** aResult, already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,

                  FromParser aFromParser, nsAtom* aIsAtom,

                  mozilla::dom::CustomElementDefinition* aDefinition)

{

  RefPtr<mozilla::dom::NodeInfo> nodeInfo = aNodeInfo;

  NS_ASSERTION(nodeInfo->NamespaceEquals(kNameSpaceID_XHTML),

               "Trying to create HTML elements that don't have the XHTML namespace");

  return nsContentUtils::NewXULOrHTMLElement(aResult, nodeInfo, aFromParser, aIsAtom, aDefinition);

}

already_AddRefed<nsGenericHTMLElement>

CreateHTMLElement(uint32_t aNodeType,

                  already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,

                  FromParser aFromParser)

{

  NS_ASSERTION(aNodeType <= NS_HTML_TAG_MAX ||

               aNodeType == eHTMLTag_userdefined,

               "aNodeType is out of bounds");

  HTMLContentCreatorFunction cb = sHTMLContentCreatorFunctions[aNodeType];

  NS_ASSERTION(cb != NS_NewHTMLNOTUSEDElement,

               "Don't know how to construct tag element!");

  RefPtr<nsGenericHTMLElement> result = cb(std::move(aNodeInfo), aFromParser);

  return result.forget();

}

//----------------------------------------------------------------------

SinkContext::SinkContext(HTMLContentSink* aSink)

  : mSink(aSink),

    mNotifyLevel(0),

    mStack(nullptr),

    mStackSize(0),

    mStackPos(0)

{

  MOZ_COUNT_CTOR(SinkContext);

}

SinkContext::~SinkContext()

{

  MOZ_COUNT_DTOR(SinkContext);

  if (mStack) {

    for (int32_t i = 0; i < mStackPos; i++) {

      NS_RELEASE(mStack[i].mContent);

    }

    delete [] mStack;

  }

}

nsresult

SinkContext::Begin(nsHTMLTag aNodeType,

                   nsGenericHTMLElement* aRoot,

                   uint32_t aNumFlushed,

                   int32_t aInsertionPoint)

{

  if (mStackSize < 1) {

    nsresult rv = GrowStack();

    if (NS_FAILED(rv)) {

      return rv;

    }

  }

  mStack[0].mType = aNodeType;

  mStack[0].mContent = aRoot;

  mStack[0].mNumFlushed = aNumFlushed;

  mStack[0].mInsertionPoint = aInsertionPoint;

  NS_ADDREF(aRoot);

  mStackPos = 1;

  return NS_OK;

}

bool

SinkContext::IsCurrentContainer(nsHTMLTag aTag)

{

  if (aTag == mStack[mStackPos - 1].mType) {

    return true;

  }

  return false;

}

void

SinkContext::DidAddContent(nsIContent* aContent)

{

  if ((mStackPos == 2) && (mSink->mBody == mStack[1].mContent)) {

    // We just finished adding something to the body

    mNotifyLevel = 0;

  }

  // If we just added content to a node for which

  // an insertion happen, we need to do an immediate

  // notification for that insertion.

  if (0 < mStackPos &&

      mStack[mStackPos - 1].mInsertionPoint != -1 &&

      mStack[mStackPos - 1].mNumFlushed <

      mStack[mStackPos - 1].mContent->GetChildCount()) {

    nsIContent* parent = mStack[mStackPos - 1].mContent;

    mSink->NotifyInsert(parent, aContent);

    mStack[mStackPos - 1].mNumFlushed = parent->GetChildCount();

  } else if (mSink->IsTimeToNotify()) {

    FlushTags();

  }

}

nsresult

SinkContext::OpenBody()

{

  if (mStackPos <= 0) {

    NS_ERROR("container w/o parent");

    return NS_ERROR_FAILURE;

  }

  nsresult rv;

  if (mStackPos + 1 > mStackSize) {

    rv = GrowStack();

    if (NS_FAILED(rv)) {

      return rv;

    }

  }

    RefPtr<mozilla::dom::NodeInfo> nodeInfo =

      mSink->mNodeInfoManager->GetNodeInfo(nsGkAtoms::body, nullptr,

                                           kNameSpaceID_XHTML,

                                           nsINode::ELEMENT_NODE);

  NS_ENSURE_TRUE(nodeInfo, NS_ERROR_UNEXPECTED);

  // Make the content object

  RefPtr<nsGenericHTMLElement> body =

    NS_NewHTMLBodyElement(nodeInfo.forget(), FROM_PARSER_NETWORK);

  if (!body) {

    return NS_ERROR_OUT_OF_MEMORY;

  }

  mStack[mStackPos].mType = eHTMLTag_body;

  body.forget(&mStack[mStackPos].mContent);

  mStack[mStackPos].mNumFlushed = 0;

  mStack[mStackPos].mInsertionPoint = -1;

  ++mStackPos;

  mStack[mStackPos - 2].Add(mStack[mStackPos - 1].mContent);

  return NS_OK;

}

bool

SinkContext::HaveNotifiedForCurrentContent() const

{

  if (0 < mStackPos) {

    nsIContent* parent = mStack[mStackPos - 1].mContent;

    return mStack[mStackPos-1].mNumFlushed == parent->GetChildCount();

  }

  return true;

}

nsIContent *

SinkContext::Node::Add(nsIContent *child)

{

  NS_ASSERTION(mContent, "No parent to insert/append into!");

  if (mInsertionPoint != -1) {

    NS_ASSERTION(mNumFlushed == mContent->GetChildCount(),

                 "Inserting multiple children without flushing.");

    nsCOMPtr<nsIContent> nodeToInsertBefore =

      mContent->GetChildAt_Deprecated(mInsertionPoint++);

    mContent->InsertChildBefore(child, nodeToInsertBefore, false);

  } else {

    mContent->AppendChildTo(child, false);

  }

  return child;

}

nsresult

SinkContext::CloseBody()

{

  NS_ASSERTION(mStackPos > 0,

               "stack out of bounds. wrong context probably!");

  if (mStackPos <= 0) {

    return NS_OK; // Fix crash - Ref. bug 45975 or 45007

  }

  --mStackPos;

  NS_ASSERTION(mStack[mStackPos].mType == eHTMLTag_body,

               "Tag mismatch.  Closing tag on wrong context or something?");

  nsGenericHTMLElement* content = mStack[mStackPos].mContent;

  content->Compact();

  // If we're in a state where we do append notifications as

  // we go up the tree, and we're at the level where the next

  // notification needs to be done, do the notification.

  if (mNotifyLevel >= mStackPos) {

    // Check to see if new content has been added after our last

    // notification

    if (mStack[mStackPos].mNumFlushed < content->GetChildCount()) {

      mSink->NotifyAppend(content, mStack[mStackPos].mNumFlushed);

      mStack[mStackPos].mNumFlushed = content->GetChildCount();

    }

    // Indicate that notification has now happened at this level

    mNotifyLevel = mStackPos - 1;

  }

  DidAddContent(content);

  NS_IF_RELEASE(content);

  return NS_OK;

}

nsresult

SinkContext::End()

{

  for (int32_t i = 0; i < mStackPos; i++) {

    NS_RELEASE(mStack[i].mContent);

  }

  mStackPos = 0;

  return NS_OK;

}

nsresult

SinkContext::GrowStack()

{

  int32_t newSize = mStackSize * 2;

  if (newSize == 0) {

    newSize = 32;

  }

  Node* stack = new Node[newSize];

  if (mStackPos != 0) {

    memcpy(stack, mStack, sizeof(Node) * mStackPos);

    delete [] mStack;

  }

  mStack = stack;

  mStackSize = newSize;

  return NS_OK;

}

/**

 * NOTE!! Forked into nsXMLContentSink. Please keep in sync.

 *

 * Flush all elements that have been seen so far such that

 * they are visible in the tree. Specifically, make sure

 * that they are all added to their respective parents.

 * Also, do notification at the top for all content that

 * has been newly added so that the frame tree is complete.

 */

nsresult

SinkContext::FlushTags()

{

  mSink->mDeferredFlushTags = false;

  bool oldBeganUpdate = mSink->mBeganUpdate;

  uint32_t oldUpdates = mSink->mUpdatesInNotification;

  ++(mSink->mInNotification);

  mSink->mUpdatesInNotification = 0;

  {

    // Scope so we call EndUpdate before we decrease mInNotification

    mozAutoDocUpdate updateBatch(mSink->mDocument, true);

    mSink->mBeganUpdate = true;

    // Start from the base of the stack (growing downward) and do

    // a notification from the node that is closest to the root of

    // tree for any content that has been added.

    // Note that we can start at stackPos == 0 here, because it's the caller's

    // responsibility to handle flushing interactions between contexts (see

    // HTMLContentSink::BeginContext).

    int32_t stackPos = 0;

    bool flushed = false;

    uint32_t childCount;

    nsGenericHTMLElement* content;

    while (stackPos < mStackPos) {

      content = mStack[stackPos].mContent;

      childCount = content->GetChildCount();

      if (!flushed && (mStack[stackPos].mNumFlushed < childCount)) {

        if (mStack[stackPos].mInsertionPoint != -1) {

          // We might have popped the child off our stack already

          // but not notified on it yet, which is why we have to get it

          // directly from its parent node.

          int32_t childIndex = mStack[stackPos].mInsertionPoint - 1;

          nsIContent* child = content->GetChildAt_Deprecated(childIndex);

          // Child not on stack anymore; can't assert it's correct

          NS_ASSERTION(!(mStackPos > (stackPos + 1)) ||

                       (child == mStack[stackPos + 1].mContent),

                       "Flushing the wrong child.");

          mSink->NotifyInsert(content, child);

        } else {

          mSink->NotifyAppend(content, mStack[stackPos].mNumFlushed);

        }

        flushed = true;

      }

      mStack[stackPos].mNumFlushed = childCount;

      stackPos++;

    }

    mNotifyLevel = mStackPos - 1;

  }

  --(mSink->mInNotification);

  if (mSink->mUpdatesInNotification > 1) {

    UpdateChildCounts();

  }

  mSink->mUpdatesInNotification = oldUpdates;

  mSink->mBeganUpdate = oldBeganUpdate;

  return NS_OK;

}

/**

 * NOTE!! Forked into nsXMLContentSink. Please keep in sync.

 */

void

SinkContext::UpdateChildCounts()

{

  // Start from the top of the stack (growing upwards) and see if any

  // new content has been appended. If so, we recognize that reflows

  // have been generated for it and we should make sure that no

  // further reflows occur.  Note that we have to include stackPos == 0

  // to properly notify on kids of <html>.

  int32_t stackPos = mStackPos - 1;

  while (stackPos >= 0) {

    Node & node = mStack[stackPos];

    node.mNumFlushed = node.mContent->GetChildCount();

    stackPos--;

  }

  mNotifyLevel = mStackPos - 1;

}

nsresult

NS_NewHTMLContentSink(nsIHTMLContentSink** aResult,

                      nsIDocument* aDoc,

                      nsIURI* aURI,

                      nsISupports* aContainer,

                      nsIChannel* aChannel)

{

  NS_ENSURE_ARG_POINTER(aResult);

  RefPtr<HTMLContentSink> it = new HTMLContentSink();

  nsresult rv = it->Init(aDoc, aURI, aContainer, aChannel);

  NS_ENSURE_SUCCESS(rv, rv);

  *aResult = it;

  NS_ADDREF(*aResult);

  return NS_OK;

}

HTMLContentSink::HTMLContentSink()

  : mMaxTextRun(0)

  , mCurrentContext(nullptr)

  , mHeadContext(nullptr)

  , mHaveSeenHead(false)

  , mNotifiedRootInsertion(false)

{

}

HTMLContentSink::~HTMLContentSink()

{

  if (mNotificationTimer) {

    mNotificationTimer->Cancel();

  }

  int32_t numContexts = mContextStack.Length();

  if (mCurrentContext == mHeadContext && numContexts > 0) {

    // Pop off the second html context if it's not done earlier

    mContextStack.RemoveElementAt(--numContexts);

  }

  int32_t i;

  for (i = 0; i < numContexts; i++) {

    SinkContext* sc = mContextStack.ElementAt(i);

    if (sc) {

      sc->End();

      if (sc == mCurrentContext) {

        mCurrentContext = nullptr;

      }

      delete sc;

    }

  }

  if (mCurrentContext == mHeadContext) {

    mCurrentContext = nullptr;

  }

  delete mCurrentContext;

  delete mHeadContext;

}

NS_IMPL_CYCLE_COLLECTION_INHERITED(HTMLContentSink, nsContentSink,

                                   mHTMLDocument,

                                   mRoot,

                                   mBody,

                                   mHead)

NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED(HTMLContentSink,

                                             nsContentSink,

                                             nsIContentSink,

                                             nsIHTMLContentSink)

nsresult

HTMLContentSink::Init(nsIDocument* aDoc,

                      nsIURI* aURI,

                      nsISupports* aContainer,

                      nsIChannel* aChannel)

{

  NS_ENSURE_TRUE(aContainer, NS_ERROR_NULL_POINTER);

  nsresult rv = nsContentSink::Init(aDoc, aURI, aContainer, aChannel);

  if (NS_FAILED(rv)) {

    return rv;

  }

  aDoc->AddObserver(this);

  mIsDocumentObserver = true;

  mHTMLDocument = do_QueryInterface(aDoc);

  NS_ASSERTION(mDocShell, "oops no docshell!");

  // Changed from 8192 to greatly improve page loading performance on

  // large pages.  See bugzilla bug 77540.

  mMaxTextRun = Preferences::GetInt("content.maxtextrun", 8191);

  RefPtr<mozilla::dom::NodeInfo> nodeInfo;

  nodeInfo = mNodeInfoManager->GetNodeInfo(nsGkAtoms::html, nullptr,

                                           kNameSpaceID_XHTML,

                                           nsINode::ELEMENT_NODE);

  // Make root part

  mRoot = NS_NewHTMLHtmlElement(nodeInfo.forget());

  if (!mRoot) {

    return NS_ERROR_OUT_OF_MEMORY;

  }

  NS_ASSERTION(mDocument->GetChildCount() == 0,

               "Document should have no kids here!");

  rv = mDocument->AppendChildTo(mRoot, false);

  NS_ENSURE_SUCCESS(rv, rv);

  // Make head part

  nodeInfo = mNodeInfoManager->GetNodeInfo(nsGkAtoms::head,

                                           nullptr, kNameSpaceID_XHTML,

                                           nsINode::ELEMENT_NODE);

  mHead = NS_NewHTMLHeadElement(nodeInfo.forget());

  if (NS_FAILED(rv)) {

    return NS_ERROR_OUT_OF_MEMORY;

  }

  mRoot->AppendChildTo(mHead, false);

  mCurrentContext = new SinkContext(this);

  mCurrentContext->Begin(eHTMLTag_html, mRoot, 0, -1);

  mContextStack.AppendElement(mCurrentContext);

  return NS_OK;

}

NS_IMETHODIMP

HTMLContentSink::WillParse(void)

{

  return WillParseImpl();

}

NS_IMETHODIMP

HTMLContentSink::WillBuildModel(nsDTDMode aDTDMode)

{

  WillBuildModelImpl();

  if (mHTMLDocument) {

    nsCompatibility mode = eCompatibility_NavQuirks;

    switch (aDTDMode) {

      case eDTDMode_full_standards:

        mode = eCompatibility_FullStandards;

        break;

      case eDTDMode_almost_standards:

        mode = eCompatibility_AlmostStandards;

        break;

      default:

        break;

    }

    mHTMLDocument->SetCompatibilityMode(mode);

  }

  // Notify document that the load is beginning

  mDocument->BeginLoad();

  return NS_OK;

}

NS_IMETHODIMP

HTMLContentSink::DidBuildModel(bool aTerminated)

{

  DidBuildModelImpl(aTerminated);

  // Reflow the last batch of content

  if (mBody) {

    mCurrentContext->FlushTags();

  } else if (!mLayoutStarted) {

    // We never saw the body, and layout never got started. Force

    // layout *now*, to get an initial reflow.

    // NOTE: only force the layout if we are NOT destroying the

    // docshell. If we are destroying it, then starting layout will

    // likely cause us to crash, or at best waste a lot of time as we

    // are just going to tear it down anyway.

    bool bDestroying = true;

    if (mDocShell) {

      mDocShell->IsBeingDestroyed(&bDestroying);

    }

    if (!bDestroying) {

      StartLayout(false);

    }

  }

  ScrollToRef();

  // Make sure we no longer respond to document mutations.  We've flushed all

  // our notifications out, so there's no need to do anything else here.

  // XXXbz I wonder whether we could End() our contexts here too, or something,

  // just to make sure we no longer notify...  Or is the mIsDocumentObserver

  // thing sufficient?

  mDocument->RemoveObserver(this);

  mIsDocumentObserver = false;

  mDocument->EndLoad();

  DropParserAndPerfHint();

  return NS_OK;

}

NS_IMETHODIMP

HTMLContentSink::SetParser(nsParserBase* aParser)

{

  MOZ_ASSERT(aParser, "Should have a parser here!");

  mParser = aParser;

  return NS_OK;

}

nsresult

HTMLContentSink::CloseHTML()

{

  if (mHeadContext) {

    if (mCurrentContext == mHeadContext) {

      uint32_t numContexts = mContextStack.Length();

      // Pop off the second html context if it's not done earlier

      mCurrentContext = mContextStack.ElementAt(--numContexts);

      mContextStack.RemoveElementAt(numContexts);

    }

    mHeadContext->End();

    delete mHeadContext;

    mHeadContext = nullptr;

  }

  return NS_OK;

}

nsresult

HTMLContentSink::OpenBody()

{

  CloseHeadContext();  // do this just in case if the HEAD was left open!

  // if we already have a body we're done

  if (mBody) {

    return NS_OK;

  }

  nsresult rv = mCurrentContext->OpenBody();

  if (NS_FAILED(rv)) {

    return rv;

  }

  mBody = mCurrentContext->mStack[mCurrentContext->mStackPos - 1].mContent;

  if (mCurrentContext->mStackPos > 1) {

    int32_t parentIndex    = mCurrentContext->mStackPos - 2;

    nsGenericHTMLElement *parent = mCurrentContext->mStack[parentIndex].mContent;

    int32_t numFlushed     = mCurrentContext->mStack[parentIndex].mNumFlushed;

    int32_t childCount = parent->GetChildCount();

    NS_ASSERTION(numFlushed < childCount, "Already notified on the body?");

    int32_t insertionPoint =

      mCurrentContext->mStack[parentIndex].mInsertionPoint;

    // XXX: I have yet to see a case where numFlushed is non-zero and

    // insertionPoint is not -1, but this code will try to handle

    // those cases too.

    uint32_t oldUpdates = mUpdatesInNotification;

    mUpdatesInNotification = 0;

    if (insertionPoint != -1) {

      NotifyInsert(parent, mBody);

    } else {

      NotifyAppend(parent, numFlushed);

    }

    mCurrentContext->mStack[parentIndex].mNumFlushed = childCount;

    if (mUpdatesInNotification > 1) {

      UpdateChildCounts();

    }

    mUpdatesInNotification = oldUpdates;

  }

  StartLayout(false);

  return NS_OK;

}

nsresult

HTMLContentSink::CloseBody()

{

  // Flush out anything that's left

  mCurrentContext->FlushTags();

  mCurrentContext->CloseBody();

  return NS_OK;

}

NS_IMETHODIMP

HTMLContentSink::OpenContainer(ElementType aElementType)

{

  nsresult rv = NS_OK;

  switch (aElementType) {

    case eBody:

      rv = OpenBody();

      break;

    case eHTML:

      if (mRoot) {

        // If we've already hit this code once, then we're done

        if (!mNotifiedRootInsertion) {

          NotifyRootInsertion();

        }

        ProcessOfflineManifest(mRoot);

      }

      break;

  }

  return rv;

}

NS_IMETHODIMP

HTMLContentSink::CloseContainer(const ElementType aTag)

{

  nsresult rv = NS_OK;

  switch (aTag) {

    case eBody:

      rv = CloseBody();

      break;

    case eHTML:

      rv = CloseHTML();

      break;

  }

  return rv;

}

NS_IMETHODIMP

HTMLContentSink::WillInterrupt()

{

  return WillInterruptImpl();

}

NS_IMETHODIMP

HTMLContentSink::WillResume()

{

  return WillResumeImpl();

}

void

HTMLContentSink::CloseHeadContext()

{

  if (mCurrentContext) {

    if (!mCurrentContext->IsCurrentContainer(eHTMLTag_head))

      return;

    mCurrentContext->FlushTags();

  }