summaryrefslogtreecommitdiffstats
path: root/dom/html/nsHTMLContentSink.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/html/nsHTMLContentSink.cpp')
-rw-r--r--dom/html/nsHTMLContentSink.cpp939
1 files changed, 939 insertions, 0 deletions
diff --git a/dom/html/nsHTMLContentSink.cpp b/dom/html/nsHTMLContentSink.cpp
new file mode 100644
index 0000000000..e7956d674c
--- /dev/null
+++ b/dom/html/nsHTMLContentSink.cpp
@@ -0,0 +1,939 @@
+/* -*- 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 "mozilla/dom/NodeInfo.h"
+#include "mozilla/dom/ScriptLoader.h"
+#include "nsCRT.h"
+#include "prtime.h"
+#include "mozilla/Logging.h"
+#include "nsIContent.h"
+#include "mozilla/dom/CustomElementRegistry.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/MutationObservers.h"
+#include "mozilla/Preferences.h"
+
+#include "nsGenericHTMLElement.h"
+
+#include "nsIScriptElement.h"
+
+#include "nsDocElementCreatedNotificationRunner.h"
+#include "nsGkAtoms.h"
+#include "nsContentUtils.h"
+#include "nsIChannel.h"
+#include "mozilla/dom/Document.h"
+#include "nsStubDocumentObserver.h"
+#include "nsHTMLDocument.h"
+#include "nsTArray.h"
+#include "nsTextFragment.h"
+#include "nsIScriptGlobalObject.h"
+#include "nsNameSpaceManager.h"
+
+#include "nsError.h"
+#include "nsContentPolicyUtils.h"
+#include "nsIDocShell.h"
+#include "nsIScriptContext.h"
+
+#include "nsLayoutCID.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(Document* 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;
+ void WillResume() 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 bool WaitForPendingSheets() override;
+ virtual void ContinueInterruptedParsingAsync() override;
+
+ // nsIHTMLContentSink
+ NS_IMETHOD OpenContainer(ElementType aNodeType) override;
+ NS_IMETHOD CloseContainer(ElementType aTag) override;
+
+ protected:
+ virtual ~HTMLContentSink();
+
+ RefPtr<nsHTMLDocument> 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 aTag) const;
+
+ 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) const {
+ return aTag == mStack[mStackPos - 1].mType;
+}
+
+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,
+ IgnoreErrors());
+ } else {
+ mContent->AppendChildTo(child, false, IgnoreErrors());
+ }
+ 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;
+ uint32_t oldUpdates = mSink->mUpdatesInNotification;
+
+ ++(mSink->mInNotification);
+ mSink->mUpdatesInNotification = 0;
+ {
+ // Scope so we call EndUpdate before we decrease mInNotification
+ mozAutoDocUpdate updateBatch(mSink->mDocument, 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;
+
+ 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, Document* 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();
+ }
+
+ if (mCurrentContext == mHeadContext && !mContextStack.IsEmpty()) {
+ // Pop off the second html context if it's not done earlier
+ mContextStack.RemoveLastElement();
+ }
+
+ for (int32_t i = 0, numContexts = mContextStack.Length(); 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(Document* 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 = aDoc->AsHTMLDocument();
+
+ 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!");
+ ErrorResult error;
+ mDocument->AppendChildTo(mRoot, false, error);
+ if (error.Failed()) {
+ return error.StealNSResult();
+ }
+
+ // 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, IgnoreErrors());
+
+ 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();
+
+ mDocument->SetCompatibilityMode(aDTDMode == eDTDMode_full_standards
+ ? eCompatibility_FullStandards
+ : eCompatibility_NavQuirks);
+
+ // 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) {
+ // Pop off the second html context if it's not done earlier
+ mCurrentContext = mContextStack.PopLastElement();
+ }
+
+ 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();
+ }
+ }
+ 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(); }
+
+void HTMLContentSink::WillResume() { WillResumeImpl(); }
+
+void HTMLContentSink::CloseHeadContext() {
+ if (mCurrentContext) {
+ if (!mCurrentContext->IsCurrentContainer(eHTMLTag_head)) return;
+
+ mCurrentContext->FlushTags();
+ }
+
+ if (!mContextStack.IsEmpty()) {
+ mCurrentContext = mContextStack.PopLastElement();
+ }
+}
+
+void HTMLContentSink::NotifyInsert(nsIContent* aContent,
+ nsIContent* aChildContent) {
+ mInNotification++;
+
+ {
+ // Scope so we call EndUpdate before we decrease mInNotification
+ // Note that aContent->OwnerDoc() may be different to mDocument already.
+ MOZ_AUTO_DOC_UPDATE(aContent ? aContent->OwnerDoc() : mDocument.get(),
+ true);
+ MutationObservers::NotifyContentInserted(NODE_FROM(aContent, mDocument),
+ aChildContent);
+ mLastNotificationTime = PR_Now();
+ }
+
+ mInNotification--;
+}
+
+void HTMLContentSink::NotifyRootInsertion() {
+ MOZ_ASSERT(!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;
+ NotifyInsert(nullptr, mRoot);
+
+ // Now update the notification information in all our
+ // contexts, since we just inserted the root and notified on
+ // our whole tree
+ UpdateChildCounts();
+
+ nsContentUtils::AddScriptRunner(
+ new nsDocElementCreatedNotificationRunner(mDocument));
+}
+
+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(FlushType 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 >= FlushType::ContentAndNotify) {
+ FlushTags();
+ }
+ }
+ if (aType >= FlushType::EnsurePresShellInitAndFrames) {
+ // 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;
+}
+
+void HTMLContentSink::SetDocumentCharset(NotNull<const Encoding*> aEncoding) {
+ MOZ_ASSERT_UNREACHABLE("<meta charset> case doesn't occur with about:blank");
+}
+
+nsISupports* HTMLContentSink::GetTarget() { return ToSupports(mDocument); }
+
+bool HTMLContentSink::IsScriptExecuting() { return IsScriptExecutingImpl(); }
+
+void HTMLContentSink::ContinueInterruptedParsingIfEnabled() {
+ if (mParser && mParser->IsParserEnabled()) {
+ static_cast<nsIParser*>(mParser.get())->ContinueInterruptedParsing();
+ }
+}
+
+bool HTMLContentSink::WaitForPendingSheets() {
+ return nsContentSink::WaitForPendingSheets();
+}
+
+void HTMLContentSink::ContinueInterruptedParsingAsync() {
+ nsCOMPtr<nsIRunnable> ev = NewRunnableMethod(
+ "HTMLContentSink::ContinueInterruptedParsingIfEnabled", this,
+ &HTMLContentSink::ContinueInterruptedParsingIfEnabled);
+
+ RefPtr<Document> doc = mHTMLDocument;
+ doc->Dispatch(mozilla::TaskCategory::Other, ev.forget());
+}