/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- * * ***** 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 Communicator client code, released * March 31, 1998. * * 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): * * 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 ***** */ /* A namespace class for static content utilities. */ #ifndef nsContentUtils_h___ #define nsContentUtils_h___ #include #if defined(XP_WIN) || defined(XP_OS2) #include #endif #if defined(SOLARIS) #include #endif //A trick to handle IEEE floating point exceptions on FreeBSD - E.D. #ifdef __FreeBSD__ #include #ifdef __alpha__ static fp_except_t allmask = FP_X_INV|FP_X_OFL|FP_X_UFL|FP_X_DZ|FP_X_IMP; #else static fp_except_t allmask = FP_X_INV|FP_X_OFL|FP_X_UFL|FP_X_DZ|FP_X_IMP|FP_X_DNML; #endif static fp_except_t oldmask = fpsetmask(~allmask); #endif #include "nsAString.h" #include "nsIStatefulFrame.h" #include "nsINodeInfo.h" #include "nsNodeInfoManager.h" #include "nsContentList.h" #include "nsDOMClassInfoID.h" #include "nsIXPCScriptable.h" #include "nsDataHashtable.h" #include "nsIScriptRuntime.h" #include "nsIScriptGlobalObject.h" #include "nsIDOMEvent.h" #include "nsTArray.h" #include "nsTextFragment.h" #include "nsReadableUtils.h" #include "nsINode.h" #include "nsHashtable.h" #include "nsIDOMNode.h" #include "nsHtml5StringParser.h" #include "nsIParser.h" #include "nsIDocument.h" #include "nsIFragmentContentSink.h" #include "nsContentSink.h" #include "nsMathUtils.h" #include "nsThreadUtils.h" #include "nsIContent.h" #include "nsCharSeparatedTokenizer.h" #include "mozilla/AutoRestore.h" #include "mozilla/GuardObjects.h" #include "mozilla/TimeStamp.h" struct nsNativeKeyEvent; // Don't include nsINativeKeyBindings.h here: it will force strange compilation error! class nsIDOMScriptObjectFactory; class nsIXPConnect; class nsIContent; class nsIDOMKeyEvent; class nsIDocument; class nsIDocumentObserver; class nsIDocShell; class nsINameSpaceManager; class nsIScriptSecurityManager; class nsIJSContextStack; class nsIThreadJSContextStack; class nsIParserService; class nsIIOService; class nsIURI; class imgIContainer; class imgIDecoderObserver; class imgIRequest; class imgILoader; class imgICache; class nsIImageLoadingContent; class nsIDOMHTMLFormElement; class nsIDOMDocument; class nsIConsoleService; class nsIStringBundleService; class nsIStringBundle; class nsIContentPolicy; class nsILineBreaker; class nsIWordBreaker; class nsIJSRuntimeService; class nsEventListenerManager; class nsIScriptContext; class nsIRunnable; class nsIInterfaceRequestor; template class nsCOMArray; template class nsRefPtrHashtable; struct JSRuntime; class nsIWidget; class nsIDragSession; class nsIPresShell; class nsIXPConnectJSObjectHolder; #ifdef MOZ_XTF class nsIXTFService; #endif #ifdef IBMBIDI class nsIBidiKeyboard; #endif class nsIMIMEHeaderParam; class nsIObserver; class nsPresContext; class nsIChannel; class nsAutoScriptBlockerSuppressNodeRemoved; struct nsIntMargin; class nsPIDOMWindow; class nsIDocumentLoaderFactory; class nsIDOMHTMLInputElement; namespace mozilla { namespace layers { class LayerManager; } // namespace layers namespace dom { class Element; } // namespace dom } // namespace mozilla extern const char kLoadAsData[]; enum EventNameType { EventNameType_None = 0x0000, EventNameType_HTML = 0x0001, EventNameType_XUL = 0x0002, EventNameType_SVGGraphic = 0x0004, // svg graphic elements EventNameType_SVGSVG = 0x0008, // the svg element EventNameType_SMIL = 0x0016, // smil elements EventNameType_HTMLXUL = 0x0003, EventNameType_All = 0xFFFF }; /** * Information retrieved from the tag. See * GetViewportInfo for more information on this functionality. */ struct ViewportInfo { // Default zoom indicates the level at which the display is 'zoomed in' // initially for the user, upon loading of the page. double defaultZoom; // The minimum zoom level permitted by the page. double minZoom; // The maximum zoom level permitted by the page. double maxZoom; // The width of the viewport, specified by the tag, // in CSS pixels. PRUint32 width; // The height of the viewport, specified by the tag, // in CSS pixels. PRUint32 height; // Whether or not we should automatically size the viewport to the device's // width. This is true if the document has been optimized for mobile, and // the width property of a specified tag is either // not specified, or is set to the special value 'device-width'. bool autoSize; // Whether or not the user can zoom in and out on the page. Default is true. bool allowZoom; // This is a holdover from e10s fennec, and might be removed in the future. // It's a hack to work around bugs that didn't allow zooming of documents // from within the parent process. It is still used in native Fennec for XUL // documents, but it should probably be removed. // Currently, from, within GetViewportInfo(), This is only set to false // if the document is a XUL document. bool autoScale; }; struct EventNameMapping { nsIAtom* mAtom; PRUint32 mId; PRInt32 mType; PRUint32 mStructType; }; struct nsShortcutCandidate { nsShortcutCandidate(PRUint32 aCharCode, bool aIgnoreShift) : mCharCode(aCharCode), mIgnoreShift(aIgnoreShift) { } PRUint32 mCharCode; bool mIgnoreShift; }; class nsContentUtils { friend class nsAutoScriptBlockerSuppressNodeRemoved; typedef mozilla::dom::Element Element; typedef mozilla::TimeDuration TimeDuration; public: static nsresult Init(); /** * Get a JSContext from the document's scope object. */ static JSContext* GetContextFromDocument(nsIDocument *aDocument); /** * Get a scope from aNewDocument. Also get a context through the scope of one * of the documents, from the stack or the safe context. * * @param aOldDocument The document to try to get a context from. May be null. * @param aNewDocument The document to get aNewScope from. * @param aCx [out] Context gotten through one of the scopes, from the stack * or the safe context. * @param aNewScope [out] Scope gotten from aNewDocument. */ static nsresult GetContextAndScope(nsIDocument *aOldDocument, nsIDocument *aNewDocument, JSContext **aCx, JSObject **aNewScope); /** * When a document's scope changes (e.g., from document.open(), call this * function to move all content wrappers from the old scope to the new one. */ static nsresult ReparentContentWrappersInScope(JSContext *cx, nsIScriptGlobalObject *aOldScope, nsIScriptGlobalObject *aNewScope); static bool IsCallerChrome(); static bool IsCallerTrustedForRead(); static bool IsCallerTrustedForWrite(); /** * Check whether a caller has UniversalXPConnect. */ static bool CallerHasUniversalXPConnect(); static bool IsImageSrcSetDisabled(); /** * Returns the parent node of aChild crossing document boundaries. */ static nsINode* GetCrossDocParentNode(nsINode* aChild); /** * Do not ever pass null pointers to this method. If one of your * nsIContents is null, you have to decide for yourself what * "IsDescendantOf" really means. * * @param aPossibleDescendant node to test for being a descendant of * aPossibleAncestor * @param aPossibleAncestor node to test for being an ancestor of * aPossibleDescendant * @return true if aPossibleDescendant is a descendant of * aPossibleAncestor (or is aPossibleAncestor). false * otherwise. */ static bool ContentIsDescendantOf(const nsINode* aPossibleDescendant, const nsINode* aPossibleAncestor); /** * Similar to ContentIsDescendantOf except it crosses document boundaries. */ static bool ContentIsCrossDocDescendantOf(nsINode* aPossibleDescendant, nsINode* aPossibleAncestor); /* * This method fills the |aArray| with all ancestor nodes of |aNode| * including |aNode| at the zero index. */ static nsresult GetAncestors(nsINode* aNode, nsTArray& aArray); /* * This method fills |aAncestorNodes| with all ancestor nodes of |aNode| * including |aNode| (QI'd to nsIContent) at the zero index. * For each ancestor, there is a corresponding element in |aAncestorOffsets| * which is the IndexOf the child in relation to its parent. * * This method just sucks. */ static nsresult GetAncestorsAndOffsets(nsIDOMNode* aNode, PRInt32 aOffset, nsTArray* aAncestorNodes, nsTArray* aAncestorOffsets); /* * The out parameter, |aCommonAncestor| will be the closest node, if any, * to both |aNode| and |aOther| which is also an ancestor of each. * Returns an error if the two nodes are disconnected and don't have * a common ancestor. */ static nsresult GetCommonAncestor(nsIDOMNode *aNode, nsIDOMNode *aOther, nsIDOMNode** aCommonAncestor); /** * Returns the common ancestor, if any, for two nodes. Returns null if the * nodes are disconnected. */ static nsINode* GetCommonAncestor(nsINode* aNode1, nsINode* aNode2); /** * Returns true if aNode1 is before aNode2 in the same connected * tree. */ static bool PositionIsBefore(nsINode* aNode1, nsINode* aNode2) { return (aNode2->CompareDocPosition(aNode1) & (nsIDOMNode::DOCUMENT_POSITION_PRECEDING | nsIDOMNode::DOCUMENT_POSITION_DISCONNECTED)) == nsIDOMNode::DOCUMENT_POSITION_PRECEDING; } /** * Utility routine to compare two "points", where a point is a * node/offset pair * Returns -1 if point1 < point2, 1, if point1 > point2, * 0 if error or if point1 == point2. * NOTE! If the two nodes aren't in the same connected subtree, * the result is 1, and the optional aDisconnected parameter * is set to true. */ static PRInt32 ComparePoints(nsINode* aParent1, PRInt32 aOffset1, nsINode* aParent2, PRInt32 aOffset2, bool* aDisconnected = nsnull); static PRInt32 ComparePoints(nsIDOMNode* aParent1, PRInt32 aOffset1, nsIDOMNode* aParent2, PRInt32 aOffset2, bool* aDisconnected = nsnull); /** * Brute-force search of the element subtree rooted at aContent for * an element with the given id. aId must be nonempty, otherwise * this method may return nodes even if they have no id! */ static Element* MatchElementId(nsIContent *aContent, const nsAString& aId); /** * Similar to above, but to be used if one already has an atom for the ID */ static Element* MatchElementId(nsIContent *aContent, const nsIAtom* aId); /** * Reverses the document position flags passed in. * * @param aDocumentPosition The document position flags to be reversed. * * @return The reversed document position flags. * * @see nsIDOMNode */ static PRUint16 ReverseDocumentPosition(PRUint16 aDocumentPosition); static PRUint32 CopyNewlineNormalizedUnicodeTo(const nsAString& aSource, PRUint32 aSrcOffset, PRUnichar* aDest, PRUint32 aLength, bool& aLastCharCR); static PRUint32 CopyNewlineNormalizedUnicodeTo(nsReadingIterator& aSrcStart, const nsReadingIterator& aSrcEnd, nsAString& aDest); static nsISupports * GetClassInfoInstance(nsDOMClassInfoID aID); static const nsDependentSubstring TrimCharsInSet(const char* aSet, const nsAString& aValue); template static const nsDependentSubstring TrimWhitespace(const nsAString& aStr, bool aTrimTrailing = true); /** * Returns true if aChar is of class Ps, Pi, Po, Pf, or Pe. */ static bool IsPunctuationMark(PRUint32 aChar); static bool IsPunctuationMarkAt(const nsTextFragment* aFrag, PRUint32 aOffset); /** * Returns true if aChar is of class Lu, Ll, Lt, Lm, Lo, Nd, Nl or No */ static bool IsAlphanumeric(PRUint32 aChar); static bool IsAlphanumericAt(const nsTextFragment* aFrag, PRUint32 aOffset); /* * Is the character an HTML whitespace character? * * We define whitespace using the list in HTML5 and css3-selectors: * U+0009, U+000A, U+000C, U+000D, U+0020 * * HTML 4.01 also lists U+200B (zero-width space). */ static bool IsHTMLWhitespace(PRUnichar aChar); /** * Parse a margin string of format 'top, right, bottom, left' into * an nsIntMargin. * * @param aString the string to parse * @param aResult the resulting integer * @return whether the value could be parsed */ static bool ParseIntMarginValue(const nsAString& aString, nsIntMargin& aResult); static void Shutdown(); /** * Checks whether two nodes come from the same origin. */ static nsresult CheckSameOrigin(nsINode* aTrustedNode, nsIDOMNode* aUnTrustedNode); // Check if the (JS) caller can access aNode. static bool CanCallerAccess(nsIDOMNode *aNode); // Check if the (JS) caller can access aWindow. // aWindow can be either outer or inner window. static bool CanCallerAccess(nsPIDOMWindow* aWindow); /** * Get the window through the JS context that's currently on the stack. * If there's no JS context currently on the stack, returns null. */ static nsPIDOMWindow *GetWindowFromCaller(); /** * The two GetDocumentFrom* functions below allow a caller to get at a * document that is relevant to the currently executing script. * * GetDocumentFromCaller gets its document by looking at the last called * function and finding the document that the function itself relates to. * For example, consider two windows A and B in the same origin. B has a * function which does something that ends up needing the current document. * If a script in window A were to call B's function, GetDocumentFromCaller * would find that function (in B) and return B's document. * * GetDocumentFromContext gets its document by looking at the currently * executing context's global object and returning its document. Thus, * given the example above, GetDocumentFromCaller would see that the * currently executing script was in window A, and return A's document. */ /** * Get the document from the currently executing function. This will return * the document that the currently executing function is in/from. * * @return The document or null if no JS Context. */ static nsIDOMDocument *GetDocumentFromCaller(); /** * Get the document through the JS context that's currently on the stack. * If there's no JS context currently on the stack it will return null. * This will return the document of the calling script. * * @return The document or null if no JS context */ static nsIDOMDocument *GetDocumentFromContext(); // Check if a node is in the document prolog, i.e. before the document // element. static bool InProlog(nsINode *aNode); static nsIParserService* GetParserService(); static nsINameSpaceManager* NameSpaceManager() { return sNameSpaceManager; } static nsIIOService* GetIOService() { return sIOService; } static imgILoader* GetImgLoader() { if (!sImgLoaderInitialized) InitImgLoader(); return sImgLoader; } #ifdef MOZ_XTF static nsIXTFService* GetXTFService(); #endif #ifdef IBMBIDI static nsIBidiKeyboard* GetBidiKeyboard(); #endif /** * Get the cache security manager service. Can return null if the layout * module has been shut down. */ static nsIScriptSecurityManager* GetSecurityManager() { return sSecurityManager; } static nsresult GenerateStateKey(nsIContent* aContent, const nsIDocument* aDocument, nsIStatefulFrame::SpecialStateID aID, nsACString& aKey); /** * Create a new nsIURI from aSpec, using aBaseURI as the base. The * origin charset of the new nsIURI will be the document charset of * aDocument. */ static nsresult NewURIWithDocumentCharset(nsIURI** aResult, const nsAString& aSpec, nsIDocument* aDocument, nsIURI* aBaseURI); /** * Convert aInput (in charset aCharset) to UTF16 in aOutput. * * @param aCharset the name of the charset; if empty, we assume UTF8 */ static nsresult ConvertStringFromCharset(const nsACString& aCharset, const nsACString& aInput, nsAString& aOutput); /** * Determine whether a buffer begins with a BOM for UTF-8, UTF-16LE, * UTF-16BE * * @param aBuffer the buffer to check * @param aLength the length of the buffer * @param aCharset empty if not found * @return boolean indicating whether a BOM was detected. */ static bool CheckForBOM(const unsigned char* aBuffer, PRUint32 aLength, nsACString& aCharset, bool *bigEndian = nsnull); /** * Determine whether aContent is in some way associated with aForm. If the * form is a container the only elements that are considered to be associated * with a form are the elements that are contained within the form. If the * form is a leaf element then all elements will be accepted into this list, * since this can happen due to content fixup when a form spans table rows or * table cells. */ static bool BelongsInForm(nsIContent *aForm, nsIContent *aContent); static nsresult CheckQName(const nsAString& aQualifiedName, bool aNamespaceAware = true); static nsresult SplitQName(const nsIContent* aNamespaceResolver, const nsAFlatString& aQName, PRInt32 *aNamespace, nsIAtom **aLocalName); static nsresult GetNodeInfoFromQName(const nsAString& aNamespaceURI, const nsAString& aQualifiedName, nsNodeInfoManager* aNodeInfoManager, PRUint16 aNodeType, nsINodeInfo** aNodeInfo); static void SplitExpatName(const PRUnichar *aExpatName, nsIAtom **aPrefix, nsIAtom **aTagName, PRInt32 *aNameSpaceID); // Get a permission-manager setting for the given uri and type. // If the pref doesn't exist or if it isn't ALLOW_ACTION, false is // returned, otherwise true is returned. static bool IsSitePermAllow(nsIURI* aURI, const char* aType); static nsILineBreaker* LineBreaker() { return sLineBreaker; } static nsIWordBreaker* WordBreaker() { return sWordBreaker; } /** * Regster aObserver as a shutdown observer. A strong reference is held * to aObserver until UnregisterShutdownObserver is called. */ static void RegisterShutdownObserver(nsIObserver* aObserver); static void UnregisterShutdownObserver(nsIObserver* aObserver); /** * @return true if aContent has an attribute aName in namespace aNameSpaceID, * and the attribute value is non-empty. */ static bool HasNonEmptyAttr(const nsIContent* aContent, PRInt32 aNameSpaceID, nsIAtom* aName); /** * Method that gets the primary presContext for the node. * * @param aContent The content node. * @return the presContext, or nsnull if the content is not in a document * (if GetCurrentDoc returns nsnull) */ static nsPresContext* GetContextForContent(const nsIContent* aContent); /** * Method to do security and content policy checks on the image URI * * @param aURI uri of the image to be loaded * @param aContext the context the image is loaded in (eg an element) * @param aLoadingDocument the document we belong to * @param aLoadingPrincipal the principal doing the load * @param aImageBlockingStatus the nsIContentPolicy blocking status for this * image. This will be set even if a security check fails for the * image, to some reasonable REJECT_* value. This out param will only * be set if it's non-null. * @return true if the load can proceed, or false if it is blocked. * Note that aImageBlockingStatus, if set will always be an ACCEPT * status if true is returned and always be a REJECT_* status if * false is returned. */ static bool CanLoadImage(nsIURI* aURI, nsISupports* aContext, nsIDocument* aLoadingDocument, nsIPrincipal* aLoadingPrincipal, PRInt16* aImageBlockingStatus = nsnull); /** * Method to start an image load. This does not do any security checks. * This method will attempt to make aURI immutable; a caller that wants to * keep a mutable version around should pass in a clone. * * @param aURI uri of the image to be loaded * @param aLoadingDocument the document we belong to * @param aLoadingPrincipal the principal doing the load * @param aReferrer the referrer URI * @param aObserver the observer for the image load * @param aLoadFlags the load flags to use. See nsIRequest * @return the imgIRequest for the image load */ static nsresult LoadImage(nsIURI* aURI, nsIDocument* aLoadingDocument, nsIPrincipal* aLoadingPrincipal, nsIURI* aReferrer, imgIDecoderObserver* aObserver, PRInt32 aLoadFlags, imgIRequest** aRequest); /** * Returns whether the given URI is in the image cache. */ static bool IsImageInCache(nsIURI* aURI); /** * Method to get an imgIContainer from an image loading content * * @param aContent The image loading content. Must not be null. * @param aRequest The image request [out] * @return the imgIContainer corresponding to the first frame of the image */ static already_AddRefed GetImageFromContent(nsIImageLoadingContent* aContent, imgIRequest **aRequest = nsnull); /** * Helper method to call imgIRequest::GetStaticRequest. */ static already_AddRefed GetStaticRequest(imgIRequest* aRequest); /** * Method that decides whether a content node is draggable * * @param aContent The content node to test. * @return whether it's draggable */ static bool ContentIsDraggable(nsIContent* aContent); /** * Method that decides whether a content node is a draggable image * * @param aContent The content node to test. * @return whether it's a draggable image */ static bool IsDraggableImage(nsIContent* aContent); /** * Method that decides whether a content node is a draggable link * * @param aContent The content node to test. * @return whether it's a draggable link */ static bool IsDraggableLink(const nsIContent* aContent); /** * Convenience method to create a new nodeinfo that differs only by name * from aNodeInfo. */ static nsresult NameChanged(nsINodeInfo *aNodeInfo, nsIAtom *aName, nsINodeInfo** aResult) { nsNodeInfoManager *niMgr = aNodeInfo->NodeInfoManager(); *aResult = niMgr->GetNodeInfo(aName, aNodeInfo->GetPrefixAtom(), aNodeInfo->NamespaceID(), aNodeInfo->NodeType(), aNodeInfo->GetExtraName()).get(); return *aResult ? NS_OK : NS_ERROR_OUT_OF_MEMORY; } /** * Returns the appropriate event argument names for the specified * namespace and event name. Added because we need to switch between * SVG's "evt" and the rest of the world's "event", and because onerror * takes 3 args. */ static void GetEventArgNames(PRInt32 aNameSpaceID, nsIAtom *aEventName, PRUint32 *aArgCount, const char*** aArgNames); /** * If aNode is not an element, return true exactly when aContent's binding * parent is null. * * If aNode is an element, return true exactly when aContent's binding parent * is the same as aNode's. * * This method is particularly useful for callers who are trying to ensure * that they are working with a non-anonymous descendant of a given node. If * aContent is a descendant of aNode, a return value of false from this * method means that it's an anonymous descendant from aNode's point of view. * * Both arguments to this method must be non-null. */ static bool IsInSameAnonymousTree(const nsINode* aNode, const nsIContent* aContent); /** * Return the nsIXPConnect service. */ static nsIXPConnect *XPConnect() { return sXPConnect; } /** * Report a localized error message to the error console. * @param aErrorFlags See nsIScriptError. * @param aCategory Name of module reporting error. * @param aDocument Reference to the document which triggered the message. * @param aFile Properties file containing localized message. * @param aMessageName Name of localized message. * @param [aParams=nsnull] (Optional) Parameters to be substituted into localized message. * @param [aParamsLength=0] (Optional) Length of aParams. * @param [aURI=nsnull] (Optional) URI of resource containing error. * @param [aSourceLine=EmptyString()] (Optional) The text of the line that contains the error (may be empty). * @param [aLineNumber=0] (Optional) Line number within resource containing error. * @param [aColumnNumber=0] (Optional) Column number within resource containing error. If aURI is null, then aDocument->GetDocumentURI() is used. */ enum PropertiesFile { eCSS_PROPERTIES, eXBL_PROPERTIES, eXUL_PROPERTIES, eLAYOUT_PROPERTIES, eFORMS_PROPERTIES, ePRINTING_PROPERTIES, eDOM_PROPERTIES, eHTMLPARSER_PROPERTIES, eSVG_PROPERTIES, eBRAND_PROPERTIES, eCOMMON_DIALOG_PROPERTIES, PropertiesFile_COUNT }; static nsresult ReportToConsole(PRUint32 aErrorFlags, const char *aCategory, nsIDocument* aDocument, PropertiesFile aFile, const char *aMessageName, const PRUnichar **aParams = nsnull, PRUint32 aParamsLength = 0, nsIURI* aURI = nsnull, const nsAFlatString& aSourceLine = EmptyString(), PRUint32 aLineNumber = 0, PRUint32 aColumnNumber = 0); /** * Get the localized string named |aKey| in properties file |aFile|. */ static nsresult GetLocalizedString(PropertiesFile aFile, const char* aKey, nsXPIDLString& aResult); /** * Fill (with the parameters given) the localized string named |aKey| in * properties file |aFile|. */ static nsresult FormatLocalizedString(PropertiesFile aFile, const char* aKey, const PRUnichar **aParams, PRUint32 aParamsLength, nsXPIDLString& aResult); /** * Returns true if aDocument is a chrome document */ static bool IsChromeDoc(nsIDocument *aDocument); /** * Returns true if aDocument is in a docshell whose parent is the same type */ static bool IsChildOfSameType(nsIDocument* aDoc); /** * Get the script file name to use when compiling the script * referenced by aURI. In cases where there's no need for any extra * security wrapper automation the script file name that's returned * will be the spec in aURI, else it will be the spec in aDocument's * URI followed by aURI's spec, separated by " -> ". Returns true * if the script file name was modified, false if it's aURI's * spec. */ static bool GetWrapperSafeScriptFilename(nsIDocument *aDocument, nsIURI *aURI, nsACString& aScriptURI); /** * Returns true if aDocument belongs to a chrome docshell for * display purposes. Returns false for null documents or documents * which do not belong to a docshell. */ static bool IsInChromeDocshell(nsIDocument *aDocument); /** * Return the content policy service */ static nsIContentPolicy *GetContentPolicy(); /** * Quick helper to determine whether there are any mutation listeners * of a given type that apply to this content or any of its ancestors. * The method has the side effect to call document's MayDispatchMutationEvent * using aTargetForSubtreeModified as the parameter. * * @param aNode The node to search for listeners * @param aType The type of listener (NS_EVENT_BITS_MUTATION_*) * @param aTargetForSubtreeModified The node which is the target of the * possible DOMSubtreeModified event. * * @return true if there are mutation listeners of the specified type */ static bool HasMutationListeners(nsINode* aNode, PRUint32 aType, nsINode* aTargetForSubtreeModified); /** * Quick helper to determine whether there are any mutation listeners * of a given type that apply to any content in this document. It is valid * to pass null for aDocument here, in which case this function always * returns true. * * @param aDocument The document to search for listeners * @param aType The type of listener (NS_EVENT_BITS_MUTATION_*) * * @return true if there are mutation listeners of the specified type */ static bool HasMutationListeners(nsIDocument* aDocument, PRUint32 aType); /** * Synchronously fire DOMNodeRemoved on aChild. Only fires the event if * there really are listeners by checking using the HasMutationListeners * function above. The function makes sure to hold the relevant objects alive * for the duration of the event firing. However there are no guarantees * that any of the objects are alive by the time the function returns. * If you depend on that you need to hold references yourself. * * @param aChild The node to fire DOMNodeRemoved at. * @param aParent The parent of aChild. * @param aOwnerDoc The ownerDocument of aChild. */ static void MaybeFireNodeRemoved(nsINode* aChild, nsINode* aParent, nsIDocument* aOwnerDoc); /** * This method creates and dispatches a trusted event. * Works only with events which can be created by calling * nsIDOMDocument::CreateEvent() with parameter "Events". * @param aDoc The document which will be used to create the event. * @param aTarget The target of the event, should be QIable to * nsIDOMEventTarget. * @param aEventName The name of the event. * @param aCanBubble Whether the event can bubble. * @param aCancelable Is the event cancelable. * @param aDefaultAction Set to true if default action should be taken, * see nsIDOMEventTarget::DispatchEvent. */ static nsresult DispatchTrustedEvent(nsIDocument* aDoc, nsISupports* aTarget, const nsAString& aEventName, bool aCanBubble, bool aCancelable, bool *aDefaultAction = nsnull); /** * This method creates and dispatches a untrusted event. * Works only with events which can be created by calling * nsIDOMDocument::CreateEvent() with parameter "Events". * @param aDoc The document which will be used to create the event. * @param aTarget The target of the event, should be QIable to * nsIDOMEventTarget. * @param aEventName The name of the event. * @param aCanBubble Whether the event can bubble. * @param aCancelable Is the event cancelable. * @param aDefaultAction Set to true if default action should be taken, * see nsIDOMEventTarget::DispatchEvent. */ static nsresult DispatchUntrustedEvent(nsIDocument* aDoc, nsISupports* aTarget, const nsAString& aEventName, bool aCanBubble, bool aCancelable, bool *aDefaultAction = nsnull); /** * This method creates and dispatches a trusted event to the chrome * event handler. * Works only with events which can be created by calling * nsIDOMDocument::CreateEvent() with parameter "Events". * @param aDocument The document which will be used to create the event, * and whose window's chrome handler will be used to * dispatch the event. * @param aTarget The target of the event, used for event->SetTarget() * @param aEventName The name of the event. * @param aCanBubble Whether the event can bubble. * @param aCancelable Is the event cancelable. * @param aDefaultAction Set to true if default action should be taken, * see nsIDOMEventTarget::DispatchEvent. */ static nsresult DispatchChromeEvent(nsIDocument* aDoc, nsISupports* aTarget, const nsAString& aEventName, bool aCanBubble, bool aCancelable, bool *aDefaultAction = nsnull); /** * Determines if an event attribute name (such as onclick) is valid for * a given element type. Types are from the EventNameType enumeration * defined above. * * @param aName the event name to look up * @param aType the type of content */ static bool IsEventAttributeName(nsIAtom* aName, PRInt32 aType); /** * Return the event id for the event with the given name. The name is the * event name with the 'on' prefix. Returns NS_USER_DEFINED_EVENT if the * event doesn't match a known event name. * * @param aName the event name to look up */ static PRUint32 GetEventId(nsIAtom* aName); /** * Return the category for the event with the given name. The name is the * event name *without* the 'on' prefix. Returns NS_EVENT if the event * is not known to be in any particular category. * * @param aName the event name to look up */ static PRUint32 GetEventCategory(const nsAString& aName); /** * Return the event id and atom for the event with the given name. * The name is the event name *without* the 'on' prefix. * Returns NS_USER_DEFINED_EVENT on the aEventID if the * event doesn't match a known event name in the category. * * @param aName the event name to look up * @param aEventStruct only return event id in aEventStruct category */ static nsIAtom* GetEventIdAndAtom(const nsAString& aName, PRUint32 aEventStruct, PRUint32* aEventID); /** * Used only during traversal of the XPCOM graph by the cycle * collector: push a pointer to the listener manager onto the * children deque, if it exists. Do nothing if there is no listener * manager. * * Crucially: does not perform any refcounting operations. * * @param aNode The node to traverse. * @param children The buffer to push a listener manager pointer into. */ static void TraverseListenerManager(nsINode *aNode, nsCycleCollectionTraversalCallback &cb); /** * Get the eventlistener manager for aNode. If a new eventlistener manager * was created, aCreated is set to true. * * @param aNode The node for which to get the eventlistener manager. * @param aCreateIfNotFound If false, returns a listener manager only if * one already exists. */ static nsEventListenerManager* GetListenerManager(nsINode* aNode, bool aCreateIfNotFound); static void UnmarkGrayJSListenersInCCGenerationDocuments(PRUint32 aGeneration); /** * Remove the eventlistener manager for aNode. * * @param aNode The node for which to remove the eventlistener manager. */ static void RemoveListenerManager(nsINode *aNode); static bool IsInitialized() { return sInitialized; } /** * Checks if the localname/prefix/namespace triple is valid wrt prefix * and namespace according to the Namespaces in XML and DOM Code * specfications. * * @param aLocalname localname of the node * @param aPrefix prefix of the node * @param aNamespaceID namespace of the node */ static bool IsValidNodeName(nsIAtom *aLocalName, nsIAtom *aPrefix, PRInt32 aNamespaceID); /** * Creates a DocumentFragment from text using a context node to resolve * namespaces. * * Note! In the HTML case with the HTML5 parser enabled, this is only called * from Range.createContextualFragment() and the implementation here is * quirky accordingly (html context node behaves like a body context node). * If you don't want that quirky behavior, don't use this method as-is! * * @param aContextNode the node which is used to resolve namespaces * @param aFragment the string which is parsed to a DocumentFragment * @param aReturn the resulting fragment * @param aPreventScriptExecution whether to mark scripts as already started */ static nsresult CreateContextualFragment(nsINode* aContextNode, const nsAString& aFragment, bool aPreventScriptExecution, nsIDOMDocumentFragment** aReturn); /** * Invoke the fragment parsing algorithm (innerHTML) using the HTML parser. * * @param aSourceBuffer the string being set as innerHTML * @param aTargetNode the target container * @param aContextLocalName local name of context node * @param aContextNamespace namespace of context node * @param aQuirks true to make not close

* @param aPreventScriptExecution true to prevent scripts from executing; * don't set to false when parsing into a target node that has been * bound to tree. * @return NS_ERROR_DOM_INVALID_STATE_ERR if a re-entrant attempt to parse * fragments is made, NS_ERROR_OUT_OF_MEMORY if aSourceBuffer is too * long and NS_OK otherwise. */ static nsresult ParseFragmentHTML(const nsAString& aSourceBuffer, nsIContent* aTargetNode, nsIAtom* aContextLocalName, PRInt32 aContextNamespace, bool aQuirks, bool aPreventScriptExecution); /** * Invoke the fragment parsing algorithm (innerHTML) using the XML parser. * * @param aSourceBuffer the string being set as innerHTML * @param aTargetNode the target container * @param aTagStack the namespace mapping context * @param aPreventExecution whether to mark scripts as already started * @param aReturn the result fragment * @return NS_ERROR_DOM_INVALID_STATE_ERR if a re-entrant attempt to parse * fragments is made, a return code from the XML parser. */ static nsresult ParseFragmentXML(const nsAString& aSourceBuffer, nsIDocument* aDocument, nsTArray& aTagStack, bool aPreventScriptExecution, nsIDOMDocumentFragment** aReturn); /** * Parse a string into a document using the HTML parser. * Script elements are marked unexecutable. * * @param aSourceBuffer the string to parse as an HTML document * @param aTargetDocument the document object to parse into. Must not have * child nodes. * @param aScriptingEnabledForNoscriptParsing whether