summaryrefslogtreecommitdiffstats
path: root/dom/xul/XULDocument.h
diff options
context:
space:
mode:
Diffstat (limited to 'dom/xul/XULDocument.h')
-rw-r--r--dom/xul/XULDocument.h791
1 files changed, 791 insertions, 0 deletions
diff --git a/dom/xul/XULDocument.h b/dom/xul/XULDocument.h
new file mode 100644
index 000000000..a2f82bb89
--- /dev/null
+++ b/dom/xul/XULDocument.h
@@ -0,0 +1,791 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_XULDocument_h
+#define mozilla_dom_XULDocument_h
+
+#include "nsAutoPtr.h"
+#include "nsCOMPtr.h"
+#include "nsXULPrototypeDocument.h"
+#include "nsXULPrototypeCache.h"
+#include "nsTArray.h"
+
+#include "mozilla/dom/XMLDocument.h"
+#include "mozilla/StyleSheet.h"
+#include "nsForwardReference.h"
+#include "nsIContent.h"
+#include "nsIDOMXULCommandDispatcher.h"
+#include "nsIDOMXULDocument.h"
+#include "nsCOMArray.h"
+#include "nsIURI.h"
+#include "nsIXULDocument.h"
+#include "nsScriptLoader.h"
+#include "nsIStreamListener.h"
+#include "nsIStreamLoader.h"
+#include "nsICSSLoaderObserver.h"
+#include "nsIXULStore.h"
+
+#include "mozilla/Attributes.h"
+
+#include "js/TracingAPI.h"
+#include "js/TypeDecls.h"
+
+class nsIRDFResource;
+class nsIRDFService;
+class nsPIWindowRoot;
+#if 0 // XXXbe save me, scc (need NSCAP_FORWARD_DECL(nsXULPrototypeScript))
+class nsIObjectInputStream;
+class nsIObjectOutputStream;
+#else
+#include "nsIObjectInputStream.h"
+#include "nsIObjectOutputStream.h"
+#include "nsXULElement.h"
+#endif
+#include "nsURIHashKey.h"
+#include "nsInterfaceHashtable.h"
+
+class nsRefMapEntry : public nsStringHashKey
+{
+public:
+ explicit nsRefMapEntry(const nsAString& aKey) :
+ nsStringHashKey(&aKey)
+ {
+ }
+ explicit nsRefMapEntry(const nsAString* aKey) :
+ nsStringHashKey(aKey)
+ {
+ }
+ nsRefMapEntry(const nsRefMapEntry& aOther) :
+ nsStringHashKey(&aOther.GetKey())
+ {
+ NS_ERROR("Should never be called");
+ }
+
+ mozilla::dom::Element* GetFirstElement();
+ void AppendAll(nsCOMArray<nsIContent>* aElements);
+ /**
+ * @return true if aElement was added, false if we failed due to OOM
+ */
+ bool AddElement(mozilla::dom::Element* aElement);
+ /**
+ * @return true if aElement was removed and it was the last content for
+ * this ref, so this entry should be removed from the map
+ */
+ bool RemoveElement(mozilla::dom::Element* aElement);
+
+private:
+ nsTArray<mozilla::dom::Element*> mRefContentList;
+};
+
+/**
+ * The XUL document class
+ */
+
+namespace mozilla {
+namespace dom {
+
+class XULDocument final : public XMLDocument,
+ public nsIXULDocument,
+ public nsIDOMXULDocument,
+ public nsIStreamLoaderObserver,
+ public nsICSSLoaderObserver,
+ public nsIOffThreadScriptReceiver
+{
+public:
+ XULDocument();
+
+ // nsISupports interface
+ NS_DECL_ISUPPORTS_INHERITED
+ NS_DECL_NSISTREAMLOADEROBSERVER
+
+ // nsIDocument interface
+ virtual void Reset(nsIChannel* aChannel, nsILoadGroup* aLoadGroup) override;
+ virtual void ResetToURI(nsIURI *aURI, nsILoadGroup* aLoadGroup,
+ nsIPrincipal* aPrincipal) override;
+
+ virtual nsresult StartDocumentLoad(const char* aCommand,
+ nsIChannel *channel,
+ nsILoadGroup* aLoadGroup,
+ nsISupports* aContainer,
+ nsIStreamListener **aDocListener,
+ bool aReset = true,
+ nsIContentSink* aSink = nullptr) override;
+
+ virtual void SetContentType(const nsAString& aContentType) override;
+
+ virtual void EndLoad() override;
+
+ // nsIMutationObserver interface
+ NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
+ NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
+ NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
+ NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED
+ NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTEWILLCHANGE
+
+ // nsIXULDocument interface
+ virtual void GetElementsForID(const nsAString& aID,
+ nsCOMArray<nsIContent>& aElements) override;
+
+ NS_IMETHOD AddSubtreeToDocument(nsIContent* aContent) override;
+ NS_IMETHOD RemoveSubtreeFromDocument(nsIContent* aContent) override;
+ NS_IMETHOD SetTemplateBuilderFor(nsIContent* aContent,
+ nsIXULTemplateBuilder* aBuilder) override;
+ NS_IMETHOD GetTemplateBuilderFor(nsIContent* aContent,
+ nsIXULTemplateBuilder** aResult) override;
+ NS_IMETHOD OnPrototypeLoadDone(bool aResumeWalk) override;
+ bool OnDocumentParserError() override;
+
+ // nsINode interface overrides
+ virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult) const override;
+
+ // nsIDOMNode interface
+ NS_FORWARD_NSIDOMNODE_TO_NSINODE
+
+ // nsIDOMDocument interface
+ using nsDocument::CreateElement;
+ using nsDocument::CreateElementNS;
+ NS_FORWARD_NSIDOMDOCUMENT(XMLDocument::)
+ // And explicitly import the things from nsDocument that we just shadowed
+ using nsDocument::GetImplementation;
+ using nsDocument::GetTitle;
+ using nsDocument::SetTitle;
+ using nsDocument::GetLastStyleSheetSet;
+ using nsDocument::MozSetImageElement;
+ using nsDocument::GetMozFullScreenElement;
+ using nsIDocument::GetLocation;
+
+ // nsDocument interface overrides
+ virtual Element* GetElementById(const nsAString & elementId) override;
+
+ // nsIDOMXULDocument interface
+ NS_DECL_NSIDOMXULDOCUMENT
+
+ // nsICSSLoaderObserver
+ NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheet* aSheet,
+ bool aWasAlternate,
+ nsresult aStatus) override;
+
+ virtual void EndUpdate(nsUpdateType aUpdateType) override;
+
+ virtual bool IsDocumentRightToLeft() override;
+
+ virtual void ResetDocumentDirection() override;
+
+ virtual int GetDocumentLWTheme() override;
+
+ virtual void ResetDocumentLWTheme() override { mDocLWTheme = Doc_Theme_Uninitialized; }
+
+ NS_IMETHOD OnScriptCompileComplete(JSScript* aScript, nsresult aStatus) override;
+
+ static bool
+ MatchAttribute(nsIContent* aContent,
+ int32_t aNameSpaceID,
+ nsIAtom* aAttrName,
+ void* aData);
+
+ NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(XULDocument, XMLDocument)
+
+ void TraceProtos(JSTracer* aTrc, uint32_t aGCNumber);
+
+ // WebIDL API
+ already_AddRefed<nsINode> GetPopupNode();
+ void SetPopupNode(nsINode* aNode);
+ already_AddRefed<nsINode> GetPopupRangeParent(ErrorResult& aRv);
+ int32_t GetPopupRangeOffset(ErrorResult& aRv);
+ already_AddRefed<nsINode> GetTooltipNode();
+ void SetTooltipNode(nsINode* aNode) { /* do nothing */ }
+ nsIDOMXULCommandDispatcher* GetCommandDispatcher() const
+ {
+ return mCommandDispatcher;
+ }
+ int32_t GetWidth(ErrorResult& aRv);
+ int32_t GetHeight(ErrorResult& aRv);
+ already_AddRefed<nsINodeList>
+ GetElementsByAttribute(const nsAString& aAttribute,
+ const nsAString& aValue);
+ already_AddRefed<nsINodeList>
+ GetElementsByAttributeNS(const nsAString& aNamespaceURI,
+ const nsAString& aAttribute,
+ const nsAString& aValue,
+ ErrorResult& aRv);
+ void AddBroadcastListenerFor(Element& aBroadcaster, Element& aListener,
+ const nsAString& aAttr, ErrorResult& aRv);
+ void RemoveBroadcastListenerFor(Element& aBroadcaster, Element& aListener,
+ const nsAString& aAttr);
+ void Persist(const nsAString& aId, const nsAString& aAttr, ErrorResult& aRv)
+ {
+ aRv = Persist(aId, aAttr);
+ }
+ using nsDocument::GetBoxObjectFor;
+ void LoadOverlay(const nsAString& aURL, nsIObserver* aObserver,
+ ErrorResult& aRv)
+ {
+ aRv = LoadOverlay(aURL, aObserver);
+ }
+
+protected:
+ virtual ~XULDocument();
+
+ // Implementation methods
+ friend nsresult
+ (::NS_NewXULDocument(nsIXULDocument** aResult));
+
+ nsresult Init(void) override;
+ nsresult StartLayout(void);
+
+ nsresult
+ AddElementToRefMap(Element* aElement);
+ void
+ RemoveElementFromRefMap(Element* aElement);
+
+ nsresult GetViewportSize(int32_t* aWidth, int32_t* aHeight);
+
+ nsresult PrepareToLoad(nsISupports* aContainer,
+ const char* aCommand,
+ nsIChannel* aChannel,
+ nsILoadGroup* aLoadGroup,
+ nsIParser** aResult);
+
+ nsresult
+ PrepareToLoadPrototype(nsIURI* aURI,
+ const char* aCommand,
+ nsIPrincipal* aDocumentPrincipal,
+ nsIParser** aResult);
+
+ nsresult
+ LoadOverlayInternal(nsIURI* aURI, bool aIsDynamic, bool* aShouldReturn,
+ bool* aFailureFromContent);
+
+ nsresult ApplyPersistentAttributes();
+ nsresult ApplyPersistentAttributesInternal();
+ nsresult ApplyPersistentAttributesToElements(const nsAString &aID,
+ nsCOMArray<nsIContent>& aElements);
+
+ nsresult
+ AddElementToDocumentPre(Element* aElement);
+
+ nsresult
+ AddElementToDocumentPost(Element* aElement);
+
+ nsresult
+ ExecuteOnBroadcastHandlerFor(Element* aBroadcaster,
+ Element* aListener,
+ nsIAtom* aAttr);
+
+ nsresult
+ BroadcastAttributeChangeFromOverlay(nsIContent* aNode,
+ int32_t aNameSpaceID,
+ nsIAtom* aAttribute,
+ nsIAtom* aPrefix,
+ const nsAString& aValue);
+
+ already_AddRefed<nsPIWindowRoot> GetWindowRoot();
+
+ static void DirectionChanged(const char* aPrefName, void* aData);
+
+ // pseudo constants
+ static int32_t gRefCnt;
+
+ static nsIAtom** kIdentityAttrs[];
+
+ static nsIRDFService* gRDFService;
+ static nsIRDFResource* kNC_persist;
+ static nsIRDFResource* kNC_attribute;
+ static nsIRDFResource* kNC_value;
+
+ static LazyLogModule gXULLog;
+
+ nsresult
+ Persist(nsIContent* aElement, int32_t aNameSpaceID, nsIAtom* aAttribute);
+ // Just like Persist but ignores the return value so we can use it
+ // as a runnable method.
+ void DoPersist(nsIContent* aElement, int32_t aNameSpaceID, nsIAtom* aAttribute)
+ {
+ Persist(aElement, aNameSpaceID, aAttribute);
+ }
+
+ virtual JSObject* WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto) override;
+
+ // IMPORTANT: The ownership implicit in the following member
+ // variables has been explicitly checked and set using nsCOMPtr
+ // for owning pointers and raw COM interface pointers for weak
+ // (ie, non owning) references. If you add any members to this
+ // class, please make the ownership explicit (pinkerton, scc).
+ // NOTE, THIS IS STILL IN PROGRESS, TALK TO PINK OR SCC BEFORE
+ // CHANGING
+
+ XULDocument* mNextSrcLoadWaiter; // [OWNER] but not COMPtr
+
+ // Tracks elements with a 'ref' attribute, or an 'id' attribute where
+ // the element's namespace has no registered ID attribute name.
+ nsTHashtable<nsRefMapEntry> mRefMap;
+ nsCOMPtr<nsIXULStore> mLocalStore;
+ bool mApplyingPersistedAttrs;
+ bool mIsWritingFastLoad;
+ bool mDocumentLoaded;
+ /**
+ * Since ResumeWalk is interruptible, it's possible that last
+ * stylesheet finishes loading while the PD walk is still in
+ * progress (waiting for an overlay to finish loading).
+ * mStillWalking prevents DoneLoading (and StartLayout) from being
+ * called in this situation.
+ */
+ bool mStillWalking;
+
+ /**
+ * These two values control where persistent attributes get applied.
+ */
+ bool mRestrictPersistence;
+ nsTHashtable<nsStringHashKey> mPersistenceIds;
+
+ /**
+ * An array of style sheets, that will be added (preserving order) to the
+ * document after all of them are loaded (in DoneWalking).
+ */
+ nsTArray<RefPtr<StyleSheet>> mOverlaySheets;
+
+ nsCOMPtr<nsIDOMXULCommandDispatcher> mCommandDispatcher; // [OWNER] of the focus tracker
+
+ // Maintains the template builders that have been attached to
+ // content elements
+ typedef nsInterfaceHashtable<nsISupportsHashKey, nsIXULTemplateBuilder>
+ BuilderTable;
+ BuilderTable* mTemplateBuilderTable;
+
+ uint32_t mPendingSheets;
+
+ /**
+ * document lightweight theme for use with :-moz-lwtheme, :-moz-lwtheme-brighttext
+ * and :-moz-lwtheme-darktext
+ */
+ DocumentTheme mDocLWTheme;
+
+ /**
+ * Context stack, which maintains the state of the Builder and allows
+ * it to be interrupted.
+ */
+ class ContextStack {
+ protected:
+ struct Entry {
+ nsXULPrototypeElement* mPrototype;
+ nsIContent* mElement;
+ int32_t mIndex;
+ Entry* mNext;
+ };
+
+ Entry* mTop;
+ int32_t mDepth;
+
+ public:
+ ContextStack();
+ ~ContextStack();
+
+ int32_t Depth() { return mDepth; }
+
+ nsresult Push(nsXULPrototypeElement* aPrototype, nsIContent* aElement);
+ nsresult Pop();
+ nsresult Peek(nsXULPrototypeElement** aPrototype, nsIContent** aElement, int32_t* aIndex);
+
+ nsresult SetTopIndex(int32_t aIndex);
+ };
+
+ friend class ContextStack;
+ ContextStack mContextStack;
+
+ enum State { eState_Master, eState_Overlay };
+ State mState;
+
+ /**
+ * An array of overlay nsIURIs that have yet to be resolved. The
+ * order of the array is significant: overlays at the _end_ of the
+ * array are resolved before overlays earlier in the array (i.e.,
+ * it is a stack).
+ *
+ * In the current implementation the order the overlays are loaded
+ * in is as follows: first overlays from xul-overlay PIs, in the
+ * same order as in the document, then the overlays from the chrome
+ * registry.
+ */
+ nsTArray<nsCOMPtr<nsIURI> > mUnloadedOverlays;
+
+ /**
+ * Load the transcluded script at the specified URI. If the
+ * prototype construction must 'block' until the load has
+ * completed, aBlock will be set to true.
+ */
+ nsresult LoadScript(nsXULPrototypeScript *aScriptProto, bool* aBlock);
+
+ /**
+ * Execute the precompiled script object scoped by this XUL document's
+ * containing window object.
+ */
+ nsresult ExecuteScript(nsXULPrototypeScript *aScript);
+
+ /**
+ * Create a delegate content model element from a prototype.
+ * Note that the resulting content node is not bound to any tree
+ */
+ nsresult CreateElementFromPrototype(nsXULPrototypeElement* aPrototype,
+ Element** aResult,
+ bool aIsRoot);
+
+ /**
+ * Create a hook-up element to which content nodes can be attached for
+ * later resolution.
+ */
+ nsresult CreateOverlayElement(nsXULPrototypeElement* aPrototype,
+ Element** aResult);
+
+ /**
+ * Add attributes from the prototype to the element.
+ */
+ nsresult AddAttributes(nsXULPrototypeElement* aPrototype, nsIContent* aElement);
+
+ /**
+ * The prototype-script of the current transcluded script that is being
+ * loaded. For document.write('<script src="nestedwrite.js"><\/script>')
+ * to work, these need to be in a stack element type, and we need to hold
+ * the top of stack here.
+ */
+ nsXULPrototypeScript* mCurrentScriptProto;
+
+ /**
+ * Whether the current transcluded script is being compiled off thread.
+ * The load event is blocked while this is in progress.
+ */
+ bool mOffThreadCompiling;
+
+ /**
+ * If the current transcluded script is being compiled off thread, the
+ * source for that script.
+ */
+ char16_t* mOffThreadCompileStringBuf;
+ size_t mOffThreadCompileStringLength;
+
+ /**
+ * Check if a XUL template builder has already been hooked up.
+ */
+ static nsresult
+ CheckTemplateBuilderHookup(nsIContent* aElement, bool* aNeedsHookup);
+
+ /**
+ * Create a XUL template builder on the specified node.
+ */
+ static nsresult
+ CreateTemplateBuilder(nsIContent* aElement);
+
+ /**
+ * Add the current prototype's style sheets (currently it's just
+ * style overlays from the chrome registry) to the document.
+ */
+ nsresult AddPrototypeSheets();
+
+
+protected:
+ /* Declarations related to forward references.
+ *
+ * Forward references are declarations which are added to the temporary
+ * list (mForwardReferences) during the document (or overlay) load and
+ * are resolved later, when the document loading is almost complete.
+ */
+
+ /**
+ * The list of different types of forward references to resolve. After
+ * a reference is resolved, it is removed from this array (and
+ * automatically deleted)
+ */
+ nsTArray<nsAutoPtr<nsForwardReference> > mForwardReferences;
+
+ /** Indicates what kind of forward references are still to be processed. */
+ nsForwardReference::Phase mResolutionPhase;
+
+ /**
+ * Adds aRef to the mForwardReferences array. Takes the ownership of aRef.
+ */
+ nsresult AddForwardReference(nsForwardReference* aRef);
+
+ /**
+ * Resolve all of the document's forward references.
+ */
+ nsresult ResolveForwardReferences();
+
+ /**
+ * Used to resolve broadcaster references
+ */
+ class BroadcasterHookup : public nsForwardReference
+ {
+ protected:
+ XULDocument* mDocument; // [WEAK]
+ RefPtr<Element> mObservesElement; // [OWNER]
+ bool mResolved;
+
+ public:
+ BroadcasterHookup(XULDocument* aDocument,
+ Element* aObservesElement)
+ : mDocument(aDocument),
+ mObservesElement(aObservesElement),
+ mResolved(false)
+ {
+ }
+
+ virtual ~BroadcasterHookup();
+
+ virtual Phase GetPhase() override { return eHookup; }
+ virtual Result Resolve() override;
+ };
+
+ friend class BroadcasterHookup;
+
+
+ /**
+ * Used to hook up overlays
+ */
+ class OverlayForwardReference : public nsForwardReference
+ {
+ protected:
+ XULDocument* mDocument; // [WEAK]
+ nsCOMPtr<nsIContent> mOverlay; // [OWNER]
+ bool mResolved;
+
+ nsresult Merge(nsIContent* aTargetNode, nsIContent* aOverlayNode, bool aNotify);
+
+ public:
+ OverlayForwardReference(XULDocument* aDocument, nsIContent* aOverlay)
+ : mDocument(aDocument), mOverlay(aOverlay), mResolved(false) {}
+
+ virtual ~OverlayForwardReference();
+
+ virtual Phase GetPhase() override { return eConstruction; }
+ virtual Result Resolve() override;
+ };
+
+ friend class OverlayForwardReference;
+
+ class TemplateBuilderHookup : public nsForwardReference
+ {
+ protected:
+ nsCOMPtr<nsIContent> mElement; // [OWNER]
+
+ public:
+ explicit TemplateBuilderHookup(nsIContent* aElement)
+ : mElement(aElement) {}
+
+ virtual Phase GetPhase() override { return eHookup; }
+ virtual Result Resolve() override;
+ };
+
+ friend class TemplateBuilderHookup;
+
+ // The out params of FindBroadcaster only have values that make sense when
+ // the method returns NS_FINDBROADCASTER_FOUND. In all other cases, the
+ // values of the out params should not be relied on (though *aListener and
+ // *aBroadcaster do need to be released if non-null, of course).
+ nsresult
+ FindBroadcaster(Element* aElement,
+ Element** aListener,
+ nsString& aBroadcasterID,
+ nsString& aAttribute,
+ Element** aBroadcaster);
+
+ nsresult
+ CheckBroadcasterHookup(Element* aElement,
+ bool* aNeedsHookup,
+ bool* aDidResolve);
+
+ void
+ SynchronizeBroadcastListener(Element *aBroadcaster,
+ Element *aListener,
+ const nsAString &aAttr);
+
+ static
+ nsresult
+ InsertElement(nsINode* aParent, nsIContent* aChild, bool aNotify);
+
+ static
+ nsresult
+ RemoveElement(nsINode* aParent, nsINode* aChild);
+
+ /**
+ * The current prototype that we are walking to construct the
+ * content model.
+ */
+ RefPtr<nsXULPrototypeDocument> mCurrentPrototype;
+
+ /**
+ * The master document (outermost, .xul) prototype, from which
+ * all subdocuments get their security principals.
+ */
+ RefPtr<nsXULPrototypeDocument> mMasterPrototype;
+
+ /**
+ * Owning references to all of the prototype documents that were
+ * used to construct this document.
+ */
+ nsTArray< RefPtr<nsXULPrototypeDocument> > mPrototypes;
+
+ /**
+ * Prepare to walk the current prototype.
+ */
+ nsresult PrepareToWalk();
+
+ /**
+ * Creates a processing instruction based on aProtoPI and inserts
+ * it to the DOM (as the aIndex-th child of aParent).
+ */
+ nsresult
+ CreateAndInsertPI(const nsXULPrototypePI* aProtoPI,
+ nsINode* aParent, uint32_t aIndex);
+
+ /**
+ * Inserts the passed <?xml-stylesheet ?> PI at the specified
+ * index. Loads and applies the associated stylesheet
+ * asynchronously.
+ * The prototype document walk can happen before the stylesheets
+ * are loaded, but the final steps in the load process (see
+ * DoneWalking()) are not run before all the stylesheets are done
+ * loading.
+ */
+ nsresult
+ InsertXMLStylesheetPI(const nsXULPrototypePI* aProtoPI,
+ nsINode* aParent,
+ uint32_t aIndex,
+ nsIContent* aPINode);
+
+ /**
+ * Inserts the passed <?xul-overlay ?> PI at the specified index.
+ * Schedules the referenced overlay URI for further processing.
+ */
+ nsresult
+ InsertXULOverlayPI(const nsXULPrototypePI* aProtoPI,
+ nsINode* aParent,
+ uint32_t aIndex,
+ nsIContent* aPINode);
+
+ /**
+ * Add overlays from the chrome registry to the set of unprocessed
+ * overlays still to do.
+ */
+ nsresult AddChromeOverlays();
+
+ /**
+ * Resume (or initiate) an interrupted (or newly prepared)
+ * prototype walk.
+ */
+ nsresult ResumeWalk();
+
+ /**
+ * Called at the end of ResumeWalk() and from StyleSheetLoaded().
+ * Expects that both the prototype document walk is complete and
+ * all referenced stylesheets finished loading.
+ */
+ nsresult DoneWalking();
+
+ /**
+ * Report that an overlay failed to load
+ * @param aURI the URI of the overlay that failed to load
+ */
+ void ReportMissingOverlay(nsIURI* aURI);
+
+ class CachedChromeStreamListener : public nsIStreamListener {
+ protected:
+ RefPtr<XULDocument> mDocument;
+ bool mProtoLoaded;
+
+ virtual ~CachedChromeStreamListener();
+
+ public:
+ CachedChromeStreamListener(XULDocument* aDocument,
+ bool aProtoLoaded);
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIREQUESTOBSERVER
+ NS_DECL_NSISTREAMLISTENER
+ };
+
+ friend class CachedChromeStreamListener;
+
+
+ class ParserObserver : public nsIRequestObserver {
+ protected:
+ RefPtr<XULDocument> mDocument;
+ RefPtr<nsXULPrototypeDocument> mPrototype;
+ virtual ~ParserObserver();
+
+ public:
+ ParserObserver(XULDocument* aDocument,
+ nsXULPrototypeDocument* aPrototype);
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIREQUESTOBSERVER
+ };
+
+ friend class ParserObserver;
+
+ /**
+ * A map from a broadcaster element to a list of listener elements.
+ */
+ PLDHashTable* mBroadcasterMap;
+
+ nsAutoPtr<nsInterfaceHashtable<nsURIHashKey,nsIObserver> > mOverlayLoadObservers;
+ nsAutoPtr<nsInterfaceHashtable<nsURIHashKey,nsIObserver> > mPendingOverlayLoadNotifications;
+
+ bool mInitialLayoutComplete;
+
+ class nsDelayedBroadcastUpdate
+ {
+ public:
+ nsDelayedBroadcastUpdate(Element* aBroadcaster,
+ Element* aListener,
+ const nsAString &aAttr)
+ : mBroadcaster(aBroadcaster), mListener(aListener), mAttr(aAttr),
+ mSetAttr(false), mNeedsAttrChange(false) {}
+
+ nsDelayedBroadcastUpdate(Element* aBroadcaster,
+ Element* aListener,
+ nsIAtom* aAttrName,
+ const nsAString &aAttr,
+ bool aSetAttr,
+ bool aNeedsAttrChange)
+ : mBroadcaster(aBroadcaster), mListener(aListener), mAttr(aAttr),
+ mAttrName(aAttrName), mSetAttr(aSetAttr),
+ mNeedsAttrChange(aNeedsAttrChange) {}
+
+ nsDelayedBroadcastUpdate(const nsDelayedBroadcastUpdate& aOther)
+ : mBroadcaster(aOther.mBroadcaster), mListener(aOther.mListener),
+ mAttr(aOther.mAttr), mAttrName(aOther.mAttrName),
+ mSetAttr(aOther.mSetAttr), mNeedsAttrChange(aOther.mNeedsAttrChange) {}
+
+ nsCOMPtr<Element> mBroadcaster;
+ nsCOMPtr<Element> mListener;
+ // Note if mAttrName isn't used, this is the name of the attr, otherwise
+ // this is the value of the attribute.
+ nsString mAttr;
+ nsCOMPtr<nsIAtom> mAttrName;
+ bool mSetAttr;
+ bool mNeedsAttrChange;
+
+ class Comparator {
+ public:
+ static bool Equals(const nsDelayedBroadcastUpdate& a, const nsDelayedBroadcastUpdate& b) {
+ return a.mBroadcaster == b.mBroadcaster && a.mListener == b.mListener && a.mAttrName == b.mAttrName;
+ }
+ };
+ };
+
+ nsTArray<nsDelayedBroadcastUpdate> mDelayedBroadcasters;
+ nsTArray<nsDelayedBroadcastUpdate> mDelayedAttrChangeBroadcasts;
+ bool mHandlingDelayedAttrChange;
+ bool mHandlingDelayedBroadcasters;
+
+ void MaybeBroadcast();
+private:
+ // helpers
+
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_XULDocument_h