diff options
Diffstat (limited to 'dom/html/nsHTMLContentSink.cpp')
| -rw-r--r-- | dom/html/nsHTMLContentSink.cpp | 1106 |
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(); +} |