michael@0: /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
michael@0:  *
michael@0:  * This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: /* A namespace class for static content utilities. */
michael@0: 
michael@0: #ifndef nsContentUtils_h___
michael@0: #define nsContentUtils_h___
michael@0: 
michael@0: #if defined(XP_WIN)
michael@0: #include <float.h>
michael@0: #endif
michael@0: 
michael@0: #if defined(SOLARIS)
michael@0: #include <ieeefp.h>
michael@0: #endif
michael@0: 
michael@0: #include "js/TypeDecls.h"
michael@0: #include "js/Value.h"
michael@0: #include "js/RootingAPI.h"
michael@0: #include "mozilla/EventForwards.h"
michael@0: #include "mozilla/GuardObjects.h"
michael@0: #include "mozilla/TimeStamp.h"
michael@0: #include "nsContentListDeclarations.h"
michael@0: #include "nsMathUtils.h"
michael@0: #include "nsTArrayForwardDeclare.h"
michael@0: #include "Units.h"
michael@0: 
michael@0: #if defined(XP_WIN)
michael@0: // Undefine LoadImage to prevent naming conflict with Windows.
michael@0: #undef LoadImage
michael@0: #endif
michael@0: 
michael@0: class imgICache;
michael@0: class imgIContainer;
michael@0: class imgINotificationObserver;
michael@0: class imgIRequest;
michael@0: class imgLoader;
michael@0: class imgRequestProxy;
michael@0: class nsAutoScriptBlockerSuppressNodeRemoved;
michael@0: class nsHtml5StringParser;
michael@0: class nsIChannel;
michael@0: class nsIConsoleService;
michael@0: class nsIContent;
michael@0: class nsIContentPolicy;
michael@0: class nsIContentSecurityPolicy;
michael@0: class nsIDocShell;
michael@0: class nsIDocument;
michael@0: class nsIDocumentLoaderFactory;
michael@0: class nsIDocumentObserver;
michael@0: class nsIDOMDocument;
michael@0: class nsIDOMDocumentFragment;
michael@0: class nsIDOMEvent;
michael@0: class nsIDOMHTMLFormElement;
michael@0: class nsIDOMHTMLInputElement;
michael@0: class nsIDOMKeyEvent;
michael@0: class nsIDOMNode;
michael@0: class nsIDOMScriptObjectFactory;
michael@0: class nsIDOMWindow;
michael@0: class nsIDragSession;
michael@0: class nsIEditor;
michael@0: class nsIFragmentContentSink;
michael@0: class nsIFrame;
michael@0: class nsIImageLoadingContent;
michael@0: class nsIInterfaceRequestor;
michael@0: class nsIIOService;
michael@0: class nsIJSRuntimeService;
michael@0: class nsILineBreaker;
michael@0: class nsNameSpaceManager;
michael@0: class nsINodeInfo;
michael@0: class nsIObserver;
michael@0: class nsIParser;
michael@0: class nsIParserService;
michael@0: class nsIPresShell;
michael@0: class nsIPrincipal;
michael@0: class nsIRunnable;
michael@0: class nsIScriptContext;
michael@0: class nsIScriptGlobalObject;
michael@0: class nsIScriptSecurityManager;
michael@0: class nsIStringBundle;
michael@0: class nsIStringBundleService;
michael@0: class nsISupportsHashKey;
michael@0: class nsIURI;
michael@0: class nsIWidget;
michael@0: class nsIWordBreaker;
michael@0: class nsIXPConnect;
michael@0: class nsNodeInfoManager;
michael@0: class nsPIDOMWindow;
michael@0: class nsPresContext;
michael@0: class nsScriptObjectTracer;
michael@0: class nsStringBuffer;
michael@0: class nsStringHashKey;
michael@0: class nsTextFragment;
michael@0: class nsViewportInfo;
michael@0: class nsWrapperCache;
michael@0: class nsAttrValue;
michael@0: 
michael@0: struct JSPropertyDescriptor;
michael@0: struct JSRuntime;
michael@0: struct nsIntMargin;
michael@0: 
michael@0: template<class E> class nsCOMArray;
michael@0: template<class K, class V> class nsDataHashtable;
michael@0: template<class K, class V> class nsRefPtrHashtable;
michael@0: template<class T> class nsReadingIterator;
michael@0: 
michael@0: namespace mozilla {
michael@0: class ErrorResult;
michael@0: class EventListenerManager;
michael@0: 
michael@0: namespace dom {
michael@0: class DocumentFragment;
michael@0: class Element;
michael@0: class EventTarget;
michael@0: class Selection;
michael@0: } // namespace dom
michael@0: 
michael@0: namespace layers {
michael@0: class LayerManager;
michael@0: } // namespace layers
michael@0: 
michael@0: // Called back from DeferredFinalize.  Should add 'thing' to the array of smart
michael@0: // pointers in 'pointers', creating the array if 'pointers' is null, and return
michael@0: // the array.
michael@0: typedef void* (*DeferredFinalizeAppendFunction)(void* pointers, void* thing);
michael@0: 
michael@0: // Called to finalize a number of objects. Slice is the number of objects
michael@0: // to finalize, or if it's UINT32_MAX, all objects should be finalized.
michael@0: // Return value indicates whether it finalized all objects in the buffer.
michael@0: typedef bool (*DeferredFinalizeFunction)(uint32_t slice, void* data);
michael@0: 
michael@0: } // namespace mozilla
michael@0: 
michael@0: class nsIBidiKeyboard;
michael@0: 
michael@0: extern const char kLoadAsData[];
michael@0: 
michael@0: // Stolen from nsReadableUtils, but that's OK, since we can declare the same
michael@0: // name multiple times.
michael@0: const nsAFlatString& EmptyString();
michael@0: const nsAFlatCString& EmptyCString();
michael@0: 
michael@0: enum EventNameType {
michael@0:   EventNameType_None = 0x0000,
michael@0:   EventNameType_HTML = 0x0001,
michael@0:   EventNameType_XUL = 0x0002,
michael@0:   EventNameType_SVGGraphic = 0x0004, // svg graphic elements
michael@0:   EventNameType_SVGSVG = 0x0008, // the svg element
michael@0:   EventNameType_SMIL = 0x0010, // smil elements
michael@0:   EventNameType_HTMLBodyOrFramesetOnly = 0x0020,
michael@0: 
michael@0:   EventNameType_HTMLXUL = 0x0003,
michael@0:   EventNameType_All = 0xFFFF
michael@0: };
michael@0: 
michael@0: struct EventNameMapping
michael@0: {
michael@0:   nsIAtom* mAtom;
michael@0:   uint32_t mId;
michael@0:   int32_t  mType;
michael@0:   uint32_t mStructType;
michael@0: };
michael@0: 
michael@0: struct nsShortcutCandidate {
michael@0:   nsShortcutCandidate(uint32_t aCharCode, bool aIgnoreShift) :
michael@0:     mCharCode(aCharCode), mIgnoreShift(aIgnoreShift)
michael@0:   {
michael@0:   }
michael@0:   uint32_t mCharCode;
michael@0:   bool     mIgnoreShift;
michael@0: };
michael@0: 
michael@0: class nsContentUtils
michael@0: {
michael@0:   friend class nsAutoScriptBlockerSuppressNodeRemoved;
michael@0:   typedef mozilla::dom::Element Element;
michael@0:   typedef mozilla::TimeDuration TimeDuration;
michael@0: 
michael@0: public:
michael@0:   static nsresult Init();
michael@0: 
michael@0:   /**
michael@0:    * Get a JSContext from the document's scope object.
michael@0:    */
michael@0:   static JSContext* GetContextFromDocument(nsIDocument *aDocument);
michael@0: 
michael@0:   static bool     IsCallerChrome();
michael@0:   static bool     ThreadsafeIsCallerChrome();
michael@0:   static bool     IsCallerXBL();
michael@0: 
michael@0:   static bool     IsImageSrcSetDisabled();
michael@0: 
michael@0:   static bool LookupBindingMember(JSContext* aCx, nsIContent *aContent,
michael@0:                                   JS::Handle<jsid> aId,
michael@0:                                   JS::MutableHandle<JSPropertyDescriptor> aDesc);
michael@0: 
michael@0:   /**
michael@0:    * Returns the parent node of aChild crossing document boundaries.
michael@0:    */
michael@0:   static nsINode* GetCrossDocParentNode(nsINode* aChild);
michael@0: 
michael@0:   /**
michael@0:    * Do not ever pass null pointers to this method.  If one of your
michael@0:    * nsIContents is null, you have to decide for yourself what
michael@0:    * "IsDescendantOf" really means.
michael@0:    *
michael@0:    * @param  aPossibleDescendant node to test for being a descendant of
michael@0:    *         aPossibleAncestor
michael@0:    * @param  aPossibleAncestor node to test for being an ancestor of
michael@0:    *         aPossibleDescendant
michael@0:    * @return true if aPossibleDescendant is a descendant of
michael@0:    *         aPossibleAncestor (or is aPossibleAncestor).  false
michael@0:    *         otherwise.
michael@0:    */
michael@0:   static bool ContentIsDescendantOf(const nsINode* aPossibleDescendant,
michael@0:                                       const nsINode* aPossibleAncestor);
michael@0: 
michael@0:   /**
michael@0:    * Similar to ContentIsDescendantOf, except will treat an HTMLTemplateElement
michael@0:    * or ShadowRoot as an ancestor of things in the corresponding DocumentFragment.
michael@0:    * See the concept of "host-including inclusive ancestor" in the DOM
michael@0:    * specification.
michael@0:    */
michael@0:   static bool ContentIsHostIncludingDescendantOf(
michael@0:     const nsINode* aPossibleDescendant, const nsINode* aPossibleAncestor);
michael@0: 
michael@0:   /**
michael@0:    * Similar to ContentIsDescendantOf except it crosses document boundaries.
michael@0:    */
michael@0:   static bool ContentIsCrossDocDescendantOf(nsINode* aPossibleDescendant,
michael@0:                                               nsINode* aPossibleAncestor);
michael@0: 
michael@0:   /*
michael@0:    * This method fills the |aArray| with all ancestor nodes of |aNode|
michael@0:    * including |aNode| at the zero index.
michael@0:    */
michael@0:   static nsresult GetAncestors(nsINode* aNode,
michael@0:                                nsTArray<nsINode*>& aArray);
michael@0: 
michael@0:   /*
michael@0:    * This method fills |aAncestorNodes| with all ancestor nodes of |aNode|
michael@0:    * including |aNode| (QI'd to nsIContent) at the zero index.
michael@0:    * For each ancestor, there is a corresponding element in |aAncestorOffsets|
michael@0:    * which is the IndexOf the child in relation to its parent.
michael@0:    *
michael@0:    * This method just sucks.
michael@0:    */
michael@0:   static nsresult GetAncestorsAndOffsets(nsIDOMNode* aNode,
michael@0:                                          int32_t aOffset,
michael@0:                                          nsTArray<nsIContent*>* aAncestorNodes,
michael@0:                                          nsTArray<int32_t>* aAncestorOffsets);
michael@0: 
michael@0:   /*
michael@0:    * The out parameter, |aCommonAncestor| will be the closest node, if any,
michael@0:    * to both |aNode| and |aOther| which is also an ancestor of each.
michael@0:    * Returns an error if the two nodes are disconnected and don't have
michael@0:    * a common ancestor.
michael@0:    */
michael@0:   static nsresult GetCommonAncestor(nsIDOMNode *aNode,
michael@0:                                     nsIDOMNode *aOther,
michael@0:                                     nsIDOMNode** aCommonAncestor);
michael@0: 
michael@0:   /**
michael@0:    * Returns the common ancestor, if any, for two nodes. Returns null if the
michael@0:    * nodes are disconnected.
michael@0:    */
michael@0:   static nsINode* GetCommonAncestor(nsINode* aNode1,
michael@0:                                     nsINode* aNode2);
michael@0: 
michael@0:   /**
michael@0:    * Returns true if aNode1 is before aNode2 in the same connected
michael@0:    * tree.
michael@0:    */
michael@0:   static bool PositionIsBefore(nsINode* aNode1, nsINode* aNode2);
michael@0: 
michael@0:   /**
michael@0:    *  Utility routine to compare two "points", where a point is a
michael@0:    *  node/offset pair
michael@0:    *  Returns -1 if point1 < point2, 1, if point1 > point2,
michael@0:    *  0 if error or if point1 == point2.
michael@0:    *  NOTE! If the two nodes aren't in the same connected subtree,
michael@0:    *  the result is 1, and the optional aDisconnected parameter
michael@0:    *  is set to true.
michael@0:    */
michael@0:   static int32_t ComparePoints(nsINode* aParent1, int32_t aOffset1,
michael@0:                                nsINode* aParent2, int32_t aOffset2,
michael@0:                                bool* aDisconnected = nullptr);
michael@0:   static int32_t ComparePoints(nsIDOMNode* aParent1, int32_t aOffset1,
michael@0:                                nsIDOMNode* aParent2, int32_t aOffset2,
michael@0:                                bool* aDisconnected = nullptr);
michael@0: 
michael@0:   /**
michael@0:    * Brute-force search of the element subtree rooted at aContent for
michael@0:    * an element with the given id.  aId must be nonempty, otherwise
michael@0:    * this method may return nodes even if they have no id!
michael@0:    */
michael@0:   static Element* MatchElementId(nsIContent *aContent, const nsAString& aId);
michael@0: 
michael@0:   /**
michael@0:    * Similar to above, but to be used if one already has an atom for the ID
michael@0:    */
michael@0:   static Element* MatchElementId(nsIContent *aContent, const nsIAtom* aId);
michael@0: 
michael@0:   /**
michael@0:    * Reverses the document position flags passed in.
michael@0:    *
michael@0:    * @param   aDocumentPosition   The document position flags to be reversed.
michael@0:    *
michael@0:    * @return  The reversed document position flags.
michael@0:    *
michael@0:    * @see nsIDOMNode
michael@0:    */
michael@0:   static uint16_t ReverseDocumentPosition(uint16_t aDocumentPosition);
michael@0: 
michael@0:   static uint32_t CopyNewlineNormalizedUnicodeTo(const nsAString& aSource,
michael@0:                                                  uint32_t aSrcOffset,
michael@0:                                                  char16_t* aDest,
michael@0:                                                  uint32_t aLength,
michael@0:                                                  bool& aLastCharCR);
michael@0: 
michael@0:   static uint32_t CopyNewlineNormalizedUnicodeTo(nsReadingIterator<char16_t>& aSrcStart, const nsReadingIterator<char16_t>& aSrcEnd, nsAString& aDest);
michael@0: 
michael@0:   static const nsDependentSubstring TrimCharsInSet(const char* aSet,
michael@0:                                                    const nsAString& aValue);
michael@0: 
michael@0:   template<bool IsWhitespace(char16_t)>
michael@0:   static const nsDependentSubstring TrimWhitespace(const nsAString& aStr,
michael@0:                                                    bool aTrimTrailing = true);
michael@0: 
michael@0:   /**
michael@0:    * Returns true if aChar is of class Ps, Pi, Po, Pf, or Pe.
michael@0:    */
michael@0:   static bool IsFirstLetterPunctuation(uint32_t aChar);
michael@0:   static bool IsFirstLetterPunctuationAt(const nsTextFragment* aFrag, uint32_t aOffset);
michael@0:  
michael@0:   /**
michael@0:    * Returns true if aChar is of class Lu, Ll, Lt, Lm, Lo, Nd, Nl or No
michael@0:    */
michael@0:   static bool IsAlphanumeric(uint32_t aChar);
michael@0:   static bool IsAlphanumericAt(const nsTextFragment* aFrag, uint32_t aOffset);
michael@0: 
michael@0:   /*
michael@0:    * Is the character an HTML whitespace character?
michael@0:    *
michael@0:    * We define whitespace using the list in HTML5 and css3-selectors:
michael@0:    * U+0009, U+000A, U+000C, U+000D, U+0020
michael@0:    *
michael@0:    * HTML 4.01 also lists U+200B (zero-width space).
michael@0:    */
michael@0:   static bool IsHTMLWhitespace(char16_t aChar);
michael@0: 
michael@0:   /*
michael@0:    * Returns whether the character is an HTML whitespace (see IsHTMLWhitespace)
michael@0:    * or a nbsp character (U+00A0).
michael@0:    */
michael@0:   static bool IsHTMLWhitespaceOrNBSP(char16_t aChar);
michael@0: 
michael@0:   /**
michael@0:    * Is the HTML local name a block element?
michael@0:    */
michael@0:   static bool IsHTMLBlock(nsIAtom* aLocalName);
michael@0: 
michael@0:   /**
michael@0:    * Is the HTML local name a void element?
michael@0:    */
michael@0:   static bool IsHTMLVoid(nsIAtom* aLocalName);
michael@0: 
michael@0:   /**
michael@0:    * Parse a margin string of format 'top, right, bottom, left' into
michael@0:    * an nsIntMargin.
michael@0:    *
michael@0:    * @param aString the string to parse
michael@0:    * @param aResult the resulting integer
michael@0:    * @return whether the value could be parsed
michael@0:    */
michael@0:   static bool ParseIntMarginValue(const nsAString& aString, nsIntMargin& aResult);
michael@0: 
michael@0:   /**
michael@0:    * Parse the value of the <font size=""> attribute according to the HTML5
michael@0:    * spec as of April 16, 2012.
michael@0:    *
michael@0:    * @param aValue the value to parse
michael@0:    * @return 1 to 7, or 0 if the value couldn't be parsed
michael@0:    */
michael@0:   static int32_t ParseLegacyFontSize(const nsAString& aValue);
michael@0: 
michael@0:   static void Shutdown();
michael@0: 
michael@0:   /**
michael@0:    * Checks whether two nodes come from the same origin.
michael@0:    */
michael@0:   static nsresult CheckSameOrigin(const nsINode* aTrustedNode,
michael@0:                                   nsIDOMNode* aUnTrustedNode);
michael@0:   static nsresult CheckSameOrigin(const nsINode* aTrustedNode,
michael@0:                                   const nsINode* unTrustedNode);
michael@0: 
michael@0:   // Check if the (JS) caller can access aNode.
michael@0:   static bool CanCallerAccess(nsIDOMNode *aNode);
michael@0:   static bool CanCallerAccess(nsINode* aNode);
michael@0: 
michael@0:   // Check if the (JS) caller can access aWindow.
michael@0:   // aWindow can be either outer or inner window.
michael@0:   static bool CanCallerAccess(nsPIDOMWindow* aWindow);
michael@0: 
michael@0:   /**
michael@0:    * Get the window through the JS context that's currently on the stack.
michael@0:    * If there's no JS context currently on the stack, returns null.
michael@0:    */
michael@0:   static nsPIDOMWindow *GetWindowFromCaller();
michael@0: 
michael@0:   /**
michael@0:    * The two GetDocumentFrom* functions below allow a caller to get at a
michael@0:    * document that is relevant to the currently executing script.
michael@0:    *
michael@0:    * GetDocumentFromCaller gets its document by looking at the last called
michael@0:    * function and finding the document that the function itself relates to.
michael@0:    * For example, consider two windows A and B in the same origin. B has a
michael@0:    * function which does something that ends up needing the current document.
michael@0:    * If a script in window A were to call B's function, GetDocumentFromCaller
michael@0:    * would find that function (in B) and return B's document.
michael@0:    *
michael@0:    * GetDocumentFromContext gets its document by looking at the currently
michael@0:    * executing context's global object and returning its document. Thus,
michael@0:    * given the example above, GetDocumentFromCaller would see that the
michael@0:    * currently executing script was in window A, and return A's document.
michael@0:    */
michael@0:   /**
michael@0:    * Get the document from the currently executing function. This will return
michael@0:    * the document that the currently executing function is in/from.
michael@0:    *
michael@0:    * @return The document or null if no JS Context.
michael@0:    */
michael@0:   static nsIDocument* GetDocumentFromCaller();
michael@0: 
michael@0:   /**
michael@0:    * Get the document through the JS context that's currently on the stack.
michael@0:    * If there's no JS context currently on the stack it will return null.
michael@0:    * This will return the document of the calling script.
michael@0:    *
michael@0:    * @return The document or null if no JS context
michael@0:    */
michael@0:   static nsIDocument* GetDocumentFromContext();
michael@0: 
michael@0:   // Check if a node is in the document prolog, i.e. before the document
michael@0:   // element.
michael@0:   static bool InProlog(nsINode *aNode);
michael@0: 
michael@0:   static nsIParserService* GetParserService();
michael@0: 
michael@0:   static nsNameSpaceManager* NameSpaceManager()
michael@0:   {
michael@0:     return sNameSpaceManager;
michael@0:   }
michael@0: 
michael@0:   static nsIIOService* GetIOService()
michael@0:   {
michael@0:     return sIOService;
michael@0:   }
michael@0: 
michael@0:   static nsIBidiKeyboard* GetBidiKeyboard();
michael@0: 
michael@0:   /**
michael@0:    * Get the cache security manager service. Can return null if the layout
michael@0:    * module has been shut down.
michael@0:    */
michael@0:   static nsIScriptSecurityManager* GetSecurityManager()
michael@0:   {
michael@0:     return sSecurityManager;
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Get the ContentSecurityPolicy for a JS context.
michael@0:    **/
michael@0:   static bool GetContentSecurityPolicy(JSContext* aCx,
michael@0:                                        nsIContentSecurityPolicy** aCSP);
michael@0: 
michael@0:   // Returns the subject principal. Guaranteed to return non-null. May only
michael@0:   // be called when nsContentUtils is initialized.
michael@0:   static nsIPrincipal* GetSubjectPrincipal();
michael@0: 
michael@0:   // Returns the principal of the given JS object. This should never be null
michael@0:   // for any object in the XPConnect runtime.
michael@0:   //
michael@0:   // In general, being interested in the principal of an object is enough to
michael@0:   // guarantee that the return value is non-null.
michael@0:   static nsIPrincipal* GetObjectPrincipal(JSObject* aObj);
michael@0: 
michael@0:   static nsresult GenerateStateKey(nsIContent* aContent,
michael@0:                                    const nsIDocument* aDocument,
michael@0:                                    nsACString& aKey);
michael@0: 
michael@0:   /**
michael@0:    * Create a new nsIURI from aSpec, using aBaseURI as the base.  The
michael@0:    * origin charset of the new nsIURI will be the document charset of
michael@0:    * aDocument.
michael@0:    */
michael@0:   static nsresult NewURIWithDocumentCharset(nsIURI** aResult,
michael@0:                                             const nsAString& aSpec,
michael@0:                                             nsIDocument* aDocument,
michael@0:                                             nsIURI* aBaseURI);
michael@0: 
michael@0:   /**
michael@0:    * Convert aInput (in encoding aEncoding) to UTF16 in aOutput.
michael@0:    *
michael@0:    * @param aEncoding the Gecko-canonical name of the encoding or the empty
michael@0:    *                  string (meaning UTF-8)
michael@0:    */
michael@0:   static nsresult ConvertStringFromEncoding(const nsACString& aEncoding,
michael@0:                                             const nsACString& aInput,
michael@0:                                             nsAString& aOutput);
michael@0: 
michael@0:   /**
michael@0:    * Determine whether a buffer begins with a BOM for UTF-8, UTF-16LE,
michael@0:    * UTF-16BE
michael@0:    *
michael@0:    * @param aBuffer the buffer to check
michael@0:    * @param aLength the length of the buffer
michael@0:    * @param aCharset empty if not found
michael@0:    * @return boolean indicating whether a BOM was detected.
michael@0:    */
michael@0:   static bool CheckForBOM(const unsigned char* aBuffer, uint32_t aLength,
michael@0:                           nsACString& aCharset);
michael@0: 
michael@0:   /**
michael@0:    * Returns true if |aName| is a valid name to be registered via
michael@0:    * document.registerElement.
michael@0:    */
michael@0:   static bool IsCustomElementName(nsIAtom* aName);
michael@0: 
michael@0:   static nsresult CheckQName(const nsAString& aQualifiedName,
michael@0:                              bool aNamespaceAware = true,
michael@0:                              const char16_t** aColon = nullptr);
michael@0: 
michael@0:   static nsresult SplitQName(const nsIContent* aNamespaceResolver,
michael@0:                              const nsAFlatString& aQName,
michael@0:                              int32_t *aNamespace, nsIAtom **aLocalName);
michael@0: 
michael@0:   static nsresult GetNodeInfoFromQName(const nsAString& aNamespaceURI,
michael@0:                                        const nsAString& aQualifiedName,
michael@0:                                        nsNodeInfoManager* aNodeInfoManager,
michael@0:                                        uint16_t aNodeType,
michael@0:                                        nsINodeInfo** aNodeInfo);
michael@0: 
michael@0:   static void SplitExpatName(const char16_t *aExpatName, nsIAtom **aPrefix,
michael@0:                              nsIAtom **aTagName, int32_t *aNameSpaceID);
michael@0: 
michael@0:   // Get a permission-manager setting for the given principal and type.
michael@0:   // If the pref doesn't exist or if it isn't ALLOW_ACTION, false is
michael@0:   // returned, otherwise true is returned. Always returns true for the
michael@0:   // system principal, and false for a null principal.
michael@0:   static bool IsSitePermAllow(nsIPrincipal* aPrincipal, const char* aType);
michael@0: 
michael@0:   // Get a permission-manager setting for the given principal and type.
michael@0:   // If the pref doesn't exist or if it isn't DENY_ACTION, false is
michael@0:   // returned, otherwise true is returned. Always returns false for the
michael@0:   // system principal, and true for a null principal.
michael@0:   static bool IsSitePermDeny(nsIPrincipal* aPrincipal, const char* aType);
michael@0: 
michael@0:   // Get a permission-manager setting for the given principal and type.
michael@0:   // If the pref doesn't exist or if it isn't ALLOW_ACTION, false is
michael@0:   // returned, otherwise true is returned. Always returns true for the
michael@0:   // system principal, and false for a null principal.
michael@0:   // This version checks the permission for an exact host match on
michael@0:   // the principal
michael@0:   static bool IsExactSitePermAllow(nsIPrincipal* aPrincipal, const char* aType);
michael@0: 
michael@0:   // Get a permission-manager setting for the given principal and type.
michael@0:   // If the pref doesn't exist or if it isn't DENY_ACTION, false is
michael@0:   // returned, otherwise true is returned. Always returns false for the
michael@0:   // system principal, and true for a null principal.
michael@0:   // This version checks the permission for an exact host match on
michael@0:   // the principal
michael@0:   static bool IsExactSitePermDeny(nsIPrincipal* aPrincipal, const char* aType);
michael@0: 
michael@0:   // Returns true if aDoc1 and aDoc2 have equal NodePrincipal()s.
michael@0:   static bool HaveEqualPrincipals(nsIDocument* aDoc1, nsIDocument* aDoc2);
michael@0: 
michael@0:   static nsILineBreaker* LineBreaker()
michael@0:   {
michael@0:     return sLineBreaker;
michael@0:   }
michael@0: 
michael@0:   static nsIWordBreaker* WordBreaker()
michael@0:   {
michael@0:     return sWordBreaker;
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Regster aObserver as a shutdown observer. A strong reference is held
michael@0:    * to aObserver until UnregisterShutdownObserver is called.
michael@0:    */
michael@0:   static void RegisterShutdownObserver(nsIObserver* aObserver);
michael@0:   static void UnregisterShutdownObserver(nsIObserver* aObserver);
michael@0: 
michael@0:   /**
michael@0:    * @return true if aContent has an attribute aName in namespace aNameSpaceID,
michael@0:    * and the attribute value is non-empty.
michael@0:    */
michael@0:   static bool HasNonEmptyAttr(const nsIContent* aContent, int32_t aNameSpaceID,
michael@0:                                 nsIAtom* aName);
michael@0: 
michael@0:   /**
michael@0:    * Method that gets the primary presContext for the node.
michael@0:    * 
michael@0:    * @param aContent The content node.
michael@0:    * @return the presContext, or nullptr if the content is not in a document
michael@0:    *         (if GetCurrentDoc returns nullptr)
michael@0:    */
michael@0:   static nsPresContext* GetContextForContent(const nsIContent* aContent);
michael@0: 
michael@0:   /**
michael@0:    * Method to do security and content policy checks on the image URI
michael@0:    *
michael@0:    * @param aURI uri of the image to be loaded
michael@0:    * @param aContext the context the image is loaded in (eg an element)
michael@0:    * @param aLoadingDocument the document we belong to
michael@0:    * @param aLoadingPrincipal the principal doing the load
michael@0:    * @param aImageBlockingStatus the nsIContentPolicy blocking status for this
michael@0:    *        image.  This will be set even if a security check fails for the
michael@0:    *        image, to some reasonable REJECT_* value.  This out param will only
michael@0:    *        be set if it's non-null.
michael@0:    * @return true if the load can proceed, or false if it is blocked.
michael@0:    *         Note that aImageBlockingStatus, if set will always be an ACCEPT
michael@0:    *         status if true is returned and always be a REJECT_* status if
michael@0:    *         false is returned.
michael@0:    */
michael@0:   static bool CanLoadImage(nsIURI* aURI,
michael@0:                              nsISupports* aContext,
michael@0:                              nsIDocument* aLoadingDocument,
michael@0:                              nsIPrincipal* aLoadingPrincipal,
michael@0:                              int16_t* aImageBlockingStatus = nullptr);
michael@0:   /**
michael@0:    * Method to start an image load.  This does not do any security checks.
michael@0:    * This method will attempt to make aURI immutable; a caller that wants to
michael@0:    * keep a mutable version around should pass in a clone.
michael@0:    *
michael@0:    * @param aURI uri of the image to be loaded
michael@0:    * @param aLoadingDocument the document we belong to
michael@0:    * @param aLoadingPrincipal the principal doing the load
michael@0:    * @param aReferrer the referrer URI
michael@0:    * @param aObserver the observer for the image load
michael@0:    * @param aLoadFlags the load flags to use.  See nsIRequest
michael@0:    * @return the imgIRequest for the image load
michael@0:    */
michael@0:   static nsresult LoadImage(nsIURI* aURI,
michael@0:                             nsIDocument* aLoadingDocument,
michael@0:                             nsIPrincipal* aLoadingPrincipal,
michael@0:                             nsIURI* aReferrer,
michael@0:                             imgINotificationObserver* aObserver,
michael@0:                             int32_t aLoadFlags,
michael@0:                             const nsAString& initiatorType,
michael@0:                             imgRequestProxy** aRequest);
michael@0: 
michael@0:   /**
michael@0:    * Obtain an image loader that respects the given document/channel's privacy status.
michael@0:    * Null document/channel arguments return the public image loader.
michael@0:    */
michael@0:   static imgLoader* GetImgLoaderForDocument(nsIDocument* aDoc);
michael@0:   static imgLoader* GetImgLoaderForChannel(nsIChannel* aChannel);
michael@0: 
michael@0:   /**
michael@0:    * Returns whether the given URI is in the image cache.
michael@0:    */
michael@0:   static bool IsImageInCache(nsIURI* aURI, nsIDocument* aDocument);
michael@0: 
michael@0:   /**
michael@0:    * Method to get an imgIContainer from an image loading content
michael@0:    *
michael@0:    * @param aContent The image loading content.  Must not be null.
michael@0:    * @param aRequest The image request [out]
michael@0:    * @return the imgIContainer corresponding to the first frame of the image
michael@0:    */
michael@0:   static already_AddRefed<imgIContainer> GetImageFromContent(nsIImageLoadingContent* aContent, imgIRequest **aRequest = nullptr);
michael@0: 
michael@0:   /**
michael@0:    * Helper method to call imgIRequest::GetStaticRequest.
michael@0:    */
michael@0:   static already_AddRefed<imgRequestProxy> GetStaticRequest(imgRequestProxy* aRequest);
michael@0: 
michael@0:   /**
michael@0:    * Method that decides whether a content node is draggable
michael@0:    *
michael@0:    * @param aContent The content node to test.
michael@0:    * @return whether it's draggable
michael@0:    */
michael@0:   static bool ContentIsDraggable(nsIContent* aContent);
michael@0: 
michael@0:   /**
michael@0:    * Method that decides whether a content node is a draggable image
michael@0:    *
michael@0:    * @param aContent The content node to test.
michael@0:    * @return whether it's a draggable image
michael@0:    */
michael@0:   static bool IsDraggableImage(nsIContent* aContent);
michael@0: 
michael@0:   /**
michael@0:    * Method that decides whether a content node is a draggable link
michael@0:    *
michael@0:    * @param aContent The content node to test.
michael@0:    * @return whether it's a draggable link
michael@0:    */
michael@0:   static bool IsDraggableLink(const nsIContent* aContent);
michael@0: 
michael@0:   /**
michael@0:    * Convenience method to create a new nodeinfo that differs only by name
michael@0:    * from aNodeInfo.
michael@0:    */
michael@0:   static nsresult NameChanged(nsINodeInfo* aNodeInfo, nsIAtom* aName,
michael@0:                               nsINodeInfo** aResult);
michael@0: 
michael@0:   /**
michael@0:    * Returns the appropriate event argument names for the specified
michael@0:    * namespace and event name.  Added because we need to switch between
michael@0:    * SVG's "evt" and the rest of the world's "event", and because onerror
michael@0:    * takes 3 args.
michael@0:    */
michael@0:   static void GetEventArgNames(int32_t aNameSpaceID, nsIAtom *aEventName,
michael@0:                                uint32_t *aArgCount, const char*** aArgNames);
michael@0: 
michael@0:   /**
michael@0:    * If aNode is not an element, return true exactly when aContent's binding
michael@0:    * parent is null.
michael@0:    *
michael@0:    * If aNode is an element, return true exactly when aContent's binding parent
michael@0:    * is the same as aNode's.
michael@0:    *
michael@0:    * This method is particularly useful for callers who are trying to ensure
michael@0:    * that they are working with a non-anonymous descendant of a given node.  If
michael@0:    * aContent is a descendant of aNode, a return value of false from this
michael@0:    * method means that it's an anonymous descendant from aNode's point of view.
michael@0:    *
michael@0:    * Both arguments to this method must be non-null.
michael@0:    */
michael@0:   static bool IsInSameAnonymousTree(const nsINode* aNode, const nsIContent* aContent);
michael@0: 
michael@0:   /**
michael@0:    * Return the nsIXPConnect service.
michael@0:    */
michael@0:   static nsIXPConnect *XPConnect()
michael@0:   {
michael@0:     return sXPConnect;
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Report simple error message to the browser console
michael@0:    *   @param aErrorText the error message
michael@0:    *   @param classification Name of the module reporting error
michael@0:    */
michael@0:   static void LogSimpleConsoleError(const nsAString& aErrorText,
michael@0:                                     const char * classification);
michael@0: 
michael@0:   /**
michael@0:    * Report a non-localized error message to the error console.
michael@0:    *   @param aErrorText the error message
michael@0:    *   @param aErrorFlags See nsIScriptError.
michael@0:    *   @param aCategory Name of module reporting error.
michael@0:    *   @param aDocument Reference to the document which triggered the message.
michael@0:    *   @param [aURI=nullptr] (Optional) URI of resource containing error.
michael@0:    *   @param [aSourceLine=EmptyString()] (Optional) The text of the line that
michael@0:               contains the error (may be empty).
michael@0:    *   @param [aLineNumber=0] (Optional) Line number within resource
michael@0:               containing error.
michael@0:    *   @param [aColumnNumber=0] (Optional) Column number within resource
michael@0:               containing error.
michael@0:               If aURI is null, then aDocument->GetDocumentURI() is used.
michael@0:    */
michael@0:   static nsresult ReportToConsoleNonLocalized(const nsAString& aErrorText,
michael@0:                                               uint32_t aErrorFlags,
michael@0:                                               const nsACString& aCategory,
michael@0:                                               nsIDocument* aDocument,
michael@0:                                               nsIURI* aURI = nullptr,
michael@0:                                               const nsAFlatString& aSourceLine
michael@0:                                                 = EmptyString(),
michael@0:                                               uint32_t aLineNumber = 0,
michael@0:                                               uint32_t aColumnNumber = 0);
michael@0: 
michael@0:   /**
michael@0:    * Report a localized error message to the error console.
michael@0:    *   @param aErrorFlags See nsIScriptError.
michael@0:    *   @param aCategory Name of module reporting error.
michael@0:    *   @param aDocument Reference to the document which triggered the message.
michael@0:    *   @param aFile Properties file containing localized message.
michael@0:    *   @param aMessageName Name of localized message.
michael@0:    *   @param [aParams=nullptr] (Optional) Parameters to be substituted into
michael@0:               localized message.
michael@0:    *   @param [aParamsLength=0] (Optional) Length of aParams.
michael@0:    *   @param [aURI=nullptr] (Optional) URI of resource containing error.
michael@0:    *   @param [aSourceLine=EmptyString()] (Optional) The text of the line that
michael@0:               contains the error (may be empty).
michael@0:    *   @param [aLineNumber=0] (Optional) Line number within resource
michael@0:               containing error.
michael@0:    *   @param [aColumnNumber=0] (Optional) Column number within resource
michael@0:               containing error.
michael@0:               If aURI is null, then aDocument->GetDocumentURI() is used.
michael@0:    */
michael@0:   enum PropertiesFile {
michael@0:     eCSS_PROPERTIES,
michael@0:     eXBL_PROPERTIES,
michael@0:     eXUL_PROPERTIES,
michael@0:     eLAYOUT_PROPERTIES,
michael@0:     eFORMS_PROPERTIES,
michael@0:     ePRINTING_PROPERTIES,
michael@0:     eDOM_PROPERTIES,
michael@0:     eHTMLPARSER_PROPERTIES,
michael@0:     eSVG_PROPERTIES,
michael@0:     eBRAND_PROPERTIES,
michael@0:     eCOMMON_DIALOG_PROPERTIES,
michael@0:     eMATHML_PROPERTIES,
michael@0:     eSECURITY_PROPERTIES,
michael@0:     PropertiesFile_COUNT
michael@0:   };
michael@0:   static nsresult ReportToConsole(uint32_t aErrorFlags,
michael@0:                                   const nsACString& aCategory,
michael@0:                                   nsIDocument* aDocument,
michael@0:                                   PropertiesFile aFile,
michael@0:                                   const char *aMessageName,
michael@0:                                   const char16_t **aParams = nullptr,
michael@0:                                   uint32_t aParamsLength = 0,
michael@0:                                   nsIURI* aURI = nullptr,
michael@0:                                   const nsAFlatString& aSourceLine
michael@0:                                     = EmptyString(),
michael@0:                                   uint32_t aLineNumber = 0,
michael@0:                                   uint32_t aColumnNumber = 0);
michael@0: 
michael@0:   static void LogMessageToConsole(const char* aMsg, ...);
michael@0:   
michael@0:   /**
michael@0:    * Get the localized string named |aKey| in properties file |aFile|.
michael@0:    */
michael@0:   static nsresult GetLocalizedString(PropertiesFile aFile,
michael@0:                                      const char* aKey,
michael@0:                                      nsXPIDLString& aResult);
michael@0: 
michael@0:   /**
michael@0:    * A helper function that parses a sandbox attribute (of an <iframe> or
michael@0:    * a CSP directive) and converts it to the set of flags used internally.
michael@0:    *
michael@0:    * @param sandboxAttr   the sandbox attribute
michael@0:    * @return              the set of flags (0 if sandboxAttr is null)
michael@0:    */
michael@0:   static uint32_t ParseSandboxAttributeToFlags(const nsAttrValue* sandboxAttr);
michael@0: 
michael@0: 
michael@0:   /**
michael@0:    * Fill (with the parameters given) the localized string named |aKey| in
michael@0:    * properties file |aFile|.
michael@0:    */
michael@0: private:
michael@0:   static nsresult FormatLocalizedString(PropertiesFile aFile,
michael@0:                                         const char* aKey,
michael@0:                                         const char16_t** aParams,
michael@0:                                         uint32_t aParamsLength,
michael@0:                                         nsXPIDLString& aResult);
michael@0:   
michael@0: public:
michael@0:   template<uint32_t N>
michael@0:   static nsresult FormatLocalizedString(PropertiesFile aFile,
michael@0:                                         const char* aKey,
michael@0:                                         const char16_t* (&aParams)[N],
michael@0:                                         nsXPIDLString& aResult)
michael@0:   {
michael@0:     return FormatLocalizedString(aFile, aKey, aParams, N, aResult);
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Returns true if aDocument is a chrome document
michael@0:    */
michael@0:   static bool IsChromeDoc(nsIDocument *aDocument);
michael@0: 
michael@0:   /**
michael@0:    * Returns true if aDocument is in a docshell whose parent is the same type
michael@0:    */
michael@0:   static bool IsChildOfSameType(nsIDocument* aDoc);
michael@0: 
michael@0:   /**
michael@0:   '* Returns true if the content-type will be rendered as plain-text.
michael@0:    */
michael@0:   static bool IsPlainTextType(const nsACString& aContentType);
michael@0: 
michael@0:   /**
michael@0:    * Get the script file name to use when compiling the script
michael@0:    * referenced by aURI. In cases where there's no need for any extra
michael@0:    * security wrapper automation the script file name that's returned
michael@0:    * will be the spec in aURI, else it will be the spec in aDocument's
michael@0:    * URI followed by aURI's spec, separated by " -> ". Returns true
michael@0:    * if the script file name was modified, false if it's aURI's
michael@0:    * spec.
michael@0:    */
michael@0:   static bool GetWrapperSafeScriptFilename(nsIDocument *aDocument,
michael@0:                                              nsIURI *aURI,
michael@0:                                              nsACString& aScriptURI);
michael@0: 
michael@0: 
michael@0:   /**
michael@0:    * Returns true if aDocument belongs to a chrome docshell for
michael@0:    * display purposes.  Returns false for null documents or documents
michael@0:    * which do not belong to a docshell.
michael@0:    */
michael@0:   static bool IsInChromeDocshell(nsIDocument *aDocument);
michael@0: 
michael@0:   /**
michael@0:    * Return the content policy service
michael@0:    */
michael@0:   static nsIContentPolicy *GetContentPolicy();
michael@0: 
michael@0:   /**
michael@0:    * Quick helper to determine whether there are any mutation listeners
michael@0:    * of a given type that apply to this content or any of its ancestors.
michael@0:    * The method has the side effect to call document's MayDispatchMutationEvent
michael@0:    * using aTargetForSubtreeModified as the parameter.
michael@0:    *
michael@0:    * @param aNode  The node to search for listeners
michael@0:    * @param aType  The type of listener (NS_EVENT_BITS_MUTATION_*)
michael@0:    * @param aTargetForSubtreeModified The node which is the target of the
michael@0:    *                                  possible DOMSubtreeModified event.
michael@0:    *
michael@0:    * @return true if there are mutation listeners of the specified type
michael@0:    */
michael@0:   static bool HasMutationListeners(nsINode* aNode,
michael@0:                                      uint32_t aType,
michael@0:                                      nsINode* aTargetForSubtreeModified);
michael@0: 
michael@0:   /**
michael@0:    * Quick helper to determine whether there are any mutation listeners
michael@0:    * of a given type that apply to any content in this document. It is valid
michael@0:    * to pass null for aDocument here, in which case this function always
michael@0:    * returns true.
michael@0:    *
michael@0:    * @param aDocument The document to search for listeners
michael@0:    * @param aType     The type of listener (NS_EVENT_BITS_MUTATION_*)
michael@0:    *
michael@0:    * @return true if there are mutation listeners of the specified type
michael@0:    */
michael@0:   static bool HasMutationListeners(nsIDocument* aDocument,
michael@0:                                      uint32_t aType);
michael@0:   /**
michael@0:    * Synchronously fire DOMNodeRemoved on aChild. Only fires the event if
michael@0:    * there really are listeners by checking using the HasMutationListeners
michael@0:    * function above. The function makes sure to hold the relevant objects alive
michael@0:    * for the duration of the event firing. However there are no guarantees
michael@0:    * that any of the objects are alive by the time the function returns.
michael@0:    * If you depend on that you need to hold references yourself.
michael@0:    *
michael@0:    * @param aChild    The node to fire DOMNodeRemoved at.
michael@0:    * @param aParent   The parent of aChild.
michael@0:    * @param aOwnerDoc The ownerDocument of aChild.
michael@0:    */
michael@0:   static void MaybeFireNodeRemoved(nsINode* aChild, nsINode* aParent,
michael@0:                                    nsIDocument* aOwnerDoc);
michael@0: 
michael@0:   /**
michael@0:    * This method creates and dispatches a trusted event.
michael@0:    * Works only with events which can be created by calling
michael@0:    * nsIDOMDocument::CreateEvent() with parameter "Events".
michael@0:    * @param aDoc           The document which will be used to create the event.
michael@0:    * @param aTarget        The target of the event, should be QIable to
michael@0:    *                       nsIDOMEventTarget.
michael@0:    * @param aEventName     The name of the event.
michael@0:    * @param aCanBubble     Whether the event can bubble.
michael@0:    * @param aCancelable    Is the event cancelable.
michael@0:    * @param aDefaultAction Set to true if default action should be taken,
michael@0:    *                       see nsIDOMEventTarget::DispatchEvent.
michael@0:    */
michael@0:   static nsresult DispatchTrustedEvent(nsIDocument* aDoc,
michael@0:                                        nsISupports* aTarget,
michael@0:                                        const nsAString& aEventName,
michael@0:                                        bool aCanBubble,
michael@0:                                        bool aCancelable,
michael@0:                                        bool *aDefaultAction = nullptr);
michael@0: 
michael@0:   /**
michael@0:    * This method creates and dispatches a untrusted event.
michael@0:    * Works only with events which can be created by calling
michael@0:    * nsIDOMDocument::CreateEvent() with parameter "Events".
michael@0:    * @param aDoc           The document which will be used to create the event.
michael@0:    * @param aTarget        The target of the event, should be QIable to
michael@0:    *                       nsIDOMEventTarget.
michael@0:    * @param aEventName     The name of the event.
michael@0:    * @param aCanBubble     Whether the event can bubble.
michael@0:    * @param aCancelable    Is the event cancelable.
michael@0:    * @param aDefaultAction Set to true if default action should be taken,
michael@0:    *                       see nsIDOMEventTarget::DispatchEvent.
michael@0:    */
michael@0:   static nsresult DispatchUntrustedEvent(nsIDocument* aDoc,
michael@0:                                          nsISupports* aTarget,
michael@0:                                          const nsAString& aEventName,
michael@0:                                          bool aCanBubble,
michael@0:                                          bool aCancelable,
michael@0:                                          bool *aDefaultAction = nullptr);
michael@0: 
michael@0:   /**
michael@0:    * This method creates and dispatches a trusted event to the chrome
michael@0:    * event handler.
michael@0:    * Works only with events which can be created by calling
michael@0:    * nsIDOMDocument::CreateEvent() with parameter "Events".
michael@0:    * @param aDocument      The document which will be used to create the event,
michael@0:    *                       and whose window's chrome handler will be used to
michael@0:    *                       dispatch the event.
michael@0:    * @param aTarget        The target of the event, used for event->SetTarget()
michael@0:    * @param aEventName     The name of the event.
michael@0:    * @param aCanBubble     Whether the event can bubble.
michael@0:    * @param aCancelable    Is the event cancelable.
michael@0:    * @param aDefaultAction Set to true if default action should be taken,
michael@0:    *                       see nsIDOMEventTarget::DispatchEvent.
michael@0:    */
michael@0:   static nsresult DispatchChromeEvent(nsIDocument* aDoc,
michael@0:                                       nsISupports* aTarget,
michael@0:                                       const nsAString& aEventName,
michael@0:                                       bool aCanBubble,
michael@0:                                       bool aCancelable,
michael@0:                                       bool *aDefaultAction = nullptr);
michael@0: 
michael@0:   /**
michael@0:    * Determines if an event attribute name (such as onclick) is valid for
michael@0:    * a given element type. Types are from the EventNameType enumeration
michael@0:    * defined above.
michael@0:    *
michael@0:    * @param aName the event name to look up
michael@0:    * @param aType the type of content
michael@0:    */
michael@0:   static bool IsEventAttributeName(nsIAtom* aName, int32_t aType);
michael@0: 
michael@0:   /**
michael@0:    * Return the event id for the event with the given name. The name is the
michael@0:    * event name with the 'on' prefix. Returns NS_USER_DEFINED_EVENT if the
michael@0:    * event doesn't match a known event name.
michael@0:    *
michael@0:    * @param aName the event name to look up
michael@0:    */
michael@0:   static uint32_t GetEventId(nsIAtom* aName);
michael@0: 
michael@0:   /**
michael@0:    * Return the category for the event with the given name. The name is the
michael@0:    * event name *without* the 'on' prefix. Returns NS_EVENT if the event
michael@0:    * is not known to be in any particular category.
michael@0:    *
michael@0:    * @param aName the event name to look up
michael@0:    */
michael@0:   static uint32_t GetEventCategory(const nsAString& aName);
michael@0: 
michael@0:   /**
michael@0:    * Return the event id and atom for the event with the given name.
michael@0:    * The name is the event name *without* the 'on' prefix.
michael@0:    * Returns NS_USER_DEFINED_EVENT on the aEventID if the
michael@0:    * event doesn't match a known event name in the category.
michael@0:    *
michael@0:    * @param aName the event name to look up
michael@0:    * @param aEventStruct only return event id in aEventStruct category
michael@0:    */
michael@0:   static nsIAtom* GetEventIdAndAtom(const nsAString& aName,
michael@0:                                     uint32_t aEventStruct,
michael@0:                                     uint32_t* aEventID);
michael@0: 
michael@0:   /**
michael@0:    * Used only during traversal of the XPCOM graph by the cycle
michael@0:    * collector: push a pointer to the listener manager onto the
michael@0:    * children deque, if it exists. Do nothing if there is no listener
michael@0:    * manager.
michael@0:    *
michael@0:    * Crucially: does not perform any refcounting operations.
michael@0:    *
michael@0:    * @param aNode The node to traverse.
michael@0:    * @param children The buffer to push a listener manager pointer into.
michael@0:    */
michael@0:   static void TraverseListenerManager(nsINode *aNode,
michael@0:                                       nsCycleCollectionTraversalCallback &cb);
michael@0: 
michael@0:   /**
michael@0:    * Get the eventlistener manager for aNode, creating it if it does not
michael@0:    * already exist.
michael@0:    *
michael@0:    * @param aNode The node for which to get the eventlistener manager.
michael@0:    */
michael@0:   static mozilla::EventListenerManager*
michael@0:     GetListenerManagerForNode(nsINode* aNode);
michael@0:   /**
michael@0:    * Get the eventlistener manager for aNode, returning null if it does not
michael@0:    * already exist.
michael@0:    *
michael@0:    * @param aNode The node for which to get the eventlistener manager.
michael@0:    */
michael@0:   static mozilla::EventListenerManager*
michael@0:     GetExistingListenerManagerForNode(const nsINode* aNode);
michael@0: 
michael@0:   static void UnmarkGrayJSListenersInCCGenerationDocuments(uint32_t aGeneration);
michael@0: 
michael@0:   /**
michael@0:    * Remove the eventlistener manager for aNode.
michael@0:    *
michael@0:    * @param aNode The node for which to remove the eventlistener manager.
michael@0:    */
michael@0:   static void RemoveListenerManager(nsINode *aNode);
michael@0: 
michael@0:   static bool IsInitialized()
michael@0:   {
michael@0:     return sInitialized;
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Checks if the localname/prefix/namespace triple is valid wrt prefix
michael@0:    * and namespace according to the Namespaces in XML and DOM Code
michael@0:    * specfications.
michael@0:    *
michael@0:    * @param aLocalname localname of the node
michael@0:    * @param aPrefix prefix of the node
michael@0:    * @param aNamespaceID namespace of the node
michael@0:    */
michael@0:   static bool IsValidNodeName(nsIAtom *aLocalName, nsIAtom *aPrefix,
michael@0:                                 int32_t aNamespaceID);
michael@0: 
michael@0:   /**
michael@0:    * Creates a DocumentFragment from text using a context node to resolve
michael@0:    * namespaces.
michael@0:    *
michael@0:    * Note! In the HTML case with the HTML5 parser enabled, this is only called
michael@0:    * from Range.createContextualFragment() and the implementation here is
michael@0:    * quirky accordingly (html context node behaves like a body context node).
michael@0:    * If you don't want that quirky behavior, don't use this method as-is!
michael@0:    *
michael@0:    * @param aContextNode the node which is used to resolve namespaces
michael@0:    * @param aFragment the string which is parsed to a DocumentFragment
michael@0:    * @param aReturn the resulting fragment
michael@0:    * @param aPreventScriptExecution whether to mark scripts as already started
michael@0:    */
michael@0:   static nsresult CreateContextualFragment(nsINode* aContextNode,
michael@0:                                            const nsAString& aFragment,
michael@0:                                            bool aPreventScriptExecution,
michael@0:                                            nsIDOMDocumentFragment** aReturn);
michael@0:   static already_AddRefed<mozilla::dom::DocumentFragment>
michael@0:   CreateContextualFragment(nsINode* aContextNode, const nsAString& aFragment,
michael@0:                            bool aPreventScriptExecution,
michael@0:                            mozilla::ErrorResult& aRv);
michael@0: 
michael@0:   /**
michael@0:    * Invoke the fragment parsing algorithm (innerHTML) using the HTML parser.
michael@0:    *
michael@0:    * @param aSourceBuffer the string being set as innerHTML
michael@0:    * @param aTargetNode the target container
michael@0:    * @param aContextLocalName local name of context node
michael@0:    * @param aContextNamespace namespace of context node
michael@0:    * @param aQuirks true to make <table> not close <p>
michael@0:    * @param aPreventScriptExecution true to prevent scripts from executing;
michael@0:    *        don't set to false when parsing into a target node that has been
michael@0:    *        bound to tree.
michael@0:    * @return NS_ERROR_DOM_INVALID_STATE_ERR if a re-entrant attempt to parse
michael@0:    *         fragments is made, NS_ERROR_OUT_OF_MEMORY if aSourceBuffer is too
michael@0:    *         long and NS_OK otherwise.
michael@0:    */
michael@0:   static nsresult ParseFragmentHTML(const nsAString& aSourceBuffer,
michael@0:                                     nsIContent* aTargetNode,
michael@0:                                     nsIAtom* aContextLocalName,
michael@0:                                     int32_t aContextNamespace,
michael@0:                                     bool aQuirks,
michael@0:                                     bool aPreventScriptExecution);
michael@0: 
michael@0:   /**
michael@0:    * Invoke the fragment parsing algorithm (innerHTML) using the XML parser.
michael@0:    *
michael@0:    * @param aSourceBuffer the string being set as innerHTML
michael@0:    * @param aTargetNode the target container
michael@0:    * @param aTagStack the namespace mapping context
michael@0:    * @param aPreventExecution whether to mark scripts as already started
michael@0:    * @param aReturn the result fragment
michael@0:    * @return NS_ERROR_DOM_INVALID_STATE_ERR if a re-entrant attempt to parse
michael@0:    *         fragments is made, a return code from the XML parser.
michael@0:    */
michael@0:   static nsresult ParseFragmentXML(const nsAString& aSourceBuffer,
michael@0:                                    nsIDocument* aDocument,
michael@0:                                    nsTArray<nsString>& aTagStack,
michael@0:                                    bool aPreventScriptExecution,
michael@0:                                    nsIDOMDocumentFragment** aReturn);
michael@0: 
michael@0:   /**
michael@0:    * Parse a string into a document using the HTML parser.
michael@0:    * Script elements are marked unexecutable.
michael@0:    *
michael@0:    * @param aSourceBuffer the string to parse as an HTML document
michael@0:    * @param aTargetDocument the document object to parse into. Must not have
michael@0:    *                        child nodes.
michael@0:    * @param aScriptingEnabledForNoscriptParsing whether <noscript> is parsed
michael@0:    *                                            as if scripting was enabled
michael@0:    * @return NS_ERROR_DOM_INVALID_STATE_ERR if a re-entrant attempt to parse
michael@0:    *         fragments is made, NS_ERROR_OUT_OF_MEMORY if aSourceBuffer is too
michael@0:    *         long and NS_OK otherwise.
michael@0:    */
michael@0:   static nsresult ParseDocumentHTML(const nsAString& aSourceBuffer,
michael@0:                                     nsIDocument* aTargetDocument,
michael@0:                                     bool aScriptingEnabledForNoscriptParsing);
michael@0: 
michael@0:   /**
michael@0:    * Converts HTML source to plain text by parsing the source and using the
michael@0:    * plain text serializer on the resulting tree.
michael@0:    *
michael@0:    * @param aSourceBuffer the string to parse as an HTML document
michael@0:    * @param aResultBuffer the string where the plain text result appears;
michael@0:    *                      may be the same string as aSourceBuffer
michael@0:    * @param aFlags Flags from nsIDocumentEncoder.
michael@0:    * @param aWrapCol Number of columns after which to line wrap; 0 for no
michael@0:    *                 auto-wrapping
michael@0:    * @return NS_ERROR_DOM_INVALID_STATE_ERR if a re-entrant attempt to parse
michael@0:    *         fragments is made, NS_ERROR_OUT_OF_MEMORY if aSourceBuffer is too
michael@0:    *         long and NS_OK otherwise.
michael@0:    */
michael@0:   static nsresult ConvertToPlainText(const nsAString& aSourceBuffer,
michael@0:                                      nsAString& aResultBuffer,
michael@0:                                      uint32_t aFlags,
michael@0:                                      uint32_t aWrapCol);
michael@0: 
michael@0:   /**
michael@0:    * Sets the text contents of a node by replacing all existing children
michael@0:    * with a single text child.
michael@0:    *
michael@0:    * The function always notifies.
michael@0:    *
michael@0:    * Will reuse the first text child if one is available. Will not reuse
michael@0:    * existing cdata children.
michael@0:    *
michael@0:    * @param aContent Node to set contents of.
michael@0:    * @param aValue   Value to set contents to.
michael@0:    * @param aTryReuse When true, the function will try to reuse an existing
michael@0:    *                  textnodes rather than always creating a new one.
michael@0:    */
michael@0:   static nsresult SetNodeTextContent(nsIContent* aContent,
michael@0:                                      const nsAString& aValue,
michael@0:                                      bool aTryReuse);
michael@0: 
michael@0:   /**
michael@0:    * Get the textual contents of a node. This is a concatenation of all
michael@0:    * textnodes that are direct or (depending on aDeep) indirect children
michael@0:    * of the node.
michael@0:    *
michael@0:    * NOTE! No serialization takes place and <br> elements
michael@0:    * are not converted into newlines. Only textnodes and cdata nodes are
michael@0:    * added to the result.
michael@0:    *
michael@0:    * @param aNode Node to get textual contents of.
michael@0:    * @param aDeep If true child elements of aNode are recursivly descended
michael@0:    *              into to find text children.
michael@0:    * @param aResult the result. Out param.
michael@0:    * @return false on out of memory errors, true otherwise.
michael@0:    */
michael@0:   static bool GetNodeTextContent(nsINode* aNode, bool aDeep,
michael@0:                                  nsAString& aResult) NS_WARN_UNUSED_RESULT;
michael@0: 
michael@0:   /**
michael@0:    * Same as GetNodeTextContents but appends the result rather than sets it.
michael@0:    */
michael@0:   static bool AppendNodeTextContent(nsINode* aNode, bool aDeep,
michael@0:                                     nsAString& aResult, const mozilla::fallible_t&);
michael@0: 
michael@0:   /**
michael@0:    * Utility method that checks if a given node has any non-empty
michael@0:    * children.
michael@0:    * NOTE! This method does not descend recursivly into elements.
michael@0:    * Though it would be easy to make it so if needed
michael@0:    */
michael@0:   static bool HasNonEmptyTextContent(nsINode* aNode);
michael@0: 
michael@0:   /**
michael@0:    * Delete strings allocated for nsContentList matches
michael@0:    */
michael@0:   static void DestroyMatchString(void* aData);
michael@0: 
michael@0:   /**
michael@0:    * Unbinds the content from the tree and nulls it out if it's not null.
michael@0:    */
michael@0:   static void DestroyAnonymousContent(nsCOMPtr<nsIContent>* aContent);
michael@0:   static void DestroyAnonymousContent(nsCOMPtr<Element>* aElement);
michael@0: 
michael@0:   static void DeferredFinalize(nsISupports* aSupports);
michael@0:   static void DeferredFinalize(mozilla::DeferredFinalizeAppendFunction aAppendFunc,
michael@0:                                mozilla::DeferredFinalizeFunction aFunc,
michael@0:                                void* aThing);
michael@0: 
michael@0:   /*
michael@0:    * Notify when the first XUL menu is opened and when the all XUL menus are
michael@0:    * closed. At opening, aInstalling should be TRUE, otherwise, it should be
michael@0:    * FALSE.
michael@0:    */
michael@0:   static void NotifyInstalledMenuKeyboardListener(bool aInstalling);
michael@0: 
michael@0:   /**
michael@0:    * Do security checks before loading a resource. Does the following checks:
michael@0:    *   nsIScriptSecurityManager::CheckLoadURIWithPrincipal
michael@0:    *   NS_CheckContentLoadPolicy
michael@0:    *   nsIScriptSecurityManager::CheckSameOriginURI
michael@0:    *
michael@0:    * You will still need to do at least SameOrigin checks before on redirects.
michael@0:    *
michael@0:    * @param aURIToLoad         URI that is getting loaded.
michael@0:    * @param aLoadingPrincipal  Principal of the resource that is initiating
michael@0:    *                           the load
michael@0:    * @param aCheckLoadFlags    Flags to be passed to
michael@0:    *                           nsIScriptSecurityManager::CheckLoadURIWithPrincipal
michael@0:    *                           NOTE: If this contains ALLOW_CHROME the
michael@0:    *                                 CheckSameOriginURI check will be skipped if
michael@0:    *                                 aURIToLoad is a chrome uri.
michael@0:    * @param aAllowData         Set to true to skip CheckSameOriginURI check when
michael@0:                                aURIToLoad is a data uri.
michael@0:    * @param aContentPolicyType Type     \
michael@0:    * @param aContext           Context   |- to be passed to
michael@0:    * @param aMimeGuess         Mimetype  |      NS_CheckContentLoadPolicy
michael@0:    * @param aExtra             Extra    /
michael@0:    */
michael@0:   static nsresult CheckSecurityBeforeLoad(nsIURI* aURIToLoad,
michael@0:                                           nsIPrincipal* aLoadingPrincipal,
michael@0:                                           uint32_t aCheckLoadFlags,
michael@0:                                           bool aAllowData,
michael@0:                                           uint32_t aContentPolicyType,
michael@0:                                           nsISupports* aContext,
michael@0:                                           const nsAFlatCString& aMimeGuess = EmptyCString(),
michael@0:                                           nsISupports* aExtra = nullptr);
michael@0: 
michael@0:   /**
michael@0:    * Returns true if aPrincipal is the system principal.
michael@0:    */
michael@0:   static bool IsSystemPrincipal(nsIPrincipal* aPrincipal);
michael@0: 
michael@0:   /**
michael@0:    * Returns true if aPrincipal is an nsExpandedPrincipal.
michael@0:    */
michael@0:   static bool IsExpandedPrincipal(nsIPrincipal* aPrincipal);
michael@0: 
michael@0:   /**
michael@0:    * Returns true if aPrincipal is the system or an nsExpandedPrincipal.
michael@0:    */
michael@0:   static bool IsSystemOrExpandedPrincipal(nsIPrincipal* aPrincipal)
michael@0:   {
michael@0:     return IsSystemPrincipal(aPrincipal) || IsExpandedPrincipal(aPrincipal);
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Gets the system principal from the security manager.
michael@0:    */
michael@0:   static nsIPrincipal* GetSystemPrincipal();
michael@0: 
michael@0:   /**
michael@0:    * *aResourcePrincipal is a principal describing who may access the contents
michael@0:    * of a resource. The resource can only be consumed by a principal that
michael@0:    * subsumes *aResourcePrincipal. MAKE SURE THAT NOTHING EVER ACTS WITH THE
michael@0:    * AUTHORITY OF *aResourcePrincipal.
michael@0:    * It may be null to indicate that the resource has no data from any origin
michael@0:    * in it yet and anything may access the resource.
michael@0:    * Additional data is being mixed into the resource from aExtraPrincipal
michael@0:    * (which may be null; if null, no data is being mixed in and this function
michael@0:    * will do nothing). Update *aResourcePrincipal to reflect the new data.
michael@0:    * If *aResourcePrincipal subsumes aExtraPrincipal, nothing needs to change,
michael@0:    * otherwise *aResourcePrincipal is replaced with the system principal.
michael@0:    * Returns true if *aResourcePrincipal changed.
michael@0:    */
michael@0:   static bool CombineResourcePrincipals(nsCOMPtr<nsIPrincipal>* aResourcePrincipal,
michael@0:                                         nsIPrincipal* aExtraPrincipal);
michael@0: 
michael@0:   /**
michael@0:    * Trigger a link with uri aLinkURI. If aClick is false, this triggers a
michael@0:    * mouseover on the link, otherwise it triggers a load after doing a
michael@0:    * security check using aContent's principal.
michael@0:    *
michael@0:    * @param aContent the node on which a link was triggered.
michael@0:    * @param aPresContext the pres context, must be non-null.
michael@0:    * @param aLinkURI the URI of the link, must be non-null.
michael@0:    * @param aTargetSpec the target (like target=, may be empty).
michael@0:    * @param aClick whether this was a click or not (if false, this method
michael@0:    *               assumes you just hovered over the link).
michael@0:    * @param aIsUserTriggered whether the user triggered the link. This would be
michael@0:    *                         false for loads from auto XLinks or from the
michael@0:    *                         click() method if we ever implement it.
michael@0:    * @param aIsTrusted If false, JS Context will be pushed to stack
michael@0:    *                   when the link is triggered.
michael@0:    */
michael@0:   static void TriggerLink(nsIContent *aContent, nsPresContext *aPresContext,
michael@0:                           nsIURI *aLinkURI, const nsString& aTargetSpec,
michael@0:                           bool aClick, bool aIsUserTriggered,
michael@0:                           bool aIsTrusted);
michael@0: 
michael@0:   /**
michael@0:    * Get the link location.
michael@0:    */
michael@0:   static void GetLinkLocation(mozilla::dom::Element* aElement,
michael@0:                               nsString& aLocationString);
michael@0: 
michael@0:   /**
michael@0:    * Return top-level widget in the parent chain.
michael@0:    */
michael@0:   static nsIWidget* GetTopLevelWidget(nsIWidget* aWidget);
michael@0: 
michael@0:   /**
michael@0:    * Return the localized ellipsis for UI.
michael@0:    */
michael@0:   static const nsDependentString GetLocalizedEllipsis();
michael@0: 
michael@0:   /**
michael@0:    * Get the candidates for accelkeys for aDOMKeyEvent.
michael@0:    *
michael@0:    * @param aDOMKeyEvent [in] the key event for accelkey handling.
michael@0:    * @param aCandidates [out] the candidate shortcut key combination list.
michael@0:    *                          the first item is most preferred.
michael@0:    */
michael@0:   static void GetAccelKeyCandidates(nsIDOMKeyEvent* aDOMKeyEvent,
michael@0:                                     nsTArray<nsShortcutCandidate>& aCandidates);
michael@0: 
michael@0:   /**
michael@0:    * Get the candidates for accesskeys for aNativeKeyEvent.
michael@0:    *
michael@0:    * @param aNativeKeyEvent [in] the key event for accesskey handling.
michael@0:    * @param aCandidates [out] the candidate access key list.
michael@0:    *                          the first item is most preferred.
michael@0:    */
michael@0:   static void GetAccessKeyCandidates(
michael@0:                 mozilla::WidgetKeyboardEvent* aNativeKeyEvent,
michael@0:                 nsTArray<uint32_t>& aCandidates);
michael@0: 
michael@0:   /**
michael@0:    * Hide any XUL popups associated with aDocument, including any documents
michael@0:    * displayed in child frames. Does nothing if aDocument is null.
michael@0:    */
michael@0:   static void HidePopupsInDocument(nsIDocument* aDocument);
michael@0: 
michael@0:   /**
michael@0:    * Retrieve the current drag session, or null if no drag is currently occuring
michael@0:    */
michael@0:   static already_AddRefed<nsIDragSession> GetDragSession();
michael@0: 
michael@0:   /*
michael@0:    * Initialize and set the dataTransfer field of an WidgetDragEvent.
michael@0:    */
michael@0:   static nsresult SetDataTransferInEvent(mozilla::WidgetDragEvent* aDragEvent);
michael@0: 
michael@0:   // filters the drag and drop action to fit within the effects allowed and
michael@0:   // returns it.
michael@0:   static uint32_t FilterDropEffect(uint32_t aAction, uint32_t aEffectAllowed);
michael@0: 
michael@0:   /*
michael@0:    * Return true if the target of a drop event is a content document that is
michael@0:    * an ancestor of the document for the source of the drag.
michael@0:    */
michael@0:   static bool CheckForSubFrameDrop(nsIDragSession* aDragSession,
michael@0:                                    mozilla::WidgetDragEvent* aDropEvent);
michael@0: 
michael@0:   /**
michael@0:    * Return true if aURI is a local file URI (i.e. file://).
michael@0:    */
michael@0:   static bool URIIsLocalFile(nsIURI *aURI);
michael@0: 
michael@0:   /**
michael@0:    * Given a URI, return set beforeHash to the part before the '#', and
michael@0:    * afterHash to the remainder of the URI, including the '#'.
michael@0:    */
michael@0:   static nsresult SplitURIAtHash(nsIURI *aURI,
michael@0:                                  nsACString &aBeforeHash,
michael@0:                                  nsACString &aAfterHash);
michael@0: 
michael@0:   /**
michael@0:    * Get the application manifest URI for this document.  The manifest URI
michael@0:    * is specified in the manifest= attribute of the root element of the
michael@0:    * document.
michael@0:    *
michael@0:    * @param aDocument The document that lists the manifest.
michael@0:    * @param aURI The manifest URI.
michael@0:    */
michael@0:   static void GetOfflineAppManifest(nsIDocument *aDocument, nsIURI **aURI);
michael@0: 
michael@0:   /**
michael@0:    * Check whether an application should be allowed to use offline APIs.
michael@0:    */
michael@0:   static bool OfflineAppAllowed(nsIURI *aURI);
michael@0: 
michael@0:   /**
michael@0:    * Check whether an application should be allowed to use offline APIs.
michael@0:    */
michael@0:   static bool OfflineAppAllowed(nsIPrincipal *aPrincipal);
michael@0: 
michael@0:   /**
michael@0:    * If offline-apps.allow_by_default is true, we set offline-app permission
michael@0:    * for the principal and return true.  Otherwise false.
michael@0:    */
michael@0:   static bool MaybeAllowOfflineAppByDefault(nsIPrincipal *aPrincipal, nsIDOMWindow *aWindow);
michael@0: 
michael@0:   /**
michael@0:    * Increases the count of blockers preventing scripts from running.
michael@0:    * NOTE: You might want to use nsAutoScriptBlocker rather than calling
michael@0:    * this directly
michael@0:    */
michael@0:   static void AddScriptBlocker();
michael@0: 
michael@0:   /**
michael@0:    * Decreases the count of blockers preventing scripts from running.
michael@0:    * NOTE: You might want to use nsAutoScriptBlocker rather than calling
michael@0:    * this directly
michael@0:    *
michael@0:    * WARNING! Calling this function could synchronously execute scripts.
michael@0:    */
michael@0:   static void RemoveScriptBlocker();
michael@0: 
michael@0:   /**
michael@0:    * Add a runnable that is to be executed as soon as it's safe to execute
michael@0:    * scripts.
michael@0:    * NOTE: If it's currently safe to execute scripts, aRunnable will be run
michael@0:    *       synchronously before the function returns.
michael@0:    *
michael@0:    * @param aRunnable  The nsIRunnable to run as soon as it's safe to execute
michael@0:    *                   scripts. Passing null is allowed and results in nothing
michael@0:    *                   happening. It is also allowed to pass an object that
michael@0:    *                   has not yet been AddRefed.
michael@0:    * @return false on out of memory, true otherwise.
michael@0:    */
michael@0:   static bool AddScriptRunner(nsIRunnable* aRunnable);
michael@0: 
michael@0:   /**
michael@0:    * Returns true if it's safe to execute content script and false otherwise.
michael@0:    *
michael@0:    * The only known case where this lies is mutation events. They run, and can
michael@0:    * run anything else, when this function returns false, but this is ok.
michael@0:    */
michael@0:   static bool IsSafeToRunScript() {
michael@0:     return sScriptBlockerCount == 0;
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Retrieve information about the viewport as a data structure.
michael@0:    * This will return information in the viewport META data section
michael@0:    * of the document. This can be used in lieu of ProcessViewportInfo(),
michael@0:    * which places the viewport information in the document header instead
michael@0:    * of returning it directly.
michael@0:    *
michael@0:    * @param aDisplayWidth width of the on-screen display area for this
michael@0:    * document, in device pixels.
michael@0:    * @param aDisplayHeight height of the on-screen display area for this
michael@0:    * document, in device pixels.
michael@0:    *
michael@0:    * NOTE: If the site is optimized for mobile (via the doctype), this
michael@0:    * will return viewport information that specifies default information.
michael@0:    */
michael@0:   static nsViewportInfo GetViewportInfo(nsIDocument* aDocument,
michael@0:                                         const mozilla::ScreenIntSize& aDisplaySize);
michael@0: 
michael@0:   // Call EnterMicroTask when you're entering JS execution.
michael@0:   // Usually the best way to do this is to use nsAutoMicroTask.
michael@0:   static void EnterMicroTask();
michael@0:   static void LeaveMicroTask();
michael@0: 
michael@0:   static bool IsInMicroTask();
michael@0:   static uint32_t MicroTaskLevel();
michael@0:   static void SetMicroTaskLevel(uint32_t aLevel);
michael@0: 
michael@0:   /* Process viewport META data. This gives us information for the scale
michael@0:    * and zoom of a page on mobile devices. We stick the information in
michael@0:    * the document header and use it later on after rendering.
michael@0:    *
michael@0:    * See Bug #436083
michael@0:    */
michael@0:   static nsresult ProcessViewportInfo(nsIDocument *aDocument,
michael@0:                                       const nsAString &viewportInfo);
michael@0: 
michael@0:   static nsIScriptContext* GetContextForEventHandlers(nsINode* aNode,
michael@0:                                                       nsresult* aRv);
michael@0: 
michael@0:   static JSContext *GetCurrentJSContext();
michael@0:   static JSContext *GetSafeJSContext();
michael@0:   static JSContext *GetCurrentJSContextForThread();
michael@0:   static JSContext *GetDefaultJSContextForThread();
michael@0: 
michael@0:   /**
michael@0:    * Case insensitive comparison between two strings. However it only ignores
michael@0:    * case for ASCII characters a-z.
michael@0:    */
michael@0:   static bool EqualsIgnoreASCIICase(const nsAString& aStr1,
michael@0:                                     const nsAString& aStr2);
michael@0: 
michael@0:   /**
michael@0:    * Convert ASCII A-Z to a-z.
michael@0:    * @return NS_OK on success, or NS_ERROR_OUT_OF_MEMORY if making the string
michael@0:    * writable needs to allocate memory and that allocation fails.
michael@0:    */
michael@0:   static nsresult ASCIIToLower(nsAString& aStr);
michael@0:   static nsresult ASCIIToLower(const nsAString& aSource, nsAString& aDest);
michael@0: 
michael@0:   /**
michael@0:    * Convert ASCII a-z to A-Z.
michael@0:    * @return NS_OK on success, or NS_ERROR_OUT_OF_MEMORY if making the string
michael@0:    * writable needs to allocate memory and that allocation fails.
michael@0:    */
michael@0:   static nsresult ASCIIToUpper(nsAString& aStr);
michael@0:   static nsresult ASCIIToUpper(const nsAString& aSource, nsAString& aDest);
michael@0: 
michael@0:   /**
michael@0:    * Return whether aStr contains an ASCII uppercase character.
michael@0:    */
michael@0:   static bool StringContainsASCIIUpper(const nsAString& aStr);
michael@0: 
michael@0:   // Returns NS_OK for same origin, error (NS_ERROR_DOM_BAD_URI) if not.
michael@0:   static nsresult CheckSameOrigin(nsIChannel *aOldChannel, nsIChannel *aNewChannel);
michael@0:   static nsIInterfaceRequestor* GetSameOriginChecker();
michael@0: 
michael@0:   // Trace the safe JS context.
michael@0:   static void TraceSafeJSContext(JSTracer* aTrc);
michael@0: 
michael@0: 
michael@0:   /**
michael@0:    * Get the Origin of the passed in nsIPrincipal or nsIURI. If the passed in
michael@0:    * nsIURI or the URI of the passed in nsIPrincipal does not have a host, the
michael@0:    * origin is set to 'null'.
michael@0:    *
michael@0:    * The ASCII versions return a ASCII strings that are puny-code encoded,
michael@0:    * suitable for, for example, header values. The UTF versions return strings
michael@0:    * containing international characters.
michael@0:    *
michael@0:    * @pre aPrincipal/aOrigin must not be null.
michael@0:    *
michael@0:    * @note this should be used for HTML5 origin determination.
michael@0:    */
michael@0:   static nsresult GetASCIIOrigin(nsIPrincipal* aPrincipal,
michael@0:                                  nsCString& aOrigin);
michael@0:   static nsresult GetASCIIOrigin(nsIURI* aURI, nsCString& aOrigin);
michael@0:   static nsresult GetUTFOrigin(nsIPrincipal* aPrincipal,
michael@0:                                nsString& aOrigin);
michael@0:   static nsresult GetUTFOrigin(nsIURI* aURI, nsString& aOrigin);
michael@0:   static void GetUTFNonNullOrigin(nsIURI* aURI, nsString& aOrigin);
michael@0: 
michael@0:   /**
michael@0:    * This method creates and dispatches "command" event, which implements
michael@0:    * nsIDOMXULCommandEvent.
michael@0:    * If aShell is not null, dispatching goes via
michael@0:    * nsIPresShell::HandleDOMEventWithTarget.
michael@0:    */
michael@0:   static nsresult DispatchXULCommand(nsIContent* aTarget,
michael@0:                                      bool aTrusted,
michael@0:                                      nsIDOMEvent* aSourceEvent = nullptr,
michael@0:                                      nsIPresShell* aShell = nullptr,
michael@0:                                      bool aCtrl = false,
michael@0:                                      bool aAlt = false,
michael@0:                                      bool aShift = false,
michael@0:                                      bool aMeta = false);
michael@0: 
michael@0:   /**
michael@0:    * Gets the nsIDocument given the script context. Will return nullptr on failure.
michael@0:    *
michael@0:    * @param aScriptContext the script context to get the document for; can be null
michael@0:    *
michael@0:    * @return the document associated with the script context
michael@0:    */
michael@0:   static nsIDocument*
michael@0:   GetDocumentFromScriptContext(nsIScriptContext* aScriptContext);
michael@0: 
michael@0:   static bool CheckMayLoad(nsIPrincipal* aPrincipal, nsIChannel* aChannel, bool aAllowIfInheritsPrincipal);
michael@0: 
michael@0:   /**
michael@0:    * The method checks whether the caller can access native anonymous content.
michael@0:    * If there is no JS in the stack or privileged JS is running, this
michael@0:    * method returns true, otherwise false.
michael@0:    */
michael@0:   static bool CanAccessNativeAnon();
michael@0: 
michael@0:   MOZ_WARN_UNUSED_RESULT
michael@0:   static nsresult WrapNative(JSContext *cx, nsISupports *native,
michael@0:                              const nsIID* aIID, JS::MutableHandle<JS::Value> vp,
michael@0:                              bool aAllowWrapping = true)
michael@0:   {
michael@0:     return WrapNative(cx, native, nullptr, aIID, vp, aAllowWrapping);
michael@0:   }
michael@0: 
michael@0:   // Same as the WrapNative above, but use this one if aIID is nsISupports' IID.
michael@0:   MOZ_WARN_UNUSED_RESULT
michael@0:   static nsresult WrapNative(JSContext *cx, nsISupports *native,
michael@0:                              JS::MutableHandle<JS::Value> vp,
michael@0:                              bool aAllowWrapping = true)
michael@0:   {
michael@0:     return WrapNative(cx, native, nullptr, nullptr, vp, aAllowWrapping);
michael@0:   }
michael@0: 
michael@0:   MOZ_WARN_UNUSED_RESULT
michael@0:   static nsresult WrapNative(JSContext *cx, nsISupports *native,
michael@0:                              nsWrapperCache *cache,
michael@0:                              JS::MutableHandle<JS::Value> vp,
michael@0:                              bool aAllowWrapping = true)
michael@0:   {
michael@0:     return WrapNative(cx, native, cache, nullptr, vp, aAllowWrapping);
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Creates an arraybuffer from a binary string.
michael@0:    */
michael@0:   static nsresult CreateArrayBuffer(JSContext *aCx, const nsACString& aData,
michael@0:                                     JSObject** aResult);
michael@0: 
michael@0:   static nsresult CreateBlobBuffer(JSContext* aCx,
michael@0:                                    const nsACString& aData,
michael@0:                                    JS::MutableHandle<JS::Value> aBlob);
michael@0: 
michael@0:   static void StripNullChars(const nsAString& aInStr, nsAString& aOutStr);
michael@0: 
michael@0:   /**
michael@0:    * Strip all \n, \r and nulls from the given string
michael@0:    * @param aString the string to remove newlines from [in/out]
michael@0:    */
michael@0:   static void RemoveNewlines(nsString &aString);
michael@0: 
michael@0:   /**
michael@0:    * Convert Windows and Mac platform linebreaks to \n.
michael@0:    * @param aString the string to convert the newlines inside [in/out]
michael@0:    */
michael@0:   static void PlatformToDOMLineBreaks(nsString &aString);
michael@0: 
michael@0:   /**
michael@0:    * Populates aResultString with the contents of the string-buffer aBuf, up
michael@0:    * to aBuf's null-terminator.  aBuf must not be null. Ownership of the string
michael@0:    * is not transferred.
michael@0:    */
michael@0:   static void PopulateStringFromStringBuffer(nsStringBuffer* aBuf,
michael@0:                                              nsAString& aResultString);
michael@0: 
michael@0:   static bool IsHandlingKeyBoardEvent()
michael@0:   {
michael@0:     return sIsHandlingKeyBoardEvent;
michael@0:   }
michael@0: 
michael@0:   static void SetIsHandlingKeyBoardEvent(bool aHandling)
michael@0:   {
michael@0:     sIsHandlingKeyBoardEvent = aHandling;
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Utility method for getElementsByClassName.  aRootNode is the node (either
michael@0:    * document or element), which getElementsByClassName was called on.
michael@0:    */
michael@0:   static already_AddRefed<nsContentList>
michael@0:   GetElementsByClassName(nsINode* aRootNode, const nsAString& aClasses)
michael@0:   {
michael@0:     NS_PRECONDITION(aRootNode, "Must have root node");
michael@0: 
michael@0:     return NS_GetFuncStringHTMLCollection(aRootNode, MatchClassNames,
michael@0:                                           DestroyClassNameArray,
michael@0:                                           AllocClassMatchingInfo,
michael@0:                                           aClasses);
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Returns a presshell for this document, if there is one. This will be
michael@0:    * aDoc's direct presshell if there is one, otherwise we'll look at all
michael@0:    * ancestor documents to try to find a presshell, so for example this can
michael@0:    * still find a presshell for documents in display:none frames that have
michael@0:    * no presentation. So you have to be careful how you use this presshell ---
michael@0:    * getting generic data like a device context or widget from it is OK, but it
michael@0:    * might not be this document's actual presentation.
michael@0:    */
michael@0:   static nsIPresShell* FindPresShellForDocument(const nsIDocument* aDoc);
michael@0: 
michael@0:   /**
michael@0:    * Returns the widget for this document if there is one. Looks at all ancestor
michael@0:    * documents to try to find a widget, so for example this can still find a
michael@0:    * widget for documents in display:none frames that have no presentation.
michael@0:    */
michael@0:   static nsIWidget* WidgetForDocument(const nsIDocument* aDoc);
michael@0: 
michael@0:   /**
michael@0:    * Returns a layer manager to use for the given document. Basically we
michael@0:    * look up the document hierarchy for the first document which has
michael@0:    * a presentation with an associated widget, and use that widget's
michael@0:    * layer manager.
michael@0:    *
michael@0:    * @param aDoc the document for which to return a layer manager.
michael@0:    * @param aAllowRetaining an outparam that states whether the returned
michael@0:    * layer manager should be used for retained layers
michael@0:    */
michael@0:   static already_AddRefed<mozilla::layers::LayerManager>
michael@0:   LayerManagerForDocument(const nsIDocument *aDoc, bool *aAllowRetaining = nullptr);
michael@0: 
michael@0:   /**
michael@0:    * Returns a layer manager to use for the given document. Basically we
michael@0:    * look up the document hierarchy for the first document which has
michael@0:    * a presentation with an associated widget, and use that widget's
michael@0:    * layer manager. In addition to the normal layer manager lookup this will
michael@0:    * specifically request a persistent layer manager. This means that the layer
michael@0:    * manager is expected to remain the layer manager for the document in the
michael@0:    * forseeable future. This function should be used carefully as it may change
michael@0:    * the document's layer manager.
michael@0:    *
michael@0:    * @param aDoc the document for which to return a layer manager.
michael@0:    * @param aAllowRetaining an outparam that states whether the returned
michael@0:    * layer manager should be used for retained layers
michael@0:    */
michael@0:   static already_AddRefed<mozilla::layers::LayerManager>
michael@0:   PersistentLayerManagerForDocument(nsIDocument *aDoc, bool *aAllowRetaining = nullptr);
michael@0: 
michael@0:   /**
michael@0:    * Determine whether a content node is focused or not,
michael@0:    *
michael@0:    * @param aContent the content node to check
michael@0:    * @return true if the content node is focused, false otherwise.
michael@0:    */
michael@0:   static bool IsFocusedContent(const nsIContent *aContent);
michael@0: 
michael@0:   /**
michael@0:    * Returns true if the DOM full-screen API is enabled.
michael@0:    */
michael@0:   static bool IsFullScreenApiEnabled();
michael@0: 
michael@0:   /**
michael@0:    * Returns true if requests for full-screen are allowed in the current
michael@0:    * context. Requests are only allowed if the user initiated them (like with
michael@0:    * a mouse-click or key press), unless this check has been disabled by
michael@0:    * setting the pref "full-screen-api.allow-trusted-requests-only" to false.
michael@0:    */
michael@0:   static bool IsRequestFullScreenAllowed();
michael@0: 
michael@0:   /**
michael@0:    * Returns true if the DOM fullscreen API is restricted to content only.
michael@0:    * This mirrors the pref "full-screen-api.content-only". If this is true,
michael@0:    * fullscreen requests in chrome are denied, and fullscreen requests in
michael@0:    * content stop percolating upwards before they reach chrome documents.
michael@0:    * That is, when an element in content requests fullscreen, only its
michael@0:    * containing frames that are in content are also made fullscreen, not
michael@0:    * the containing frame in the chrome document.
michael@0:    *
michael@0:    * Note if the fullscreen API is running in content only mode then multiple
michael@0:    * branches of a doctree can be fullscreen at the same time, but no fullscreen
michael@0:    * document will have a common ancestor with another fullscreen document
michael@0:    * that is also fullscreen (since the only common ancestor they can have
michael@0:    * is the chrome document, and that can't be fullscreen). i.e. multiple
michael@0:    * child documents of the chrome document can be fullscreen, but the chrome
michael@0:    * document won't be fullscreen.
michael@0:    *
michael@0:    * Making the fullscreen API content only is useful on platforms where we
michael@0:    * still want chrome to be visible or accessible while content is
michael@0:    * fullscreen, like on Windows 8 in Metro mode.
michael@0:    *
michael@0:    * Note that if the fullscreen API is content only, chrome can still go
michael@0:    * fullscreen by setting the "fullScreen" attribute on its XUL window.
michael@0:    */
michael@0:   static bool IsFullscreenApiContentOnly();
michael@0: 
michael@0:   /**
michael@0:    * Returns true if the idle observers API is enabled.
michael@0:    */
michael@0:   static bool IsIdleObserverAPIEnabled() { return sIsIdleObserverAPIEnabled; }
michael@0: 
michael@0:   /*
michael@0:    * Returns true if the performance timing APIs are enabled.
michael@0:    */
michael@0:   static bool IsPerformanceTimingEnabled()
michael@0:   {
michael@0:     return sIsPerformanceTimingEnabled;
michael@0:   }
michael@0:   
michael@0:   /*
michael@0:    * Returns true if the performance timing APIs are enabled.
michael@0:    */
michael@0:   static bool IsResourceTimingEnabled()
michael@0:   {
michael@0:     return sIsResourceTimingEnabled;
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Returns true if the doc tree branch which contains aDoc contains any
michael@0:    * plugins which we don't control event dispatch for, i.e. do any plugins
michael@0:    * in the same tab as this document receive key events outside of our
michael@0:    * control? This always returns false on MacOSX.
michael@0:    */
michael@0:   static bool HasPluginWithUncontrolledEventDispatch(nsIDocument* aDoc);
michael@0: 
michael@0:   /**
michael@0:    * Fire mutation events for changes caused by parsing directly into a
michael@0:    * context node.
michael@0:    *
michael@0:    * @param aDoc the document of the node
michael@0:    * @param aDest the destination node that got stuff appended to it
michael@0:    * @param aOldChildCount the number of children the node had before parsing
michael@0:    */
michael@0:   static void FireMutationEventsForDirectParsing(nsIDocument* aDoc,
michael@0:                                                  nsIContent* aDest,
michael@0:                                                  int32_t aOldChildCount);
michael@0: 
michael@0:   /**
michael@0:    * Returns true if the content is in a document and contains a plugin
michael@0:    * which we don't control event dispatch for, i.e. do any plugins in this
michael@0:    * doc tree receive key events outside of our control? This always returns
michael@0:    * false on MacOSX.
michael@0:    */
michael@0:   static bool HasPluginWithUncontrolledEventDispatch(nsIContent* aContent);
michael@0: 
michael@0:   /**
michael@0:    * Returns the document that is the closest ancestor to aDoc that is
michael@0:    * fullscreen. If aDoc is fullscreen this returns aDoc. If aDoc is not
michael@0:    * fullscreen and none of aDoc's ancestors are fullscreen this returns
michael@0:    * nullptr.
michael@0:    */
michael@0:   static nsIDocument* GetFullscreenAncestor(nsIDocument* aDoc);
michael@0: 
michael@0:   /**
michael@0:    * Returns true if aWin and the current pointer lock document
michael@0:    * have common scriptable top window.
michael@0:    */
michael@0:   static bool IsInPointerLockContext(nsIDOMWindow* aWin);
michael@0: 
michael@0:   /**
michael@0:    * Returns the time limit on handling user input before
michael@0:    * EventStateManager::IsHandlingUserInput() stops returning true.
michael@0:    * This enables us to detect long running user-generated event handlers.
michael@0:    */
michael@0:   static TimeDuration HandlingUserInputTimeout();
michael@0: 
michael@0:   static void GetShiftText(nsAString& text);
michael@0:   static void GetControlText(nsAString& text);
michael@0:   static void GetMetaText(nsAString& text);
michael@0:   static void GetOSText(nsAString& text);
michael@0:   static void GetAltText(nsAString& text);
michael@0:   static void GetModifierSeparatorText(nsAString& text);
michael@0: 
michael@0:   /**
michael@0:    * Returns if aContent has a tabbable subdocument.
michael@0:    * A sub document isn't tabbable when it's a zombie document.
michael@0:    *
michael@0:    * @param aElement element to test.
michael@0:    *
michael@0:    * @return Whether the subdocument is tabbable.
michael@0:    */
michael@0:   static bool IsSubDocumentTabbable(nsIContent* aContent);
michael@0: 
michael@0:   /**
michael@0:    * Returns if aNode ignores user focus.
michael@0:    *
michael@0:    * @param aNode node to test
michael@0:    *
michael@0:    * @return Whether the node ignores user focus.
michael@0:    */
michael@0:   static bool IsUserFocusIgnored(nsINode* aNode);
michael@0: 
michael@0:   /**
michael@0:    * Returns if aContent has the 'scrollgrab' property.
michael@0:    * aContent may be null (in this case false is returned).
michael@0:    */
michael@0:   static bool HasScrollgrab(nsIContent* aContent);
michael@0: 
michael@0:   /**
michael@0:    * Flushes the layout tree (recursively)
michael@0:    *
michael@0:    * @param aWindow the window the flush should start at
michael@0:    *
michael@0:    */
michael@0:   static void FlushLayoutForTree(nsIDOMWindow* aWindow);
michael@0: 
michael@0:   /**
michael@0:    * Returns true if content with the given principal is allowed to use XUL
michael@0:    * and XBL and false otherwise.
michael@0:    */
michael@0:   static bool AllowXULXBLForPrincipal(nsIPrincipal* aPrincipal);
michael@0: 
michael@0:   /**
michael@0:    * Perform cleanup that's appropriate for XPCOM shutdown.
michael@0:    */
michael@0:   static void XPCOMShutdown();
michael@0: 
michael@0:   enum ContentViewerType
michael@0:   {
michael@0:       TYPE_UNSUPPORTED,
michael@0:       TYPE_CONTENT,
michael@0:       TYPE_PLUGIN,
michael@0:       TYPE_UNKNOWN
michael@0:   };
michael@0: 
michael@0:   static already_AddRefed<nsIDocumentLoaderFactory>
michael@0:   FindInternalContentViewer(const char* aType,
michael@0:                             ContentViewerType* aLoaderType = nullptr);
michael@0: 
michael@0:   /**
michael@0:    * This helper method returns true if the aPattern pattern matches aValue.
michael@0:    * aPattern should not contain leading and trailing slashes (/).
michael@0:    * The pattern has to match the entire value not just a subset.
michael@0:    * aDocument must be a valid pointer (not null).
michael@0:    *
michael@0:    * This is following the HTML5 specification:
michael@0:    * http://dev.w3.org/html5/spec/forms.html#attr-input-pattern
michael@0:    *
michael@0:    * WARNING: This method mutates aPattern and aValue!
michael@0:    *
michael@0:    * @param aValue    the string to check.
michael@0:    * @param aPattern  the string defining the pattern.
michael@0:    * @param aDocument the owner document of the element.
michael@0:    * @result          whether the given string is matches the pattern.
michael@0:    */
michael@0:   static bool IsPatternMatching(nsAString& aValue, nsAString& aPattern,
michael@0:                                   nsIDocument* aDocument);
michael@0: 
michael@0:   /**
michael@0:    * Calling this adds support for
michael@0:    * ontouch* event handler DOM attributes.
michael@0:    */
michael@0:   static void InitializeTouchEventTable();
michael@0: 
michael@0:   /**
michael@0:    * Test whether the given URI always inherits a security context
michael@0:    * from the document it comes from.
michael@0:    */
michael@0:   static nsresult URIInheritsSecurityContext(nsIURI *aURI, bool *aResult);
michael@0: 
michael@0:   /**
michael@0:    * Set the given principal as the owner of the given channel, if
michael@0:    * needed.  aURI must be the URI of aChannel.  aPrincipal may be
michael@0:    * null.  If aSetUpForAboutBlank is true, then about:blank will get
michael@0:    * the principal set up on it. If aForceOwner is true, the owner
michael@0:    * will be set on the channel, even if the principal can be determined
michael@0:    * from the channel.
michael@0:    * The return value is whether the principal was set up as the owner
michael@0:    * of the channel.
michael@0:    */
michael@0:   static bool SetUpChannelOwner(nsIPrincipal* aLoadingPrincipal,
michael@0:                                 nsIChannel* aChannel,
michael@0:                                 nsIURI* aURI,
michael@0:                                 bool aSetUpForAboutBlank,
michael@0:                                 bool aForceOwner = false);
michael@0: 
michael@0:   static nsresult Btoa(const nsAString& aBinaryData,
michael@0:                        nsAString& aAsciiBase64String);
michael@0: 
michael@0:   static nsresult Atob(const nsAString& aAsciiString,
michael@0:                        nsAString& aBinaryData);
michael@0: 
michael@0:   /**
michael@0:    * Returns whether the input element passed in parameter has the autocomplete
michael@0:    * functionality enabled. It is taking into account the form owner.
michael@0:    * NOTE: the caller has to make sure autocomplete makes sense for the
michael@0:    * element's type.
michael@0:    *
michael@0:    * @param aInput the input element to check. NOTE: aInput can't be null.
michael@0:    * @return whether the input element has autocomplete enabled.
michael@0:    */
michael@0:   static bool IsAutocompleteEnabled(nsIDOMHTMLInputElement* aInput);
michael@0: 
michael@0:   /**
michael@0:    * This will parse aSource, to extract the value of the pseudo attribute
michael@0:    * with the name specified in aName. See
michael@0:    * http://www.w3.org/TR/xml-stylesheet/#NT-StyleSheetPI for the specification
michael@0:    * which is used to parse aSource.
michael@0:    *
michael@0:    * @param aSource the string to parse
michael@0:    * @param aName the name of the attribute to get the value for
michael@0:    * @param aValue [out] the value for the attribute with name specified in
michael@0:    *                     aAttribute. Empty if the attribute isn't present.
michael@0:    * @return true     if the attribute exists and was successfully parsed.
michael@0:    *         false if the attribute doesn't exist, or has a malformed
michael@0:    *                  value, such as an unknown or unterminated entity.
michael@0:    */
michael@0:   static bool GetPseudoAttributeValue(const nsString& aSource, nsIAtom *aName,
michael@0:                                       nsAString& aValue);
michael@0: 
michael@0:   /**
michael@0:    * Returns true if the language name is a version of JavaScript and
michael@0:    * false otherwise
michael@0:    */
michael@0:   static bool IsJavaScriptLanguage(const nsString& aName);
michael@0: 
michael@0:   /**
michael@0:    * Returns the JSVersion for a string of the form '1.n', n = 0, ..., 8, and
michael@0:    * JSVERSION_UNKNOWN for other strings.
michael@0:    */
michael@0:   static JSVersion ParseJavascriptVersion(const nsAString& aVersionStr);
michael@0: 
michael@0:   static bool IsJavascriptMIMEType(const nsAString& aMIMEType);
michael@0: 
michael@0:   static void SplitMimeType(const nsAString& aValue, nsString& aType,
michael@0:                             nsString& aParams);
michael@0: 
michael@0:   /**
michael@0:    * Function checks if the user is idle.
michael@0:    * 
michael@0:    * @param aRequestedIdleTimeInMS    The idle observer's requested idle time.
michael@0:    * @param aUserIsIdle               boolean indicating if the user 
michael@0:    *                                  is currently idle or not.   *
michael@0:    * @return NS_OK                    NS_OK returned if the requested idle service and 
michael@0:    *                                  the current idle time were successfully obtained.
michael@0:    *                                  NS_ERROR_FAILURE returned if the the requested
michael@0:    *                                  idle service or the current idle were not obtained.
michael@0:    */
michael@0:   static nsresult IsUserIdle(uint32_t aRequestedIdleTimeInMS, bool* aUserIsIdle);
michael@0: 
michael@0:   /**
michael@0:    * Takes a selection, and a text control element (<input> or <textarea>), and
michael@0:    * returns the offsets in the text content corresponding to the selection.
michael@0:    * The selection's anchor and focus must both be in the root node passed or a
michael@0:    * descendant.
michael@0:    *
michael@0:    * @param aSelection      Selection to check
michael@0:    * @param aRoot           Root <input> or <textarea> element
michael@0:    * @param aOutStartOffset Output start offset
michael@0:    * @param aOutEndOffset   Output end offset
michael@0:    */
michael@0:   static void GetSelectionInTextControl(mozilla::dom::Selection* aSelection,
michael@0:                                         Element* aRoot,
michael@0:                                         int32_t& aOutStartOffset,
michael@0:                                         int32_t& aOutEndOffset);
michael@0: 
michael@0:   /**
michael@0:    * Takes a frame for anonymous content within a text control (<input> or
michael@0:    * <textarea>), and returns an offset in the text content, adjusted for a
michael@0:    * trailing <br> frame.
michael@0:    *
michael@0:    * @param aOffsetFrame      Frame for the text content in which the offset
michael@0:    *                          lies
michael@0:    * @param aOffset           Offset as calculated by GetContentOffsetsFromPoint
michael@0:    * @param aOutOffset        Output adjusted offset
michael@0:    *
michael@0:    * @see GetSelectionInTextControl for the original basis of this function.
michael@0:    */
michael@0:   static int32_t GetAdjustedOffsetInTextControl(nsIFrame* aOffsetFrame,
michael@0:                                                 int32_t aOffset);
michael@0: 
michael@0:   static nsIEditor* GetHTMLEditor(nsPresContext* aPresContext);
michael@0: 
michael@0:   /**
michael@0:    * Check whether a spec feature/version is supported.
michael@0:    * @param aObject the object, which should support the feature,
michael@0:    *        for example nsIDOMNode or nsIDOMDOMImplementation
michael@0:    * @param aFeature the feature ("Views", "Core", "HTML", "Range" ...)
michael@0:    * @param aVersion the version ("1.0", "2.0", ...)
michael@0:    * @return whether the feature is supported or not
michael@0:    */
michael@0:   static bool InternalIsSupported(nsISupports* aObject,
michael@0:                                   const nsAString& aFeature,
michael@0:                                   const nsAString& aVersion);
michael@0: 
michael@0:   /**
michael@0:    * Return true if the browser.dom.window.dump.enabled pref is set.
michael@0:    */
michael@0:   static bool DOMWindowDumpEnabled();
michael@0: 
michael@0:   /**
michael@0:    * Returns whether a content is an insertion point for XBL
michael@0:    * bindings or web components ShadowRoot. In web components,
michael@0:    * this corresponds to a <content> element that participates
michael@0:    * in node distribution. In XBL this corresponds to an
michael@0:    * <xbl:children> element in anonymous content.
michael@0:    *
michael@0:    * @param aContent The content to test for being an insertion point.
michael@0:    */
michael@0:   static bool IsContentInsertionPoint(const nsIContent* aContent);
michael@0: 
michael@0: private:
michael@0:   static bool InitializeEventTable();
michael@0: 
michael@0:   static nsresult EnsureStringBundle(PropertiesFile aFile);
michael@0: 
michael@0:   static bool CanCallerAccess(nsIPrincipal* aSubjectPrincipal,
michael@0:                                 nsIPrincipal* aPrincipal);
michael@0: 
michael@0:   static nsresult WrapNative(JSContext *cx, nsISupports *native,
michael@0:                              nsWrapperCache *cache, const nsIID* aIID,
michael@0:                              JS::MutableHandle<JS::Value> vp,
michael@0:                              bool aAllowWrapping);
michael@0: 
michael@0:   static nsresult DispatchEvent(nsIDocument* aDoc,
michael@0:                                 nsISupports* aTarget,
michael@0:                                 const nsAString& aEventName,
michael@0:                                 bool aCanBubble,
michael@0:                                 bool aCancelable,
michael@0:                                 bool aTrusted,
michael@0:                                 bool *aDefaultAction = nullptr);
michael@0: 
michael@0:   static void InitializeModifierStrings();
michael@0: 
michael@0:   static void DropFragmentParsers();
michael@0: 
michael@0:   static bool MatchClassNames(nsIContent* aContent, int32_t aNamespaceID,
michael@0:                               nsIAtom* aAtom, void* aData);
michael@0:   static void DestroyClassNameArray(void* aData);
michael@0:   static void* AllocClassMatchingInfo(nsINode* aRootNode,
michael@0:                                       const nsString* aClasses);
michael@0: 
michael@0:   static nsIXPConnect *sXPConnect;
michael@0: 
michael@0:   static nsIScriptSecurityManager *sSecurityManager;
michael@0: 
michael@0:   static nsIParserService *sParserService;
michael@0: 
michael@0:   static nsNameSpaceManager *sNameSpaceManager;
michael@0: 
michael@0:   static nsIIOService *sIOService;
michael@0: 
michael@0:   static bool sImgLoaderInitialized;
michael@0:   static void InitImgLoader();
michael@0: 
michael@0:   // The following four members are initialized lazily
michael@0:   static imgLoader* sImgLoader;
michael@0:   static imgLoader* sPrivateImgLoader;
michael@0:   static imgICache* sImgCache;
michael@0:   static imgICache* sPrivateImgCache;
michael@0: 
michael@0:   static nsIConsoleService* sConsoleService;
michael@0: 
michael@0:   static nsDataHashtable<nsISupportsHashKey, EventNameMapping>* sAtomEventTable;
michael@0:   static nsDataHashtable<nsStringHashKey, EventNameMapping>* sStringEventTable;
michael@0:   static nsCOMArray<nsIAtom>* sUserDefinedEvents;
michael@0: 
michael@0:   static nsIStringBundleService* sStringBundleService;
michael@0:   static nsIStringBundle* sStringBundles[PropertiesFile_COUNT];
michael@0: 
michael@0:   static nsIContentPolicy* sContentPolicyService;
michael@0:   static bool sTriedToGetContentPolicy;
michael@0: 
michael@0:   static nsILineBreaker* sLineBreaker;
michael@0:   static nsIWordBreaker* sWordBreaker;
michael@0: 
michael@0:   static nsIBidiKeyboard* sBidiKeyboard;
michael@0: 
michael@0:   static bool sInitialized;
michael@0:   static uint32_t sScriptBlockerCount;
michael@0: #ifdef DEBUG
michael@0:   static uint32_t sDOMNodeRemovedSuppressCount;
michael@0: #endif
michael@0:   static uint32_t sMicroTaskLevel;
michael@0:   // Not an nsCOMArray because removing elements from those is slower
michael@0:   static nsTArray< nsCOMPtr<nsIRunnable> >* sBlockedScriptRunners;
michael@0:   static uint32_t sRunnersCountAtFirstBlocker;
michael@0:   static uint32_t sScriptBlockerCountWhereRunnersPrevented;
michael@0: 
michael@0:   static nsIInterfaceRequestor* sSameOriginChecker;
michael@0: 
michael@0:   static bool sIsHandlingKeyBoardEvent;
michael@0:   static bool sAllowXULXBL_for_file;
michael@0:   static bool sIsFullScreenApiEnabled;
michael@0:   static bool sTrustedFullScreenOnly;
michael@0:   static bool sFullscreenApiIsContentOnly;
michael@0:   static uint32_t sHandlingInputTimeout;
michael@0:   static bool sIsIdleObserverAPIEnabled;
michael@0:   static bool sIsPerformanceTimingEnabled;
michael@0:   static bool sIsResourceTimingEnabled;
michael@0: 
michael@0:   static nsHtml5StringParser* sHTMLFragmentParser;
michael@0:   static nsIParser* sXMLFragmentParser;
michael@0:   static nsIFragmentContentSink* sXMLFragmentSink;
michael@0: 
michael@0:   /**
michael@0:    * True if there's a fragment parser activation on the stack.
michael@0:    */
michael@0:   static bool sFragmentParsingActive;
michael@0: 
michael@0:   static nsString* sShiftText;
michael@0:   static nsString* sControlText;
michael@0:   static nsString* sMetaText;
michael@0:   static nsString* sOSText;
michael@0:   static nsString* sAltText;
michael@0:   static nsString* sModifierSeparator;
michael@0: 
michael@0: #if !(defined(DEBUG) || defined(MOZ_ENABLE_JS_DUMP))
michael@0:   static bool sDOMWindowDumpEnabled;
michael@0: #endif
michael@0: };
michael@0: 
michael@0: class MOZ_STACK_CLASS nsAutoScriptBlocker {
michael@0: public:
michael@0:   nsAutoScriptBlocker(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM) {
michael@0:     MOZ_GUARD_OBJECT_NOTIFIER_INIT;
michael@0:     nsContentUtils::AddScriptBlocker();
michael@0:   }
michael@0:   ~nsAutoScriptBlocker() {
michael@0:     nsContentUtils::RemoveScriptBlocker();
michael@0:   }
michael@0: private:
michael@0:   MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
michael@0: };
michael@0: 
michael@0: class MOZ_STACK_CLASS nsAutoScriptBlockerSuppressNodeRemoved :
michael@0:                           public nsAutoScriptBlocker {
michael@0: public:
michael@0:   nsAutoScriptBlockerSuppressNodeRemoved() {
michael@0: #ifdef DEBUG
michael@0:     ++nsContentUtils::sDOMNodeRemovedSuppressCount;
michael@0: #endif
michael@0:   }
michael@0:   ~nsAutoScriptBlockerSuppressNodeRemoved() {
michael@0: #ifdef DEBUG
michael@0:     --nsContentUtils::sDOMNodeRemovedSuppressCount;
michael@0: #endif
michael@0:   }
michael@0: };
michael@0: 
michael@0: class MOZ_STACK_CLASS nsAutoMicroTask
michael@0: {
michael@0: public:
michael@0:   nsAutoMicroTask()
michael@0:   {
michael@0:     nsContentUtils::EnterMicroTask();
michael@0:   }
michael@0:   ~nsAutoMicroTask()
michael@0:   {
michael@0:     nsContentUtils::LeaveMicroTask();
michael@0:   }
michael@0: };
michael@0: 
michael@0: namespace mozilla {
michael@0: namespace dom {
michael@0: 
michael@0: class TreeOrderComparator {
michael@0: public:
michael@0:   bool Equals(nsINode* aElem1, nsINode* aElem2) const {
michael@0:     return aElem1 == aElem2;
michael@0:   }
michael@0:   bool LessThan(nsINode* aElem1, nsINode* aElem2) const {
michael@0:     return nsContentUtils::PositionIsBefore(aElem1, aElem2);
michael@0:   }
michael@0: };
michael@0: 
michael@0: } // namespace dom
michael@0: } // namespace mozilla
michael@0: 
michael@0: #define NS_INTERFACE_MAP_ENTRY_TEAROFF(_interface, _allocator)                \
michael@0:   if (aIID.Equals(NS_GET_IID(_interface))) {                                  \
michael@0:     foundInterface = static_cast<_interface *>(_allocator);                   \
michael@0:     if (!foundInterface) {                                                    \
michael@0:       *aInstancePtr = nullptr;                                                 \
michael@0:       return NS_ERROR_OUT_OF_MEMORY;                                          \
michael@0:     }                                                                         \
michael@0:   } else
michael@0: 
michael@0: /*
michael@0:  * In the following helper macros we exploit the fact that the result of a
michael@0:  * series of additions will not be finite if any one of the operands in the
michael@0:  * series is not finite.
michael@0:  */
michael@0: #define NS_ENSURE_FINITE(f, rv)                                               \
michael@0:   if (!NS_finite(f)) {                                                        \
michael@0:     return (rv);                                                              \
michael@0:   }
michael@0: 
michael@0: #define NS_ENSURE_FINITE2(f1, f2, rv)                                         \
michael@0:   if (!NS_finite((f1)+(f2))) {                                                \
michael@0:     return (rv);                                                              \
michael@0:   }
michael@0: 
michael@0: #define NS_ENSURE_FINITE4(f1, f2, f3, f4, rv)                                 \
michael@0:   if (!NS_finite((f1)+(f2)+(f3)+(f4))) {                                      \
michael@0:     return (rv);                                                              \
michael@0:   }
michael@0: 
michael@0: #define NS_ENSURE_FINITE5(f1, f2, f3, f4, f5, rv)                             \
michael@0:   if (!NS_finite((f1)+(f2)+(f3)+(f4)+(f5))) {                                 \
michael@0:     return (rv);                                                              \
michael@0:   }
michael@0: 
michael@0: #define NS_ENSURE_FINITE6(f1, f2, f3, f4, f5, f6, rv)                         \
michael@0:   if (!NS_finite((f1)+(f2)+(f3)+(f4)+(f5)+(f6))) {                            \
michael@0:     return (rv);                                                              \
michael@0:   }
michael@0: 
michael@0: // Deletes a linked list iteratively to avoid blowing up the stack (bug 460444).
michael@0: #define NS_CONTENT_DELETE_LIST_MEMBER(type_, ptr_, member_)                   \
michael@0:   {                                                                           \
michael@0:     type_ *cur = (ptr_)->member_;                                             \
michael@0:     (ptr_)->member_ = nullptr;                                                 \
michael@0:     while (cur) {                                                             \
michael@0:       type_ *next = cur->member_;                                             \
michael@0:       cur->member_ = nullptr;                                                  \
michael@0:       delete cur;                                                             \
michael@0:       cur = next;                                                             \
michael@0:     }                                                                         \
michael@0:   }
michael@0: 
michael@0: #endif /* nsContentUtils_h___ */