/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=2 sw=2 et tw=78: */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * The Original Code is mozilla.org code. * * The Initial Developer of the Original Code is * Netscape Communications Corporation. * Portions created by the Initial Developer are Copyright (C) 1998 * the Initial Developer. All Rights Reserved. * * Contributor(s): * Johnny Stenback * L. David Baron * Pierre Phaneuf * Pete Collins * James Ross * * Alternatively, the contents of this file may be used under the terms of * either of the GNU General Public License Version 2 or later (the "GPL"), * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to * use your version of this file under the terms of the MPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ /* * Base class for all our document implementations. */ #include "plstr.h" #include "prprf.h" #include "nsIInterfaceRequestor.h" #include "nsIInterfaceRequestorUtils.h" #include "nsDocument.h" #include "nsUnicharUtils.h" #include "nsIPrivateDOMEvent.h" #include "nsIEventStateManager.h" #include "nsIFocusController.h" #include "nsContentList.h" #include "nsIObserver.h" #include "nsIBaseWindow.h" #include "nsIDocShell.h" #include "nsIDocShellTreeItem.h" #include "nsIScriptRuntime.h" #include "nsCOMArray.h" #include "nsGUIEvent.h" #include "nsIDOMStyleSheet.h" #include "nsDOMAttribute.h" #include "nsIDOMDOMStringList.h" #include "nsIDOMDOMImplementation.h" #include "nsIDOMDocumentView.h" #include "nsIDOMAbstractView.h" #include "nsIDOMDocumentXBL.h" #include "nsGenericElement.h" #include "nsIDOMEventGroup.h" #include "nsIDOMCDATASection.h" #include "nsIDOMProcessingInstruction.h" #include "nsDOMString.h" #include "nsNodeUtils.h" #include "nsLayoutUtils.h" // for GetFrameForPoint #include "nsIFrame.h" #include "nsRange.h" #include "nsIDOMText.h" #include "nsIDOMComment.h" #include "nsDOMDocumentType.h" #include "nsNodeIterator.h" #include "nsTreeWalker.h" #include "nsIServiceManager.h" #include "nsContentCID.h" #include "nsDOMError.h" #include "nsIPresShell.h" #include "nsPresContext.h" #include "nsThreadUtils.h" #include "nsNodeInfoManager.h" #include "nsIXBLService.h" #include "nsIXPointer.h" #include "nsIFileChannel.h" #include "nsIMultiPartChannel.h" #include "nsIRefreshURI.h" #include "nsIWebNavigation.h" #include "nsIScriptError.h" #include "nsNetUtil.h" // for NS_MakeAbsoluteURI #include "nsIScriptSecurityManager.h" #include "nsIPrincipal.h" #include "nsIPrivateDOMImplementation.h" #include "nsIDOMWindowInternal.h" #include "nsPIDOMWindow.h" #include "nsIDOMElement.h" #include "nsGkAtoms.h" // for radio group stuff #include "nsIDOMHTMLInputElement.h" #include "nsIRadioVisitor.h" #include "nsIFormControl.h" #include "nsXMLEventsManager.h" #include "nsBidiUtils.h" static NS_DEFINE_CID(kDOMEventGroupCID, NS_DOMEVENTGROUP_CID); #include "nsIDOMUserDataHandler.h" #include "nsScriptEventManager.h" #include "nsIDOMXPathEvaluator.h" #include "nsIXPathEvaluatorInternal.h" #include "nsIParserService.h" #include "nsContentCreatorFunctions.h" #include "nsIScriptContext.h" #include "nsBindingManager.h" #include "nsIDOMHTMLDocument.h" #include "nsIDOMHTMLFormElement.h" #include "nsIRequest.h" #include "nsILink.h" #include "nsICharsetAlias.h" #include "nsIParser.h" #include "nsIContentSink.h" #include "nsDateTimeFormatCID.h" #include "nsIDateTimeFormat.h" #include "nsEventDispatcher.h" #include "nsMutationEvent.h" #include "nsIDOMXPathEvaluator.h" #include "nsDOMCID.h" #include "nsIJSContextStack.h" #include "nsIXPConnect.h" #include "nsCycleCollector.h" #include "nsCCUncollectableMarker.h" #include "nsIContentPolicy.h" #include "nsFrameLoader.h" #include "mozAutoDocUpdate.h" #ifdef MOZ_LOGGING // so we can get logging even in release builds #define FORCE_PR_LOG 1 #endif #include "prlog.h" #ifdef PR_LOGGING static PRLogModuleInfo* gDocumentLeakPRLog; #endif void nsUint32ToContentHashEntry::Destroy() { HashSet* set = GetHashSet(); if (set) { delete set; } else { nsIContent* content = GetContent(); NS_IF_RELEASE(content); } } nsresult nsUint32ToContentHashEntry::PutContent(nsIContent* aVal) { // Add the value to the hash if it is there HashSet* set = GetHashSet(); if (set) { nsISupportsHashKey* entry = set->PutEntry(aVal); return entry ? NS_OK : NS_ERROR_OUT_OF_MEMORY; } // If an element is already there, create a hashtable and both of these to it nsIContent* oldVal = GetContent(); if (oldVal) { nsresult rv = InitHashSet(&set); NS_ENSURE_SUCCESS(rv, rv); nsISupportsHashKey* entry = set->PutEntry(oldVal); if (!entry) { // OOM - we can't insert aVal, but we can at least put oldVal back (even // if we didn't, we'd still have to release oldVal so that we don't leak) delete set; SetContent(oldVal); // SetContent adds another reference, so release the one we had NS_RELEASE(oldVal); return NS_ERROR_OUT_OF_MEMORY; } // The hashset adds its own reference, so release the one we had NS_RELEASE(oldVal); entry = set->PutEntry(aVal); return entry ? NS_OK : NS_ERROR_OUT_OF_MEMORY; } // Nothing exists in the hash right now, so just set the single pointer return SetContent(aVal); } void nsUint32ToContentHashEntry::RemoveContent(nsIContent* aVal) { // Remove from the hash if the hash is there HashSet* set = GetHashSet(); if (set) { set->RemoveEntry(aVal); if (set->Count() == 0) { delete set; mValOrHash = nsnull; } return; } // Remove the ptr if there is just a ptr nsIContent* v = GetContent(); if (v == aVal) { NS_IF_RELEASE(v); mValOrHash = nsnull; } } nsresult nsUint32ToContentHashEntry::InitHashSet(HashSet** aSet) { HashSet* newSet = new HashSet(); if (!newSet) { return NS_ERROR_OUT_OF_MEMORY; } nsresult rv = newSet->Init(); NS_ENSURE_SUCCESS(rv, rv); mValOrHash = newSet; *aSet = newSet; return NS_OK; } static PLDHashOperator PR_CALLBACK nsUint32ToContentHashEntryVisitorCallback(nsISupportsHashKey* aEntry, void* aClosure) { nsUint32ToContentHashEntry::Visitor* visitor = static_cast(aClosure); visitor->Visit(static_cast(aEntry->GetKey())); return PL_DHASH_NEXT; } void nsUint32ToContentHashEntry::VisitContent(Visitor* aVisitor) { HashSet* set = GetHashSet(); if (set) { set->EnumerateEntries(nsUint32ToContentHashEntryVisitorCallback, aVisitor); if (set->Count() == 0) { delete set; mValOrHash = nsnull; } return; } nsIContent* v = GetContent(); if (v) { aVisitor->Visit(v); } } #define ID_NOT_IN_DOCUMENT ((nsIContent *)2) #define NAME_NOT_VALID ((nsBaseContentList*)1) nsIdentifierMapEntry::~nsIdentifierMapEntry() { if (mNameContentList && mNameContentList != NAME_NOT_VALID) { NS_RELEASE(mNameContentList); } } void nsIdentifierMapEntry::Traverse(nsCycleCollectionTraversalCallback* aCallback) { if (mNameContentList != NAME_NOT_VALID) aCallback->NoteXPCOMChild(mNameContentList); aCallback->NoteXPCOMChild(static_cast(mDocAllList)); } void nsIdentifierMapEntry::SetInvalidName() { mNameContentList = NAME_NOT_VALID; } PRBool nsIdentifierMapEntry::IsInvalidName() { return mNameContentList == NAME_NOT_VALID; } nsresult nsIdentifierMapEntry::CreateNameContentList() { mNameContentList = new nsBaseContentList(); NS_ENSURE_TRUE(mNameContentList, NS_ERROR_OUT_OF_MEMORY); NS_ADDREF(mNameContentList); return NS_OK; } nsIContent* nsIdentifierMapEntry::GetIdContent(PRBool* aNotInDocument) { nsIContent* c = static_cast(mIdContentList.SafeElementAt(0)); if (aNotInDocument) { *aNotInDocument = c == ID_NOT_IN_DOCUMENT; } return c != ID_NOT_IN_DOCUMENT ? c : nsnull; } void nsIdentifierMapEntry::AppendAllIdContent(nsCOMArray* aElements) { for (PRInt32 i = 0; i < mIdContentList.Count(); ++i) { aElements->AppendObject(static_cast(mIdContentList[i])); } } void nsIdentifierMapEntry::AddContentChangeCallback(nsIDocument::IDTargetObserver aCallback, void* aData) { if (!mChangeCallbacks) { mChangeCallbacks = new nsTHashtable; if (!mChangeCallbacks) return; mChangeCallbacks->Init(); } ChangeCallback cc = { aCallback, aData }; mChangeCallbacks->PutEntry(cc); } void nsIdentifierMapEntry::RemoveContentChangeCallback(nsIDocument::IDTargetObserver aCallback, void* aData) { if (!mChangeCallbacks) return; ChangeCallback cc = { aCallback, aData }; mChangeCallbacks->RemoveEntry(cc); if (mChangeCallbacks->Count() == 0) { mChangeCallbacks = nsnull; } } struct FireChangeArgs { nsIContent* mFrom; nsIContent* mTo; }; PR_STATIC_CALLBACK(PLDHashOperator) FireChangeEnumerator(nsIdentifierMapEntry::ChangeCallbackEntry *aEntry, void *aArg) { FireChangeArgs* args = static_cast(aArg); return aEntry->mKey.mCallback(args->mFrom, args->mTo, aEntry->mKey.mData) ? PL_DHASH_NEXT : PL_DHASH_REMOVE; } void nsIdentifierMapEntry::FireChangeCallbacks(nsIContent* aOldContent, nsIContent* aNewContent) { if (!mChangeCallbacks) return; FireChangeArgs args = { aOldContent, aNewContent }; mChangeCallbacks->EnumerateEntries(FireChangeEnumerator, &args); } PRBool nsIdentifierMapEntry::AddIdContent(nsIContent* aContent) { NS_PRECONDITION(aContent, "Must have content"); NS_PRECONDITION(mIdContentList.IndexOf(nsnull) < 0, "Why is null in our list?"); NS_PRECONDITION(aContent != ID_NOT_IN_DOCUMENT, "Bogus content pointer"); nsIContent* currentContent = static_cast(mIdContentList.SafeElementAt(0)); if (currentContent == ID_NOT_IN_DOCUMENT) { NS_ASSERTION(mIdContentList.Count() == 1, "Bogus count"); mIdContentList.ReplaceElementAt(aContent, 0); FireChangeCallbacks(nsnull, aContent); return PR_TRUE; } // Common case if (mIdContentList.Count() == 0) { if (!mIdContentList.AppendElement(aContent)) return PR_FALSE; FireChangeCallbacks(nsnull, aContent); return PR_TRUE; } // We seem to have multiple content nodes for the same id, or we're doing our // top-down registration when the id table is going live. Search for the // right place to insert the content. PRInt32 start = 0; PRInt32 end = mIdContentList.Count(); do { NS_ASSERTION(start < end, "Bogus start/end"); PRInt32 cur = (start + end) / 2; NS_ASSERTION(cur >= start && cur < end, "What happened here?"); nsIContent* curContent = static_cast(mIdContentList[cur]); if (curContent == aContent) { // Already in the list, so already in the right spot. Get out of here. return PR_TRUE; } if (nsContentUtils::PositionIsBefore(aContent, curContent)) { end = cur; } else { start = cur + 1; } } while (start != end); if (!mIdContentList.InsertElementAt(aContent, start)) return PR_FALSE; if (start == 0) { FireChangeCallbacks(currentContent, aContent); } return PR_TRUE; } PRBool nsIdentifierMapEntry::RemoveIdContent(nsIContent* aContent) { // This should only be called while the document is in an update. // Assertions near the call to this method guarantee this. // XXXbz should this ever Compact() I guess when all the content is gone // we'll just get cleaned up in the natural order of things... nsIContent* currentContent = static_cast(mIdContentList.SafeElementAt(0)); if (!mIdContentList.RemoveElement(aContent)) return PR_FALSE; if (currentContent == aContent) { FireChangeCallbacks(currentContent, static_cast(mIdContentList.SafeElementAt(0))); } return mIdContentList.Count() == 0 && !mNameContentList && !mChangeCallbacks; } void nsIdentifierMapEntry::FlagIDNotInDocument() { NS_ASSERTION(mIdContentList.Count() == 0, "Flagging ID not in document when we have content?"); // Note that if this fails that's OK; this is just an optimization mIdContentList.AppendElement(ID_NOT_IN_DOCUMENT); } void nsIdentifierMapEntry::AddNameContent(nsIContent* aContent) { if (!mNameContentList || mNameContentList == NAME_NOT_VALID) return; // NOTE: this indexof is absolutely needed, since we don't flush // content notifications when we do document.foo resolution. So // aContent may be in our list already and just now getting notified // for! if (mNameContentList->IndexOf(aContent, PR_FALSE) < 0) { mNameContentList->AppendElement(aContent); } } void nsIdentifierMapEntry::RemoveNameContent(nsIContent* aContent) { if (mNameContentList && mNameContentList != NAME_NOT_VALID) { mNameContentList->RemoveElement(aContent); } } // Helper structs for the content->subdoc map class SubDocMapEntry : public PLDHashEntryHdr { public: // Both of these are strong references nsIContent *mKey; // must be first, to look like PLDHashEntryStub nsIDocument *mSubDocument; }; struct FindContentData { FindContentData(nsIDocument *aSubDoc) : mSubDocument(aSubDoc), mResult(nsnull) { } nsISupports *mSubDocument; nsIContent *mResult; }; /** * A struct that holds all the information about a radio group. */ struct nsRadioGroupStruct { /** * A strong pointer to the currently selected radio button. */ nsCOMPtr mSelectedRadioButton; nsCOMArray mRadioButtons; }; nsDOMStyleSheetList::nsDOMStyleSheetList(nsIDocument *aDocument) { mLength = -1; // Not reference counted to avoid circular references. // The document will tell us when its going away. mDocument = aDocument; mDocument->AddObserver(this); } nsDOMStyleSheetList::~nsDOMStyleSheetList() { if (mDocument) { mDocument->RemoveObserver(this); } } // XXX couldn't we use the GetIIDs method from CSSStyleSheetList here? // QueryInterface implementation for nsDOMStyleSheetList NS_INTERFACE_TABLE_HEAD(nsDOMStyleSheetList) NS_INTERFACE_TABLE3(nsDOMStyleSheetList, nsIDOMStyleSheetList, nsIDocumentObserver, nsIMutationObserver) NS_INTERFACE_TABLE_TO_MAP_SEGUE NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(DocumentStyleSheetList) NS_INTERFACE_MAP_END NS_IMPL_ADDREF(nsDOMStyleSheetList) NS_IMPL_RELEASE(nsDOMStyleSheetList) NS_IMETHODIMP nsDOMStyleSheetList::GetLength(PRUint32* aLength) { if (mDocument) { // XXX Find the number and then cache it. We'll use the // observer notification to figure out if new ones have // been added or removed. if (-1 == mLength) { mLength = mDocument->GetNumberOfStyleSheets(); #ifdef DEBUG PRInt32 i; for (i = 0; i < mLength; i++) { nsIStyleSheet *sheet = mDocument->GetStyleSheetAt(i); nsCOMPtr domss(do_QueryInterface(sheet)); NS_ASSERTION(domss, "All \"normal\" sheets implement nsIDOMStyleSheet"); } #endif } *aLength = mLength; } else { *aLength = 0; } return NS_OK; } NS_IMETHODIMP nsDOMStyleSheetList::Item(PRUint32 aIndex, nsIDOMStyleSheet** aReturn) { *aReturn = nsnull; if (mDocument) { PRInt32 count = mDocument->GetNumberOfStyleSheets(); if (aIndex < (PRUint32)count) { nsIStyleSheet *sheet = mDocument->GetStyleSheetAt(aIndex); NS_ASSERTION(sheet, "Must have a sheet"); return CallQueryInterface(sheet, aReturn); } } return NS_OK; } void nsDOMStyleSheetList::NodeWillBeDestroyed(const nsINode *aNode) { mDocument = nsnull; } void nsDOMStyleSheetList::StyleSheetAdded(nsIDocument *aDocument, nsIStyleSheet* aStyleSheet, PRBool aDocumentSheet) { if (aDocumentSheet && -1 != mLength) { nsCOMPtr domss(do_QueryInterface(aStyleSheet)); if (domss) { mLength++; } } } void nsDOMStyleSheetList::StyleSheetRemoved(nsIDocument *aDocument, nsIStyleSheet* aStyleSheet, PRBool aDocumentSheet) { if (aDocumentSheet && -1 != mLength) { nsCOMPtr domss(do_QueryInterface(aStyleSheet)); if (domss) { mLength--; } } } // nsOnloadBlocker implementation NS_IMPL_ISUPPORTS1(nsOnloadBlocker, nsIRequest) NS_IMETHODIMP nsOnloadBlocker::GetName(nsACString &aResult) { aResult.AssignLiteral("about:document-onload-blocker"); return NS_OK; } NS_IMETHODIMP nsOnloadBlocker::IsPending(PRBool *_retval) { *_retval = PR_TRUE; return NS_OK; } NS_IMETHODIMP nsOnloadBlocker::GetStatus(nsresult *status) { *status = NS_OK; return NS_OK; } NS_IMETHODIMP nsOnloadBlocker::Cancel(nsresult status) { return NS_OK; } NS_IMETHODIMP nsOnloadBlocker::Suspend(void) { return NS_OK; } NS_IMETHODIMP nsOnloadBlocker::Resume(void) { return NS_OK; } NS_IMETHODIMP nsOnloadBlocker::GetLoadGroup(nsILoadGroup * *aLoadGroup) { *aLoadGroup = nsnull; return NS_OK; } NS_IMETHODIMP nsOnloadBlocker::SetLoadGroup(nsILoadGroup * aLoadGroup) { return NS_OK; } NS_IMETHODIMP nsOnloadBlocker::GetLoadFlags(nsLoadFlags *aLoadFlags) { *aLoadFlags = nsIRequest::LOAD_NORMAL; return NS_OK; } NS_IMETHODIMP nsOnloadBlocker::SetLoadFlags(nsLoadFlags aLoadFlags) { return NS_OK; } // ================================================================== // = // ================================================================== // If we ever have an nsIDocumentObserver notification for stylesheet title // changes, we could make this inherit from nsDOMStringList instead of // reimplementing nsIDOMDOMStringList. class nsDOMStyleSheetSetList : public nsIDOMDOMStringList { public: NS_DECL_ISUPPORTS NS_DECL_NSIDOMDOMSTRINGLIST nsDOMStyleSheetSetList(nsIDocument* aDocument); void Disconnect() { mDocument = nsnull; } protected: // Rebuild our list of style sets nsresult GetSets(nsStringArray& aStyleSets); nsIDocument* mDocument; // Our document; weak ref. It'll let us know if it // dies. }; NS_IMPL_ADDREF(nsDOMStyleSheetSetList) NS_IMPL_RELEASE(nsDOMStyleSheetSetList) NS_INTERFACE_MAP_BEGIN(nsDOMStyleSheetSetList) NS_INTERFACE_MAP_ENTRY(nsIDOMDOMStringList) NS_INTERFACE_MAP_ENTRY(nsISupports) NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(DOMStringList) NS_INTERFACE_MAP_END nsDOMStyleSheetSetList::nsDOMStyleSheetSetList(nsIDocument* aDocument) : mDocument(aDocument) { NS_ASSERTION(mDocument, "Must have document!"); } NS_IMETHODIMP nsDOMStyleSheetSetList::Item(PRUint32 aIndex, nsAString& aResult) { nsStringArray styleSets; nsresult rv = GetSets(styleSets); NS_ENSURE_SUCCESS(rv, rv); if (aIndex >= (PRUint32)styleSets.Count()) { SetDOMStringToNull(aResult); } else { styleSets.StringAt(aIndex, aResult); } return NS_OK; } NS_IMETHODIMP nsDOMStyleSheetSetList::GetLength(PRUint32 *aLength) { nsStringArray styleSets; nsresult rv = GetSets(styleSets); NS_ENSURE_SUCCESS(rv, rv); *aLength = (PRUint32)styleSets.Count(); return NS_OK; } NS_IMETHODIMP nsDOMStyleSheetSetList::Contains(const nsAString& aString, PRBool *aResult) { nsStringArray styleSets; nsresult rv = GetSets(styleSets); NS_ENSURE_SUCCESS(rv, rv); *aResult = styleSets.IndexOf(aString) != -1; return NS_OK; } nsresult nsDOMStyleSheetSetList::GetSets(nsStringArray& aStyleSets) { if (!mDocument) { return NS_OK; // Spec says "no exceptions", and we have no style sets if we // have no document, for sure } PRInt32 count = mDocument->GetNumberOfStyleSheets(); nsAutoString title; nsAutoString temp; for (PRInt32 index = 0; index < count; index++) { nsIStyleSheet* sheet = mDocument->GetStyleSheetAt(index); NS_ASSERTION(sheet, "Null sheet in sheet list!"); sheet->GetTitle(title); if (!title.IsEmpty() && aStyleSets.IndexOf(title) == -1 && !aStyleSets.AppendString(title)) { return NS_ERROR_OUT_OF_MEMORY; } } return NS_OK; } // ================================================================== // = // ================================================================== class nsDOMImplementation : public nsIDOMDOMImplementation, public nsIPrivateDOMImplementation { public: nsDOMImplementation(nsIScriptGlobalObject* aScriptObject, nsIURI* aDocumentURI, nsIURI* aBaseURI, nsIPrincipal* aPrincipal); virtual ~nsDOMImplementation(); NS_DECL_ISUPPORTS // nsIDOMDOMImplementation NS_DECL_NSIDOMDOMIMPLEMENTATION // nsIPrivateDOMImplementation NS_IMETHOD Init(nsIURI* aDocumentURI, nsIURI* aBaseURI, nsIPrincipal* aPrincipal); protected: nsWeakPtr mScriptObject; nsCOMPtr mDocumentURI; nsCOMPtr mBaseURI; nsCOMPtr mPrincipal; }; nsresult NS_NewDOMImplementation(nsIDOMDOMImplementation** aInstancePtrResult) { *aInstancePtrResult = new nsDOMImplementation(nsnull, nsnull, nsnull, nsnull); if (!*aInstancePtrResult) { return NS_ERROR_OUT_OF_MEMORY; } NS_ADDREF(*aInstancePtrResult); return NS_OK; } nsDOMImplementation::nsDOMImplementation(nsIScriptGlobalObject* aScriptObject, nsIURI* aDocumentURI, nsIURI* aBaseURI, nsIPrincipal* aPrincipal) : mScriptObject(do_GetWeakReference(aScriptObject)), mDocumentURI(aDocumentURI), mBaseURI(aBaseURI), mPrincipal(aPrincipal) { } nsDOMImplementation::~nsDOMImplementation() { } // QueryInterface implementation for nsDOMImplementation NS_INTERFACE_MAP_BEGIN(nsDOMImplementation) NS_INTERFACE_MAP_ENTRY(nsIDOMDOMImplementation) NS_INTERFACE_MAP_ENTRY(nsIPrivateDOMImplementation) NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMDOMImplementation) NS_INTERFACE_MAP_ENTRY_CONTENT_CLASSINFO(DOMImplementation) NS_INTERFACE_MAP_END NS_IMPL_ADDREF(nsDOMImplementation) NS_IMPL_RELEASE(nsDOMImplementation) NS_IMETHODIMP nsDOMImplementation::HasFeature(const nsAString& aFeature, const nsAString& aVersion, PRBool* aReturn) { return nsGenericElement::InternalIsSupported( static_cast(this), aFeature, aVersion, aReturn); } NS_IMETHODIMP nsDOMImplementation::CreateDocumentType(const nsAString& aQualifiedName, const nsAString& aPublicId, const nsAString& aSystemId, nsIDOMDocumentType** aReturn) { *aReturn = nsnull; nsresult rv = nsContentUtils::CheckQName(aQualifiedName); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr name = do_GetAtom(aQualifiedName); NS_ENSURE_TRUE(name, NS_ERROR_OUT_OF_MEMORY); // Indicate that there is no internal subset (not just an empty one) nsAutoString voidString; voidString.SetIsVoid(PR_TRUE); return NS_NewDOMDocumentType(aReturn, nsnull, mPrincipal, name, nsnull, nsnull, aPublicId, aSystemId, voidString); } NS_IMETHODIMP nsDOMImplementation::CreateDocument(const nsAString& aNamespaceURI, const nsAString& aQualifiedName, nsIDOMDocumentType* aDoctype, nsIDOMDocument** aReturn) { *aReturn = nsnull; nsresult rv; if (!aQualifiedName.IsEmpty()) { nsIParserService *parserService = nsContentUtils::GetParserService(); NS_ENSURE_TRUE(parserService, NS_ERROR_FAILURE); const nsAFlatString& qName = PromiseFlatString(aQualifiedName); const PRUnichar *colon; rv = parserService->CheckQName(qName, PR_TRUE, &colon); NS_ENSURE_SUCCESS(rv, rv); if (colon && (DOMStringIsNull(aNamespaceURI) || (Substring(qName.get(), colon).EqualsLiteral("xml") && !aNamespaceURI.EqualsLiteral("http://www.w3.org/XML/1998/namespace")))) { return NS_ERROR_DOM_NAMESPACE_ERR; } } else if (DOMStringIsNull(aQualifiedName) && !DOMStringIsNull(aNamespaceURI)) { return NS_ERROR_DOM_NAMESPACE_ERR; } if (aDoctype) { nsCOMPtr owner; aDoctype->GetOwnerDocument(getter_AddRefs(owner)); if (owner) { return NS_ERROR_DOM_WRONG_DOCUMENT_ERR; } } nsCOMPtr scriptHandlingObject = do_QueryReferent(mScriptObject); return nsContentUtils::CreateDocument(aNamespaceURI, aQualifiedName, aDoctype, mDocumentURI, mBaseURI, mPrincipal, scriptHandlingObject, aReturn); } NS_IMETHODIMP nsDOMImplementation::Init(nsIURI* aDocumentURI, nsIURI* aBaseURI, nsIPrincipal* aPrincipal) { // Note: can't require that the args be non-null, since at least one // caller (XMLHttpRequest) doesn't have decent args to pass in. mDocumentURI = aDocumentURI; mBaseURI = aBaseURI; mPrincipal = aPrincipal; return NS_OK; } // ================================================================== // = // ================================================================== // NOTE! nsDocument::operator new() zeroes out all members, so don't // bother initializing members to 0. nsDocument::nsDocument(const char* aContentType) : nsIDocument(), mVisible(PR_TRUE) { mContentType = aContentType; #ifdef PR_LOGGING if (!gDocumentLeakPRLog) gDocumentLeakPRLog = PR_NewLogModule("DocumentLeak"); if (gDocumentLeakPRLog) PR_LOG(gDocumentLeakPRLog, PR_LOG_DEBUG, ("DOCUMENT %p created", this)); #endif // Start out mLastStyleSheetSet as null, per spec SetDOMStringToNull(mLastStyleSheetSet); } PR_STATIC_CALLBACK(PLDHashOperator) ClearAllBoxObjects(const void* aKey, nsPIBoxObject* aBoxObject, void* aUserArg) { if (aBoxObject) { aBoxObject->Clear(); } return PL_DHASH_NEXT; } nsDocument::~nsDocument() { #ifdef PR_LOGGING if (gDocumentLeakPRLog) PR_LOG(gDocumentLeakPRLog, PR_LOG_DEBUG, ("DOCUMENT %p destroyed", this)); #endif #ifdef DEBUG nsCycleCollector_DEBUG_wasFreed(static_cast(this)); #endif mInDestructor = PR_TRUE; // Clear mObservers to keep it in sync with the mutationobserver list mObservers.Clear(); if (mStyleSheetSetList) { mStyleSheetSetList->Disconnect(); } mParentDocument = nsnull; // Kill the subdocument map, doing this will release its strong // references, if any. if (mSubDocuments) { PL_DHashTableDestroy(mSubDocuments); mSubDocuments = nsnull; } // Destroy link map now so we don't waste time removing // links one by one DestroyLinkMap(); nsAutoScriptBlocker scriptBlocker; PRInt32 indx; // must be signed PRUint32 count = mChildren.ChildCount(); for (indx = PRInt32(count) - 1; indx >= 0; --indx) { mChildren.ChildAt(indx)->UnbindFromTree(); mChildren.RemoveChildAt(indx); } mCachedRootContent = nsnull; // Let the stylesheets know we're going away indx = mStyleSheets.Count(); while (--indx >= 0) { mStyleSheets[indx]->SetOwningDocument(nsnull); } indx = mCatalogSheets.Count(); while (--indx >= 0) { mCatalogSheets[indx]->SetOwningDocument(nsnull); } if (mAttrStyleSheet) mAttrStyleSheet->SetOwningDocument(nsnull); if (mStyleAttrStyleSheet) mStyleAttrStyleSheet->SetOwningDocument(nsnull); if (mListenerManager) { mListenerManager->Disconnect(); } if (mScriptLoader) { mScriptLoader->DropDocumentReference(); } if (mCSSLoader) { // Could be null here if Init() failed mCSSLoader->DropDocumentReference(); NS_RELEASE(mCSSLoader); } // XXX Ideally we'd do this cleanup in the nsIDocument destructor. if (mNodeInfoManager) { mNodeInfoManager->DropDocumentReference(); NS_RELEASE(mNodeInfoManager); } if (mAttrStyleSheet) { mAttrStyleSheet->SetOwningDocument(nsnull); } if (mStyleAttrStyleSheet) { mStyleAttrStyleSheet->SetOwningDocument(nsnull); } delete mHeaderData; if (mBoxObjectTable) { mBoxObjectTable->EnumerateRead(ClearAllBoxObjects, nsnull); delete mBoxObjectTable; } delete mContentWrapperHash; } NS_IMPL_CYCLE_COLLECTION_CLASS(nsDocument) NS_INTERFACE_TABLE_HEAD(nsDocument) NS_INTERFACE_TABLE_BEGIN NS_INTERFACE_TABLE_ENTRY(nsDocument, nsINode) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDocument) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMDocument) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMNSDocument) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMDocumentEvent) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOM3DocumentEvent) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMDocumentStyle) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMNSDocumentStyle) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMDocumentView) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMDocumentRange) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMDocumentTraversal) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMDocumentXBL) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIScriptObjectPrincipal) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMEventTarget) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOM3EventTarget) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMNSEventTarget) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMNode) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsPIDOMEventTarget) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOM3Node) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOM3Document) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsISupportsWeakReference) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIRadioGroupContainer) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIMutationObserver) NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMNodeSelector) // nsNodeSH::PreCreate() depends on the identity pointer being the // same as nsINode (which nsIDocument inherits), so if you change // the below line, make sure nsNodeSH::PreCreate() still does the // right thing! NS_INTERFACE_TABLE_ENTRY_AMBIGUOUS(nsDocument, nsISupports, nsIDocument) NS_INTERFACE_TABLE_END NS_INTERFACE_TABLE_TO_MAP_SEGUE_CYCLE_COLLECTION(nsDocument) if (aIID.Equals(NS_GET_IID(nsIDOMXPathEvaluator)) || aIID.Equals(NS_GET_IID(nsIXPathEvaluatorInternal))) { if (!mXPathEvaluatorTearoff) { nsresult rv; mXPathEvaluatorTearoff = do_CreateInstance(NS_XPATH_EVALUATOR_CONTRACTID, static_cast(this), &rv); NS_ENSURE_SUCCESS(rv, rv); } return mXPathEvaluatorTearoff->QueryInterface(aIID, aInstancePtr); } else NS_INTERFACE_MAP_END NS_IMPL_CYCLE_COLLECTING_ADDREF_AMBIGUOUS(nsDocument, nsIDocument) NS_IMPL_CYCLE_COLLECTING_RELEASE_AMBIGUOUS_WITH_DESTROY(nsDocument, nsIDocument, nsNodeUtils::LastRelease(this)) PR_STATIC_CALLBACK(PLDHashOperator) SubDocTraverser(PLDHashTable *table, PLDHashEntryHdr *hdr, PRUint32 number, void *arg) { SubDocMapEntry *entry = static_cast(hdr); nsCycleCollectionTraversalCallback *cb = static_cast(arg); NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mSubDocuments entry->mKey"); cb->NoteXPCOMChild(entry->mKey); NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mSubDocuments entry->mSubDocument"); cb->NoteXPCOMChild(entry->mSubDocument); return PL_DHASH_NEXT; } PR_STATIC_CALLBACK(PLDHashOperator) RadioGroupsTraverser(const nsAString& aKey, nsAutoPtr& aData, void* aClosure) { nsCycleCollectionTraversalCallback *cb = static_cast(aClosure); NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mRadioGroups entry->mSelectedRadioButton"); cb->NoteXPCOMChild(aData->mSelectedRadioButton); PRUint32 i, count = aData->mRadioButtons.Count(); for (i = 0; i < count; ++i) { NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mRadioGroups entry->mRadioButtons[i]"); cb->NoteXPCOMChild(aData->mRadioButtons[i]); } return PL_DHASH_NEXT; } PR_STATIC_CALLBACK(PLDHashOperator) BoxObjectTraverser(const void* key, nsPIBoxObject* boxObject, void* userArg) { nsCycleCollectionTraversalCallback *cb = static_cast(userArg); NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mBoxObjectTable entry"); cb->NoteXPCOMChild(boxObject); return PL_DHASH_NEXT; } class LinkMapTraversalVisitor : public nsUint32ToContentHashEntry::Visitor { public: nsCycleCollectionTraversalCallback *mCb; virtual void Visit(nsIContent* aContent) { mCb->NoteXPCOMChild(aContent); } }; PR_STATIC_CALLBACK(PLDHashOperator) LinkMapTraverser(nsUint32ToContentHashEntry* aEntry, void* userArg) { LinkMapTraversalVisitor visitor; visitor.mCb = static_cast(userArg); NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*visitor.mCb, "mLinkMap entry"); aEntry->VisitContent(&visitor); return PL_DHASH_NEXT; } PR_STATIC_CALLBACK(PLDHashOperator) IdentifierMapEntryTraverse(nsIdentifierMapEntry *aEntry, void *aArg) { nsCycleCollectionTraversalCallback *cb = static_cast(aArg); aEntry->Traverse(cb); return PL_DHASH_NEXT; } NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsDocument) if (nsCCUncollectableMarker::InGeneration(tmp->GetMarkedCCGeneration())) { return NS_OK; } tmp->mIdentifierMap.EnumerateEntries(IdentifierMapEntryTraverse, &cb); NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mNodeInfo) // Traverse the mChildren nsAttrAndChildArray. for (PRInt32 indx = PRInt32(tmp->mChildren.ChildCount()); indx > 0; --indx) { NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mChildren[i]"); cb.NoteXPCOMChild(tmp->mChildren.ChildAt(indx - 1)); } NS_IMPL_CYCLE_COLLECTION_TRAVERSE_USERDATA // Traverse all nsIDocument pointer members. NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mCachedRootContent) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NATIVE_MEMBER(mNodeInfoManager, nsNodeInfoManager) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mSecurityInfo) // Traverse all nsDocument nsCOMPtrs. NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mParser) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mScriptGlobalObject) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mListenerManager) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mDOMStyleSheets) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mScriptLoader) tmp->mRadioGroups.Enumerate(RadioGroupsTraverser, &cb); // The boxobject for an element will only exist as long as it's in the // document, so we'll traverse the table here instead of from the element. if (tmp->mBoxObjectTable) { tmp->mBoxObjectTable->EnumerateRead(BoxObjectTraverser, &cb); } NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mChannel) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mStyleAttrStyleSheet) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mScriptEventManager) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mXPathEvaluatorTearoff) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mLayoutHistoryState) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mOnloadBlocker) // An element will only be in the linkmap as long as it's in the // document, so we'll traverse the table here instead of from the element. if (tmp->mLinkMap.IsInitialized()) { tmp->mLinkMap.EnumerateEntries(LinkMapTraverser, &cb); } // Traverse all our nsCOMArrays. NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMARRAY(mStyleSheets) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMARRAY(mCatalogSheets) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMARRAY(mVisitednessChangedURIs) // Traverse any associated preserved wrapper. NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "[preserved wrapper]"); cb.NoteXPCOMChild(tmp->GetReference(tmp)); if (tmp->mSubDocuments && tmp->mSubDocuments->ops) { PL_DHashTableEnumerate(tmp->mSubDocuments, SubDocTraverser, &cb); } NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsDocument) // Tear down linkmap. This is a performance optimization so that we // don't waste time removing links one by one as they are removed // from the doc. tmp->DestroyLinkMap(); nsAutoScriptBlocker scriptBlocker; // Unlink the mChildren nsAttrAndChildArray. for (PRInt32 indx = PRInt32(tmp->mChildren.ChildCount()) - 1; indx >= 0; --indx) { tmp->mChildren.ChildAt(indx)->UnbindFromTree(); tmp->mChildren.RemoveChildAt(indx); } NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mCachedRootContent) NS_IMPL_CYCLE_COLLECTION_UNLINK_USERDATA // Drop the content hash. delete tmp->mContentWrapperHash; tmp->mContentWrapperHash = nsnull; tmp->mParentDocument = nsnull; // nsDocument has a pretty complex destructor, so we're going to // assume that *most* cycles you actually want to break somewhere // else, and not unlink an awful lot here. // // In rare cases where you think an unlink will help here, add one // manually. NS_IMPL_CYCLE_COLLECTION_UNLINK_END nsresult nsDocument::Init() { if (mCSSLoader || mNodeInfoManager || mScriptLoader) { return NS_ERROR_ALREADY_INITIALIZED; } mIdentifierMap.Init(); mLinkMap.Init(); mRadioGroups.Init(); // Force initialization. nsINode::nsSlots* slots = GetSlots(); NS_ENSURE_TRUE(slots,NS_ERROR_OUT_OF_MEMORY); // Prepend self as mutation-observer whether we need it or not (some // subclasses currently do, other don't). This is because the code in // nsNodeUtils always notifies the first observer first, expecting the // first observer to be the document. NS_ENSURE_TRUE(slots->mMutationObservers.PrependElementUnlessExists(static_cast(this)), NS_ERROR_OUT_OF_MEMORY); mOnloadBlocker = new nsOnloadBlocker(); NS_ENSURE_TRUE(mOnloadBlocker, NS_ERROR_OUT_OF_MEMORY); NS_NewCSSLoader(this, &mCSSLoader); NS_ENSURE_TRUE(mCSSLoader, NS_ERROR_OUT_OF_MEMORY); // Assume we're not HTML and not quirky, until we know otherwise mCSSLoader->SetCaseSensitive(PR_TRUE); mCSSLoader->SetCompatibilityMode(eCompatibility_FullStandards); mNodeInfoManager = new nsNodeInfoManager(); NS_ENSURE_TRUE(mNodeInfoManager, NS_ERROR_OUT_OF_MEMORY); NS_ADDREF(mNodeInfoManager); nsresult rv = mNodeInfoManager->Init(this); NS_ENSURE_SUCCESS(rv, rv); mNodeInfo = mNodeInfoManager->GetDocumentNodeInfo(); NS_ENSURE_TRUE(mNodeInfo, NS_ERROR_OUT_OF_MEMORY); NS_ASSERTION(GetOwnerDoc() == this, "Our nodeinfo is busted!"); mScriptLoader = new nsScriptLoader(this); NS_ENSURE_TRUE(mScriptLoader, NS_ERROR_OUT_OF_MEMORY); return NS_OK; } nsresult nsDocument::AddXMLEventsContent(nsIContent *aXMLEventsElement) { if (!mXMLEventsManager) { mXMLEventsManager = new nsXMLEventsManager(); NS_ENSURE_TRUE(mXMLEventsManager, NS_ERROR_OUT_OF_MEMORY); AddObserver(mXMLEventsManager); } mXMLEventsManager->AddXMLEventsContent(aXMLEventsElement); return NS_OK; } void nsDocument::Reset(nsIChannel* aChannel, nsILoadGroup* aLoadGroup) { nsCOMPtr uri; nsCOMPtr principal; if (aChannel) { // Note: this code is duplicated in nsXULDocument::StartDocumentLoad and // nsScriptSecurityManager::GetChannelPrincipal. // Note: this should match nsDocShell::OnLoadingSite NS_GetFinalChannelURI(aChannel, getter_AddRefs(uri)); nsIScriptSecurityManager *securityManager = nsContentUtils::GetSecurityManager(); if (securityManager) { securityManager->GetChannelPrincipal(aChannel, getter_AddRefs(principal)); } } ResetToURI(uri, aLoadGroup, principal); mChannel = aChannel; } void nsDocument::ResetToURI(nsIURI *aURI, nsILoadGroup *aLoadGroup, nsIPrincipal* aPrincipal) { NS_PRECONDITION(aURI, "Null URI passed to ResetToURI"); #ifdef PR_LOGGING if (gDocumentLeakPRLog && PR_LOG_TEST(gDocumentLeakPRLog, PR_LOG_DEBUG)) { nsCAutoString spec; aURI->GetSpec(spec); PR_LogPrint("DOCUMENT %p ResetToURI %s", this, spec.get()); } #endif mDocumentTitle.SetIsVoid(PR_TRUE); mIdentifierMap.Clear(); SetPrincipal(nsnull); mSecurityInfo = nsnull; mDocumentLoadGroup = nsnull; // Delete references to sub-documents and kill the subdocument map, // if any. It holds strong references if (mSubDocuments) { PL_DHashTableDestroy(mSubDocuments); mSubDocuments = nsnull; } // Destroy link map now so we don't waste time removing // links one by one DestroyLinkMap(); PRUint32 count = mChildren.ChildCount(); { // Scope for update MOZ_AUTO_DOC_UPDATE(this, UPDATE_CONTENT_MODEL, PR_TRUE); for (PRInt32 i = PRInt32(count) - 1; i >= 0; i--) { nsCOMPtr content = mChildren.ChildAt(i); // XXXbz this is backwards from how ContentRemoved normally works. That // is, usually it's dispatched after the content has been removed from // the tree. nsNodeUtils::ContentRemoved(this, content, i); content->UnbindFromTree(); mChildren.RemoveChildAt(i); } } mCachedRootContent = nsnull; // Reset our stylesheets ResetStylesheetsToURI(aURI); // Release the listener manager if (mListenerManager) { mListenerManager->Disconnect(); mListenerManager = nsnull; } // Release the stylesheets list. mDOMStyleSheets = nsnull; SetDocumentURI(aURI); mDocumentBaseURI = mDocumentURI; if (aLoadGroup) { mDocumentLoadGroup = do_GetWeakReference(aLoadGroup); // there was an assertion here that aLoadGroup was not null. This // is no longer valid nsWebShell::SetDocument does not create a // load group, and it works just fine. } mLastModified.Truncate(); // XXXbz I guess we're assuming that the caller will either pass in // a channel with a useful type or call SetContentType? mContentType.Truncate(); mContentLanguage.Truncate(); mBaseTarget.Truncate(); mReferrer.Truncate(); mXMLDeclarationBits = 0; // Now get our new principal if (aPrincipal) { SetPrincipal(aPrincipal); } else { nsIScriptSecurityManager *securityManager = nsContentUtils::GetSecurityManager(); if (securityManager) { nsCOMPtr principal; nsresult rv = securityManager->GetCodebasePrincipal(mDocumentURI, getter_AddRefs(principal)); if (NS_SUCCEEDED(rv)) { SetPrincipal(principal); } } } } nsresult nsDocument::ResetStylesheetsToURI(nsIURI* aURI) { NS_PRECONDITION(aURI, "Null URI passed to ResetStylesheetsToURI"); mozAutoDocUpdate upd(this, UPDATE_STYLE, PR_TRUE); // The stylesheets should forget us PRInt32 indx = mStyleSheets.Count(); while (--indx >= 0) { nsIStyleSheet* sheet = mStyleSheets[indx]; sheet->SetOwningDocument(nsnull); PRBool applicable; sheet->GetApplicable(applicable); if (applicable) { RemoveStyleSheetFromStyleSets(sheet); } // XXX Tell observers? } indx = mCatalogSheets.Count(); while (--indx >= 0) { nsIStyleSheet* sheet = mCatalogSheets[indx]; sheet->SetOwningDocument(nsnull); PRBool applicable; sheet->GetApplicable(applicable); if (applicable) { nsPresShellIterator iter(this); nsCOMPtr shell; while ((shell = iter.GetNextShell())) { shell->StyleSet()->RemoveStyleSheet(nsStyleSet::eAgentSheet, sheet); } } // XXX Tell observers? } // Release all the sheets mStyleSheets.Clear(); // NOTE: We don't release the catalog sheets. It doesn't really matter // now, but it could in the future -- in which case not releasing them // is probably the right thing to do. // Now reset our inline style and attribute sheets. nsresult rv; nsStyleSet::sheetType attrSheetType = GetAttrSheetType(); if (mAttrStyleSheet) { // Remove this sheet from all style sets nsPresShellIterator iter(this); nsCOMPtr shell; while ((shell = iter.GetNextShell())) { shell->StyleSet()->RemoveStyleSheet(attrSheetType, mAttrStyleSheet); } rv = mAttrStyleSheet->Reset(aURI); } else { rv = NS_NewHTMLStyleSheet(getter_AddRefs(mAttrStyleSheet), aURI, this); } NS_ENSURE_SUCCESS(rv, rv); // Don't use AddStyleSheet, since it'll put the sheet into style // sets in the document level, which is not desirable here. mAttrStyleSheet->SetOwningDocument(this); if (mStyleAttrStyleSheet) { // Remove this sheet from all style sets nsPresShellIterator iter(this); nsCOMPtr shell; while ((shell = iter.GetNextShell())) { shell->StyleSet()-> RemoveStyleSheet(nsStyleSet::eStyleAttrSheet, mStyleAttrStyleSheet); } rv = mStyleAttrStyleSheet->Reset(aURI); } else { rv = NS_NewHTMLCSSStyleSheet(getter_AddRefs(mStyleAttrStyleSheet), aURI, this); } NS_ENSURE_SUCCESS(rv, rv); // The loop over style sets below will handle putting this sheet // into style sets as needed. mStyleAttrStyleSheet->SetOwningDocument(this); // Now set up our style sets nsPresShellIterator iter(this); nsCOMPtr shell; while ((shell = iter.GetNextShell())) { FillStyleSet(shell->StyleSet()); } return rv; } nsStyleSet::sheetType nsDocument::GetAttrSheetType() { return nsStyleSet::ePresHintSheet; } void nsDocument::FillStyleSet(nsStyleSet* aStyleSet) { NS_PRECONDITION(aStyleSet, "Must have a style set"); NS_PRECONDITION(aStyleSet->SheetCount(nsStyleSet::ePresHintSheet) == 0, "Style set already has a preshint sheet?"); NS_PRECONDITION(aStyleSet->SheetCount(nsStyleSet::eHTMLPresHintSheet) == 0, "Style set already has a HTML preshint sheet?"); NS_PRECONDITION(aStyleSet->SheetCount(nsStyleSet::eDocSheet) == 0, "Style set already has document sheets?"); NS_PRECONDITION(aStyleSet->SheetCount(nsStyleSet::eStyleAttrSheet) == 0, "Style set already has style attr sheets?"); NS_PRECONDITION(mStyleAttrStyleSheet, "No style attr stylesheet?"); NS_PRECONDITION(mAttrStyleSheet, "No attr stylesheet?"); aStyleSet->AppendStyleSheet(GetAttrSheetType(), mAttrStyleSheet); aStyleSet->AppendStyleSheet(nsStyleSet::eStyleAttrSheet, mStyleAttrStyleSheet); PRInt32 i; for (i = mStyleSheets.Count() - 1; i >= 0; --i) { nsIStyleSheet* sheet = mStyleSheets[i]; PRBool sheetApplicable; sheet->GetApplicable(sheetApplicable); if (sheetApplicable) { aStyleSet->AddDocStyleSheet(sheet, this); } } for (i = mCatalogSheets.Count() - 1; i >= 0; --i) { nsIStyleSheet* sheet = mCatalogSheets[i]; PRBool sheetApplicable; sheet->GetApplicable(sheetApplicable); if (sheetApplicable) { aStyleSet->AppendStyleSheet(nsStyleSet::eAgentSheet, sheet); } } } nsresult nsDocument::StartDocumentLoad(const char* aCommand, nsIChannel* aChannel, nsILoadGroup* aLoadGroup, nsISupports* aContainer, nsIStreamListener **aDocListener, PRBool aReset, nsIContentSink* aSink) { #ifdef PR_LOGGING if (gDocumentLeakPRLog && PR_LOG_TEST(gDocumentLeakPRLog, PR_LOG_DEBUG)) { nsCOMPtr uri; aChannel->GetURI(getter_AddRefs(uri)); nsCAutoString spec; if (uri) uri->GetSpec(spec); PR_LogPrint("DOCUMENT %p StartDocumentLoad %s", this, spec.get()); } #endif if (nsCRT::strcmp(kLoadAsData, aCommand) == 0) { mLoadedAsData = PR_TRUE; // We need to disable script & style loading in this case. // We leave them disabled even in EndLoad(), and let anyone // who puts the document on display to worry about enabling. // Do not load/process scripts when loading as data ScriptLoader()->SetEnabled(PR_FALSE); // styles CSSLoader()->SetEnabled(PR_FALSE); // Do not load/process styles when loading as data } mMayStartLayout = PR_FALSE; mHaveInputEncoding = PR_TRUE; if (aReset) { Reset(aChannel, aLoadGroup); } nsCAutoString contentType; if (NS_SUCCEEDED(aChannel->GetContentType(contentType))) { // XXX this is only necessary for viewsource: nsACString::const_iterator start, end, semicolon; contentType.BeginReading(start); contentType.EndReading(end); semicolon = start; FindCharInReadable(';', semicolon, end); mContentType = Substring(start, semicolon); } RetrieveRelevantHeaders(aChannel); mChannel = aChannel; return NS_OK; } void nsDocument::StopDocumentLoad() { if (mParser) { mParser->Terminate(); } } void nsDocument::SetDocumentURI(nsIURI* aURI) { mDocumentURI = NS_TryToMakeImmutable(aURI); } NS_IMETHODIMP nsDocument::GetLastModified(nsAString& aLastModified) { if (!mLastModified.IsEmpty()) { aLastModified.Assign(mLastModified); } else { // If we for whatever reason failed to find the last modified time // (or even the current time), fall back to what NS4.x returned. aLastModified.Assign(NS_LITERAL_STRING("01/01/1970 00:00:00")); } return NS_OK; } void nsDocument::UpdateNameTableEntry(nsIContent *aContent) { if (!mIsRegularHTML) return; nsIAtom* name = nsContentUtils::IsNamedItem(aContent); if (!name) return; nsIdentifierMapEntry *entry = mIdentifierMap.GetEntry(name); if (!entry) { // We're not tracking the elements with this name return; } entry->AddNameContent(aContent); } void nsDocument::RemoveFromNameTable(nsIContent *aContent) { if (!mIsRegularHTML) return; nsIAtom* name = nsContentUtils::IsNamedItem(aContent); if (!name) return; nsIdentifierMapEntry *entry = mIdentifierMap.GetEntry(name); if (!entry) { // We're not tracking the elements with this name return; } entry->RemoveNameContent(aContent); } void nsDocument::UpdateIdTableEntry(nsIContent *aContent) { nsIAtom* id = aContent->GetID(); if (!id) return; PRBool liveTable = IdTableIsLive(); nsIdentifierMapEntry *entry = liveTable ? mIdentifierMap.PutEntry(id) : mIdentifierMap.GetEntry(id); if (entry) { entry->AddIdContent(aContent); } } void nsDocument::RemoveFromIdTable(nsIContent *aContent) { nsIAtom* id = aContent->GetID(); if (!id) return; nsIdentifierMapEntry *entry = mIdentifierMap.GetEntry(id); if (!entry) return; if (entry->RemoveIdContent(aContent)) { mIdentifierMap.RemoveEntry(id); } } void nsDocument::UnregisterNamedItems(nsIContent *aContent) { if (aContent->IsNodeOfType(nsINode::eTEXT)) { // Text nodes are not named items nor can they have children. return; } RemoveFromNameTable(aContent); RemoveFromIdTable(aContent); PRUint32 i, count = aContent->GetChildCount(); for (i = 0; i < count; ++i) { UnregisterNamedItems(aContent->GetChildAt(i)); } } void nsDocument::RegisterNamedItems(nsIContent *aContent) { if (aContent->IsNodeOfType(nsINode::eTEXT)) { // Text nodes are not named items nor can they have children. return; } UpdateNameTableEntry(aContent); UpdateIdTableEntry(aContent); PRUint32 i, count = aContent->GetChildCount(); for (i = 0; i < count; ++i) { RegisterNamedItems(aContent->GetChildAt(i)); } } void nsDocument::ContentAppended(nsIDocument* aDocument, nsIContent* aContainer, PRInt32 aNewIndexInContainer) { NS_ASSERTION(aDocument == this, "unexpected doc"); PRUint32 count = aContainer->GetChildCount(); for (PRUint32 i = aNewIndexInContainer; i < count; ++i) { RegisterNamedItems(aContainer->GetChildAt(i)); } } void nsDocument::ContentInserted(nsIDocument* aDocument, nsIContent* aContainer, nsIContent* aContent, PRInt32 aIndexInContainer) { NS_ASSERTION(aDocument == this, "unexpected doc"); NS_ABORT_IF_FALSE(aContent, "Null content!"); RegisterNamedItems(aContent); } void nsDocument::ContentRemoved(nsIDocument* aDocument, nsIContent* aContainer, nsIContent* aChild, PRInt32 aIndexInContainer) { NS_ASSERTION(aDocument == this, "unexpected doc"); NS_ABORT_IF_FALSE(aChild, "Null content!"); UnregisterNamedItems(aChild); } void nsDocument::AttributeWillChange(nsIContent* aContent, PRInt32 aNameSpaceID, nsIAtom* aAttribute) { NS_ABORT_IF_FALSE(aContent, "Null content!"); NS_PRECONDITION(aAttribute, "Must have an attribute that's changing!"); if (aNameSpaceID != kNameSpaceID_None) return; if (aAttribute == nsGkAtoms::name) { RemoveFromNameTable(aContent); } else if (aAttribute == aContent->GetIDAttributeName()) { RemoveFromIdTable(aContent); } } void nsDocument::AttributeChanged(nsIDocument* aDocument, nsIContent* aContent, PRInt32 aNameSpaceID, nsIAtom* aAttribute, PRInt32 aModType, PRUint32 aStateMask) { NS_ASSERTION(aDocument == this, "unexpected doc"); NS_ABORT_IF_FALSE(aContent, "Null content!"); NS_PRECONDITION(aAttribute, "Must have an attribute that's changing!"); if (aNameSpaceID != kNameSpaceID_None) return; if (aAttribute == nsGkAtoms::name) { UpdateNameTableEntry(aContent); } else if (aAttribute == aContent->GetIDAttributeName()) { UpdateIdTableEntry(aContent); } } nsIPrincipal* nsDocument::GetPrincipal() { return NodePrincipal(); } void nsDocument::SetPrincipal(nsIPrincipal *aNewPrincipal) { mNodeInfoManager->SetDocumentPrincipal(aNewPrincipal); } NS_IMETHODIMP nsDocument::GetContentType(nsAString& aContentType) { CopyUTF8toUTF16(mContentType, aContentType); return NS_OK; } void nsDocument::SetContentType(const nsAString& aContentType) { NS_ASSERTION(mContentType.IsEmpty() || mContentType.Equals(NS_ConvertUTF16toUTF8(aContentType)), "Do you really want to change the content-type?"); CopyUTF16toUTF8(aContentType, mContentType); } /* Return true if the document is in the focused top-level window, and is an * ancestor of the focused DOMWindow. */ NS_IMETHODIMP nsDocument::HasFocus(PRBool* aResult) { *aResult = PR_FALSE; nsPIDOMWindow* window = GetWindow(); nsIFocusController* focusController = window ? window->GetRootFocusController() : nsnull; if (!focusController) { return NS_OK; } // Does the top-level window have focus? PRBool active; nsresult rv = focusController->GetActive(&active); NS_ENSURE_SUCCESS(rv, rv); if (!active){ return NS_OK; } // Is there a focused DOMWindow? nsCOMPtr focusedWindow; rv = focusController->GetFocusedWindow(getter_AddRefs(focusedWindow)); NS_ENSURE_SUCCESS(rv, rv); if (!focusedWindow) { return NS_ERROR_FAILURE; } // Are we an ancestor of the focused DOMWindow? nsCOMPtr domDocument; focusedWindow->GetDocument(getter_AddRefs(domDocument)); nsCOMPtr document = do_QueryInterface(domDocument); for (nsIDocument* currentDoc = document; currentDoc; currentDoc = currentDoc->GetParentDocument()) { if (currentDoc == this) { // Yes, we are an ancestor *aResult = PR_TRUE; return NS_OK; } } return NS_OK; } NS_IMETHODIMP nsDocument::GetReferrer(nsAString& aReferrer) { CopyUTF8toUTF16(mReferrer, aReferrer); return NS_OK; } NS_IMETHODIMP nsDocument::GetActiveElement(nsIDOMElement **aElement) { *aElement = nsnull; // Get the focused element. nsPIDOMWindow* window = GetWindow(); if (!window) { return NS_ERROR_NOT_AVAILABLE; } nsIFocusController* focusController = window->GetRootFocusController(); if (!focusController) { return NS_ERROR_FAILURE; } nsCOMPtr focusedElement; focusController->GetFocusedElement(getter_AddRefs(focusedElement)); nsCOMPtr content = do_QueryInterface(focusedElement); if (content) { // Found a focused element. See if it's in this document. nsIDocument* currentDoc = content->GetCurrentDoc(); if (currentDoc == this) { focusedElement.swap(*aElement); return NS_OK; } // Not in this document. If it's in a child document, return the iframe in // this document that's an ancestor of the child. if (currentDoc) { *aElement = CheckAncestryAndGetFrame(currentDoc).get(); if (*aElement) { return NS_OK; } } } // Couldn't find a focused element. Check if something like an IFRAME is // focused, which will give us a focused window rather than a focused // element. nsCOMPtr focusedWindow; focusController->GetFocusedWindow(getter_AddRefs(focusedWindow)); if (focusedWindow) { // Found a focused window. See if it's in a child of this document. (If // the window's document is this, then we should just fall through to // returning the BODY below). nsCOMPtr domDocument; focusedWindow->GetDocument(getter_AddRefs(domDocument)); nsCOMPtr document = do_QueryInterface(domDocument); if (document && (document != this)) { *aElement = CheckAncestryAndGetFrame(document).get(); if (*aElement) { return NS_OK; } } } // No focused element anywhere in this document. Try to get the BODY. nsCOMPtr htmlDoc = do_QueryInterface(static_cast(this)); if (htmlDoc) { nsCOMPtr bodyElement; htmlDoc->GetBody(getter_AddRefs(bodyElement)); if (bodyElement) { *aElement = bodyElement; NS_ADDREF(*aElement); } // Because of IE compatibility, return null when html document doesn't have // a body. return NS_OK; } // If we couldn't get a BODY, return the root element. return GetDocumentElement(aElement); } NS_IMETHODIMP nsDocument::ElementFromPoint(PRInt32 aX, PRInt32 aY, nsIDOMElement** aReturn) { NS_ENSURE_ARG_POINTER(aReturn); *aReturn = nsnull; // As per the the spec, we return null if either coord is negative if (aX < 0 || aY < 0) return NS_OK; nscoord x = nsPresContext::CSSPixelsToAppUnits(aX); nscoord y = nsPresContext::CSSPixelsToAppUnits(aY); nsPoint pt(x, y); // Make sure the layout information we get is up-to-date, and // ensure we get a root frame (for everything but XUL) FlushPendingNotifications(Flush_Layout); nsIPresShell *ps = GetPrimaryShell(); NS_ENSURE_STATE(ps); nsIFrame *rootFrame = ps->GetRootFrame(); // XUL docs, unlike HTML, have no frame tree until everything's done loading if (!rootFrame) return NS_OK; // return null to premature XUL callers as a reminder to wait nsIFrame *ptFrame = nsLayoutUtils::GetFrameForPoint(rootFrame, pt, PR_TRUE); if (!ptFrame) return NS_OK; nsIContent* ptContent = ptFrame->GetContent(); NS_ENSURE_STATE(ptContent); // If the content is in a subdocument, try to get the element from |this| doc nsIDocument *currentDoc = ptContent->GetCurrentDoc(); if (currentDoc && (currentDoc != this)) { *aReturn = CheckAncestryAndGetFrame(currentDoc).get(); return NS_OK; } // If we have an anonymous element (such as an internal div from a textbox), // or a node that isn't an element (such as a text frame node), // replace it with the first non-anonymous parent node of type element. while (ptContent && !ptContent->IsNodeOfType(nsINode::eELEMENT) || ptContent->IsInAnonymousSubtree()) { // XXXldb: Faster to jump to GetBindingParent if non-null? ptContent = ptContent->GetParent(); } if (ptContent) CallQueryInterface(ptContent, aReturn); return NS_OK; } NS_IMETHODIMP nsDocument::GetElementsByClassName(const nsAString& aClasses, nsIDOMNodeList** aReturn) { return GetElementsByClassNameHelper(this, aClasses, aReturn); } // static GetElementsByClassName helpers nsresult nsDocument::GetElementsByClassNameHelper(nsINode* aRootNode, const nsAString& aClasses, nsIDOMNodeList** aReturn) { NS_PRECONDITION(aRootNode, "Must have root node"); nsAttrValue attrValue; attrValue.ParseAtomArray(aClasses); // nsAttrValue::Equals is sensitive to order, so we'll send an array nsCOMArray* classes = new nsCOMArray; NS_ENSURE_TRUE(classes, NS_ERROR_OUT_OF_MEMORY); if (attrValue.Type() == nsAttrValue::eAtomArray) { classes->AppendObjects(*(attrValue.GetAtomArrayValue())); } else if (!attrValue.IsEmptyString()) { classes->AppendObject(attrValue.GetAtomValue()); } nsBaseContentList* elements; if (classes->Count() > 0) { elements = new nsContentList(aRootNode, MatchClassNames, DestroyClassNameArray, classes); } else { delete classes; classes = nsnull; elements = new nsBaseContentList(); } if (!elements) { delete classes; return NS_ERROR_OUT_OF_MEMORY; } *aReturn = elements; NS_ADDREF(*aReturn); return NS_OK; } // static PRBool nsDocument::MatchClassNames(nsIContent* aContent, PRInt32 aNamespaceID, nsIAtom* aAtom, void* aData) { // We can't match if there are no class names const nsAttrValue* classAttr = aContent->GetClasses(); if (!classAttr) { return PR_FALSE; } // need to match *all* of the classes nsCOMArray* classes = static_cast*>(aData); PRInt32 length = classes->Count(); PRInt32 i; for (i = 0; i < length; ++i) { if (!classAttr->Contains(classes->ObjectAt(i), eCaseMatters)) { return PR_FALSE; } } return PR_TRUE; } // static void nsDocument::DestroyClassNameArray(void* aData) { nsCOMArray* classes = static_cast*>(aData); delete classes; } nsresult nsDocument::SetBaseURI(nsIURI* aURI) { nsresult rv = NS_OK; if (aURI) { rv = nsContentUtils::GetSecurityManager()-> CheckLoadURIWithPrincipal(NodePrincipal(), aURI, nsIScriptSecurityManager::STANDARD); if (NS_SUCCEEDED(rv)) { mDocumentBaseURI = NS_TryToMakeImmutable(aURI); } } else { mDocumentBaseURI = nsnull; } return rv; } void nsDocument::GetBaseTarget(nsAString &aBaseTarget) const { aBaseTarget.Assign(mBaseTarget); } void nsDocument::SetBaseTarget(const nsAString &aBaseTarget) { mBaseTarget.Assign(aBaseTarget); } void nsDocument::SetDocumentCharacterSet(const nsACString& aCharSetID) { if (!mCharacterSet.Equals(aCharSetID)) { mCharacterSet = aCharSetID; #ifdef DEBUG nsCOMPtr calias(do_GetService(NS_CHARSETALIAS_CONTRACTID)); if (calias) { nsCAutoString canonicalName; calias->GetPreferred(aCharSetID, canonicalName); NS_ASSERTION(canonicalName.Equals(aCharSetID), "charset name must be canonical"); } #endif PRInt32 n = mCharSetObservers.Count(); for (PRInt32 i = 0; i < n; i++) { nsIObserver* observer = static_cast(mCharSetObservers.ElementAt(i)); observer->Observe(static_cast(this), "charset", NS_ConvertASCIItoUTF16(aCharSetID).get()); } } } nsresult nsDocument::AddCharSetObserver(nsIObserver* aObserver) { NS_ENSURE_ARG_POINTER(aObserver); NS_ENSURE_TRUE(mCharSetObservers.AppendElement(aObserver), NS_ERROR_FAILURE); return NS_OK; } void nsDocument::RemoveCharSetObserver(nsIObserver* aObserver) { mCharSetObservers.RemoveElement(aObserver); } void nsDocument::GetHeaderData(nsIAtom* aHeaderField, nsAString& aData) const { aData.Truncate(); const nsDocHeaderData* data = mHeaderData; while (data) { if (data->mField == aHeaderField) { aData = data->mData; break; } data = data->mNext; } } void nsDocument::SetHeaderData(nsIAtom* aHeaderField, const nsAString& aData) { if (!aHeaderField) { NS_ERROR("null headerField"); return; } if (!mHeaderData) { if (!aData.IsEmpty()) { // don't bother storing empty string mHeaderData = new nsDocHeaderData(aHeaderField, aData); } } else { nsDocHeaderData* data = mHeaderData; nsDocHeaderData** lastPtr = &mHeaderData; PRBool found = PR_FALSE; do { // look for existing and replace if (data->mField == aHeaderField) { if (!aData.IsEmpty()) { data->mData.Assign(aData); } else { // don't store empty string *lastPtr = data->mNext; data->mNext = nsnull; delete data; } found = PR_TRUE; break; } lastPtr = &(data->mNext); data = *lastPtr; } while (data); if (!aData.IsEmpty() && !found) { // didn't find, append *lastPtr = new nsDocHeaderData(aHeaderField, aData); } } if (aHeaderField == nsGkAtoms::headerContentLanguage) { CopyUTF16toUTF8(aData, mContentLanguage); } // Set the default script-type on the root element. if (aHeaderField == nsGkAtoms::headerContentScriptType) { nsIContent *root = GetRootContent(); if (root) { // Get the script-type ID for this value. nsresult rv; nsCOMPtr runtime; rv = NS_GetScriptRuntime(aData, getter_AddRefs(runtime)); if (NS_FAILED(rv) || runtime == nsnull) { NS_WARNING("The script-type is unknown"); } else { root->SetScriptTypeID(runtime->GetScriptTypeID()); } } } if (aHeaderField == nsGkAtoms::headerDefaultStyle) { // Only mess with our stylesheets if we don't have a lastStyleSheetSet, per // spec. if (DOMStringIsNull(mLastStyleSheetSet)) { // Calling EnableStyleSheetsForSetInternal, not SetSelectedStyleSheetSet, // per spec. The idea here is that we're changing our preferred set and // that shouldn't change the value of lastStyleSheetSet. Also, we're // using the Internal version so we can update the CSSLoader and not have // to worry about null strings. EnableStyleSheetsForSetInternal(aData, PR_TRUE); } } if (aHeaderField == nsGkAtoms::refresh) { // We get into this code before we have a script global yet, so get to // our container via mDocumentContainer. nsCOMPtr refresher = do_QueryReferent(mDocumentContainer); if (refresher) { // Note: using mDocumentURI instead of mBaseURI here, for consistency // (used to just use the current URI of our webnavigation, but that // should really be the same thing). Note that this code can run // before the current URI of the webnavigation has been updated, so we // can't assert equality here. refresher->SetupRefreshURIFromHeader(mDocumentURI, NS_ConvertUTF16toUTF8(aData)); } } } PRBool nsDocument::TryChannelCharset(nsIChannel *aChannel, PRInt32& aCharsetSource, nsACString& aCharset) { if(kCharsetFromChannel <= aCharsetSource) { return PR_TRUE; } if (aChannel) { nsCAutoString charsetVal; nsresult rv = aChannel->GetContentCharset(charsetVal); if (NS_SUCCEEDED(rv)) { nsCOMPtr calias(do_GetService(NS_CHARSETALIAS_CONTRACTID)); if (calias) { nsCAutoString preferred; rv = calias->GetPreferred(charsetVal, preferred); if(NS_SUCCEEDED(rv)) { aCharset = preferred; aCharsetSource = kCharsetFromChannel; return PR_TRUE; } } } } return PR_FALSE; } nsresult nsDocument::CreateShell(nsPresContext* aContext, nsIViewManager* aViewManager, nsStyleSet* aStyleSet, nsIPresShell** aInstancePtrResult) { // Don't add anything here. Add it to |doCreateShell| instead. // This exists so that subclasses can pass other values for the 4th // parameter some of the time. return doCreateShell(aContext, aViewManager, aStyleSet, eCompatibility_FullStandards, aInstancePtrResult); } nsresult nsDocument::doCreateShell(nsPresContext* aContext, nsIViewManager* aViewManager, nsStyleSet* aStyleSet, nsCompatibility aCompatMode, nsIPresShell** aInstancePtrResult) { *aInstancePtrResult = nsnull; NS_ENSURE_FALSE(mShellsAreHidden, NS_ERROR_FAILURE); FillStyleSet(aStyleSet); nsCOMPtr shell; nsresult rv = NS_NewPresShell(getter_AddRefs(shell)); if (NS_FAILED(rv)) { return rv; } rv = shell->Init(this, aContext, aViewManager, aStyleSet, aCompatMode); NS_ENSURE_SUCCESS(rv, rv); // Note: we don't hold a ref to the shell (it holds a ref to us) NS_ENSURE_TRUE(mPresShells.AppendElementUnlessExists(shell), NS_ERROR_OUT_OF_MEMORY); shell.swap(*aInstancePtrResult); return NS_OK; } PRBool nsDocument::DeleteShell(nsIPresShell* aShell) { return mPresShells.RemoveElement(aShell); } nsIPresShell * nsDocument::GetPrimaryShell() const { return mShellsAreHidden ? nsnull : mPresShells.SafeElementAt(0, nsnull); } PR_STATIC_CALLBACK(void) SubDocClearEntry(PLDHashTable *table, PLDHashEntryHdr *entry) { SubDocMapEntry *e = static_cast(entry); NS_RELEASE(e->mKey); if (e->mSubDocument) { e->mSubDocument->SetParentDocument(nsnull); NS_RELEASE(e->mSubDocument); } } PR_STATIC_CALLBACK(PRBool) SubDocInitEntry(PLDHashTable *table, PLDHashEntryHdr *entry, const void *key) { SubDocMapEntry *e = const_cast (static_cast(entry)); e->mKey = const_cast (static_cast(key)); NS_ADDREF(e->mKey); e->mSubDocument = nsnull; return PR_TRUE; } nsresult nsDocument::SetSubDocumentFor(nsIContent *aContent, nsIDocument* aSubDoc) { NS_ENSURE_TRUE(aContent, NS_ERROR_UNEXPECTED); if (!aSubDoc) { // aSubDoc is nsnull, remove the mapping if (mSubDocuments) { SubDocMapEntry *entry = static_cast (PL_DHashTableOperate(mSubDocuments, aContent, PL_DHASH_LOOKUP)); if (PL_DHASH_ENTRY_IS_BUSY(entry)) { PL_DHashTableRawRemove(mSubDocuments, entry); } } } else { if (!mSubDocuments) { // Create a new hashtable static PLDHashTableOps hash_table_ops = { PL_DHashAllocTable, PL_DHashFreeTable, PL_DHashVoidPtrKeyStub, PL_DHashMatchEntryStub, PL_DHashMoveEntryStub, SubDocClearEntry, PL_DHashFinalizeStub, SubDocInitEntry }; mSubDocuments = PL_NewDHashTable(&hash_table_ops, nsnull, sizeof(SubDocMapEntry), 16); if (!mSubDocuments) { return NS_ERROR_OUT_OF_MEMORY; } } // Add a mapping to the hash table SubDocMapEntry *entry = static_cast (PL_DHashTableOperate(mSubDocuments, aContent, PL_DHASH_ADD)); if (!entry) { return NS_ERROR_OUT_OF_MEMORY; } if (entry->mSubDocument) { entry->mSubDocument->SetParentDocument(nsnull); // Release the old sub document NS_RELEASE(entry->mSubDocument); } entry->mSubDocument = aSubDoc; NS_ADDREF(entry->mSubDocument); aSubDoc->SetParentDocument(this); } return NS_OK; } nsIDocument* nsDocument::GetSubDocumentFor(nsIContent *aContent) const { if (mSubDocuments) { SubDocMapEntry *entry = static_cast (PL_DHashTableOperate(mSubDocuments, aContent, PL_DHASH_LOOKUP)); if (PL_DHASH_ENTRY_IS_BUSY(entry)) { return entry->mSubDocument; } } return nsnull; } PR_STATIC_CALLBACK(PLDHashOperator) FindContentEnumerator(PLDHashTable *table, PLDHashEntryHdr *hdr, PRUint32 number, void *arg) { SubDocMapEntry *entry = static_cast(hdr); FindContentData *data = static_cast(arg); if (entry->mSubDocument == data->mSubDocument) { data->mResult = entry->mKey; return PL_DHASH_STOP; } return PL_DHASH_NEXT; } nsIContent* nsDocument::FindContentForSubDocument(nsIDocument *aDocument) const { NS_ENSURE_TRUE(aDocument, nsnull); if (!mSubDocuments) { return nsnull; } FindContentData data(aDocument); PL_DHashTableEnumerate(mSubDocuments, FindContentEnumerator, &data); return data.mResult; } PRBool nsDocument::IsNodeOfType(PRUint32 aFlags) const { return !(aFlags & ~eDOCUMENT); } nsIContent* nsDocument::GetRootContentInternal() const { // Loop backwards because any non-elements, such as doctypes and PIs // are likely to appear before the root element. PRUint32 i; for (i = mChildren.ChildCount(); i > 0; --i) { nsIContent* child = mChildren.ChildAt(i - 1); if (child->IsNodeOfType(nsINode::eELEMENT)) { const_cast(this)->mCachedRootContent = child; return child; } } const_cast(this)->mCachedRootContent = nsnull; return nsnull; } nsIContent * nsDocument::GetChildAt(PRUint32 aIndex) const { return mChildren.GetSafeChildAt(aIndex); } PRInt32 nsDocument::IndexOf(nsINode* aPossibleChild) const { return mChildren.IndexOfChild(aPossibleChild); } PRUint32 nsDocument::GetChildCount() const { return mChildren.ChildCount(); } nsIContent * const * nsDocument::GetChildArray() const { return mChildren.GetChildArray(); } nsresult nsDocument::InsertChildAt(nsIContent* aKid, PRUint32 aIndex, PRBool aNotify) { if (aKid->IsNodeOfType(nsINode::eELEMENT) && GetRootContent()) { NS_ERROR("Inserting element child when we already have one"); return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR; } return nsGenericElement::doInsertChildAt(aKid, aIndex, aNotify, nsnull, this, mChildren); } nsresult nsDocument::AppendChildTo(nsIContent* aKid, PRBool aNotify) { // Make sure to _not_ call the subclass InsertChildAt here. If // subclasses wanted to hook into this stuff, they would have // overridden AppendChildTo. // XXXbz maybe this should just be a non-virtual method on nsINode? // Feels that way to me... return nsDocument::InsertChildAt(aKid, GetChildCount(), aNotify); } nsresult nsDocument::RemoveChildAt(PRUint32 aIndex, PRBool aNotify) { nsCOMPtr oldKid = GetChildAt(aIndex); if (!oldKid) { return NS_OK; } if (oldKid->IsNodeOfType(nsINode::eELEMENT)) { // Destroy the link map up front before we mess with the child list. DestroyLinkMap(); } nsresult rv = nsGenericElement::doRemoveChildAt(aIndex, aNotify, oldKid, nsnull, this, mChildren); mCachedRootContent = nsnull; return rv; } PRInt32 nsDocument::GetNumberOfStyleSheets() const { return mStyleSheets.Count(); } nsIStyleSheet* nsDocument::GetStyleSheetAt(PRInt32 aIndex) const { NS_ENSURE_TRUE(0 <= aIndex && aIndex < mStyleSheets.Count(), nsnull); return mStyleSheets[aIndex]; } PRInt32 nsDocument::GetIndexOfStyleSheet(nsIStyleSheet* aSheet) const { return mStyleSheets.IndexOf(aSheet); } void nsDocument::AddStyleSheetToStyleSets(nsIStyleSheet* aSheet) { nsPresShellIterator iter(this); nsCOMPtr shell; while ((shell = iter.GetNextShell())) { shell->StyleSet()->AddDocStyleSheet(aSheet, this); } } void nsDocument::AddStyleSheet(nsIStyleSheet* aSheet) { NS_PRECONDITION(aSheet, "null arg"); mStyleSheets.AppendObject(aSheet); aSheet->SetOwningDocument(this); PRBool applicable; aSheet->GetApplicable(applicable); if (applicable) { AddStyleSheetToStyleSets(aSheet); } NS_DOCUMENT_NOTIFY_OBSERVERS(StyleSheetAdded, (this, aSheet, PR_TRUE)); } void nsDocument::RemoveStyleSheetFromStyleSets(nsIStyleSheet* aSheet) { nsPresShellIterator iter(this); nsCOMPtr shell; while ((shell = iter.GetNextShell())) { shell->StyleSet()->RemoveStyleSheet(nsStyleSet::eDocSheet, aSheet); } } void nsDocument::RemoveStyleSheet(nsIStyleSheet* aSheet) { NS_PRECONDITION(aSheet, "null arg"); nsCOMPtr sheet = aSheet; // hold ref so it won't die too soon if (!mStyleSheets.RemoveObject(aSheet)) { NS_NOTREACHED("stylesheet not found"); return; } if (!mIsGoingAway) { PRBool applicable = PR_TRUE; aSheet->GetApplicable(applicable); if (applicable) { RemoveStyleSheetFromStyleSets(aSheet); } NS_DOCUMENT_NOTIFY_OBSERVERS(StyleSheetRemoved, (this, aSheet, PR_TRUE)); } aSheet->SetOwningDocument(nsnull); } void nsDocument::UpdateStyleSheets(nsCOMArray& aOldSheets, nsCOMArray& aNewSheets) { BeginUpdate(UPDATE_STYLE); // XXX Need to set the sheet on the ownernode, if any NS_PRECONDITION(aOldSheets.Count() == aNewSheets.Count(), "The lists must be the same length!"); PRInt32 count = aOldSheets.Count(); nsCOMPtr oldSheet; PRInt32 i; for (i = 0; i < count; ++i) { oldSheet = aOldSheets[i]; // First remove the old sheet. NS_ASSERTION(oldSheet, "None of the old sheets should be null"); PRInt32 oldIndex = mStyleSheets.IndexOf(oldSheet); RemoveStyleSheet(oldSheet); // This does the right notifications // Now put the new one in its place. If it's null, just ignore it. nsIStyleSheet* newSheet = aNewSheets[i]; if (newSheet) { mStyleSheets.InsertObjectAt(newSheet, oldIndex); newSheet->SetOwningDocument(this); PRBool applicable = PR_TRUE; newSheet->GetApplicable(applicable); if (applicable) { AddStyleSheetToStyleSets(newSheet); } NS_DOCUMENT_NOTIFY_OBSERVERS(StyleSheetAdded, (this, newSheet, PR_TRUE)); } } EndUpdate(UPDATE_STYLE); } void nsDocument::InsertStyleSheetAt(nsIStyleSheet* aSheet, PRInt32 aIndex) { NS_PRECONDITION(aSheet, "null ptr"); mStyleSheets.InsertObjectAt(aSheet, aIndex); aSheet->SetOwningDocument(this); PRBool applicable; aSheet->GetApplicable(applicable); if (applicable) { AddStyleSheetToStyleSets(aSheet); } NS_DOCUMENT_NOTIFY_OBSERVERS(StyleSheetAdded, (this, aSheet, PR_TRUE)); } void nsDocument::SetStyleSheetApplicableState(nsIStyleSheet* aSheet, PRBool aApplicable) { NS_PRECONDITION(aSheet, "null arg"); // If we're actually in the document style sheet list if (-1 != mStyleSheets.IndexOf(aSheet)) { if (aApplicable) { AddStyleSheetToStyleSets(aSheet); } else { RemoveStyleSheetFromStyleSets(aSheet); } } // We have to always notify, since this will be called for sheets // that are children of sheets in our style set, as well as some // sheets for nsHTMLEditor. NS_DOCUMENT_NOTIFY_OBSERVERS(StyleSheetApplicableStateChanged, (this, aSheet, aApplicable)); } // These three functions are a lot like the implementation of the // corresponding API for regular stylesheets. PRInt32 nsDocument::GetNumberOfCatalogStyleSheets() const { return mCatalogSheets.Count(); } nsIStyleSheet* nsDocument::GetCatalogStyleSheetAt(PRInt32 aIndex) const { NS_ENSURE_TRUE(0 <= aIndex && aIndex < mCatalogSheets.Count(), nsnull); return mCatalogSheets[aIndex]; } void nsDocument::AddCatalogStyleSheet(nsIStyleSheet* aSheet) { mCatalogSheets.AppendObject(aSheet); aSheet->SetOwningDocument(this); PRBool applicable; aSheet->GetApplicable(applicable); if (applicable) { // This is like |AddStyleSheetToStyleSets|, but for an agent sheet. nsPresShellIterator iter(this); nsCOMPtr shell; while ((shell = iter.GetNextShell())) { shell->StyleSet()->AppendStyleSheet(nsStyleSet::eAgentSheet, aSheet); } } NS_DOCUMENT_NOTIFY_OBSERVERS(StyleSheetAdded, (this, aSheet, PR_FALSE)); } void nsDocument::EnsureCatalogStyleSheet(const char *aStyleSheetURI) { nsICSSLoader* cssLoader = CSSLoader(); PRBool enabled; if (NS_SUCCEEDED(cssLoader->GetEnabled(&enabled)) && enabled) { PRInt32 sheetCount = GetNumberOfCatalogStyleSheets(); for (PRInt32 i = 0; i < sheetCount; i++) { nsIStyleSheet* sheet = GetCatalogStyleSheetAt(i); NS_ASSERTION(sheet, "unexpected null stylesheet in the document"); if (sheet) { nsCOMPtr uri; sheet->GetSheetURI(getter_AddRefs(uri)); nsCAutoString uriStr; uri->GetSpec(uriStr); if (uriStr.Equals(aStyleSheetURI)) return; } } nsCOMPtr uri; NS_NewURI(getter_AddRefs(uri), aStyleSheetURI); if (uri) { nsCOMPtr sheet; cssLoader->LoadSheetSync(uri, PR_TRUE, getter_AddRefs(sheet)); if (sheet) { BeginUpdate(UPDATE_STYLE); AddCatalogStyleSheet(sheet); EndUpdate(UPDATE_STYLE); } } } } nsIScriptGlobalObject* nsDocument::GetScriptGlobalObject() const { // If we're going away, we've already released the reference to our // ScriptGlobalObject. We can, however, try to obtain it for the // caller through our docshell. // We actually need to start returning the docshell's script global // object as soon as nsDocumentViewer::Close has called // RemovedFromDocShell on us. if (mRemovedFromDocShell) { nsCOMPtr requestor = do_QueryReferent(mDocumentContainer); if (requestor) { nsCOMPtr globalObject = do_GetInterface(requestor); return globalObject; } } return mScriptGlobalObject; } nsIScriptGlobalObject* nsDocument::GetScopeObject() { nsCOMPtr scope(do_QueryReferent(mScopeObject)); return scope; } void nsDocument::SetScriptGlobalObject(nsIScriptGlobalObject *aScriptGlobalObject) { #ifdef DEBUG { nsCOMPtr win(do_QueryInterface(aScriptGlobalObject)); NS_ASSERTION(!win || win->IsInnerWindow(), "Script global object must be an inner window!"); } #endif if (mScriptGlobalObject && !aScriptGlobalObject) { // We're detaching from the window. We need to grab a pointer to // our layout history state now. mLayoutHistoryState = GetLayoutHistoryState(); // Also make sure to remove our onload blocker now if we haven't done it yet if (mOnloadBlockCount != 0) { nsCOMPtr loadGroup = GetDocumentLoadGroup(); if (loadGroup) { loadGroup->RemoveRequest(mOnloadBlocker, nsnull, NS_OK); } } } mScriptGlobalObject = aScriptGlobalObject; if (aScriptGlobalObject) { mHasHadScriptHandlingObject = PR_TRUE; // Go back to using the docshell for the layout history state mLayoutHistoryState = nsnull; mScopeObject = do_GetWeakReference(aScriptGlobalObject); } // Remember the pointer to our window (or lack there of), to avoid // having to QI every time it's asked for. nsCOMPtr window = do_QueryInterface(mScriptGlobalObject); mWindow = window; } nsIScriptGlobalObject* nsDocument::GetScriptHandlingObject(PRBool& aHasHadScriptHandlingObject) const { aHasHadScriptHandlingObject = mHasHadScriptHandlingObject; if (mScriptGlobalObject) { return mScriptGlobalObject; } nsCOMPtr scriptHandlingObject = do_QueryReferent(mScriptObject); nsCOMPtr win = do_QueryInterface(scriptHandlingObject); if (win) { NS_ASSERTION(win->IsInnerWindow(), "Should have inner window here!"); nsPIDOMWindow* outer = win->GetOuterWindow(); if (!outer || outer->GetCurrentInnerWindow() != win) { NS_WARNING("Wrong inner/outer window combination!"); return nsnull; } } return scriptHandlingObject; } void nsDocument::SetScriptHandlingObject(nsIScriptGlobalObject* aScriptObject) { NS_ASSERTION(!mScriptGlobalObject || mScriptGlobalObject == aScriptObject, "Wrong script object!"); nsCOMPtr win = do_QueryInterface(aScriptObject); NS_ASSERTION(!win || win->IsInnerWindow(), "Should have inner window here!"); mScopeObject = mScriptObject = do_GetWeakReference(aScriptObject); if (aScriptObject) { mHasHadScriptHandlingObject = PR_TRUE; } } nsPIDOMWindow * nsDocument::GetWindow() { if (mWindow) { return mWindow->GetOuterWindow(); } nsCOMPtr win(do_QueryInterface(GetScriptGlobalObject())); if (!win) { return nsnull; } return win->GetOuterWindow(); } nsPIDOMWindow * nsDocument::GetInnerWindow() { nsCOMPtr win(do_QueryInterface(GetScriptGlobalObject())); return win; } nsScriptLoader* nsDocument::ScriptLoader() { return mScriptLoader; } // Note: We don't hold a reference to the document observer; we assume // that it has a live reference to the document. void nsDocument::AddObserver(nsIDocumentObserver* aObserver) { // The array makes sure the observer isn't already in the list mObservers.AppendElementUnlessExists(aObserver); AddMutationObserver(aObserver); } PRBool nsDocument::RemoveObserver(nsIDocumentObserver* aObserver) { // If we're in the process of destroying the document (and we're // informing the observers of the destruction), don't remove the // observers from the list. This is not a big deal, since we // don't hold a live reference to the observers. if (!mInDestructor) { RemoveMutationObserver(aObserver); return mObservers.RemoveElement(aObserver); } return mObservers.Contains(aObserver); } void nsDocument::BeginUpdate(nsUpdateType aUpdateType) { if (mUpdateNestLevel == 0) { BindingManager()->BeginOutermostUpdate(); } ++mUpdateNestLevel; NS_DOCUMENT_NOTIFY_OBSERVERS(BeginUpdate, (this, aUpdateType)); if (aUpdateType == UPDATE_CONTENT_MODEL) { nsContentUtils::AddRemovableScriptBlocker(); } else { nsContentUtils::AddScriptBlocker(); } } void nsDocument::EndUpdate(nsUpdateType aUpdateType) { if (aUpdateType == UPDATE_CONTENT_MODEL) { nsContentUtils::RemoveRemovableScriptBlocker(); } else { nsContentUtils::RemoveScriptBlocker(); } NS_DOCUMENT_NOTIFY_OBSERVERS(EndUpdate, (this, aUpdateType)); --mUpdateNestLevel; if (mUpdateNestLevel == 0) { // This set of updates may have created XBL bindings. Let the // binding manager know we're done. BindingManager()->EndOutermostUpdate(); } if (mUpdateNestLevel == 0 && !mDelayFrameLoaderInitialization) { InitializeFinalizeFrameLoaders(); } } void nsDocument::BeginLoad() { // Block onload here to prevent having to deal with blocking and // unblocking it while we know the document is loading. BlockOnload(); if (mScriptLoader) { mScriptLoader->BeginDeferringScripts(); } NS_DOCUMENT_NOTIFY_OBSERVERS(BeginLoad, (this)); } PRBool nsDocument::CheckGetElementByIdArg(const nsIAtom* aId) { if (aId == nsGkAtoms::_empty) { nsContentUtils::ReportToConsole( nsContentUtils::eDOM_PROPERTIES, "EmptyGetElementByIdParam", nsnull, 0, nsnull, EmptyString(), 0, 0, nsIScriptError::warningFlag, "DOM"); return PR_FALSE; } return PR_TRUE; } static void MatchAllElementsId(nsIContent* aContent, nsIAtom* aId, nsIdentifierMapEntry* aEntry) { if (aId == aContent->GetID()) { aEntry->AddIdContent(aContent); } PRUint32 i, count = aContent->GetChildCount(); for (i = 0; i < count; i++) { MatchAllElementsId(aContent->GetChildAt(i), aId, aEntry); } } nsIdentifierMapEntry* nsDocument::GetElementByIdInternal(nsIAtom* aID) { // We don't have to flush before we do the initial hashtable lookup, since if // the id is already in the hashtable it couldn't have been removed without // us being notified (all removals notify immediately, as far as I can tell). // So do the lookup first. nsIdentifierMapEntry *entry = mIdentifierMap.PutEntry(aID); NS_ENSURE_TRUE(entry, nsnull); if (entry->GetIdContent()) return entry; // Now we have to flush. It could be that we have a cached "not in // document" or know nothing about this ID yet but more content has been // added to the document since. Note that we have to flush notifications, // so that the entry will get updated properly. // Make sure to stash away the current generation so we can check whether // the table changes when we flush. PRUint32 generation = mIdentifierMap.GetGeneration(); FlushPendingNotifications(Flush_ContentAndNotify); if (generation != mIdentifierMap.GetGeneration()) { // Table changed, so the entry pointer is no longer valid; look up the // entry again, adding if necessary (the adding may be necessary in case // the flush actually deleted entries). entry = mIdentifierMap.PutEntry(aID); } PRBool isNotInDocument; nsIContent *e = entry->GetIdContent(&isNotInDocument); if (e || isNotInDocument) return entry; // Status of this id is unknown, search document nsIContent* root = GetRootContent(); if (!IdTableIsLive()) { if (IdTableShouldBecomeLive()) { // Just make sure our table is up to date and call this method again // to look up in the hashtable. if (root) { RegisterNamedItems(root); } return GetElementByIdInternal(aID); } if (root) { // No-one should have registered an ID change callback yet. We don't // want to fire one as a side-effect of getElementById! This shouldn't // happen, since if someone called AddIDTargetObserver already for // this ID, we should have filled in this entry with content or // not-in-document. NS_ASSERTION(!entry->HasContentChangeCallback(), "No callbacks should be registered while we set up this entry"); MatchAllElementsId(root, aID, entry); e = entry->GetIdContent(); } } if (!e) { #ifdef DEBUG // No reason to call MatchElementId if !IdTableIsLive, since // we'd have done just that already if (IdTableIsLive() && root && aID != nsGkAtoms::_empty) { nsIContent* eDebug = nsContentUtils::MatchElementId(root, aID); NS_ASSERTION(!eDebug, "We got null for |e| but MatchElementId found something?"); } #endif // There is no element with the given id in the document, cache // the fact that it's not in the document entry->FlagIDNotInDocument(); return entry; } return entry; } NS_IMETHODIMP nsDocument::GetElementById(const nsAString& aElementId, nsIDOMElement** aReturn) { NS_ENSURE_ARG_POINTER(aReturn); *aReturn = nsnull; nsCOMPtr idAtom(do_GetAtom(aElementId)); NS_ENSURE_TRUE(idAtom, NS_ERROR_OUT_OF_MEMORY); if (!CheckGetElementByIdArg(idAtom)) return NS_OK; nsIdentifierMapEntry *entry = GetElementByIdInternal(idAtom); NS_ENSURE_TRUE(entry, NS_ERROR_OUT_OF_MEMORY); PRBool isNotInDocument; nsIContent *e = entry->GetIdContent(&isNotInDocument); NS_ASSERTION(e || isNotInDocument, "Incomplete map entry!"); if (isNotInDocument) return NS_OK; return CallQueryInterface(e, aReturn); } nsIContent* nsDocument::AddIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver, void* aData) { if (!CheckGetElementByIdArg(aID)) return nsnull; nsIdentifierMapEntry *entry = GetElementByIdInternal(aID); NS_ENSURE_TRUE(entry, nsnull); entry->AddContentChangeCallback(aObserver, aData); return entry->GetIdContent(); } void nsDocument::RemoveIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver, void* aData) { if (!CheckGetElementByIdArg(aID)) return; nsIdentifierMapEntry *entry = GetElementByIdInternal(aID); if (!entry) return; entry->RemoveContentChangeCallback(aObserver, aData); } void nsDocument::DispatchContentLoadedEvents() { // If you add early returns from this method, make sure you're // calling UnblockOnload properly. // Fire a DOM event notifying listeners that this document has been // loaded (excluding images and other loads initiated by this // document). nsContentUtils::DispatchTrustedEvent(this, static_cast(this), NS_LITERAL_STRING("DOMContentLoaded"), PR_TRUE, PR_TRUE); // If this document is a [i]frame, fire a DOMFrameContentLoaded // event on all parent documents notifying that the HTML (excluding // other external files such as images and stylesheets) in a frame // has finished loading. // target_frame is the [i]frame element that will be used as the // target for the event. It's the [i]frame whose content is done // loading. nsCOMPtr target_frame; if (mParentDocument) { target_frame = do_QueryInterface(mParentDocument->FindContentForSubDocument(this)); } if (target_frame) { nsCOMPtr parent = mParentDocument; do { nsCOMPtr document_event = do_QueryInterface(parent); nsCOMPtr event; nsCOMPtr privateEvent; if (document_event) { document_event->CreateEvent(NS_LITERAL_STRING("Events"), getter_AddRefs(event)); privateEvent = do_QueryInterface(event); } if (event && privateEvent) { event->InitEvent(NS_LITERAL_STRING("DOMFrameContentLoaded"), PR_TRUE, PR_TRUE); privateEvent->SetTarget(target_frame); privateEvent->SetTrusted(PR_TRUE); // To dispatch this event we must manually call // nsEventDispatcher::Dispatch() on the ancestor document since the // target is not in the same document, so the event would never reach // the ancestor document if we used the normal event // dispatching code. nsEvent* innerEvent; privateEvent->GetInternalNSEvent(&innerEvent); if (innerEvent) { nsEventStatus status = nsEventStatus_eIgnore; nsIPresShell *shell = parent->GetPrimaryShell(); if (shell) { nsCOMPtr context = shell->GetPresContext(); if (context) { nsEventDispatcher::Dispatch(parent, context, innerEvent, event, &status); } } } } parent = parent->GetParentDocument(); } while (parent); } if (mScriptLoader) { mScriptLoader->EndDeferringScripts(); } UnblockOnload(PR_TRUE); } void nsDocument::EndLoad() { // Drop the ref to our parser, if any, but keep hold of the sink so that we // can flush it from FlushPendingNotifications as needed. We might have to // do that to get a StartLayout() to happen. if (mParser) { mWeakSink = do_GetWeakReference(mParser->GetContentSink()); mParser = nsnull; } NS_DOCUMENT_NOTIFY_OBSERVERS(EndLoad, (this)); if (!mSynchronousDOMContentLoaded) { nsRefPtr ev = new nsRunnableMethod(this, &nsDocument::DispatchContentLoadedEvents); NS_DispatchToCurrentThread(ev); } else { DispatchContentLoadedEvents(); } } void nsDocument::ContentStatesChanged(nsIContent* aContent1, nsIContent* aContent2, PRInt32 aStateMask) { NS_DOCUMENT_NOTIFY_OBSERVERS(ContentStatesChanged, (this, aContent1, aContent2, aStateMask)); } void nsDocument::StyleRuleChanged(nsIStyleSheet* aStyleSheet, nsIStyleRule* aOldStyleRule, nsIStyleRule* aNewStyleRule) { NS_DOCUMENT_NOTIFY_OBSERVERS(StyleRuleChanged, (this, aStyleSheet, aOldStyleRule, aNewStyleRule)); } void nsDocument::StyleRuleAdded(nsIStyleSheet* aStyleSheet, nsIStyleRule* aStyleRule) { NS_DOCUMENT_NOTIFY_OBSERVERS(StyleRuleAdded, (this, aStyleSheet, aStyleRule)); } void nsDocument::StyleRuleRemoved(nsIStyleSheet* aStyleSheet, nsIStyleRule* aStyleRule) { NS_DOCUMENT_NOTIFY_OBSERVERS(StyleRuleRemoved, (this, aStyleSheet, aStyleRule)); } // // nsIDOMDocument interface // NS_IMETHODIMP nsDocument::GetDoctype(nsIDOMDocumentType** aDoctype) { NS_ENSURE_ARG_POINTER(aDoctype); *aDoctype = nsnull; PRInt32 i, count; count = mChildren.ChildCount(); for (i = 0; i < count; i++) { CallQueryInterface(mChildren.ChildAt(i), aDoctype); if (*aDoctype) { return NS_OK; } } return NS_OK; } NS_IMETHODIMP nsDocument::GetImplementation(nsIDOMDOMImplementation** aImplementation) { // For now, create a new implementation every time. This shouldn't // be a high bandwidth operation nsCOMPtr uri; NS_NewURI(getter_AddRefs(uri), "about:blank"); NS_ENSURE_TRUE(uri, NS_ERROR_OUT_OF_MEMORY); PRBool hasHadScriptObject = PR_TRUE; nsIScriptGlobalObject* scriptObject = GetScriptHandlingObject(hasHadScriptObject); NS_ENSURE_STATE(scriptObject || !hasHadScriptObject); *aImplementation = new nsDOMImplementation(scriptObject, uri, uri, NodePrincipal()); if (!*aImplementation) { return NS_ERROR_OUT_OF_MEMORY; } NS_ADDREF(*aImplementation); return NS_OK; } NS_IMETHODIMP nsDocument::GetDocumentElement(nsIDOMElement** aDocumentElement) { NS_ENSURE_ARG_POINTER(aDocumentElement); nsIContent* root = GetRootContent(); if (root) { return CallQueryInterface(root, aDocumentElement); } *aDocumentElement = nsnull; return NS_OK; } NS_IMETHODIMP nsDocument::CreateElement(const nsAString& aTagName, nsIDOMElement** aReturn) { *aReturn = nsnull; nsresult rv = nsContentUtils::CheckQName(aTagName, PR_FALSE); NS_ENSURE_SUCCESS(rv, rv); NS_ASSERTION(IsCaseSensitive(), "nsDocument::CreateElement() called on document that is not " "case sensitive. Fix caller, or fix " "nsDocument::CreateElement()!"); nsCOMPtr name = do_GetAtom(aTagName); nsCOMPtr content; rv = CreateElem(name, nsnull, GetDefaultNamespaceID(), PR_TRUE, getter_AddRefs(content)); NS_ENSURE_SUCCESS(rv, rv); return CallQueryInterface(content, aReturn); } NS_IMETHODIMP nsDocument::CreateElementNS(const nsAString& aNamespaceURI, const nsAString& aQualifiedName, nsIDOMElement** aReturn) { *aReturn = nsnull; nsCOMPtr nodeInfo; nsresult rv = nsContentUtils::GetNodeInfoFromQName(aNamespaceURI, aQualifiedName, mNodeInfoManager, getter_AddRefs(nodeInfo)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr content; NS_NewElement(getter_AddRefs(content), nodeInfo->NamespaceID(), nodeInfo, PR_FALSE); NS_ENSURE_SUCCESS(rv, rv); return CallQueryInterface(content, aReturn); } NS_IMETHODIMP nsDocument::CreateTextNode(const nsAString& aData, nsIDOMText** aReturn) { *aReturn = nsnull; nsCOMPtr text; nsresult rv = NS_NewTextNode(getter_AddRefs(text), mNodeInfoManager); if (NS_SUCCEEDED(rv)) { // Don't notify; this node is still being created. text->SetText(aData, PR_FALSE); rv = CallQueryInterface(text, aReturn); } return rv; } NS_IMETHODIMP nsDocument::CreateDocumentFragment(nsIDOMDocumentFragment** aReturn) { return NS_NewDocumentFragment(aReturn, mNodeInfoManager); } NS_IMETHODIMP nsDocument::CreateComment(const nsAString& aData, nsIDOMComment** aReturn) { *aReturn = nsnull; // Make sure the substring "--" is not present in aData. Otherwise // we'll create a document that can't be serialized. if (FindInReadable(NS_LITERAL_STRING("--"), aData)) { return NS_ERROR_DOM_INVALID_CHARACTER_ERR; } nsCOMPtr comment; nsresult rv = NS_NewCommentNode(getter_AddRefs(comment), mNodeInfoManager); if (NS_SUCCEEDED(rv)) { // Don't notify; this node is still being created. comment->SetText(aData, PR_FALSE); rv = CallQueryInterface(comment, aReturn); } return rv; } NS_IMETHODIMP nsDocument::CreateCDATASection(const nsAString& aData, nsIDOMCDATASection** aReturn) { NS_ENSURE_ARG_POINTER(aReturn); *aReturn = nsnull; if (FindInReadable(NS_LITERAL_STRING("]]>"), aData)) return NS_ERROR_DOM_INVALID_CHARACTER_ERR; nsCOMPtr content; nsresult rv = NS_NewXMLCDATASection(getter_AddRefs(content), mNodeInfoManager); if (NS_SUCCEEDED(rv)) { // Don't notify; this node is still being created. content->SetText(aData, PR_FALSE); rv = CallQueryInterface(content, aReturn); } return rv; } NS_IMETHODIMP nsDocument::CreateProcessingInstruction(const nsAString& aTarget, const nsAString& aData, nsIDOMProcessingInstruction** aReturn) { *aReturn = nsnull; nsresult rv = nsContentUtils::CheckQName(aTarget, PR_FALSE); NS_ENSURE_SUCCESS(rv, rv); if (FindInReadable(NS_LITERAL_STRING("?>"), aData)) { return NS_ERROR_DOM_INVALID_CHARACTER_ERR; } nsCOMPtr content; rv = NS_NewXMLProcessingInstruction(getter_AddRefs(content), mNodeInfoManager, aTarget, aData); if (NS_FAILED(rv)) { return rv; } return CallQueryInterface(content, aReturn); } NS_IMETHODIMP nsDocument::CreateAttribute(const nsAString& aName, nsIDOMAttr** aReturn) { *aReturn = nsnull; NS_ENSURE_TRUE(mNodeInfoManager, NS_ERROR_NOT_INITIALIZED); nsresult rv = nsContentUtils::CheckQName(aName, PR_FALSE); NS_ENSURE_SUCCESS(rv, rv); nsAutoString value; nsDOMAttribute* attribute; nsCOMPtr nodeInfo; rv = mNodeInfoManager->GetNodeInfo(aName, nsnull, kNameSpaceID_None, getter_AddRefs(nodeInfo)); NS_ENSURE_SUCCESS(rv, rv); attribute = new nsDOMAttribute(nsnull, nodeInfo, value); NS_ENSURE_TRUE(attribute, NS_ERROR_OUT_OF_MEMORY); return CallQueryInterface(attribute, aReturn); } NS_IMETHODIMP nsDocument::CreateAttributeNS(const nsAString & aNamespaceURI, const nsAString & aQualifiedName, nsIDOMAttr **aResult) { NS_ENSURE_ARG_POINTER(aResult); *aResult = nsnull; nsCOMPtr nodeInfo; nsresult rv = nsContentUtils::GetNodeInfoFromQName(aNamespaceURI, aQualifiedName, mNodeInfoManager, getter_AddRefs(nodeInfo)); NS_ENSURE_SUCCESS(rv, rv); nsAutoString value; nsDOMAttribute* attribute = new nsDOMAttribute(nsnull, nodeInfo, value); NS_ENSURE_TRUE(attribute, NS_ERROR_OUT_OF_MEMORY); return CallQueryInterface(attribute, aResult); } NS_IMETHODIMP nsDocument::CreateEntityReference(const nsAString& aName, nsIDOMEntityReference** aReturn) { NS_ENSURE_ARG_POINTER(aReturn); *aReturn = nsnull; return NS_OK; } NS_IMETHODIMP nsDocument::GetElementsByTagName(const nsAString& aTagname, nsIDOMNodeList** aReturn) { nsCOMPtr nameAtom = do_GetAtom(aTagname); NS_ENSURE_TRUE(nameAtom, NS_ERROR_OUT_OF_MEMORY); nsContentList *list = NS_GetContentList(this, nameAtom, kNameSpaceID_Unknown).get(); NS_ENSURE_TRUE(list, NS_ERROR_OUT_OF_MEMORY); // transfer ref to aReturn *aReturn = list; return NS_OK; } NS_IMETHODIMP nsDocument::GetElementsByTagNameNS(const nsAString& aNamespaceURI, const nsAString& aLocalName, nsIDOMNodeList** aReturn) { PRInt32 nameSpaceId = kNameSpaceID_Wildcard; if (!aNamespaceURI.EqualsLiteral("*")) { nsresult rv = nsContentUtils::NameSpaceManager()->RegisterNameSpace(aNamespaceURI, nameSpaceId); NS_ENSURE_SUCCESS(rv, rv); } nsCOMPtr nameAtom = do_GetAtom(aLocalName); NS_ENSURE_TRUE(nameAtom, NS_ERROR_OUT_OF_MEMORY); nsContentList *list = NS_GetContentList(this, nameAtom, nameSpaceId).get(); NS_ENSURE_TRUE(list, NS_ERROR_OUT_OF_MEMORY); // transfer ref to aReturn *aReturn = list; return NS_OK; } NS_IMETHODIMP nsDocument::GetAsync(PRBool *aAsync) { NS_ERROR("nsDocument::GetAsync() should be overriden by subclass!"); return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP nsDocument::SetAsync(PRBool aAsync) { NS_ERROR("nsDocument::SetAsync() should be overriden by subclass!"); return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP nsDocument::Load(const nsAString& aUrl, PRBool *aReturn) { NS_ERROR("nsDocument::Load() should be overriden by subclass!"); return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP nsDocument::EvaluateFIXptr(const nsAString& aExpression, nsIDOMRange **aRange) { NS_ERROR("nsDocument::EvaluateFIXptr() should be overriden by subclass!"); return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP nsDocument::EvaluateXPointer(const nsAString& aExpression, nsIXPointerResult **aResult) { NS_ERROR("nsDocument::EvaluateXPointer() should be overriden by subclass!"); return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP nsDocument::GetStyleSheets(nsIDOMStyleSheetList** aStyleSheets) { if (!mDOMStyleSheets) { mDOMStyleSheets = new nsDOMStyleSheetList(this); if (!mDOMStyleSheets) { return NS_ERROR_OUT_OF_MEMORY; } } *aStyleSheets = mDOMStyleSheets; NS_ADDREF(*aStyleSheets); return NS_OK; } NS_IMETHODIMP nsDocument::GetSelectedStyleSheetSet(nsAString& aSheetSet) { aSheetSet.Truncate(); // Look through our sheets, find the selected set title PRInt32 count = GetNumberOfStyleSheets(); nsAutoString title; for (PRInt32 index = 0; index < count; index++) { nsIStyleSheet* sheet = GetStyleSheetAt(index); NS_ASSERTION(sheet, "Null sheet in sheet list!"); nsCOMPtr domSheet = do_QueryInterface(sheet); NS_ASSERTION(domSheet, "Sheet must QI to nsIDOMStyleSheet"); PRBool disabled; domSheet->GetDisabled(&disabled); if (disabled) { // Disabled sheets don't affect the currently selected set continue; } sheet->GetTitle(title); if (aSheetSet.IsEmpty()) { aSheetSet = title; } else if (!title.IsEmpty() && !aSheetSet.Equals(title)) { // Sheets from multiple sets enabled; return null string, per spec. SetDOMStringToNull(aSheetSet); break; } } return NS_OK; } NS_IMETHODIMP nsDocument::SetSelectedStyleSheetSet(const nsAString& aSheetSet) { if (DOMStringIsNull(aSheetSet)) { return NS_OK; } // Must update mLastStyleSheetSet before doing anything else with stylesheets // or CSSLoaders. mLastStyleSheetSet = aSheetSet; EnableStyleSheetsForSetInternal(aSheetSet, PR_TRUE); return NS_OK; } NS_IMETHODIMP nsDocument::GetLastStyleSheetSet(nsAString& aSheetSet) { aSheetSet = mLastStyleSheetSet; return NS_OK; } NS_IMETHODIMP nsDocument::GetPreferredStyleSheetSet(nsAString& aSheetSet) { GetHeaderData(nsGkAtoms::headerDefaultStyle, aSheetSet); return NS_OK; } NS_IMETHODIMP nsDocument::GetStyleSheetSets(nsIDOMDOMStringList** aList) { if (!mStyleSheetSetList) { mStyleSheetSetList = new nsDOMStyleSheetSetList(this); if (!mStyleSheetSetList) { return NS_ERROR_OUT_OF_MEMORY; } } NS_ADDREF(*aList = mStyleSheetSetList); return NS_OK; } NS_IMETHODIMP nsDocument::EnableStyleSheetsForSet(const nsAString& aSheetSet) { // Per spec, passing in null is a no-op. if (!DOMStringIsNull(aSheetSet)) { // Note: must make sure to not change the CSSLoader's preferred sheet -- // that value should be equal to either our lastStyleSheetSet (if that's // non-null) or to our preferredStyleSheetSet. And this method doesn't // change either of those. EnableStyleSheetsForSetInternal(aSheetSet, PR_FALSE); } return NS_OK; } void nsDocument::EnableStyleSheetsForSetInternal(const nsAString& aSheetSet, PRBool aUpdateCSSLoader) { BeginUpdate(UPDATE_STYLE); PRInt32 count = GetNumberOfStyleSheets(); nsAutoString title; for (PRInt32 index = 0; index < count; index++) { nsIStyleSheet* sheet = GetStyleSheetAt(index); NS_ASSERTION(sheet, "Null sheet in sheet list!"); sheet->GetTitle(title); if (!title.IsEmpty()) { sheet->SetEnabled(title.Equals(aSheetSet)); } } if (aUpdateCSSLoader) { CSSLoader()->SetPreferredSheet(aSheetSet); } EndUpdate(UPDATE_STYLE); } NS_IMETHODIMP nsDocument::GetCharacterSet(nsAString& aCharacterSet) { CopyASCIItoUTF16(GetDocumentCharacterSet(), aCharacterSet); return NS_OK; } NS_IMETHODIMP nsDocument::ImportNode(nsIDOMNode* aImportedNode, PRBool aDeep, nsIDOMNode** aResult) { NS_ENSURE_ARG(aImportedNode); *aResult = nsnull; nsresult rv = nsContentUtils::CheckSameOrigin(this, aImportedNode); if (NS_FAILED(rv)) { return rv; } PRUint16 nodeType; aImportedNode->GetNodeType(&nodeType); switch (nodeType) { case nsIDOMNode::ATTRIBUTE_NODE: case nsIDOMNode::DOCUMENT_FRAGMENT_NODE: case nsIDOMNode::ELEMENT_NODE: case nsIDOMNode::PROCESSING_INSTRUCTION_NODE: case nsIDOMNode::TEXT_NODE: case nsIDOMNode::CDATA_SECTION_NODE: case nsIDOMNode::COMMENT_NODE: { nsCOMPtr imported = do_QueryInterface(aImportedNode); NS_ENSURE_TRUE(imported, NS_ERROR_FAILURE); nsCOMPtr newNode; nsCOMArray nodesWithProperties; rv = nsNodeUtils::Clone(imported, aDeep, mNodeInfoManager, nodesWithProperties, getter_AddRefs(newNode)); NS_ENSURE_SUCCESS(rv, rv); nsIDocument *ownerDoc = imported->GetOwnerDoc(); if (ownerDoc) { rv = nsNodeUtils::CallUserDataHandlers(nodesWithProperties, ownerDoc, nsIDOMUserDataHandler::NODE_IMPORTED, PR_TRUE); NS_ENSURE_SUCCESS(rv, rv); } newNode.swap(*aResult); return NS_OK; } case nsIDOMNode::ENTITY_NODE: case nsIDOMNode::ENTITY_REFERENCE_NODE: case nsIDOMNode::NOTATION_NODE: { return NS_ERROR_NOT_IMPLEMENTED; } default: { NS_WARNING("Don't know how to clone this nodetype for importNode."); return NS_ERROR_DOM_NOT_SUPPORTED_ERR; } } } NS_IMETHODIMP nsDocument::AddBinding(nsIDOMElement* aContent, const nsAString& aURI) { NS_ENSURE_ARG(aContent); nsresult rv = nsContentUtils::CheckSameOrigin(this, aContent); if (NS_FAILED(rv)) { return rv; } nsCOMPtr content(do_QueryInterface(aContent)); nsCOMPtr uri; rv = NS_NewURI(getter_AddRefs(uri), aURI); if (NS_FAILED(rv)) { return rv; } // Figure out the right principal to use nsCOMPtr subject; nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager(); if (secMan) { rv = secMan->GetSubjectPrincipal(getter_AddRefs(subject)); NS_ENSURE_SUCCESS(rv, rv); } if (!subject) { // Fall back to our principal. Or should we fall back to the null // principal? The latter would just mean no binding loads.... subject = NodePrincipal(); } return BindingManager()->AddLayeredBinding(content, uri, subject); } NS_IMETHODIMP nsDocument::RemoveBinding(nsIDOMElement* aContent, const nsAString& aURI) { NS_ENSURE_ARG(aContent); nsresult rv = nsContentUtils::CheckSameOrigin(this, aContent); if (NS_FAILED(rv)) { return rv; } nsCOMPtr uri; rv = NS_NewURI(getter_AddRefs(uri), aURI); if (NS_FAILED(rv)) { return rv; } nsCOMPtr content(do_QueryInterface(aContent)); return BindingManager()->RemoveLayeredBinding(content, uri); } NS_IMETHODIMP nsDocument::LoadBindingDocument(const nsAString& aURI) { nsCOMPtr uri; nsresult rv = NS_NewURI(getter_AddRefs(uri), aURI, mCharacterSet.get(), static_cast(this)->GetBaseURI()); NS_ENSURE_SUCCESS(rv, rv); // Figure out the right principal to use nsCOMPtr subject; nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager(); if (secMan) { rv = secMan->GetSubjectPrincipal(getter_AddRefs(subject)); NS_ENSURE_SUCCESS(rv, rv); } if (!subject) { // Fall back to our principal. Or should we fall back to the null // principal? The latter would just mean no binding loads.... subject = NodePrincipal(); } BindingManager()->LoadBindingDocument(this, uri, subject); return NS_OK; } NS_IMETHODIMP nsDocument::GetBindingParent(nsIDOMNode* aNode, nsIDOMElement** aResult) { *aResult = nsnull; nsCOMPtr content(do_QueryInterface(aNode)); if (!content) return NS_ERROR_FAILURE; nsCOMPtr elt(do_QueryInterface(content->GetBindingParent())); NS_IF_ADDREF(*aResult = elt); return NS_OK; } static nsresult GetElementByAttribute(nsIContent* aContent, nsIAtom* aAttrName, const nsAString& aAttrValue, PRBool aUniversalMatch, nsIDOMElement** aResult) { if (aUniversalMatch ? aContent->HasAttr(kNameSpaceID_None, aAttrName) : aContent->AttrValueIs(kNameSpaceID_None, aAttrName, aAttrValue, eCaseMatters)) { return CallQueryInterface(aContent, aResult); } PRUint32 childCount = aContent->GetChildCount(); for (PRUint32 i = 0; i < childCount; ++i) { nsIContent *current = aContent->GetChildAt(i); GetElementByAttribute(current, aAttrName, aAttrValue, aUniversalMatch, aResult); if (*aResult) return NS_OK; } return NS_OK; } NS_IMETHODIMP nsDocument::GetAnonymousElementByAttribute(nsIDOMElement* aElement, const nsAString& aAttrName, const nsAString& aAttrValue, nsIDOMElement** aResult) { *aResult = nsnull; nsCOMPtr nodeList; GetAnonymousNodes(aElement, getter_AddRefs(nodeList)); if (!nodeList) return NS_OK; nsCOMPtr attribute = do_GetAtom(aAttrName); PRUint32 length; nodeList->GetLength(&length); PRBool universalMatch = aAttrValue.EqualsLiteral("*"); for (PRUint32 i = 0; i < length; ++i) { nsCOMPtr current; nodeList->Item(i, getter_AddRefs(current)); nsCOMPtr content(do_QueryInterface(current)); GetElementByAttribute(content, attribute, aAttrValue, universalMatch, aResult); if (*aResult) return NS_OK; } return NS_OK; } NS_IMETHODIMP nsDocument::GetAnonymousNodes(nsIDOMElement* aElement, nsIDOMNodeList** aResult) { *aResult = nsnull; nsCOMPtr content(do_QueryInterface(aElement)); return BindingManager()->GetAnonymousNodesFor(content, aResult); } NS_IMETHODIMP nsDocument::CreateRange(nsIDOMRange** aReturn) { nsresult rv = NS_NewRange(aReturn); if (NS_SUCCEEDED(rv)) { (*aReturn)->SetStart(this, 0); (*aReturn)->SetEnd(this, 0); } return rv; } NS_IMETHODIMP nsDocument::CreateNodeIterator(nsIDOMNode *aRoot, PRUint32 aWhatToShow, nsIDOMNodeFilter *aFilter, PRBool aEntityReferenceExpansion, nsIDOMNodeIterator **_retval) { *_retval = nsnull; if (!aRoot) return NS_ERROR_DOM_NOT_SUPPORTED_ERR; nsresult rv = nsContentUtils::CheckSameOrigin(this, aRoot); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_ARG_POINTER(_retval); nsCOMPtr root = do_QueryInterface(aRoot); NS_ENSURE_TRUE(root, NS_ERROR_DOM_NOT_SUPPORTED_ERR); nsNodeIterator *iterator = new nsNodeIterator(root, aWhatToShow, aFilter, aEntityReferenceExpansion); NS_ENSURE_TRUE(iterator, NS_ERROR_OUT_OF_MEMORY); NS_ADDREF(*_retval = iterator); return NS_OK; } NS_IMETHODIMP nsDocument::CreateTreeWalker(nsIDOMNode *aRoot, PRUint32 aWhatToShow, nsIDOMNodeFilter *aFilter, PRBool aEntityReferenceExpansion, nsIDOMTreeWalker **_retval) { *_retval = nsnull; if (!aRoot) return NS_ERROR_DOM_NOT_SUPPORTED_ERR; nsresult rv = nsContentUtils::CheckSameOrigin(this, aRoot); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_ARG_POINTER(_retval); nsCOMPtr root = do_QueryInterface(aRoot); NS_ENSURE_TRUE(root, NS_ERROR_DOM_NOT_SUPPORTED_ERR); nsTreeWalker* walker = new nsTreeWalker(root, aWhatToShow, aFilter, aEntityReferenceExpansion); NS_ENSURE_TRUE(walker, NS_ERROR_OUT_OF_MEMORY); NS_ADDREF(*_retval = walker); return NS_OK; } NS_IMETHODIMP nsDocument::GetDefaultView(nsIDOMAbstractView** aDefaultView) { nsPIDOMWindow* win = GetWindow(); if (win) { return CallQueryInterface(win, aDefaultView); } *aDefaultView = nsnull; return NS_OK; } NS_IMETHODIMP nsDocument::GetLocation(nsIDOMLocation **_retval) { NS_ENSURE_ARG_POINTER(_retval); *_retval = nsnull; nsCOMPtr w(do_QueryInterface(mScriptGlobalObject)); if (!w) { return NS_OK; } return w->GetLocation(_retval); } NS_IMETHODIMP nsDocument::GetTitle(nsAString& aTitle) { aTitle.Assign(mDocumentTitle); // Make sure not to return null from this method even if // mDocumentTitle is void. aTitle.SetIsVoid(PR_FALSE); return NS_OK; } NS_IMETHODIMP nsDocument::SetTitle(const nsAString& aTitle) { nsPresShellIterator iter(this); nsCOMPtr shell; while ((shell = iter.GetNextShell())) { nsCOMPtr container = shell->GetPresContext()->GetContainer(); if (!container) continue; nsCOMPtr docShellWin = do_QueryInterface(container); if (!docShellWin) continue; nsresult rv = docShellWin->SetTitle(PromiseFlatString(aTitle).get()); NS_ENSURE_SUCCESS(rv, rv); } mDocumentTitle.Assign(aTitle); // Fire a DOM event for the title change. nsContentUtils::DispatchTrustedEvent(this, static_cast(this), NS_LITERAL_STRING("DOMTitleChanged"), PR_TRUE, PR_TRUE); return NS_OK; } NS_IMETHODIMP nsDocument::GetBoxObjectFor(nsIDOMElement* aElement, nsIBoxObject** aResult) { nsCOMPtr content(do_QueryInterface(aElement)); NS_ENSURE_TRUE(content, NS_ERROR_UNEXPECTED); nsIDocument* doc = content->GetOwnerDoc(); NS_ENSURE_TRUE(doc == this, NS_ERROR_DOM_WRONG_DOCUMENT_ERR); if (!mHasWarnedAboutBoxObjects && !content->IsNodeOfType(eXUL)) { mHasWarnedAboutBoxObjects = PR_TRUE; nsContentUtils::ReportToConsole(nsContentUtils::eDOM_PROPERTIES, "UseOfGetBoxObjectForWarning", nsnull, 0, static_cast(this)-> GetDocumentURI(), EmptyString(), 0, 0, nsIScriptError::warningFlag, "BoxObjects"); } *aResult = nsnull; if (!mBoxObjectTable) { mBoxObjectTable = new nsInterfaceHashtable; if (mBoxObjectTable && !mBoxObjectTable->Init(12)) { mBoxObjectTable = nsnull; } } else { // Want to use Get(content, aResult); but it's the wrong type *aResult = mBoxObjectTable->GetWeak(content); if (*aResult) { NS_ADDREF(*aResult); return NS_OK; } } PRInt32 namespaceID; nsCOMPtr tag = BindingManager()->ResolveTag(content, &namespaceID); nsCAutoString contractID("@mozilla.org/layout/xul-boxobject"); if (namespaceID == kNameSpaceID_XUL) { if (tag == nsGkAtoms::browser || tag == nsGkAtoms::editor || tag == nsGkAtoms::iframe) contractID += "-container"; else if (tag == nsGkAtoms::menu) contractID += "-menu"; else if (tag == nsGkAtoms::popup || tag == nsGkAtoms::menupopup || tag == nsGkAtoms::panel || tag == nsGkAtoms::tooltip) contractID += "-popup"; else if (tag == nsGkAtoms::tree) contractID += "-tree"; else if (tag == nsGkAtoms::listbox) contractID += "-listbox"; else if (tag == nsGkAtoms::scrollbox) contractID += "-scrollbox"; } contractID += ";1"; nsCOMPtr boxObject(do_CreateInstance(contractID.get())); if (!boxObject) return NS_ERROR_FAILURE; boxObject->Init(content); if (mBoxObjectTable) { mBoxObjectTable->Put(content, boxObject.get()); } *aResult = boxObject; NS_ADDREF(*aResult); return NS_OK; } void nsDocument::ClearBoxObjectFor(nsIContent* aContent) { if (mBoxObjectTable) { nsPIBoxObject *boxObject = mBoxObjectTable->GetWeak(aContent); if (boxObject) { boxObject->Clear(); mBoxObjectTable->Remove(aContent); } } } nsresult nsDocument::GetXBLChildNodesFor(nsIContent* aContent, nsIDOMNodeList** aResult) { return BindingManager()->GetXBLChildNodesFor(aContent, aResult); } nsresult nsDocument::GetContentListFor(nsIContent* aContent, nsIDOMNodeList** aResult) { return BindingManager()->GetContentListFor(aContent, aResult); } void nsDocument::FlushSkinBindings() { BindingManager()->FlushSkinBindings(); } nsresult nsDocument::InitializeFrameLoader(nsFrameLoader* aLoader) { mInitializableFrameLoaders.RemoveElement(aLoader); // Don't even try to initialize. if (mInDestructor) { NS_WARNING("Trying to initialize a frame loader while" "document is being deleted"); return NS_ERROR_FAILURE; } if (mUpdateNestLevel == 0 && !mDelayFrameLoaderInitialization) { nsRefPtr loader = aLoader; return loader->ReallyStartLoading(); } else { mInitializableFrameLoaders.AppendElement(aLoader); } return NS_OK; } nsresult nsDocument::FinalizeFrameLoader(nsFrameLoader* aLoader) { mInitializableFrameLoaders.RemoveElement(aLoader); if (mInDestructor) { return NS_ERROR_FAILURE; } if (mUpdateNestLevel == 0) { nsRefPtr loader = aLoader; loader->Finalize(); } else { mFinalizableFrameLoaders.AppendElement(aLoader); } return NS_OK; } void nsDocument::InitializeFinalizeFrameLoaders() { NS_ASSERTION(mUpdateNestLevel == 0 && !mDelayFrameLoaderInitialization, "Wrong time to call InitializeFinalizeFrameLoaders!"); // Don't use a temporary array for mInitializableFrameLoaders, because // loading a frame may cause some other frameloader to be removed from the // array. But be careful to keep the loader alive when starting the load! while (mInitializableFrameLoaders.Length()) { nsRefPtr loader = mInitializableFrameLoaders[0]; mInitializableFrameLoaders.RemoveElementAt(0); NS_ASSERTION(loader, "null frameloader in the array?"); loader->ReallyStartLoading(); } PRUint32 length = mFinalizableFrameLoaders.Length(); if (length > 0) { nsTArray > loaders; mFinalizableFrameLoaders.SwapElements(loaders); for (PRUint32 i = 0; i < length; ++i) { loaders[i]->Finalize(); } } } void nsDocument::TryCancelFrameLoaderInitialization(nsIDocShell* aShell) { PRUint32 length = mInitializableFrameLoaders.Length(); for (PRUint32 i = 0; i < length; ++i) { if (mInitializableFrameLoaders[i]->GetExistingDocShell() == aShell) { mInitializableFrameLoaders.RemoveElementAt(i); return; } } } PRBool nsDocument::FrameLoaderScheduledToBeFinalized(nsIDocShell* aShell) { if (aShell) { PRUint32 length = mFinalizableFrameLoaders.Length(); for (PRUint32 i = 0; i < length; ++i) { if (mFinalizableFrameLoaders[i]->GetExistingDocShell() == aShell) { return PR_TRUE; } } } return PR_FALSE; } struct DirTable { const char* mName; PRUint8 mValue; }; static const DirTable dirAttributes[] = { {"ltr", IBMBIDI_TEXTDIRECTION_LTR}, {"rtl", IBMBIDI_TEXTDIRECTION_RTL}, {0} }; /** * Retrieve the "direction" property of the document. * * @lina 01/09/2001 */ NS_IMETHODIMP nsDocument::GetDir(nsAString& aDirection) { PRUint32 options = GetBidiOptions(); for (const DirTable* elt = dirAttributes; elt->mName; elt++) { if (GET_BIDI_OPTION_DIRECTION(options) == elt->mValue) { CopyASCIItoUTF16(elt->mName, aDirection); break; } } return NS_OK; } /** * Set the "direction" property of the document. * * @lina 01/09/2001 */ NS_IMETHODIMP nsDocument::SetDir(const nsAString& aDirection) { PRUint32 options = GetBidiOptions(); for (const DirTable* elt = dirAttributes; elt->mName; elt++) { if (aDirection == NS_ConvertASCIItoUTF16(elt->mName)) { if (GET_BIDI_OPTION_DIRECTION(options) != elt->mValue) { SET_BIDI_OPTION_DIRECTION(options, elt->mValue); nsIPresShell *shell = GetPrimaryShell(); if (shell) { nsPresContext *context = shell->GetPresContext(); NS_ENSURE_TRUE(context, NS_ERROR_UNEXPECTED); context->SetBidi(options, PR_TRUE); } else { // No presentation; just set it on ourselves SetBidiOptions(options); } } break; } } return NS_OK; } // // nsIDOMNode methods // NS_IMETHODIMP nsDocument::GetNodeName(nsAString& aNodeName) { aNodeName.AssignLiteral("#document"); return NS_OK; } NS_IMETHODIMP nsDocument::GetNodeValue(nsAString& aNodeValue) { SetDOMStringToNull(aNodeValue); return NS_OK; } NS_IMETHODIMP nsDocument::SetNodeValue(const nsAString& aNodeValue) { // The DOM spec says that when nodeValue is defined to be null "setting it // has no effect", so we don't throw an exception. return NS_OK; } NS_IMETHODIMP nsDocument::GetNodeType(PRUint16* aNodeType) { *aNodeType = nsIDOMNode::DOCUMENT_NODE; return NS_OK; } NS_IMETHODIMP nsDocument::GetParentNode(nsIDOMNode** aParentNode) { *aParentNode = nsnull; return NS_OK; } NS_IMETHODIMP nsDocument::GetChildNodes(nsIDOMNodeList** aChildNodes) { nsSlots *slots = GetSlots(); NS_ENSURE_TRUE(slots, NS_ERROR_OUT_OF_MEMORY); if (!slots->mChildNodes) { slots->mChildNodes = new nsChildContentList(this); NS_ENSURE_TRUE(slots->mChildNodes, NS_ERROR_OUT_OF_MEMORY); NS_ADDREF(slots->mChildNodes); } NS_ADDREF(*aChildNodes = slots->mChildNodes); return NS_OK; } NS_IMETHODIMP nsDocument::HasChildNodes(PRBool* aHasChildNodes) { NS_ENSURE_ARG(aHasChildNodes); *aHasChildNodes = (mChildren.ChildCount() != 0); return NS_OK; } NS_IMETHODIMP nsDocument::HasAttributes(PRBool* aHasAttributes) { NS_ENSURE_ARG(aHasAttributes); *aHasAttributes = PR_FALSE; return NS_OK; } NS_IMETHODIMP nsDocument::GetFirstChild(nsIDOMNode** aFirstChild) { if (mChildren.ChildCount()) { return CallQueryInterface(mChildren.ChildAt(0), aFirstChild); } *aFirstChild = nsnull; return NS_OK; } NS_IMETHODIMP nsDocument::GetLastChild(nsIDOMNode** aLastChild) { PRInt32 count = mChildren.ChildCount(); if (count) { return CallQueryInterface(mChildren.ChildAt(count-1), aLastChild); } *aLastChild = nsnull; return NS_OK; } NS_IMETHODIMP nsDocument::GetPreviousSibling(nsIDOMNode** aPreviousSibling) { *aPreviousSibling = nsnull; return NS_OK; } NS_IMETHODIMP nsDocument::GetNextSibling(nsIDOMNode** aNextSibling) { *aNextSibling = nsnull; return NS_OK; } NS_IMETHODIMP nsDocument::GetAttributes(nsIDOMNamedNodeMap** aAttributes) { *aAttributes = nsnull; return NS_OK; } NS_IMETHODIMP nsDocument::GetNamespaceURI(nsAString& aNamespaceURI) { SetDOMStringToNull(aNamespaceURI); return NS_OK; } NS_IMETHODIMP nsDocument::GetPrefix(nsAString& aPrefix) { SetDOMStringToNull(aPrefix); return NS_OK; } NS_IMETHODIMP nsDocument::SetPrefix(const nsAString& aPrefix) { return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR; } NS_IMETHODIMP nsDocument::GetLocalName(nsAString& aLocalName) { SetDOMStringToNull(aLocalName); return NS_OK; } NS_IMETHODIMP nsDocument::InsertBefore(nsIDOMNode* aNewChild, nsIDOMNode* aRefChild, nsIDOMNode** aReturn) { return nsGenericElement::doReplaceOrInsertBefore(PR_FALSE, aNewChild, aRefChild, nsnull, this, aReturn); } NS_IMETHODIMP nsDocument::ReplaceChild(nsIDOMNode* aNewChild, nsIDOMNode* aOldChild, nsIDOMNode** aReturn) { return nsGenericElement::doReplaceOrInsertBefore(PR_TRUE, aNewChild, aOldChild, nsnull, this, aReturn); } NS_IMETHODIMP nsDocument::RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aReturn) { return nsGenericElement::doRemoveChild(aOldChild, nsnull, this, aReturn); } NS_IMETHODIMP nsDocument::AppendChild(nsIDOMNode* aNewChild, nsIDOMNode** aReturn) { return nsDocument::InsertBefore(aNewChild, nsnull, aReturn); } NS_IMETHODIMP nsDocument::CloneNode(PRBool aDeep, nsIDOMNode** aReturn) { // XXX should be implemented by subclass *aReturn = nsnull; return NS_OK; } NS_IMETHODIMP nsDocument::Normalize() { PRInt32 count = mChildren.ChildCount(); for (PRInt32 i = 0; i < count; ++i) { nsCOMPtr node(do_QueryInterface(mChildren.ChildAt(i))); if (node) { node->Normalize(); } } return NS_OK; } NS_IMETHODIMP nsDocument::IsSupported(const nsAString& aFeature, const nsAString& aVersion, PRBool* aReturn) { return nsGenericElement::InternalIsSupported(static_cast(this), aFeature, aVersion, aReturn); } NS_IMETHODIMP nsDocument::GetBaseURI(nsAString &aURI) { nsCAutoString spec; if (mDocumentBaseURI) { mDocumentBaseURI->GetSpec(spec); } CopyUTF8toUTF16(spec, aURI); return NS_OK; } NS_IMETHODIMP nsDocument::GetTextContent(nsAString &aTextContent) { SetDOMStringToNull(aTextContent); return NS_OK; } NS_IMETHODIMP nsDocument::SetTextContent(const nsAString& aTextContent) { return NS_OK; } NS_IMETHODIMP nsDocument::CompareDocumentPosition(nsIDOMNode* aOther, PRUint16* aReturn) { NS_ENSURE_ARG_POINTER(aOther); // We could optimize this by getting the other nodes current document // and comparing with ourself. But then we'd have to deal with the // current document being null and such so it's easier this way. // It's hardly a case to optimize anyway. nsCOMPtr other = do_QueryInterface(aOther); NS_ENSURE_TRUE(other, NS_ERROR_DOM_NOT_SUPPORTED_ERR); *aReturn = nsContentUtils::ComparePosition(other, this); return NS_OK; } NS_IMETHODIMP nsDocument::IsSameNode(nsIDOMNode* aOther, PRBool* aReturn) { PRBool sameNode = PR_FALSE; if (this == aOther) { sameNode = PR_TRUE; } *aReturn = sameNode; return NS_OK; } NS_IMETHODIMP nsDocument::IsEqualNode(nsIDOMNode* aOther, PRBool* aReturn) { NS_ENSURE_ARG_POINTER(aOther); *aReturn = PR_FALSE; // Node type check by QI. We also reuse this later. nsCOMPtr aOtherDoc = do_QueryInterface(aOther); if (!aOtherDoc) { return NS_OK; } // Child nodes check. PRUint32 childCount = GetChildCount(); if (childCount != aOtherDoc->GetChildCount()) { return NS_OK; } for (PRUint32 i = 0; i < childCount; i++) { nsIContent* aChild1 = GetChildAt(i); nsIContent* aChild2 = aOtherDoc->GetChildAt(i); if (!nsNode3Tearoff::AreNodesEqual(aChild1, aChild2)) { return NS_OK; } } /* Checks not needed: Prefix, namespace URI, local name, node name, node value, attributes. */ *aReturn = PR_TRUE; return NS_OK; } NS_IMETHODIMP nsDocument::IsDefaultNamespace(const nsAString& aNamespaceURI, PRBool* aReturn) { nsAutoString defaultNamespace; LookupNamespaceURI(EmptyString(), defaultNamespace); *aReturn = aNamespaceURI.Equals(defaultNamespace); return NS_OK; } NS_IMETHODIMP nsDocument::GetFeature(const nsAString& aFeature, const nsAString& aVersion, nsISupports** aReturn) { return nsGenericElement::InternalGetFeature(static_cast(this), aFeature, aVersion, aReturn); } NS_IMETHODIMP nsDocument::SetUserData(const nsAString &aKey, nsIVariant *aData, nsIDOMUserDataHandler *aHandler, nsIVariant **aResult) { return nsNodeUtils::SetUserData(this, aKey, aData, aHandler, aResult); } NS_IMETHODIMP nsDocument::GetUserData(const nsAString &aKey, nsIVariant **aResult) { return nsNodeUtils::GetUserData(this, aKey, aResult); } NS_IMETHODIMP nsDocument::LookupPrefix(const nsAString& aNamespaceURI, nsAString& aPrefix) { nsCOMPtr root(do_QueryInterface(GetRootContent())); if (root) { return root->LookupPrefix(aNamespaceURI, aPrefix); } SetDOMStringToNull(aPrefix); return NS_OK; } NS_IMETHODIMP nsDocument::LookupNamespaceURI(const nsAString& aNamespacePrefix, nsAString& aNamespaceURI) { if (NS_FAILED(nsContentUtils::LookupNamespaceURI(GetRootContent(), aNamespacePrefix, aNamespaceURI))) { SetDOMStringToNull(aNamespaceURI); } return NS_OK; } NS_IMETHODIMP nsDocument::GetInputEncoding(nsAString& aInputEncoding) { if (mHaveInputEncoding) { return GetCharacterSet(aInputEncoding); } SetDOMStringToNull(aInputEncoding); return NS_OK; } NS_IMETHODIMP nsDocument::GetXmlEncoding(nsAString& aXmlEncoding) { if (mXMLDeclarationBits & XML_DECLARATION_BITS_DECLARATION_EXISTS && mXMLDeclarationBits & XML_DECLARATION_BITS_ENCODING_EXISTS) { // XXX We don't store the encoding given in the xml declaration. // For now, just output the inputEncoding which we do store. GetInputEncoding(aXmlEncoding); } else { SetDOMStringToNull(aXmlEncoding); } return NS_OK; } NS_IMETHODIMP nsDocument::GetXmlStandalone(PRBool *aXmlStandalone) { *aXmlStandalone = mXMLDeclarationBits & XML_DECLARATION_BITS_DECLARATION_EXISTS && mXMLDeclarationBits & XML_DECLARATION_BITS_STANDALONE_EXISTS && mXMLDeclarationBits & XML_DECLARATION_BITS_STANDALONE_YES; return NS_OK; } NS_IMETHODIMP nsDocument::SetXmlStandalone(PRBool aXmlStandalone) { return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP nsDocument::GetXmlVersion(nsAString& aXmlVersion) { // If there is no declaration, the value is "1.0". // XXX We only support "1.0", so always output "1.0" until that changes. aXmlVersion.AssignLiteral("1.0"); return NS_OK; } NS_IMETHODIMP nsDocument::SetXmlVersion(const nsAString& aXmlVersion) { return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP nsDocument::GetStrictErrorChecking(PRBool *aStrictErrorChecking) { // This attribute is true by default, and we don't really support it being false. *aStrictErrorChecking = PR_TRUE; return NS_OK; } NS_IMETHODIMP nsDocument::SetStrictErrorChecking(PRBool aStrictErrorChecking) { // We don't really support non-strict error checking, so just no-op for now. return NS_OK; } NS_IMETHODIMP nsDocument::GetDocumentURI(nsAString& aDocumentURI) { if (mDocumentURI) { nsCAutoString uri; mDocumentURI->GetSpec(uri); CopyUTF8toUTF16(uri, aDocumentURI); } else { SetDOMStringToNull(aDocumentURI); } return NS_OK; } NS_IMETHODIMP nsDocument::SetDocumentURI(const nsAString& aDocumentURI) { // Not allowing this yet, need to think about security ramifications first. // We use mDocumentURI to get principals for this document. return NS_ERROR_NOT_IMPLEMENTED; } static void BlastSubtreeToPieces(nsINode *aNode); PLDHashOperator PR_CALLBACK BlastFunc(nsAttrHashKey::KeyType aKey, nsIDOMNode *aData, void* aUserArg) { nsCOMPtr *attr = static_cast*>(aUserArg); *attr = do_QueryInterface(aData); NS_ASSERTION(attr->get(), "non-nsIAttribute somehow made it into the hashmap?!"); return PL_DHASH_STOP; } static void BlastSubtreeToPieces(nsINode *aNode) { PRUint32 i, count; if (aNode->IsNodeOfType(nsINode::eELEMENT)) { nsGenericElement *element = static_cast(aNode); const nsDOMAttributeMap *map = element->GetAttributeMap(); if (map) { nsCOMPtr attr; while (map->Enumerate(BlastFunc, &attr) > 0) { BlastSubtreeToPieces(attr); nsresult rv = element->UnsetAttr(attr->NodeInfo()->NamespaceID(), attr->NodeInfo()->NameAtom(), PR_FALSE); // XXX Should we abort here? NS_ASSERTION(NS_SUCCEEDED(rv), "Uhoh, UnsetAttr shouldn't fail!"); } } } count = aNode->GetChildCount(); for (i = 0; i < count; ++i) { BlastSubtreeToPieces(aNode->GetChildAt(0)); nsresult rv = aNode->RemoveChildAt(0, PR_FALSE); // XXX Should we abort here? NS_ASSERTION(NS_SUCCEEDED(rv), "Uhoh, RemoveChildAt shouldn't fail!"); } } NS_IMETHODIMP nsDocument::AdoptNode(nsIDOMNode *aAdoptedNode, nsIDOMNode **aResult) { NS_ENSURE_ARG(aAdoptedNode); *aResult = nsnull; nsresult rv = nsContentUtils::CheckSameOrigin(this, aAdoptedNode); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr adoptedNode; PRUint16 nodeType; aAdoptedNode->GetNodeType(&nodeType); switch (nodeType) { case nsIDOMNode::ATTRIBUTE_NODE: { // Remove from ownerElement. nsCOMPtr adoptedAttr = do_QueryInterface(aAdoptedNode, &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr ownerElement; rv = adoptedAttr->GetOwnerElement(getter_AddRefs(ownerElement)); NS_ENSURE_SUCCESS(rv, rv); if (ownerElement) { nsCOMPtr newAttr; rv = ownerElement->RemoveAttributeNode(adoptedAttr, getter_AddRefs(newAttr)); NS_ENSURE_SUCCESS(rv, rv); newAttr.swap(adoptedAttr); } adoptedNode = do_QueryInterface(adoptedAttr, &rv); NS_ENSURE_SUCCESS(rv, rv); break; } case nsIDOMNode::DOCUMENT_FRAGMENT_NODE: case nsIDOMNode::ELEMENT_NODE: case nsIDOMNode::PROCESSING_INSTRUCTION_NODE: case nsIDOMNode::TEXT_NODE: case nsIDOMNode::CDATA_SECTION_NODE: case nsIDOMNode::COMMENT_NODE: { adoptedNode = do_QueryInterface(aAdoptedNode, &rv); NS_ENSURE_SUCCESS(rv, rv); // We don't want to adopt an element into its own contentDocument or into // a descendant contentDocument, so we check if the frameElement of this // document or any of its parents is the adopted node or one of its // descendants. nsIDocument *doc = this; do { nsPIDOMWindow *win = doc->GetWindow(); if (win) { nsCOMPtr node = do_QueryInterface(win->GetFrameElementInternal()); if (node && nsContentUtils::ContentIsDescendantOf(node, adoptedNode)) { return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR; } } } while ((doc = doc->GetParentDocument())); // Remove from parent. nsCOMPtr parent; aAdoptedNode->GetParentNode(getter_AddRefs(parent)); NS_ENSURE_SUCCESS(rv, rv); if (parent) { nsCOMPtr newChild; rv = parent->RemoveChild(aAdoptedNode, getter_AddRefs(newChild)); NS_ENSURE_SUCCESS(rv, rv); } break; } case nsIDOMNode::ENTITY_REFERENCE_NODE: { return NS_ERROR_NOT_IMPLEMENTED; } case nsIDOMNode::DOCUMENT_NODE: case nsIDOMNode::DOCUMENT_TYPE_NODE: case nsIDOMNode::ENTITY_NODE: case nsIDOMNode::NOTATION_NODE: { return NS_ERROR_DOM_NOT_SUPPORTED_ERR; } default: { NS_WARNING("Don't know how to adopt this nodetype for adoptNode."); return NS_ERROR_DOM_NOT_SUPPORTED_ERR; } } nsIDocument *oldDocument = adoptedNode->GetOwnerDoc(); PRBool sameDocument = oldDocument == this; JSContext *cx = nsnull; JSObject *oldScope = nsnull; JSObject *newScope = nsnull; if (!sameDocument && oldDocument) { rv = nsContentUtils::GetContextAndScopes(oldDocument, this, &cx, &oldScope, &newScope); NS_ENSURE_SUCCESS(rv, rv); } nsCOMArray nodesWithProperties; rv = nsNodeUtils::Adopt(adoptedNode, sameDocument ? nsnull : mNodeInfoManager, cx, oldScope, newScope, nodesWithProperties); if (NS_FAILED(rv)) { // Disconnect all nodes from their parents, since some have the old document // as their ownerDocument and some have this as their ownerDocument. BlastSubtreeToPieces(adoptedNode); if (!sameDocument && oldDocument) { PRUint32 i, count = nodesWithProperties.Count(); for (i = 0; i < count; ++i) { // Remove all properties. oldDocument->PropertyTable()-> DeleteAllPropertiesFor(nodesWithProperties[i]); } } return rv; } PRUint32 i, count = nodesWithProperties.Count(); if (!sameDocument && oldDocument) { nsPropertyTable *oldTable = oldDocument->PropertyTable(); nsPropertyTable *newTable = PropertyTable(); for (i = 0; i < count; ++i) { rv = oldTable->TransferOrDeleteAllPropertiesFor(nodesWithProperties[i], newTable); if (NS_FAILED(rv)) { while (++i < count) { oldTable->DeleteAllPropertiesFor(nodesWithProperties[i]); } // Disconnect all nodes from their parents. BlastSubtreeToPieces(adoptedNode); return rv; } } } rv = nsNodeUtils::CallUserDataHandlers(nodesWithProperties, this, nsIDOMUserDataHandler::NODE_ADOPTED, PR_FALSE); NS_ENSURE_SUCCESS(rv, rv); return CallQueryInterface(adoptedNode, aResult); } NS_IMETHODIMP nsDocument::GetDomConfig(nsIDOMDOMConfiguration **aConfig) { return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP nsDocument::NormalizeDocument() { // We don't support DOMConfigurations yet, so this just // does a straight shot of normalization. return Normalize(); } NS_IMETHODIMP nsDocument::RenameNode(nsIDOMNode *aNode, const nsAString& namespaceURI, const nsAString& qualifiedName, nsIDOMNode **aReturn) { return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP nsDocument::GetOwnerDocument(nsIDOMDocument** aOwnerDocument) { *aOwnerDocument = nsnull; return NS_OK; } nsresult nsDocument::GetListenerManager(PRBool aCreateIfNotFound, nsIEventListenerManager** aInstancePtrResult) { if (mListenerManager) { *aInstancePtrResult = mListenerManager; NS_ADDREF(*aInstancePtrResult); return NS_OK; } if (!aCreateIfNotFound) { *aInstancePtrResult = nsnull; return NS_OK; } nsresult rv = NS_NewEventListenerManager(getter_AddRefs(mListenerManager)); NS_ENSURE_SUCCESS(rv, rv); mListenerManager->SetListenerTarget(static_cast(this)); *aInstancePtrResult = mListenerManager; NS_ADDREF(*aInstancePtrResult); return NS_OK; } nsresult nsDocument::GetSystemEventGroup(nsIDOMEventGroup **aGroup) { nsCOMPtr manager; if (NS_SUCCEEDED(GetListenerManager(PR_TRUE, getter_AddRefs(manager))) && manager) { return manager->GetSystemEventGroupLM(aGroup); } return NS_ERROR_FAILURE; } nsresult nsDocument::PreHandleEvent(nsEventChainPreVisitor& aVisitor) { aVisitor.mCanHandle = PR_TRUE; // FIXME! This is a hack to make middle mouse paste working also in Editor. // Bug 329119 aVisitor.mForceContentDispatch = PR_TRUE; // Load events must not propagate to |window| object, see bug 335251. if (aVisitor.mEvent->message != NS_LOAD) { aVisitor.mParentTarget = GetWindow(); } return NS_OK; } nsresult nsDocument::PostHandleEvent(nsEventChainPostVisitor& aVisitor) { return NS_OK; } nsresult nsDocument::DispatchDOMEvent(nsEvent* aEvent, nsIDOMEvent* aDOMEvent, nsPresContext* aPresContext, nsEventStatus* aEventStatus) { return nsEventDispatcher::DispatchDOMEvent(static_cast(this), aEvent, aDOMEvent, aPresContext, aEventStatus); } nsresult nsDocument::AddEventListenerByIID(nsIDOMEventListener *aListener, const nsIID& aIID) { nsCOMPtr manager; GetListenerManager(PR_TRUE, getter_AddRefs(manager)); if (manager) { manager->AddEventListenerByIID(aListener, aIID, NS_EVENT_FLAG_BUBBLE); return NS_OK; } return NS_ERROR_FAILURE; } nsresult nsDocument::RemoveEventListenerByIID(nsIDOMEventListener *aListener, const nsIID& aIID) { if (!mListenerManager) { return NS_ERROR_FAILURE; } mListenerManager->RemoveEventListenerByIID(aListener, aIID, NS_EVENT_FLAG_BUBBLE); return NS_OK; } nsresult nsDocument::AddEventListener(const nsAString& aType, nsIDOMEventListener* aListener, PRBool aUseCapture) { return AddEventListener(aType, aListener, aUseCapture, !nsContentUtils::IsChromeDoc(this)); } nsresult nsDocument::RemoveEventListener(const nsAString& aType, nsIDOMEventListener* aListener, PRBool aUseCapture) { return RemoveGroupedEventListener(aType, aListener, aUseCapture, nsnull); } NS_IMETHODIMP nsDocument::DispatchEvent(nsIDOMEvent* aEvent, PRBool *_retval) { // Obtain a presentation context nsIPresShell *shell = GetPrimaryShell(); nsCOMPtr context; if (shell) { context = shell->GetPresContext(); } nsEventStatus status = nsEventStatus_eIgnore; nsresult rv = nsEventDispatcher::DispatchDOMEvent(static_cast(this), nsnull, aEvent, context, &status); *_retval = (status != nsEventStatus_eConsumeNoDefault); return rv; } NS_IMETHODIMP nsDocument::AddGroupedEventListener(const nsAString& aType, nsIDOMEventListener *aListener, PRBool aUseCapture, nsIDOMEventGroup *aEvtGrp) { nsCOMPtr manager; nsresult rv = GetListenerManager(PR_TRUE, getter_AddRefs(manager)); if (NS_SUCCEEDED(rv) && manager) { PRInt32 flags = aUseCapture ? NS_EVENT_FLAG_CAPTURE : NS_EVENT_FLAG_BUBBLE; manager->AddEventListenerByType(aListener, aType, flags, aEvtGrp); return NS_OK; } return rv; } NS_IMETHODIMP nsDocument::RemoveGroupedEventListener(const nsAString& aType, nsIDOMEventListener *aListener, PRBool aUseCapture, nsIDOMEventGroup *aEvtGrp) { if (!mListenerManager) { return NS_ERROR_FAILURE; } PRInt32 flags = aUseCapture ? NS_EVENT_FLAG_CAPTURE : NS_EVENT_FLAG_BUBBLE; mListenerManager->RemoveEventListenerByType(aListener, aType, flags, aEvtGrp); return NS_OK; } NS_IMETHODIMP nsDocument::CanTrigger(const nsAString & type, PRBool *_retval) { return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP nsDocument::IsRegisteredHere(const nsAString & type, PRBool *_retval) { return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP nsDocument::AddEventListener(const nsAString& aType, nsIDOMEventListener *aListener, PRBool aUseCapture, PRBool aWantsUntrusted) { nsCOMPtr manager; nsresult rv = GetListenerManager(PR_TRUE, getter_AddRefs(manager)); NS_ENSURE_SUCCESS(rv, rv); PRInt32 flags = aUseCapture ? NS_EVENT_FLAG_CAPTURE : NS_EVENT_FLAG_BUBBLE; if (aWantsUntrusted) { flags |= NS_PRIV_EVENT_UNTRUSTED_PERMITTED; } return manager->AddEventListenerByType(aListener, aType, flags, nsnull); } NS_IMETHODIMP nsDocument::CreateEvent(const nsAString& aEventType, nsIDOMEvent** aReturn) { NS_ENSURE_ARG_POINTER(aReturn); *aReturn = nsnull; // Obtain a presentation shell nsIPresShell *shell = GetPrimaryShell(); nsPresContext *presContext = nsnull; if (shell) { // Retrieve the context presContext = shell->GetPresContext(); } // Create event even without presContext. return nsEventDispatcher::CreateEvent(presContext, nsnull, aEventType, aReturn); } NS_IMETHODIMP nsDocument::CreateEventGroup(nsIDOMEventGroup **aInstancePtrResult) { nsresult rv; nsCOMPtr group(do_CreateInstance(kDOMEventGroupCID, &rv)); NS_ENSURE_SUCCESS(rv, rv); *aInstancePtrResult = group; NS_ADDREF(*aInstancePtrResult); return NS_OK; } void nsDocument::FlushPendingNotifications(mozFlushType aType) { nsCOMPtr sink; if (mParser) { sink = mParser->GetContentSink(); } else { sink = do_QueryReferent(mWeakSink); } // Determine if it is safe to flush the sink notifications // by determining if it safe to flush all the presshells. if (sink && (aType == Flush_Content || IsSafeToFlush())) { sink->FlushPendingNotifications(aType); } // Should we be flushing pending binding constructors in here? nsPIDOMWindow *window = GetWindow(); if (aType <= Flush_ContentAndNotify || !window) { // Nothing to do here return; } // If we have a parent we must flush the parent too to ensure that our // container is reflown if its size was changed. But if it's not safe to // flush ourselves, then don't flush the parent, since that can cause things // like resizes of our frame's widget, which we can't handle while flushing // is unsafe. // Since media queries mean that a size change of our container can // affect style, we need to promote a style flush on ourself to a // layout flush on our parent, since we need our container to be the // correct size to determine the correct style. if (mParentDocument && IsSafeToFlush()) { mozFlushType parentType = aType; if (aType == Flush_Style) parentType = Flush_Layout; mParentDocument->FlushPendingNotifications(parentType); } nsPresShellIterator iter(this); nsCOMPtr shell; while ((shell = iter.GetNextShell())) { shell->FlushPendingNotifications(aType); } } void nsDocument::AddReference(void *aKey, nsISupports *aReference) { if (mScriptGlobalObject) { if (!mContentWrapperHash) { mContentWrapperHash = new nsInterfaceHashtable; if (mContentWrapperHash) { mContentWrapperHash->Init(10); } } if (mContentWrapperHash) mContentWrapperHash->Put(aKey, aReference); } } nsISupports* nsDocument::GetReference(void *aKey) { // NB: This method is part of content cycle collection, // and must *not* Addref its return value. if (mContentWrapperHash) return mContentWrapperHash->GetWeak(aKey); return nsnull; } void nsDocument::RemoveReference(void *aKey) { if (mContentWrapperHash) { mContentWrapperHash->Remove(aKey); } } nsIScriptEventManager* nsDocument::GetScriptEventManager() { if (!mScriptEventManager) { mScriptEventManager = new nsScriptEventManager(this); // automatically AddRefs } return mScriptEventManager; } void nsDocument::SetXMLDeclaration(const PRUnichar *aVersion, const PRUnichar *aEncoding, const PRInt32 aStandalone) { if (!aVersion || *aVersion == '\0') { mXMLDeclarationBits = 0; return; } mXMLDeclarationBits = XML_DECLARATION_BITS_DECLARATION_EXISTS; if (aEncoding && *aEncoding != '\0') { mXMLDeclarationBits |= XML_DECLARATION_BITS_ENCODING_EXISTS; } if (aStandalone == 1) { mXMLDeclarationBits |= XML_DECLARATION_BITS_STANDALONE_EXISTS | XML_DECLARATION_BITS_STANDALONE_YES; } else if (aStandalone == 0) { mXMLDeclarationBits |= XML_DECLARATION_BITS_STANDALONE_EXISTS; } } void nsDocument::GetXMLDeclaration(nsAString& aVersion, nsAString& aEncoding, nsAString& aStandalone) { aVersion.Truncate(); aEncoding.Truncate(); aStandalone.Truncate(); if (!(mXMLDeclarationBits & XML_DECLARATION_BITS_DECLARATION_EXISTS)) { return; } // always until we start supporting 1.1 etc. aVersion.AssignLiteral("1.0"); if (mXMLDeclarationBits & XML_DECLARATION_BITS_ENCODING_EXISTS) { // This is what we have stored, not necessarily what was written // in the original GetCharacterSet(aEncoding); } if (mXMLDeclarationBits & XML_DECLARATION_BITS_STANDALONE_EXISTS) { if (mXMLDeclarationBits & XML_DECLARATION_BITS_STANDALONE_YES) { aStandalone.AssignLiteral("yes"); } else { aStandalone.AssignLiteral("no"); } } } PRBool nsDocument::IsScriptEnabled() { nsCOMPtr sm(do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID)); NS_ENSURE_TRUE(sm, PR_TRUE); nsIScriptGlobalObject* globalObject = GetScriptGlobalObject(); NS_ENSURE_TRUE(globalObject, PR_TRUE); nsIScriptContext *scriptContext = globalObject->GetContext(); NS_ENSURE_TRUE(scriptContext, PR_TRUE); JSContext* cx = (JSContext *) scriptContext->GetNativeContext(); NS_ENSURE_TRUE(cx, PR_TRUE); PRBool enabled; nsresult rv = sm->CanExecuteScripts(cx, NodePrincipal(), &enabled); NS_ENSURE_SUCCESS(rv, PR_TRUE); return enabled; } nsresult nsDocument::GetRadioGroup(const nsAString& aName, nsRadioGroupStruct **aRadioGroup) { nsAutoString tmKey(aName); if(!IsCaseSensitive()) ToLowerCase(tmKey); //should case-insensitive. if (mRadioGroups.Get(tmKey, aRadioGroup)) return NS_OK; nsAutoPtr radioGroup(new nsRadioGroupStruct()); NS_ENSURE_TRUE(radioGroup, NS_ERROR_OUT_OF_MEMORY); NS_ENSURE_TRUE(mRadioGroups.Put(tmKey, radioGroup), NS_ERROR_OUT_OF_MEMORY); *aRadioGroup = radioGroup; radioGroup.forget(); return NS_OK; } NS_IMETHODIMP nsDocument::SetCurrentRadioButton(const nsAString& aName, nsIDOMHTMLInputElement* aRadio) { nsRadioGroupStruct* radioGroup = nsnull; GetRadioGroup(aName, &radioGroup); if (radioGroup) { radioGroup->mSelectedRadioButton = aRadio; } return NS_OK; } NS_IMETHODIMP nsDocument::GetCurrentRadioButton(const nsAString& aName, nsIDOMHTMLInputElement** aRadio) { nsRadioGroupStruct* radioGroup = nsnull; GetRadioGroup(aName, &radioGroup); if (radioGroup) { *aRadio = radioGroup->mSelectedRadioButton; NS_IF_ADDREF(*aRadio); } return NS_OK; } NS_IMETHODIMP nsDocument::GetPositionInGroup(nsIDOMHTMLInputElement *aRadio, PRInt32 *aPositionIndex, PRInt32 *aItemsInGroup) { *aPositionIndex = 0; *aItemsInGroup = 1; nsAutoString name; aRadio->GetName(name); if (name.IsEmpty()) { return NS_OK; } nsRadioGroupStruct* radioGroup = nsnull; nsresult rv = GetRadioGroup(name, &radioGroup); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr radioControl(do_QueryInterface(aRadio)); NS_ASSERTION(radioControl, "Radio button should implement nsIFormControl"); *aPositionIndex = radioGroup->mRadioButtons.IndexOf(radioControl); NS_ASSERTION(*aPositionIndex >= 0, "Radio button not found in its own group"); *aItemsInGroup = radioGroup->mRadioButtons.Count(); return NS_OK; } NS_IMETHODIMP nsDocument::GetNextRadioButton(const nsAString& aName, const PRBool aPrevious, nsIDOMHTMLInputElement* aFocusedRadio, nsIDOMHTMLInputElement** aRadioOut) { // XXX Can we combine the HTML radio button method impls of // nsDocument and nsHTMLFormControl? // XXX Why is HTML radio button stuff in nsDocument, as // opposed to nsHTMLDocument? *aRadioOut = nsnull; nsRadioGroupStruct* radioGroup = nsnull; GetRadioGroup(aName, &radioGroup); if (!radioGroup) { return NS_ERROR_FAILURE; } // Return the radio button relative to the focused radio button. // If no radio is focused, get the radio relative to the selected one. nsCOMPtr currentRadio; if (aFocusedRadio) { currentRadio = aFocusedRadio; } else { currentRadio = radioGroup->mSelectedRadioButton; if (!currentRadio) { return NS_ERROR_FAILURE; } } nsCOMPtr radioControl(do_QueryInterface(currentRadio)); PRInt32 index = radioGroup->mRadioButtons.IndexOf(radioControl); if (index < 0) { return NS_ERROR_FAILURE; } PRInt32 numRadios = radioGroup->mRadioButtons.Count(); PRBool disabled; nsCOMPtr radio; do { if (aPrevious) { if (--index < 0) { index = numRadios -1; } } else if (++index >= numRadios) { index = 0; } radio = do_QueryInterface(radioGroup->mRadioButtons[index]); NS_ASSERTION(radio, "mRadioButtons holding a non-radio button"); radio->GetDisabled(&disabled); } while (disabled && radio != currentRadio); NS_IF_ADDREF(*aRadioOut = radio); return NS_OK; } NS_IMETHODIMP nsDocument::AddToRadioGroup(const nsAString& aName, nsIFormControl* aRadio) { nsRadioGroupStruct* radioGroup = nsnull; GetRadioGroup(aName, &radioGroup); if (radioGroup) { radioGroup->mRadioButtons.AppendObject(aRadio); } return NS_OK; } NS_IMETHODIMP nsDocument::RemoveFromRadioGroup(const nsAString& aName, nsIFormControl* aRadio) { nsRadioGroupStruct* radioGroup = nsnull; GetRadioGroup(aName, &radioGroup); if (radioGroup) { radioGroup->mRadioButtons.RemoveObject(aRadio); } return NS_OK; } NS_IMETHODIMP nsDocument::WalkRadioGroup(const nsAString& aName, nsIRadioVisitor* aVisitor, PRBool aFlushContent) { nsRadioGroupStruct* radioGroup = nsnull; GetRadioGroup(aName, &radioGroup); if (!radioGroup) { return NS_OK; } PRBool stop = PR_FALSE; for (int i = 0; i < radioGroup->mRadioButtons.Count(); i++) { aVisitor->Visit(radioGroup->mRadioButtons[i], &stop); if (stop) { return NS_OK; } } return NS_OK; } void nsDocument::RetrieveRelevantHeaders(nsIChannel *aChannel) { nsCOMPtr httpChannel = do_QueryInterface(aChannel); PRTime modDate = LL_ZERO; nsresult rv; if (httpChannel) { nsCAutoString tmp; rv = httpChannel->GetResponseHeader(NS_LITERAL_CSTRING("last-modified"), tmp); if (NS_SUCCEEDED(rv)) { PRTime time; PRStatus st = PR_ParseTimeString(tmp.get(), PR_TRUE, &time); if (st == PR_SUCCESS) { modDate = time; } } // The misspelled key 'referer' is as per the HTTP spec rv = httpChannel->GetRequestHeader(NS_LITERAL_CSTRING("referer"), mReferrer); if (NS_FAILED(rv)) { mReferrer.Truncate(); } static const char *const headers[] = { "default-style", "content-style-type", "content-language", "content-disposition", "refresh", // add more http headers if you need // XXXbz don't add content-location support without reading bug // 238654 and its dependencies/dups first. 0 }; nsCAutoString headerVal; const char *const *name = headers; while (*name) { rv = httpChannel->GetResponseHeader(nsDependentCString(*name), headerVal); if (NS_SUCCEEDED(rv) && !headerVal.IsEmpty()) { nsCOMPtr key = do_GetAtom(*name); SetHeaderData(key, NS_ConvertASCIItoUTF16(headerVal)); } ++name; } } else { nsCOMPtr fileChannel = do_QueryInterface(aChannel); if (fileChannel) { nsCOMPtr file; fileChannel->GetFile(getter_AddRefs(file)); if (file) { PRTime msecs; rv = file->GetLastModifiedTime(&msecs); if (NS_SUCCEEDED(rv)) { PRInt64 intermediateValue; LL_I2L(intermediateValue, PR_USEC_PER_MSEC); LL_MUL(modDate, msecs, intermediateValue); } } } else { nsCOMPtr partChannel = do_QueryInterface(aChannel); if (partChannel) { nsCAutoString contentDisp; rv = partChannel->GetContentDisposition(contentDisp); if (NS_SUCCEEDED(rv) && !contentDisp.IsEmpty()) { SetHeaderData(nsGkAtoms::headerContentDisposition, NS_ConvertASCIItoUTF16(contentDisp)); } } } } if (LL_IS_ZERO(modDate)) { // We got nothing from our attempt to ask nsIFileChannel and // nsIHttpChannel for the last modified time. Return the current // time. modDate = PR_Now(); } mLastModified.Truncate(); if (LL_NE(modDate, LL_ZERO)) { PRExplodedTime prtime; PR_ExplodeTime(modDate, PR_LocalTimeParameters, &prtime); // "MM/DD/YYYY hh:mm:ss" char formatedTime[24]; if (PR_snprintf(formatedTime, sizeof(formatedTime), "%02ld/%02ld/%04hd %02ld:%02ld:%02ld", prtime.tm_month + 1, prtime.tm_mday, prtime.tm_year, prtime.tm_hour , prtime.tm_min, prtime.tm_sec)) { CopyASCIItoUTF16(nsDependentCString(formatedTime), mLastModified); } } } nsresult nsDocument::CreateElem(nsIAtom *aName, nsIAtom *aPrefix, PRInt32 aNamespaceID, PRBool aDocumentDefaultType, nsIContent **aResult) { nsresult rv; #ifdef DEBUG nsAutoString qName; if (aPrefix) { aPrefix->ToString(qName); qName.Append(':'); } const char *name; aName->GetUTF8String(&name); AppendUTF8toUTF16(name, qName); // Note: "a:b:c" is a valid name in non-namespaces XML, and // nsDocument::CreateElement can call us with such a name and no prefix, // which would cause an error if we just used PR_TRUE here. PRBool nsAware = aPrefix != nsnull || aNamespaceID != GetDefaultNamespaceID(); NS_ASSERTION(NS_SUCCEEDED(nsContentUtils::CheckQName(qName, nsAware)), "Don't pass invalid prefixes to nsDocument::CreateElem, " "check caller."); #endif *aResult = nsnull; PRInt32 elementType = aDocumentDefaultType ? mDefaultElementType : aNamespaceID; nsCOMPtr nodeInfo; rv = mNodeInfoManager->GetNodeInfo(aName, aPrefix, aNamespaceID, getter_AddRefs(nodeInfo)); NS_ENSURE_SUCCESS(rv, rv); return NS_NewElement(aResult, elementType, nodeInfo, PR_FALSE); } PRBool nsDocument::IsSafeToFlush() const { PRBool isSafeToFlush = PR_TRUE; nsPresShellIterator iter(const_cast (static_cast(this))); nsCOMPtr shell; while ((shell = iter.GetNextShell()) && isSafeToFlush) { shell->IsSafeToFlush(isSafeToFlush); } return isSafeToFlush; } nsresult nsDocument::Sanitize() { // Sanitize the document by resetting all password fields and any form // fields with autocomplete=off to their default values. We do this now, // instead of when the presentation is restored, to offer some protection // in case there is ever an exploit that allows a cached document to be // accessed from a different document. // First locate all input elements, regardless of whether they are // in a form, and reset the password and autocomplete=off elements. nsCOMPtr nodes; nsresult rv = GetElementsByTagName(NS_LITERAL_STRING("input"), getter_AddRefs(nodes)); NS_ENSURE_SUCCESS(rv, rv); PRUint32 length = 0; if (nodes) nodes->GetLength(&length); nsCOMPtr item; nsAutoString value; PRUint32 i; for (i = 0; i < length; ++i) { nodes->Item(i, getter_AddRefs(item)); NS_ASSERTION(item, "null item in node list!"); nsCOMPtr input = do_QueryInterface(item); if (!input) continue; PRBool resetValue = PR_FALSE; input->GetAttribute(NS_LITERAL_STRING("autocomplete"), value); if (value.LowerCaseEqualsLiteral("off")) { resetValue = PR_TRUE; } else { input->GetType(value); if (value.LowerCaseEqualsLiteral("password")) resetValue = PR_TRUE; } if (resetValue) { nsCOMPtr fc = do_QueryInterface(input); fc->Reset(); } } // Now locate all _form_ elements that have autocomplete=off and reset them rv = GetElementsByTagName(NS_LITERAL_STRING("form"), getter_AddRefs(nodes)); NS_ENSURE_SUCCESS(rv, rv); length = 0; if (nodes) nodes->GetLength(&length); for (i = 0; i < length; ++i) { nodes->Item(i, getter_AddRefs(item)); NS_ASSERTION(item, "null item in nodelist"); nsCOMPtr form = do_QueryInterface(item); if (!form) continue; form->GetAttribute(NS_LITERAL_STRING("autocomplete"), value); if (value.LowerCaseEqualsLiteral("off")) form->Reset(); } return NS_OK; } struct SubDocEnumArgs { nsIDocument::nsSubDocEnumFunc callback; void *data; }; PR_STATIC_CALLBACK(PLDHashOperator) SubDocHashEnum(PLDHashTable *table, PLDHashEntryHdr *hdr, PRUint32 number, void *arg) { SubDocMapEntry *entry = static_cast(hdr); SubDocEnumArgs *args = static_cast(arg); nsIDocument *subdoc = entry->mSubDocument; PRBool next = subdoc ? args->callback(subdoc, args->data) : PR_TRUE; return next ? PL_DHASH_NEXT : PL_DHASH_STOP; } void nsDocument::EnumerateSubDocuments(nsSubDocEnumFunc aCallback, void *aData) { if (mSubDocuments) { SubDocEnumArgs args = { aCallback, aData }; PL_DHashTableEnumerate(mSubDocuments, SubDocHashEnum, &args); } } PR_STATIC_CALLBACK(PLDHashOperator) CanCacheSubDocument(PLDHashTable *table, PLDHashEntryHdr *hdr, PRUint32 number, void *arg) { SubDocMapEntry *entry = static_cast(hdr); PRBool *canCacheArg = static_cast(arg); nsIDocument *subdoc = entry->mSubDocument; // The aIgnoreRequest we were passed is only for us, so don't pass it on. PRBool canCache = subdoc ? subdoc->CanSavePresentation(nsnull) : PR_FALSE; if (!canCache) { *canCacheArg = PR_FALSE; return PL_DHASH_STOP; } return PL_DHASH_NEXT; } #ifdef DEBUG_bryner #define DEBUG_PAGE_CACHE #endif PRBool nsDocument::CanSavePresentation(nsIRequest *aNewRequest) { // Check our event listener manager for unload/beforeunload listeners. nsCOMPtr piTarget = do_QueryInterface(mScriptGlobalObject); if (piTarget) { nsCOMPtr manager; piTarget->GetListenerManager(PR_FALSE, getter_AddRefs(manager)); if (manager && manager->HasUnloadListeners()) { return PR_FALSE; } } nsCOMPtr loadGroup = GetDocumentLoadGroup(); if (loadGroup) { nsCOMPtr requests; loadGroup->GetRequests(getter_AddRefs(requests)); PRBool hasMore = PR_FALSE; while (NS_SUCCEEDED(requests->HasMoreElements(&hasMore)) && hasMore) { nsCOMPtr elem; requests->GetNext(getter_AddRefs(elem)); nsCOMPtr request = do_QueryInterface(elem); if (request && request != aNewRequest) { #ifdef DEBUG_PAGE_CACHE nsCAutoString requestName, docSpec; request->GetName(requestName); if (mDocumentURI) mDocumentURI->GetSpec(docSpec); printf("document %s has request %s\n", docSpec.get(), requestName.get()); #endif return PR_FALSE; } } } PRBool canCache = PR_TRUE; if (mSubDocuments) PL_DHashTableEnumerate(mSubDocuments, CanCacheSubDocument, &canCache); return canCache; } void nsDocument::Destroy() { // The ContentViewer wants to release the document now. So, tell our content // to drop any references to the document so that it can be destroyed. if (mIsGoingAway) return; mIsGoingAway = PR_TRUE; RemovedFromDocShell(); PRUint32 i, count = mChildren.ChildCount(); for (i = 0; i < count; ++i) { mChildren.ChildAt(i)->DestroyContent(); } mLayoutHistoryState = nsnull; nsContentList::OnDocumentDestroy(this); // XXX We really should let cycle collection do this, but that currently still // leaks (see https://bugzilla.mozilla.org/show_bug.cgi?id=406684). // When we start relying on cycle collection again we should remove the // check for mScriptGlobalObject in AddReference. delete mContentWrapperHash; mContentWrapperHash = nsnull; } void nsDocument::RemovedFromDocShell() { if (mRemovedFromDocShell) return; mRemovedFromDocShell = PR_TRUE; PRUint32 i, count = mChildren.ChildCount(); for (i = 0; i < count; ++i) { mChildren.ChildAt(i)->SaveSubtreeState(); } } already_AddRefed nsDocument::GetLayoutHistoryState() const { nsILayoutHistoryState* state = nsnull; if (!mScriptGlobalObject) { NS_IF_ADDREF(state = mLayoutHistoryState); } else { nsCOMPtr docShell(do_QueryReferent(mDocumentContainer)); if (docShell) { docShell->GetLayoutHistoryState(&state); } } return state; } void nsDocument::BlockOnload() { // If mScriptGlobalObject is null, we shouldn't be messing with the loadgroup // -- it's not ours. if (mOnloadBlockCount == 0 && mScriptGlobalObject) { nsCOMPtr loadGroup = GetDocumentLoadGroup(); if (loadGroup) { loadGroup->AddRequest(mOnloadBlocker, nsnull); } } ++mOnloadBlockCount; } void nsDocument::UnblockOnload(PRBool aFireSync) { if (mOnloadBlockCount == 0) { NS_NOTREACHED("More UnblockOnload() calls than BlockOnload() calls; dropping call"); return; } --mOnloadBlockCount; // If mScriptGlobalObject is null, we shouldn't be messing with the loadgroup // -- it's not ours. if (mOnloadBlockCount == 0 && mScriptGlobalObject) { if (aFireSync) { // Increment mOnloadBlockCount, since DoUnblockOnload will decrement it ++mOnloadBlockCount; DoUnblockOnload(); } else { PostUnblockOnloadEvent(); } } } class nsUnblockOnloadEvent : public nsRunnable { public: nsUnblockOnloadEvent(nsDocument *doc) : mDoc(doc) {} NS_IMETHOD Run() { mDoc->DoUnblockOnload(); return NS_OK; } private: nsRefPtr mDoc; }; void nsDocument::PostUnblockOnloadEvent() { nsCOMPtr evt = new nsUnblockOnloadEvent(this); nsresult rv = NS_DispatchToCurrentThread(evt); if (NS_SUCCEEDED(rv)) { // Stabilize block count so we don't post more events while this one is up ++mOnloadBlockCount; } else { NS_WARNING("failed to dispatch nsUnblockOnloadEvent"); } } void nsDocument::DoUnblockOnload() { NS_ASSERTION(mOnloadBlockCount != 0, "Shouldn't have a count of zero here, since we stabilized in " "PostUnblockOnloadEvent"); --mOnloadBlockCount; if (mOnloadBlockCount != 0) { // We blocked again after the last unblock. Nothing to do here. We'll // post a new event when we unblock again. return; } // If mScriptGlobalObject is null, we shouldn't be messing with the loadgroup // -- it's not ours. if (mScriptGlobalObject) { nsCOMPtr loadGroup = GetDocumentLoadGroup(); if (loadGroup) { loadGroup->RemoveRequest(mOnloadBlocker, nsnull, NS_OK); } } } /* See if document is a child of this. If so, return the frame element in this * document that holds currentDoc (or an ancestor). */ already_AddRefed nsDocument::CheckAncestryAndGetFrame(nsIDocument* aDocument) const { nsIDocument* parentDoc; for (parentDoc = aDocument->GetParentDocument(); parentDoc != static_cast(this); parentDoc = parentDoc->GetParentDocument()) { if (!parentDoc) { return nsnull; } aDocument = parentDoc; } // In a child document. Get the appropriate frame. nsPIDOMWindow* currentWindow = aDocument->GetWindow(); if (!currentWindow) { return nsnull; } nsIDOMElement* frameElement = currentWindow->GetFrameElementInternal(); if (!frameElement) { return nsnull; } // Sanity check result nsCOMPtr domDocument; frameElement->GetOwnerDocument(getter_AddRefs(domDocument)); if (domDocument != this) { NS_ERROR("Child documents should live in windows the parent owns"); return nsnull; } NS_ADDREF(frameElement); return frameElement; } void nsDocument::DispatchEventToWindow(nsEvent *aEvent) { nsPIDOMWindow *window = GetWindow(); if (!window) return; aEvent->target = static_cast(this); nsEventDispatcher::Dispatch(window, nsnull, aEvent); } void nsDocument::OnPageShow(PRBool aPersisted) { mVisible = PR_TRUE; UpdateLinkMap(); nsIContent* root = GetRootContent(); if (aPersisted && root) { // Send out notifications that our elements are attached. nsRefPtr links = NS_GetContentList(root, nsGkAtoms::link, kNameSpaceID_Unknown); if (links) { PRUint32 linkCount = links->Length(PR_TRUE); for (PRUint32 i = 0; i < linkCount; ++i) { nsCOMPtr link = do_QueryInterface(links->Item(i, PR_FALSE)); if (link) { link->LinkAdded(); } } } } nsPageTransitionEvent event(PR_TRUE, NS_PAGE_SHOW, aPersisted); DispatchEventToWindow(&event); } void nsDocument::OnPageHide(PRBool aPersisted) { // Send out notifications that our elements are detached, // but only if this is not a full unload. nsIContent* root = GetRootContent(); if (aPersisted && root) { nsRefPtr links = NS_GetContentList(root, nsGkAtoms::link, kNameSpaceID_Unknown); if (links) { PRUint32 linkCount = links->Length(PR_TRUE); for (PRUint32 i = 0; i < linkCount; ++i) { nsCOMPtr link = do_QueryInterface(links->Item(i, PR_FALSE)); if (link) { link->LinkRemoved(); } } } } // Now send out a PageHide event. nsPageTransitionEvent event(PR_TRUE, NS_PAGE_HIDE, aPersisted); DispatchEventToWindow(&event); mVisible = PR_FALSE; } void nsDocument::WillDispatchMutationEvent(nsINode* aTarget) { NS_ASSERTION(mSubtreeModifiedDepth != 0 || mSubtreeModifiedTargets.Count() == 0, "mSubtreeModifiedTargets not cleared after dispatching?"); ++mSubtreeModifiedDepth; if (aTarget) { // MayDispatchMutationEvent is often called just before this method, // so it has already appended the node to mSubtreeModifiedTargets. PRInt32 count = mSubtreeModifiedTargets.Count(); if (!count || mSubtreeModifiedTargets[count - 1] != aTarget) { mSubtreeModifiedTargets.AppendObject(aTarget); } } } void nsDocument::MutationEventDispatched(nsINode* aTarget) { --mSubtreeModifiedDepth; if (mSubtreeModifiedDepth == 0) { PRInt32 count = mSubtreeModifiedTargets.Count(); if (!count) { return; } nsCOMPtr window; window = do_QueryInterface(GetScriptGlobalObject()); if (window && !window->HasMutationListeners(NS_EVENT_BITS_MUTATION_SUBTREEMODIFIED)) { mSubtreeModifiedTargets.Clear(); return; } nsCOMArray realTargets; for (PRInt32 i = 0; i < count; ++i) { nsINode* possibleTarget = mSubtreeModifiedTargets[i]; nsCOMPtr content = do_QueryInterface(possibleTarget); if (content && content->IsInNativeAnonymousSubtree()) { continue; } nsINode* commonAncestor = nsnull; PRInt32 realTargetCount = realTargets.Count(); for (PRInt32 j = 0; j < realTargetCount; ++j) { commonAncestor = nsContentUtils::GetCommonAncestor(possibleTarget, realTargets[j]); if (commonAncestor) { realTargets.ReplaceObjectAt(commonAncestor, j); break; } } if (!commonAncestor) { realTargets.AppendObject(possibleTarget); } } mSubtreeModifiedTargets.Clear(); PRInt32 realTargetCount = realTargets.Count(); for (PRInt32 k = 0; k < realTargetCount; ++k) { mozAutoRemovableBlockerRemover blockerRemover; nsMutationEvent mutation(PR_TRUE, NS_MUTATION_SUBTREEMODIFIED); nsEventDispatcher::Dispatch(realTargets[k], nsnull, &mutation); } } } static PRUint32 GetURIHash(nsIURI* aURI) { nsCAutoString str; aURI->GetSpec(str); return HashString(str); } void nsDocument::AddStyleRelevantLink(nsIContent* aContent, nsIURI* aURI) { nsUint32ToContentHashEntry* entry = mLinkMap.PutEntry(GetURIHash(aURI)); if (!entry) // out of memory? return; entry->PutContent(aContent); } void nsDocument::ForgetLink(nsIContent* aContent) { // Important optimization! If the link map is empty (as it will be // during teardown because we destroy the map early), then stop // now before we waste time constructing a URI object. if (mLinkMap.Count() == 0) return; nsCOMPtr uri; if (!aContent->IsLink(getter_AddRefs(uri))) return; PRUint32 hash = GetURIHash(uri); nsUint32ToContentHashEntry* entry = mLinkMap.GetEntry(hash); if (!entry) return; entry->RemoveContent(aContent); if (entry->IsEmpty()) { // Remove the entry and allow the table to resize, in case // a lot of links are being removed from the document or modified mLinkMap.RemoveEntry(hash); } } class URIVisitNotifier : public nsUint32ToContentHashEntry::Visitor { public: nsCAutoString matchURISpec; nsCOMArray contentVisited; virtual void Visit(nsIContent* aContent) { // Ensure that the URIs really match before we try to do anything nsCOMPtr uri; if (!aContent->IsLink(getter_AddRefs(uri))) { NS_ERROR("Should have found a URI for content in the link map"); return; } nsCAutoString spec; uri->GetSpec(spec); // We use nsCString::Equals here instead of nsIURI::Equals because // history matching is all based on spec equality if (!spec.Equals(matchURISpec)) return; // Throw away the cached link state so it gets refetched by the style // system nsCOMPtr link = do_QueryInterface(aContent); if (link) { link->SetLinkState(eLinkState_Unknown); } contentVisited.AppendObject(aContent); } }; void nsDocument::NotifyURIVisitednessChanged(nsIURI* aURI) { if (!mVisible) { mVisitednessChangedURIs.AppendObject(aURI); return; } nsUint32ToContentHashEntry* entry = mLinkMap.GetEntry(GetURIHash(aURI)); if (!entry) return; URIVisitNotifier visitor; aURI->GetSpec(visitor.matchURISpec); entry->VisitContent(&visitor); for (PRUint32 count = visitor.contentVisited.Count(), i = 0; i < count; ++i) { ContentStatesChanged(visitor.contentVisited[i], nsnull, NS_EVENT_STATE_VISITED); } } void nsDocument::DestroyLinkMap() { mVisitednessChangedURIs.Clear(); mLinkMap.Clear(); } void nsDocument::UpdateLinkMap() { NS_ASSERTION(mVisible, "Should only be updating the link map in visible documents"); if (!mVisible) return; PRInt32 count = mVisitednessChangedURIs.Count(); for (PRInt32 i = 0; i < count; ++i) { NotifyURIVisitednessChanged(mVisitednessChangedURIs[i]); } mVisitednessChangedURIs.Clear(); } NS_IMETHODIMP nsDocument::GetScriptTypeID(PRUint32 *aScriptType) { NS_ERROR("No default script type here - ask some element"); return nsIProgrammingLanguage::UNKNOWN; } NS_IMETHODIMP nsDocument::SetScriptTypeID(PRUint32 aScriptType) { NS_ERROR("Can't change default script type for a document"); return NS_ERROR_NOT_IMPLEMENTED; } NS_IMETHODIMP nsDocument::QuerySelector(const nsAString& aSelector, nsIDOMElement **aReturn) { return nsGenericElement::doQuerySelector(this, aSelector, aReturn); } NS_IMETHODIMP nsDocument::QuerySelectorAll(const nsAString& aSelector, nsIDOMNodeList **aReturn) { return nsGenericElement::doQuerySelectorAll(this, aSelector, aReturn); }