Add m-esr52 at 52.6.0

1 files changed, 1106 insertions, 0 deletions

diff --git a/dom/html/nsHTMLContentSink.cpp b/dom/html/nsHTMLContentSink.cpp
new file mode 100644
index 000000000..3e8e019b8
--- /dev/null
+++ b/dom/html/nsHTMLContentSink.cpp
@@ -0,0 +1,1106 @@
+/* -*- 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 "nsReadableUtils.h"
+#include "nsUnicharUtils.h"
+#include "nsIHTMLContentSink.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsScriptLoader.h"
+#include "nsIURI.h"
+#include "nsIContentViewer.h"
+#include "mozilla/dom/NodeInfo.h"
+#include "nsToken.h"
+#include "nsIAppShell.h"
+#include "nsCRT.h"
+#include "prtime.h"
+#include "mozilla/Logging.h"
+#include "nsNodeUtils.h"
+#include "nsIContent.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/Preferences.h"
+
+#include "nsGenericHTMLElement.h"
+
+#include "nsIDOMDocument.h"
+#include "nsIDOMDocumentType.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 "nsIDOMHTMLMapElement.h"
+#include "nsICookieService.h"
+#include "nsTArray.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsIPrincipal.h"
+#include "nsTextFragment.h"
+#include "nsIScriptGlobalObject.h"
+#include "nsNameSpaceManager.h"
+
+#include "nsIParserService.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;
+
+//----------------------------------------------------------------------
+
+typedef nsGenericHTMLElement*
+  (*contentCreatorCallback)(already_AddRefed<mozilla::dom::NodeInfo>&&,
+                            FromParser aFromParser);
+
+nsGenericHTMLElement*
+NS_NewHTMLNOTUSEDElement(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,
+                         FromParser aFromParser)
+{
+  NS_NOTREACHED("The element ctor should never be called");
+  return nullptr;
+}
+
+#define HTML_TAG(_tag, _classname) NS_NewHTML##_classname##Element,
+#define HTML_HTMLELEMENT_TAG(_tag) NS_NewHTMLElement,
+#define HTML_OTHER(_tag) NS_NewHTMLNOTUSEDElement,
+static const contentCreatorCallback sContentCreatorCallbacks[] = {
+  NS_NewHTMLUnknownElement,
+#include "nsHTMLTagList.h"
+#undef HTML_TAG
+#undef HTML_HTMLELEMENT_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();
+
+  NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
+
+  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(mozFlushType aType) override;
+  NS_IMETHOD SetDocumentCharset(nsACString& aCharset) override;
+  virtual nsISupports *GetTarget() override;
+  virtual bool IsScriptExecuting() 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,
+                    int32_t aIndexInContainer);
+  void NotifyRootInsertion();
+};
+
+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, const nsAString* aIs)
+{
+  *aResult = nullptr;
+
+  RefPtr<mozilla::dom::NodeInfo> nodeInfo = aNodeInfo;
+
+  nsIParserService* parserService = nsContentUtils::GetParserService();
+  if (!parserService)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  nsIAtom *name = nodeInfo->NameAtom();
+
+  NS_ASSERTION(nodeInfo->NamespaceEquals(kNameSpaceID_XHTML),
+               "Trying to HTML elements that don't have the XHTML namespace");
+
+  int32_t tag = parserService->HTMLCaseSensitiveAtomTagToId(name);
+
+  // Per the Custom Element specification, unknown tags that are valid custom
+  // element names should be HTMLElement instead of HTMLUnknownElement.
+  bool isCustomElementName = (tag == eHTMLTag_userdefined &&
+                              nsContentUtils::IsCustomElementName(name));
+  if (isCustomElementName) {
+    NS_IF_ADDREF(*aResult = NS_NewHTMLElement(nodeInfo.forget(), aFromParser));
+  } else {
+    *aResult = CreateHTMLElement(tag, nodeInfo.forget(), aFromParser).take();
+  }
+
+  if (!*aResult) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  if (isCustomElementName || aIs) {
+    nsContentUtils::SetupCustomElement(*aResult, aIs);
+  }
+
+  return NS_OK;
+}
+
+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");
+
+  contentCreatorCallback cb = sContentCreatorCallbacks[aNodeType];
+
+  NS_ASSERTION(cb != NS_NewHTMLNOTUSEDElement,
+               "Don't know how to construct tag element!");
+
+  RefPtr<nsGenericHTMLElement> result = cb(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;
+    int32_t childIndex = mStack[mStackPos - 1].mInsertionPoint - 1;
+    NS_ASSERTION(parent->GetChildAt(childIndex) == aContent,
+                 "Flushing the wrong child.");
+    mSink->NotifyInsert(parent, aContent, childIndex);
+    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,
+                                           nsIDOMNode::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.");
+    mContent->InsertChildAt(child, mInsertionPoint++, 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, UPDATE_CONTENT_MODEL,
+                                 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(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, childIndex);
+        } 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()
+{
+  // Note: operator new zeros our memory
+}
+
+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_CLASS(HTMLContentSink)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(HTMLContentSink, nsContentSink)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mHTMLDocument)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mRoot)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mBody)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mHead)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(HTMLContentSink,
+                                                  nsContentSink)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mHTMLDocument)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRoot)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBody)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mHead)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(HTMLContentSink)
+  NS_INTERFACE_TABLE_BEGIN
+    NS_INTERFACE_TABLE_ENTRY(HTMLContentSink, nsIContentSink)
+    NS_INTERFACE_TABLE_ENTRY(HTMLContentSink, nsIHTMLContentSink)
+  NS_INTERFACE_TABLE_END
+NS_INTERFACE_TABLE_TAIL_INHERITING(nsContentSink)
+
+NS_IMPL_ADDREF_INHERITED(HTMLContentSink, nsContentSink)
+NS_IMPL_RELEASE_INHERITED(HTMLContentSink, nsContentSink)
+
+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,
+                                           nsIDOMNode::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,
+                                           nsIDOMNode::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)
+{
+  NS_PRECONDITION(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, insertionPoint - 1);
+    } 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();
+  }
+
+  if (!mContextStack.IsEmpty())
+  {
+    uint32_t n = mContextStack.Length() - 1;
+    mCurrentContext = mContextStack.ElementAt(n);
+    mContextStack.RemoveElementAt(n);
+  }
+}
+
+void
+HTMLContentSink::NotifyInsert(nsIContent* aContent,
+                              nsIContent* aChildContent,
+                              int32_t aIndexInContainer)
+{
+  if (aContent && aContent->GetUncomposedDoc() != mDocument) {
+    // aContent is not actually in our document anymore.... Just bail out of
+    // here; notifying on our document for this insert would be wrong.
+    return;
+  }
+
+  mInNotification++;
+
+  {
+    // Scope so we call EndUpdate before we decrease mInNotification
+    MOZ_AUTO_DOC_UPDATE(mDocument, UPDATE_CONTENT_MODEL, !mBeganUpdate);
+    nsNodeUtils::ContentInserted(NODE_FROM(aContent, mDocument),
+                                 aChildContent, aIndexInContainer);
+    mLastNotificationTime = PR_Now();
+  }
+
+  mInNotification--;
+}
+
+void
+HTMLContentSink::NotifyRootInsertion()
+{
+  NS_PRECONDITION(!mNotifiedRootInsertion, "Double-notifying on root?");
+  NS_ASSERTION(!mLayoutStarted,
+               "How did we start layout without notifying on root?");
+  // Now make sure to notify that we have now inserted our root.  If
+  // there has been no initial reflow yet it'll be a no-op, but if
+  // there has been one we need this to get its frames constructed.
+  // Note that if mNotifiedRootInsertion is true we don't notify here,
+  // since that just means there are multiple <html> tags in the
+  // document; in those cases we just want to put all the attrs on one
+  // tag.
+  mNotifiedRootInsertion = true;
+  int32_t index = mDocument->IndexOf(mRoot);
+  NS_ASSERTION(index != -1, "mRoot not child of document?");
+  NotifyInsert(nullptr, mRoot, index);
+
+  // Now update the notification information in all our
+  // contexts, since we just inserted the root and notified on
+  // our whole tree
+  UpdateChildCounts();
+}
+
+void
+HTMLContentSink::UpdateChildCounts()
+{
+  uint32_t numContexts = mContextStack.Length();
+  for (uint32_t i = 0; i < numContexts; i++) {
+    SinkContext* sc = mContextStack.ElementAt(i);
+
+    sc->UpdateChildCounts();
+  }
+
+  mCurrentContext->UpdateChildCounts();
+}
+
+void
+HTMLContentSink::FlushPendingNotifications(mozFlushType aType)
+{
+  // Only flush tags if we're not doing the notification ourselves
+  // (since we aren't reentrant)
+  if (!mInNotification) {
+    // Only flush if we're still a document observer (so that our child counts
+    // should be correct).
+    if (mIsDocumentObserver) {
+      if (aType >= Flush_ContentAndNotify) {
+        FlushTags();
+      }
+    }
+    if (aType >= Flush_InterruptibleLayout) {
+      // Make sure that layout has started so that the reflow flush
+      // will actually happen.
+      StartLayout(true);
+    }
+  }
+}
+
+nsresult
+HTMLContentSink::FlushTags()
+{
+  if (!mNotifiedRootInsertion) {
+    NotifyRootInsertion();
+    return NS_OK;
+  }
+
+  return mCurrentContext ? mCurrentContext->FlushTags() : NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLContentSink::SetDocumentCharset(nsACString& aCharset)
+{
+  MOZ_ASSERT_UNREACHABLE("<meta charset> case doesn't occur with about:blank");
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+nsISupports *
+HTMLContentSink::GetTarget()
+{
+  return mDocument;
+}
+
+bool
+HTMLContentSink::IsScriptExecuting()
+{
+  return IsScriptExecutingImpl();
+}