Bug 848796 part 1. Rename nsXULDocument to mozilla::dom::XULDocument. r=ms2ger
authorBoris Zbarsky <bzbarsky@mit.edu>
Tue, 26 Mar 2013 11:31:53 -0400
changeset 126234 698edae2049f1a20d9b31095d173d714f498f8da
parent 126233 fabc285294b55fab4ed260d89834f98a2e1a2034
child 126235 117757b468b0da5b439492bb952cae88bca777ec
push id25370
push userbzbarsky@mozilla.com
push dateTue, 26 Mar 2013 15:32:45 +0000
treeherdermozilla-inbound@782744e0d347 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersms2ger
bugs848796
milestone22.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 848796 part 1. Rename nsXULDocument to mozilla::dom::XULDocument. r=ms2ger
.gdbinit
browser/components/nsBrowserGlue.js
browser/components/places/tests/browser/browser_toolbar_migration.js
caps/src/nsScriptSecurityManager.cpp
content/base/src/nsCCUncollectableMarker.cpp
content/base/src/nsDocument.cpp
content/xul/content/src/nsXULElement.cpp
content/xul/content/src/nsXULElement.h
content/xul/document/src/Makefile.in
content/xul/document/src/XULDocument.cpp
content/xul/document/src/XULDocument.h
content/xul/document/src/nsXULDocument.cpp
content/xul/document/src/nsXULDocument.h
content/xul/document/src/nsXULPrototypeDocument.cpp
content/xul/document/src/nsXULPrototypeDocument.h
xpcom/base/ErrorList.h
--- a/.gdbinit
+++ b/.gdbinit
@@ -83,17 +83,17 @@ end
 def pa
   set $atom = $arg0
   if (sizeof(*((&*$atom)->mString)) == 2)
     pu (&*$atom)->mString
   end
 end
 
 # define a "pxul" command to display the type of a XUL element from
-# an nsXULDocument* pointer.
+# an nsXULElement* pointer.
 def pxul
   set $p = $arg0
   print $p->mNodeInfo.mRawPtr->mInner.mName->mStaticAtom->mString
 end
 
 # define a "prefcnt" command to display the refcount of an XPCOM obj
 def prefcnt
   set $p = $arg0
--- a/browser/components/nsBrowserGlue.js
+++ b/browser/components/nsBrowserGlue.js
@@ -1393,17 +1393,17 @@ BrowserGlue.prototype = {
         else
           this._dataSource.Unassert(aSource, aProperty, oldTarget);
       }
       else {
         this._dataSource.Assert(aSource, aProperty, this._rdf.GetLiteral(aTarget), true);
       }
 
       // Add the entry to the persisted set for this document if it's not there.
-      // This code is mostly borrowed from nsXULDocument::Persist.
+      // This code is mostly borrowed from XULDocument::Persist.
       let docURL = aSource.ValueUTF8.split("#")[0];
       let docResource = this._rdf.GetResource(docURL);
       let persistResource = this._rdf.GetResource("http://home.netscape.com/NC-rdf#persist");
       if (!this._dataSource.HasAssertion(docResource, persistResource, aSource, true)) {
         this._dataSource.Assert(docResource, persistResource, aSource, true);
       }
     }
     catch(ex) {}
--- a/browser/components/places/tests/browser/browser_toolbar_migration.js
+++ b/browser/components/places/tests/browser/browser_toolbar_migration.js
@@ -14,17 +14,17 @@ let localStore = {
   get RDF() Cc["@mozilla.org/rdf/rdf-service;1"].getService(Ci.nsIRDFService),
   get store() this.RDF.GetDataSource("rdf:local-store"),
 
   get toolbar()
   {
     delete this.toolbar;
     let toolbar = this.RDF.GetResource(BROWSER_URL + "#PersonalToolbar");
     // Add the entry to the persisted set for this document if it's not there.
-    // See nsXULDocument::Persist.
+    // See XULDocument::Persist.
     let doc = this.RDF.GetResource(BROWSER_URL);
     let persist = this.RDF.GetResource("http://home.netscape.com/NC-rdf#persist");
     if (!this.store.HasAssertion(doc, persist, toolbar, true)) {
       this.store.Assert(doc, persist, toolbar, true);
     }
     return this.toolbar = toolbar;
   },
 
--- a/caps/src/nsScriptSecurityManager.cpp
+++ b/caps/src/nsScriptSecurityManager.cpp
@@ -325,17 +325,17 @@ nsScriptSecurityManager::GetChannelPrinc
     if (owner) {
         CallQueryInterface(owner, aPrincipal);
         if (*aPrincipal) {
             return NS_OK;
         }
     }
 
     // OK, get the principal from the URI.  Make sure this does the same thing
-    // as nsDocument::Reset and nsXULDocument::StartDocumentLoad.
+    // as nsDocument::Reset and XULDocument::StartDocumentLoad.
     nsCOMPtr<nsIURI> uri;
     nsresult rv = NS_GetFinalChannelURI(aChannel, getter_AddRefs(uri));
     NS_ENSURE_SUCCESS(rv, rv);
 
     nsCOMPtr<nsIDocShell> docShell;
     NS_QueryNotificationCallbacks(aChannel, docShell);
 
     if (docShell) {
--- a/content/base/src/nsCCUncollectableMarker.cpp
+++ b/content/base/src/nsCCUncollectableMarker.cpp
@@ -4,17 +4,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "nsCCUncollectableMarker.h"
 #include "nsIObserverService.h"
 #include "nsIDocShell.h"
 #include "nsServiceManagerUtils.h"
 #include "nsIContentViewer.h"
 #include "nsIDocument.h"
-#include "nsXULDocument.h"
+#include "XULDocument.h"
 #include "nsIWindowMediator.h"
 #include "nsPIDOMWindow.h"
 #include "nsIWebNavigation.h"
 #include "nsISHistory.h"
 #include "nsISHEntry.h"
 #include "nsISHContainer.h"
 #include "nsIWindowWatcher.h"
 #include "mozilla/Services.h"
@@ -420,17 +420,17 @@ TraceActiveWindowGlobal(const uint64_t& 
   if (aWindow->GetDocShell() && aWindow->IsOuterWindow()) {
     TraceClosure* closure = static_cast<TraceClosure*>(aClosure);
     if (JSObject* global = aWindow->FastGetGlobalJSObject()) {
       JS_CALL_OBJECT_TRACER(closure->mTrc, global, "active window global");
     }
 #ifdef MOZ_XUL
     nsIDocument* doc = aWindow->GetExtantDoc();
     if (doc && doc->IsXUL()) {
-      nsXULDocument* xulDoc = static_cast<nsXULDocument*>(doc);
+      XULDocument* xulDoc = static_cast<XULDocument*>(doc);
       xulDoc->TraceProtos(closure->mTrc, closure->mGCNumber);
     }
 #endif
   }
   return PL_DHASH_NEXT;
 }
 
 void
--- a/content/base/src/nsDocument.cpp
+++ b/content/base/src/nsDocument.cpp
@@ -1940,17 +1940,17 @@ nsIDocument::IsVisibleConsideringAncesto
       }
 
 void
 nsDocument::Reset(nsIChannel* aChannel, nsILoadGroup* aLoadGroup)
 {
   nsCOMPtr<nsIURI> uri;
   nsCOMPtr<nsIPrincipal> principal;
   if (aChannel) {
-    // Note: this code is duplicated in nsXULDocument::StartDocumentLoad and
+    // Note: this code is duplicated in XULDocument::StartDocumentLoad and
     // nsScriptSecurityManager::GetChannelPrincipal.
     // Note: this should match nsDocShell::OnLoadingSite
     NS_GetFinalChannelURI(aChannel, getter_AddRefs(uri));
 
     nsIScriptSecurityManager *securityManager =
       nsContentUtils::GetSecurityManager();
     if (securityManager) {
       securityManager->GetChannelPrincipal(aChannel,
--- a/content/xul/content/src/nsXULElement.cpp
+++ b/content/xul/content/src/nsXULElement.cpp
@@ -60,17 +60,17 @@
 #include "nsLayoutCID.h"
 #include "nsContentCID.h"
 #include "nsRDFCID.h"
 #include "nsStyleConsts.h"
 #include "nsXPIDLString.h"
 #include "nsXULControllers.h"
 #include "nsIBoxObject.h"
 #include "nsPIBoxObject.h"
-#include "nsXULDocument.h"
+#include "XULDocument.h"
 #include "nsXULPopupListener.h"
 #include "nsRuleWalker.h"
 #include "nsIDOMCSSStyleDeclaration.h"
 #include "nsCSSParser.h"
 #include "nsIListBoxObject.h"
 #include "nsContentUtils.h"
 #include "nsContentList.h"
 #include "nsMutationEvent.h"
@@ -101,16 +101,17 @@
 #include "mozAutoDocUpdate.h"
 #include "nsIDOMXULCommandEvent.h"
 #include "nsCCUncollectableMarker.h"
 #include "nsICSSDeclaration.h"
 
 #include "mozilla/dom/XULElementBinding.h"
 
 using namespace mozilla;
+using namespace mozilla::dom;
 
 //----------------------------------------------------------------------
 
 static NS_DEFINE_CID(kXULPopupListenerCID,        NS_XULPOPUPLISTENER_CID);
 
 //----------------------------------------------------------------------
 
 #ifdef XUL_PROTOTYPE_ATTRIBUTE_METERING
@@ -431,17 +432,17 @@ nsXULElement::GetElementsByAttribute(con
 already_AddRefed<nsINodeList>
 nsXULElement::GetElementsByAttribute(const nsAString& aAttribute,
                                      const nsAString& aValue)
 {
     nsCOMPtr<nsIAtom> attrAtom(do_GetAtom(aAttribute));
     void* attrValue = new nsString(aValue);
     nsRefPtr<nsContentList> list =
         new nsContentList(this,
-                          nsXULDocument::MatchAttribute,
+                          XULDocument::MatchAttribute,
                           nsContentUtils::DestroyMatchString,
                           attrValue,
                           true,
                           attrAtom,
                           kNameSpaceID_Unknown);
     return list.forget();
 }
 
@@ -473,17 +474,17 @@ nsXULElement::GetElementsByAttributeNS(c
       if (rv.Failed()) {
           return nullptr;
       }
     }
 
     void* attrValue = new nsString(aValue);
     nsRefPtr<nsContentList> list =
         new nsContentList(this,
-                          nsXULDocument::MatchAttribute,
+                          XULDocument::MatchAttribute,
                           nsContentUtils::DestroyMatchString,
                           attrValue,
                           true,
                           attrAtom,
                           nameSpaceId);
 
     return list.forget();
 }
@@ -2487,17 +2488,17 @@ nsXULPrototypeScript::DeserializeOutOfLi
     nsXULPrototypeCache* cache = nsXULPrototypeCache::GetInstance();
   
     nsCOMPtr<nsIObjectInputStream> objectInput = aInput;
     if (cache) {
         bool useXULCache = true;
         if (mSrcURI) {
             // NB: we must check the XUL script cache early, to avoid
             // multiple deserialization attempts for a given script.            
-            // Note that nsXULDocument::LoadScript
+            // Note that XULDocument::LoadScript
             // checks the XUL script cache too, in order to handle the
             // serialization case.
             //
             // We need do this only for <script src='strres.js'> and the
             // like, i.e., out-of-line scripts that are included by several
             // different XUL documents stored in the cache file.
             useXULCache = cache->IsEnabled();
 
@@ -2595,17 +2596,17 @@ nsXULPrototypeScript::Compile(const PRUn
 
     rv = context->CompileScript(aText,
                                 aTextLength,
                                 // Use the enclosing document's principal
                                 // XXX is this right? or should we use the
                                 // protodoc's?
                                 // If we start using the protodoc's, make sure
                                 // the DowngradePrincipalIfNeeded stuff in
-                                // nsXULDocument::OnStreamComplete still works!
+                                // XULDocument::OnStreamComplete still works!
                                 aDocument->NodePrincipal(),
                                 urlspec.get(),
                                 aLineNo,
                                 mLangVersion,
                                 &newScriptObject,
                                 saveSource);
     if (NS_FAILED(rv))
         return rv;
--- a/content/xul/content/src/nsXULElement.h
+++ b/content/xul/content/src/nsXULElement.h
@@ -194,17 +194,21 @@ public:
 
     uint32_t                 mNumAttributes:29;
     uint32_t                 mHasIdAttribute:1;
     uint32_t                 mHasClassAttribute:1;
     uint32_t                 mHasStyleAttribute:1;
     nsXULPrototypeAttribute* mAttributes;         // [OWNER]
 };
 
-class nsXULDocument;
+namespace mozilla {
+namespace dom {
+class XULDocument;
+} // namespace dom
+} // namespace mozilla
 
 class nsXULPrototypeScript : public nsXULPrototypeNode
 {
 public:
     nsXULPrototypeScript(uint32_t aLineNo, uint32_t version);
     virtual ~nsXULPrototypeScript();
 
 #ifdef NS_BUILD_REFCNT_LOGGING
@@ -237,17 +241,17 @@ public:
     {
         return mScriptObject;
     }
 
     nsCOMPtr<nsIURI>         mSrcURI;
     uint32_t                 mLineNo;
     bool                     mSrcLoading;
     bool                     mOutOfLine;
-    nsXULDocument*           mSrcLoadWaiters;   // [OWNER] but not COMPtr
+    mozilla::dom::XULDocument* mSrcLoadWaiters;   // [OWNER] but not COMPtr
     uint32_t                 mLangVersion;
 private:
     JSScript*                mScriptObject;
 };
 
 class nsXULPrototypeText : public nsXULPrototypeNode
 {
 public:
--- a/content/xul/document/src/Makefile.in
+++ b/content/xul/document/src/Makefile.in
@@ -15,17 +15,17 @@ LIBXUL_LIBRARY	= 1
 
 
 CPPSRCS		= nsXULControllers.cpp
 
 ifdef MOZ_XUL
 CPPSRCS		+= \
 		nsXULCommandDispatcher.cpp \
 		nsXULContentSink.cpp \
-		nsXULDocument.cpp \
+		XULDocument.cpp \
 		nsXULPrototypeCache.cpp \
 		nsXULPrototypeDocument.cpp \
 		$(NULL)
 endif
 
 # we don't want the shared lib, but we want to force the creation of a
 # static lib.
 FORCE_STATIC_LIB = 1
rename from content/xul/document/src/nsXULDocument.cpp
rename to content/xul/document/src/XULDocument.cpp
--- a/content/xul/document/src/nsXULDocument.cpp
+++ b/content/xul/document/src/XULDocument.cpp
@@ -19,17 +19,17 @@
      document observer methods will never be called because we'll be
      adding the XUL nodes into the content model "quietly".
 
 */
 
 #include "mozilla/Util.h"
 
 // Note the ALPHABETICAL ORDERING
-#include "nsXULDocument.h"
+#include "XULDocument.h"
 
 #include "nsError.h"
 #include "nsIBoxObject.h"
 #include "nsIChromeRegistry.h"
 #include "nsView.h"
 #include "nsViewManager.h"
 #include "nsIContentViewer.h"
 #include "nsGUIEvent.h"
@@ -96,17 +96,16 @@ using namespace mozilla::dom;
 //
 // CIDs
 //
 
 static NS_DEFINE_CID(kParserCID,                 NS_PARSER_CID);
 
 static bool IsChromeURI(nsIURI* aURI)
 {
-    // why is this check a member function of nsXULDocument? -gagan
     bool isChrome = false;
     if (NS_SUCCEEDED(aURI->SchemeIs("chrome", &isChrome)) && isChrome)
         return true;
     return false;
 }
 
 static bool IsOverlayAllowed(nsIURI* aURI)
 {
@@ -132,24 +131,24 @@ const nsForwardReference::Phase nsForwar
 const uint32_t kMaxAttrNameLength = 512;
 const uint32_t kMaxAttributeLength = 4096;
 
 //----------------------------------------------------------------------
 //
 // Statics
 //
 
-int32_t nsXULDocument::gRefCnt = 0;
-
-nsIRDFService* nsXULDocument::gRDFService;
-nsIRDFResource* nsXULDocument::kNC_persist;
-nsIRDFResource* nsXULDocument::kNC_attribute;
-nsIRDFResource* nsXULDocument::kNC_value;
-
-PRLogModuleInfo* nsXULDocument::gXULLog;
+int32_t XULDocument::gRefCnt = 0;
+
+nsIRDFService* XULDocument::gRDFService;
+nsIRDFResource* XULDocument::kNC_persist;
+nsIRDFResource* XULDocument::kNC_attribute;
+nsIRDFResource* XULDocument::kNC_value;
+
+PRLogModuleInfo* XULDocument::gXULLog;
 
 //----------------------------------------------------------------------
 
 struct BroadcasterMapEntry : public PLDHashEntryHdr {
     nsIDOMElement*   mBroadcaster; // [WEAK]
     nsSmallVoidArray mListeners;   // [OWNING] of BroadcastListener objects
 };
 
@@ -187,20 +186,22 @@ nsRefMapEntry::RemoveElement(Element* aE
     return mRefContentList.Count() == 0;
 }
 
 //----------------------------------------------------------------------
 //
 // ctors & dtors
 //
 
-    // NOTE! nsDocument::operator new() zeroes out all members, so
-    // don't bother initializing members to 0.
-
-nsXULDocument::nsXULDocument(void)
+DOMCI_NODE_DATA(XULDocument, XULDocument)
+
+namespace mozilla {
+namespace dom {
+
+XULDocument::XULDocument(void)
     : XMLDocument("application/vnd.mozilla.xul+xml"),
       mDocLWTheme(Doc_Theme_Uninitialized),
       mState(eState_Master),
       mResolutionPhase(nsForwardReference::eStart)
 {
 
     // NOTE! nsDocument::operator new() zeroes out all members, so don't
     // bother initializing members to 0.
@@ -211,17 +212,17 @@ nsXULDocument::nsXULDocument(void)
     mDefaultElementType = kNameSpaceID_XUL;
     mIsXUL = true;
 
     mDelayFrameLoaderInitialization = true;
 
     mAllowXULXBL = eTriTrue;
 }
 
-nsXULDocument::~nsXULDocument()
+XULDocument::~XULDocument()
 {
     NS_ASSERTION(mNextSrcLoadWaiter == nullptr,
         "unreferenced document still waiting for script source to load?");
 
     // In case we failed somewhere early on and the forward observer
     // decls never got resolved.
     mForwardReferences.Clear();
 
@@ -234,52 +235,58 @@ nsXULDocument::~nsXULDocument()
         nsCOMPtr<nsIRDFRemoteDataSource> remote =
             do_QueryInterface(mLocalStore);
         if (remote)
             remote->Flush();
     }
 
     delete mTemplateBuilderTable;
 
-    Preferences::UnregisterCallback(nsXULDocument::DirectionChanged,
+    Preferences::UnregisterCallback(XULDocument::DirectionChanged,
                                     "intl.uidirection.", this);
 
     if (--gRefCnt == 0) {
         NS_IF_RELEASE(gRDFService);
 
         NS_IF_RELEASE(kNC_persist);
         NS_IF_RELEASE(kNC_attribute);
         NS_IF_RELEASE(kNC_value);
     }
 }
 
+} // namespace dom
+} // namespace mozilla
+
 nsresult
 NS_NewXULDocument(nsIXULDocument** result)
 {
     NS_PRECONDITION(result != nullptr, "null ptr");
     if (! result)
         return NS_ERROR_NULL_POINTER;
 
-    nsXULDocument* doc = new nsXULDocument();
+    XULDocument* doc = new XULDocument();
     if (! doc)
         return NS_ERROR_OUT_OF_MEMORY;
 
     NS_ADDREF(doc);
 
     nsresult rv;
     if (NS_FAILED(rv = doc->Init())) {
         NS_RELEASE(doc);
         return rv;
     }
 
     *result = doc;
     return NS_OK;
 }
 
 
+namespace mozilla {
+namespace dom {
+
 //----------------------------------------------------------------------
 //
 // nsISupports interface
 //
 
 static PLDHashOperator
 TraverseTemplateBuilders(nsISupports* aKey, nsIXULTemplateBuilder* aData,
                          void* aContext)
@@ -302,19 +309,19 @@ TraverseObservers(nsIURI* aKey, nsIObser
         static_cast<nsCycleCollectionTraversalCallback*>(aContext);
 
     NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mOverlayLoadObservers/mPendingOverlayLoadNotifications value");
     cb->NoteXPCOMChild(aData);
 
     return PL_DHASH_NEXT;
 }
 
-NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(nsXULDocument, XMLDocument)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(XULDocument, XMLDocument)
     NS_ASSERTION(!nsCCUncollectableMarker::InGeneration(cb, tmp->GetMarkedCCGeneration()),
-                 "Shouldn't traverse nsXULDocument!");
+                 "Shouldn't traverse XULDocument!");
     // XXX tmp->mForwardReferences?
     // XXX tmp->mContextStack?
 
     // An element will only have a template builder as long as it's in the
     // document, so we'll traverse the table here instead of from the element.
     if (tmp->mTemplateBuilderTable)
         tmp->mTemplateBuilderTable->EnumerateRead(TraverseTemplateBuilders, &cb);
         
@@ -331,78 +338,76 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_
     NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLocalStore)
 
     if (tmp->mOverlayLoadObservers.IsInitialized())
         tmp->mOverlayLoadObservers.EnumerateRead(TraverseObservers, &cb);
     if (tmp->mPendingOverlayLoadNotifications.IsInitialized())
         tmp->mPendingOverlayLoadNotifications.EnumerateRead(TraverseObservers, &cb);
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
-NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(nsXULDocument, XMLDocument)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(XULDocument, XMLDocument)
     delete tmp->mTemplateBuilderTable;
     tmp->mTemplateBuilderTable = nullptr;
 
     NS_IMPL_CYCLE_COLLECTION_UNLINK(mCommandDispatcher)
     //XXX We should probably unlink all the objects we traverse.
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
-NS_IMPL_ADDREF_INHERITED(nsXULDocument, XMLDocument)
-NS_IMPL_RELEASE_INHERITED(nsXULDocument, XMLDocument)
-
-
-DOMCI_NODE_DATA(XULDocument, nsXULDocument)
-
-// QueryInterface implementation for nsXULDocument
-NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(nsXULDocument)
-    NS_DOCUMENT_INTERFACE_TABLE_BEGIN(nsXULDocument)
-      NS_INTERFACE_TABLE_ENTRY(nsXULDocument, nsIXULDocument)
-      NS_INTERFACE_TABLE_ENTRY(nsXULDocument, nsIDOMXULDocument)
-      NS_INTERFACE_TABLE_ENTRY(nsXULDocument, nsIStreamLoaderObserver)
-      NS_INTERFACE_TABLE_ENTRY(nsXULDocument, nsICSSLoaderObserver)
+NS_IMPL_ADDREF_INHERITED(XULDocument, XMLDocument)
+NS_IMPL_RELEASE_INHERITED(XULDocument, XMLDocument)
+
+
+// QueryInterface implementation for XULDocument
+NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(XULDocument)
+    NS_DOCUMENT_INTERFACE_TABLE_BEGIN(XULDocument)
+      NS_INTERFACE_TABLE_ENTRY(XULDocument, nsIXULDocument)
+      NS_INTERFACE_TABLE_ENTRY(XULDocument, nsIDOMXULDocument)
+      NS_INTERFACE_TABLE_ENTRY(XULDocument, nsIStreamLoaderObserver)
+      NS_INTERFACE_TABLE_ENTRY(XULDocument, nsICSSLoaderObserver)
     NS_OFFSET_AND_INTERFACE_TABLE_END
     NS_OFFSET_AND_INTERFACE_TABLE_TO_MAP_SEGUE
     NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(XULDocument)
 NS_INTERFACE_MAP_END_INHERITING(XMLDocument)
 
 
 //----------------------------------------------------------------------
 //
 // nsIDocument interface
 //
 
 void
-nsXULDocument::Reset(nsIChannel* aChannel, nsILoadGroup* aLoadGroup)
+XULDocument::Reset(nsIChannel* aChannel, nsILoadGroup* aLoadGroup)
 {
     NS_NOTREACHED("Reset");
 }
 
 void
-nsXULDocument::ResetToURI(nsIURI* aURI, nsILoadGroup* aLoadGroup,
-                          nsIPrincipal* aPrincipal)
+XULDocument::ResetToURI(nsIURI* aURI, nsILoadGroup* aLoadGroup,
+                        nsIPrincipal* aPrincipal)
 {
     NS_NOTREACHED("ResetToURI");
 }
 
 void
-nsXULDocument::SetContentType(const nsAString& aContentType)
+XULDocument::SetContentType(const nsAString& aContentType)
 {
     NS_ASSERTION(aContentType.EqualsLiteral("application/vnd.mozilla.xul+xml"),
                  "xul-documents always has content-type application/vnd.mozilla.xul+xml");
     // Don't do anything, xul always has the mimetype
     // application/vnd.mozilla.xul+xml
 }
 
 // This is called when the master document begins loading, whether it's
 // being cached or not.
 nsresult
-nsXULDocument::StartDocumentLoad(const char* aCommand, nsIChannel* aChannel,
-                                 nsILoadGroup* aLoadGroup,
-                                 nsISupports* aContainer,
-                                 nsIStreamListener **aDocListener,
-                                 bool aReset, nsIContentSink* aSink)
+XULDocument::StartDocumentLoad(const char* aCommand, nsIChannel* aChannel,
+                               nsILoadGroup* aLoadGroup,
+                               nsISupports* aContainer,
+                               nsIStreamListener **aDocListener,
+                               bool aReset, nsIContentSink* aSink)
 {
 #ifdef PR_LOGGING
     if (PR_LOG_TEST(gXULLog, PR_LOG_WARNING)) {
 
         nsCOMPtr<nsIURI> uri;
         nsresult rv = aChannel->GetOriginalURI(getter_AddRefs(uri));
         if (NS_SUCCEEDED(rv)) {
             nsAutoCString urlspec;
@@ -436,17 +441,17 @@ nsXULDocument::StartDocumentLoad(const c
 
     // Look in the chrome cache: we've got this puppy loaded
     // already.
     nsXULPrototypeDocument* proto = IsChromeURI(mDocumentURI) ?
             nsXULPrototypeCache::GetInstance()->GetPrototype(mDocumentURI) :
             nullptr;
 
     // Same comment as nsChromeProtocolHandler::NewChannel and
-    // nsXULDocument::ResumeWalk
+    // XULDocument::ResumeWalk
     // - Ben Goodger
     //
     // We don't abort on failure here because there are too many valid
     // cases that can return failure, and the null-ness of |proto| is enough
     // to trigger the fail-safe parse-from-disk solution. Example failure cases
     // (for reference) include:
     //
     // NS_ERROR_NOT_AVAILABLE: the URI cannot be found in the startup cache,
@@ -454,31 +459,31 @@ nsXULDocument::StartDocumentLoad(const c
     // other: the startup cache file could not be found, probably
     //        due to being accessed before a profile has been selected (e.g.
     //        loading chrome for the profile manager itself). This must be
     //        parsed from disk.
 
     if (proto) {
         // If we're racing with another document to load proto, wait till the
         // load has finished loading before trying to add cloned style sheets.
-        // nsXULDocument::EndLoad will call proto->NotifyLoadDone, which will
+        // XULDocument::EndLoad will call proto->NotifyLoadDone, which will
         // find all racing documents and notify them via OnPrototypeLoadDone,
         // which will add style sheet clones to each document.
         bool loaded;
         rv = proto->AwaitLoadDone(this, &loaded);
         if (NS_FAILED(rv)) return rv;
 
         mMasterPrototype = mCurrentPrototype = proto;
 
         // Set up the right principal on ourselves.
         SetPrincipal(proto->DocumentPrincipal());
 
         // We need a listener, even if proto is not yet loaded, in which
         // event the listener's OnStopRequest method does nothing, and all
-        // the interesting work happens below nsXULDocument::EndLoad, from
+        // the interesting work happens below XULDocument::EndLoad, from
         // the call there to mCurrentPrototype->NotifyLoadDone().
         *aDocListener = new CachedChromeStreamListener(this, loaded);
         if (! *aDocListener)
             return NS_ERROR_OUT_OF_MEMORY;
     }
     else {
         bool useXULCache = nsXULPrototypeCache::GetInstance()->IsEnabled();
         bool fillXULCache = (useXULCache && IsChromeURI(mDocumentURI));
@@ -516,17 +521,17 @@ nsXULDocument::StartDocumentLoad(const c
 
     NS_IF_ADDREF(*aDocListener);
     return NS_OK;
 }
 
 // This gets invoked after a prototype for this document or one of
 // its overlays is fully built in the content sink.
 void
-nsXULDocument::EndLoad()
+XULDocument::EndLoad()
 {
     // This can happen if an overlay fails to load
     if (!mCurrentPrototype)
         return;
 
     nsresult rv;
 
     // Whack the prototype document into the cache so that the next
@@ -536,17 +541,17 @@ nsXULDocument::EndLoad()
     bool isChrome = IsChromeURI(uri);
 
     // Remember if the XUL cache is on
     bool useXULCache = nsXULPrototypeCache::GetInstance()->IsEnabled();
 
     // If the current prototype is an overlay document (non-master prototype)
     // and we're filling the FastLoad disk cache, tell the cache we're done
     // loading it, and write the prototype. The master prototype is put into
-    // the cache earlier in nsXULDocument::StartDocumentLoad.
+    // the cache earlier in XULDocument::StartDocumentLoad.
     if (useXULCache && mIsWritingFastLoad && isChrome &&
         mMasterPrototype != mCurrentPrototype) {
         nsXULPrototypeCache::GetInstance()->WritePrototype(mCurrentPrototype);
     }
 
     if (IsOverlayAllowed(uri)) {
         nsCOMPtr<nsIXULOverlayProvider> reg =
             mozilla::services::GetXULOverlayProviderService();
@@ -594,17 +599,17 @@ nsXULDocument::EndLoad()
             PR_LOG(gXULLog, PR_LOG_WARNING,
                    ("xul: Finished loading document '%s'", urlspec.get()));
         }
     }
 #endif
 }
 
 NS_IMETHODIMP
-nsXULDocument::OnPrototypeLoadDone(bool aResumeWalk)
+XULDocument::OnPrototypeLoadDone(bool aResumeWalk)
 {
     nsresult rv;
 
     // Add the style overlays from chrome registry, if any.
     rv = AddPrototypeSheets();
     if (NS_FAILED(rv)) return rv;
 
     rv = PrepareToWalk();
@@ -614,17 +619,17 @@ nsXULDocument::OnPrototypeLoadDone(bool 
     if (aResumeWalk) {
         rv = ResumeWalk();
     }
     return rv;
 }
 
 // called when an error occurs parsing a document
 bool
-nsXULDocument::OnDocumentParserError()
+XULDocument::OnDocumentParserError()
 {
   // don't report errors that are from overlays
   if (mCurrentPrototype && mMasterPrototype != mCurrentPrototype) {
     nsCOMPtr<nsIURI> uri = mCurrentPrototype->GetURI();
     if (IsChromeURI(uri)) {
       nsCOMPtr<nsIObserverService> os =
         mozilla::services::GetObserverService();
       if (os)
@@ -677,19 +682,19 @@ struct nsAttrNameInfo
     mNamespaceID(aOther.mNamespaceID), mName(aOther.mName),
     mPrefix(aOther.mPrefix) {}
   int32_t           mNamespaceID;
   nsCOMPtr<nsIAtom> mName;
   nsCOMPtr<nsIAtom> mPrefix;
 };
 
 void
-nsXULDocument::SynchronizeBroadcastListener(nsIDOMElement   *aBroadcaster,
-                                            nsIDOMElement   *aListener,
-                                            const nsAString &aAttr)
+XULDocument::SynchronizeBroadcastListener(nsIDOMElement   *aBroadcaster,
+                                          nsIDOMElement   *aListener,
+                                          const nsAString &aAttr)
 {
     if (!nsContentUtils::IsSafeToRunScript()) {
         nsDelayedBroadcastUpdate delayedUpdate(aBroadcaster, aListener,
                                                aAttr);
         mDelayedBroadcasters.AppendElement(delayedUpdate);
         MaybeBroadcast();
         return;
     }
@@ -750,19 +755,19 @@ nsXULDocument::SynchronizeBroadcastListe
         // handler before the |onload| handler, which could define JS
         // properties that mask XBL properties, etc.
         ExecuteOnBroadcastHandlerFor(broadcaster, aListener, name);
 #endif
     }
 }
 
 NS_IMETHODIMP
-nsXULDocument::AddBroadcastListenerFor(nsIDOMElement* aBroadcaster,
-                                       nsIDOMElement* aListener,
-                                       const nsAString& aAttr)
+XULDocument::AddBroadcastListenerFor(nsIDOMElement* aBroadcaster,
+                                     nsIDOMElement* aListener,
+                                     const nsAString& aAttr)
 {
     NS_ENSURE_ARG(aBroadcaster && aListener);
     
     nsresult rv =
         nsContentUtils::CheckSameOrigin(this, aBroadcaster);
 
     if (NS_FAILED(rv)) {
         return rv;
@@ -837,19 +842,19 @@ nsXULDocument::AddBroadcastListenerFor(n
 
     entry->mListeners.AppendElement(bl);
 
     SynchronizeBroadcastListener(aBroadcaster, aListener, aAttr);
     return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXULDocument::RemoveBroadcastListenerFor(nsIDOMElement* aBroadcaster,
-                                          nsIDOMElement* aListener,
-                                          const nsAString& aAttr)
+XULDocument::RemoveBroadcastListenerFor(nsIDOMElement* aBroadcaster,
+                                        nsIDOMElement* aListener,
+                                        const nsAString& aAttr)
 {
     // If we haven't added any broadcast listeners, then there sure
     // aren't any to remove.
     if (! mBroadcasterMap)
         return NS_OK;
 
     BroadcasterMapEntry* entry =
         static_cast<BroadcasterMapEntry*>
@@ -876,19 +881,19 @@ nsXULDocument::RemoveBroadcastListenerFo
             }
         }
     }
 
     return NS_OK;
 }
 
 nsresult
-nsXULDocument::ExecuteOnBroadcastHandlerFor(nsIContent* aBroadcaster,
-                                            nsIDOMElement* aListener,
-                                            nsIAtom* aAttr)
+XULDocument::ExecuteOnBroadcastHandlerFor(nsIContent* aBroadcaster,
+                                          nsIDOMElement* aListener,
+                                          nsIAtom* aAttr)
 {
     // Now we execute the onchange handler in the context of the
     // observer. We need to find the observer in order to
     // execute the handler.
 
     nsCOMPtr<nsIContent> listener = do_QueryInterface(aListener);
     for (nsIContent* child = listener->GetFirstChild();
          child;
@@ -936,37 +941,37 @@ nsXULDocument::ExecuteOnBroadcastHandler
                                         &status);
         }
     }
 
     return NS_OK;
 }
 
 void
-nsXULDocument::AttributeWillChange(nsIDocument* aDocument,
-                                   Element* aElement, int32_t aNameSpaceID,
-                                   nsIAtom* aAttribute, int32_t aModType)
+XULDocument::AttributeWillChange(nsIDocument* aDocument,
+                                 Element* aElement, int32_t aNameSpaceID,
+                                 nsIAtom* aAttribute, int32_t aModType)
 {
     NS_ABORT_IF_FALSE(aElement, "Null content!");
     NS_PRECONDITION(aAttribute, "Must have an attribute that's changing!");
 
     // XXXbz check aNameSpaceID, dammit!
     // See if we need to update our ref map.
     if (aAttribute == nsGkAtoms::ref ||
         (aAttribute == nsGkAtoms::id && !aElement->GetIDAttributeName())) {
         // Might not need this, but be safe for now.
         nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this);
         RemoveElementFromRefMap(aElement);
     }
 }
 
 void
-nsXULDocument::AttributeChanged(nsIDocument* aDocument,
-                                Element* aElement, int32_t aNameSpaceID,
-                                nsIAtom* aAttribute, int32_t aModType)
+XULDocument::AttributeChanged(nsIDocument* aDocument,
+                              Element* aElement, int32_t aNameSpaceID,
+                              nsIAtom* aAttribute, int32_t aModType)
 {
     NS_ASSERTION(aDocument == this, "unexpected doc");
 
     // Might not need this, but be safe for now.
     nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this);
 
     // XXXbz check aNameSpaceID, dammit!
     // See if we need to update our ref map.
@@ -1051,103 +1056,103 @@ nsXULDocument::AttributeChanged(nsIDocum
         if (persist.Find(nsDependentAtomString(aAttribute)) >= 0) {
             rv = Persist(aElement, kNameSpaceID_None, aAttribute);
             if (NS_FAILED(rv)) return;
         }
     }
 }
 
 void
-nsXULDocument::ContentAppended(nsIDocument* aDocument,
-                               nsIContent* aContainer,
-                               nsIContent* aFirstNewContent,
-                               int32_t aNewIndexInContainer)
+XULDocument::ContentAppended(nsIDocument* aDocument,
+                             nsIContent* aContainer,
+                             nsIContent* aFirstNewContent,
+                             int32_t aNewIndexInContainer)
 {
     NS_ASSERTION(aDocument == this, "unexpected doc");
     
     // Might not need this, but be safe for now.
     nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this);
 
     // Update our element map
     nsresult rv = NS_OK;
     for (nsIContent* cur = aFirstNewContent; cur && NS_SUCCEEDED(rv);
          cur = cur->GetNextSibling()) {
         rv = AddSubtreeToDocument(cur);
     }
 }
 
 void
-nsXULDocument::ContentInserted(nsIDocument* aDocument,
-                               nsIContent* aContainer,
-                               nsIContent* aChild,
-                               int32_t aIndexInContainer)
+XULDocument::ContentInserted(nsIDocument* aDocument,
+                             nsIContent* aContainer,
+                             nsIContent* aChild,
+                             int32_t aIndexInContainer)
 {
     NS_ASSERTION(aDocument == this, "unexpected doc");
 
     // Might not need this, but be safe for now.
     nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this);
 
     AddSubtreeToDocument(aChild);
 }
 
 void
-nsXULDocument::ContentRemoved(nsIDocument* aDocument,
-                              nsIContent* aContainer,
-                              nsIContent* aChild,
-                              int32_t aIndexInContainer,
-                              nsIContent* aPreviousSibling)
+XULDocument::ContentRemoved(nsIDocument* aDocument,
+                            nsIContent* aContainer,
+                            nsIContent* aChild,
+                            int32_t aIndexInContainer,
+                            nsIContent* aPreviousSibling)
 {
     NS_ASSERTION(aDocument == this, "unexpected doc");
 
     // Might not need this, but be safe for now.
     nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this);
 
     RemoveSubtreeFromDocument(aChild);
 }
 
 //----------------------------------------------------------------------
 //
 // nsIXULDocument interface
 //
 
 void
-nsXULDocument::GetElementsForID(const nsAString& aID,
-                                nsCOMArray<nsIContent>& aElements)
+XULDocument::GetElementsForID(const nsAString& aID,
+                              nsCOMArray<nsIContent>& aElements)
 {
     aElements.Clear();
 
     nsIdentifierMapEntry *entry = mIdentifierMap.GetEntry(aID);
     if (entry) {
         entry->AppendAllIdContent(&aElements);
     }
     nsRefMapEntry *refEntry = mRefMap.GetEntry(aID);
     if (refEntry) {
         refEntry->AppendAll(&aElements);
     }
 }
 
 nsresult
-nsXULDocument::AddForwardReference(nsForwardReference* aRef)
+XULDocument::AddForwardReference(nsForwardReference* aRef)
 {
     if (mResolutionPhase < aRef->GetPhase()) {
         if (!mForwardReferences.AppendElement(aRef)) {
             delete aRef;
             return NS_ERROR_OUT_OF_MEMORY;
         }
     }
     else {
         NS_ERROR("forward references have already been resolved");
         delete aRef;
     }
 
     return NS_OK;
 }
 
 nsresult
-nsXULDocument::ResolveForwardReferences()
+XULDocument::ResolveForwardReferences()
 {
     if (mResolutionPhase == nsForwardReference::eDone)
         return NS_OK;
 
     NS_ASSERTION(mResolutionPhase == nsForwardReference::eStart,
                  "nested ResolveForwardReferences()");
         
     // Resolve each outstanding 'forward' reference. We iterate
@@ -1180,47 +1185,47 @@ nsXULDocument::ResolveForwardReferences(
 
                     case nsForwardReference::eResolve_Later:
                         // do nothing. we'll try again later
                         ;
                     }
 
                     if (mResolutionPhase == nsForwardReference::eStart) {
                         // Resolve() loaded a dynamic overlay,
-                        // (see nsXULDocument::LoadOverlayInternal()).
+                        // (see XULDocument::LoadOverlayInternal()).
                         // Return for now, we will be called again.
                         return NS_OK;
                     }
                 }
             }
         }
 
         ++pass;
     }
 
     mForwardReferences.Clear();
     return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXULDocument::GetScriptGlobalObjectOwner(nsIScriptGlobalObjectOwner** aGlobalOwner)
+XULDocument::GetScriptGlobalObjectOwner(nsIScriptGlobalObjectOwner** aGlobalOwner)
 {
     NS_IF_ADDREF(*aGlobalOwner = mMasterPrototype);
     return NS_OK;
 }
 
 //----------------------------------------------------------------------
 //
 // nsIDOMDocument interface
 //
 
 NS_IMETHODIMP
-nsXULDocument::GetElementsByAttribute(const nsAString& aAttribute,
-                                      const nsAString& aValue,
-                                      nsIDOMNodeList** aReturn)
+XULDocument::GetElementsByAttribute(const nsAString& aAttribute,
+                                    const nsAString& aValue,
+                                    nsIDOMNodeList** aReturn)
 {
     nsCOMPtr<nsIAtom> attrAtom(do_GetAtom(aAttribute));
     NS_ENSURE_TRUE(attrAtom, NS_ERROR_OUT_OF_MEMORY);
     void* attrValue = new nsString(aValue);
     NS_ENSURE_TRUE(attrValue, NS_ERROR_OUT_OF_MEMORY);
     nsContentList *list = new nsContentList(this,
                                             MatchAttribute,
                                             nsContentUtils::DestroyMatchString,
@@ -1230,20 +1235,20 @@ nsXULDocument::GetElementsByAttribute(co
                                             kNameSpaceID_Unknown);
     NS_ENSURE_TRUE(list, NS_ERROR_OUT_OF_MEMORY);
     
     NS_ADDREF(*aReturn = list);
     return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXULDocument::GetElementsByAttributeNS(const nsAString& aNamespaceURI,
-                                        const nsAString& aAttribute,
-                                        const nsAString& aValue,
-                                        nsIDOMNodeList** aReturn)
+XULDocument::GetElementsByAttributeNS(const nsAString& aNamespaceURI,
+                                      const nsAString& aAttribute,
+                                      const nsAString& aValue,
+                                      nsIDOMNodeList** aReturn)
 {
     nsCOMPtr<nsIAtom> attrAtom(do_GetAtom(aAttribute));
     NS_ENSURE_TRUE(attrAtom, NS_ERROR_OUT_OF_MEMORY);
     void* attrValue = new nsString(aValue);
     NS_ENSURE_TRUE(attrValue, NS_ERROR_OUT_OF_MEMORY);
 
     int32_t nameSpaceId = kNameSpaceID_Wildcard;
     if (!aNamespaceURI.EqualsLiteral("*")) {
@@ -1262,18 +1267,18 @@ nsXULDocument::GetElementsByAttributeNS(
                                             nameSpaceId);
     NS_ENSURE_TRUE(list, NS_ERROR_OUT_OF_MEMORY);
 
     NS_ADDREF(*aReturn = list);
     return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXULDocument::Persist(const nsAString& aID,
-                       const nsAString& aAttr)
+XULDocument::Persist(const nsAString& aID,
+                     const nsAString& aAttr)
 {
     // If we're currently reading persisted attributes out of the
     // localstore, _don't_ re-enter and try to set them again!
     if (mApplyingPersistedAttrs)
         return NS_OK;
 
     nsresult rv;
 
@@ -1312,18 +1317,18 @@ nsXULDocument::Persist(const nsAString& 
 
     rv = Persist(element, nameSpaceID, tag);
     if (NS_FAILED(rv)) return rv;
 
     return NS_OK;
 }
 
 nsresult
-nsXULDocument::Persist(nsIContent* aElement, int32_t aNameSpaceID,
-                       nsIAtom* aAttribute)
+XULDocument::Persist(nsIContent* aElement, int32_t aNameSpaceID,
+                     nsIAtom* aAttribute)
 {
     // For non-chrome documents, persistance is simply broken
     if (!nsContentUtils::IsSystemPrincipal(NodePrincipal()))
         return NS_ERROR_NOT_AVAILABLE;
 
     // First make sure we _have_ a local store to stuff the persisted
     // information into. (We might not have one if profile information
     // hasn't been loaded yet...)
@@ -1419,18 +1424,18 @@ nsXULDocument::Persist(nsIContent* aElem
         }
     }
 
     return NS_OK;
 }
 
 
 nsresult
-nsXULDocument::GetViewportSize(int32_t* aWidth,
-                               int32_t* aHeight)
+XULDocument::GetViewportSize(int32_t* aWidth,
+                             int32_t* aHeight)
 {
     *aWidth = *aHeight = 0;
 
     FlushPendingNotifications(Flush_Layout);
 
     nsIPresShell *shell = GetShell();
     NS_ENSURE_TRUE(shell, NS_ERROR_FAILURE);
 
@@ -1441,40 +1446,40 @@ nsXULDocument::GetViewportSize(int32_t* 
 
     *aWidth = nsPresContext::AppUnitsToIntCSSPixels(size.width);
     *aHeight = nsPresContext::AppUnitsToIntCSSPixels(size.height);
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXULDocument::GetWidth(int32_t* aWidth)
+XULDocument::GetWidth(int32_t* aWidth)
 {
     NS_ENSURE_ARG_POINTER(aWidth);
 
     int32_t height;
     return GetViewportSize(aWidth, &height);
 }
 
 NS_IMETHODIMP
-nsXULDocument::GetHeight(int32_t* aHeight)
+XULDocument::GetHeight(int32_t* aHeight)
 {
     NS_ENSURE_ARG_POINTER(aHeight);
 
     int32_t width;
     return GetViewportSize(&width, aHeight);
 }
 
 //----------------------------------------------------------------------
 //
 // nsIDOMXULDocument interface
 //
 
 NS_IMETHODIMP
-nsXULDocument::GetPopupNode(nsIDOMNode** aNode)
+XULDocument::GetPopupNode(nsIDOMNode** aNode)
 {
     *aNode = nullptr;
 
     nsCOMPtr<nsIDOMNode> node;
     nsCOMPtr<nsPIWindowRoot> rootWin = GetWindowRoot();
     if (rootWin)
         node = rootWin->GetPopupNode(); // addref happens here
 
@@ -1487,17 +1492,17 @@ nsXULDocument::GetPopupNode(nsIDOMNode**
 
     if (node && nsContentUtils::CanCallerAccess(node))
       node.swap(*aNode);
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXULDocument::SetPopupNode(nsIDOMNode* aNode)
+XULDocument::SetPopupNode(nsIDOMNode* aNode)
 {
     if (aNode) {
         // only allow real node objects
         nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
         NS_ENSURE_ARG(node);
     }
 
     nsCOMPtr<nsPIWindowRoot> rootWin = GetWindowRoot();
@@ -1505,17 +1510,17 @@ nsXULDocument::SetPopupNode(nsIDOMNode* 
         rootWin->SetPopupNode(aNode); // addref happens here
 
     return NS_OK;
 }
 
 // Returns the rangeOffset element from the XUL Popup Manager. This is for
 // chrome callers only.
 NS_IMETHODIMP
-nsXULDocument::GetPopupRangeParent(nsIDOMNode** aRangeParent)
+XULDocument::GetPopupRangeParent(nsIDOMNode** aRangeParent)
 {
     NS_ENSURE_ARG_POINTER(aRangeParent);
     *aRangeParent = nullptr;
 
     nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
     if (!pm)
         return NS_ERROR_FAILURE;
 
@@ -1528,17 +1533,17 @@ nsXULDocument::GetPopupRangeParent(nsIDO
     }
 
     return NS_OK;
 }
 
 // Returns the rangeOffset element from the XUL Popup Manager. We check the
 // rangeParent to determine if the caller has rights to access to the data.
 NS_IMETHODIMP
-nsXULDocument::GetPopupRangeOffset(int32_t* aRangeOffset)
+XULDocument::GetPopupRangeOffset(int32_t* aRangeOffset)
 {
     NS_ENSURE_ARG_POINTER(aRangeOffset);
 
     nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
     if (!pm)
         return NS_ERROR_FAILURE;
 
     int32_t offset;
@@ -1548,48 +1553,48 @@ nsXULDocument::GetPopupRangeOffset(int32
     if (parent && !nsContentUtils::CanCallerAccess(parent))
         return NS_ERROR_DOM_SECURITY_ERR;
 
     *aRangeOffset = offset;
     return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXULDocument::GetTooltipNode(nsIDOMNode** aNode)
+XULDocument::GetTooltipNode(nsIDOMNode** aNode)
 {
     *aNode = nullptr;
 
     nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
     if (pm) {
         nsCOMPtr<nsIDOMNode> node = pm->GetLastTriggerTooltipNode(this);
         if (node && nsContentUtils::CanCallerAccess(node))
             node.swap(*aNode);
     }
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXULDocument::SetTooltipNode(nsIDOMNode* aNode)
+XULDocument::SetTooltipNode(nsIDOMNode* aNode)
 {
     // do nothing
     return NS_OK;
 }
 
 
 NS_IMETHODIMP
-nsXULDocument::GetCommandDispatcher(nsIDOMXULCommandDispatcher** aTracker)
+XULDocument::GetCommandDispatcher(nsIDOMXULCommandDispatcher** aTracker)
 {
     *aTracker = mCommandDispatcher;
     NS_IF_ADDREF(*aTracker);
     return NS_OK;
 }
 
 Element*
-nsXULDocument::GetElementById(const nsAString& aId)
+XULDocument::GetElementById(const nsAString& aId)
 {
     if (!CheckGetElementByIdArg(aId))
         return nullptr;
 
     nsIdentifierMapEntry *entry = mIdentifierMap.GetEntry(aId);
     if (entry) {
         Element* element = entry->GetIdElement();
         if (element)
@@ -1601,17 +1606,17 @@ nsXULDocument::GetElementById(const nsAS
         NS_ASSERTION(refEntry->GetFirstElement(),
                      "nsRefMapEntries should have nonempty content lists");
         return refEntry->GetFirstElement();
     }
     return nullptr;
 }
 
 nsresult
-nsXULDocument::AddElementToDocumentPre(Element* aElement)
+XULDocument::AddElementToDocumentPre(Element* aElement)
 {
     // Do a bunch of work that's necessary when an element gets added
     // to the XUL Document.
     nsresult rv;
 
     // 1. Add the element to the resource-to-element map. Also add it to
     // the id map, since it seems this can be called when creating
     // elements from prototypes.
@@ -1648,17 +1653,17 @@ nsXULDocument::AddElementToDocumentPre(E
         rv = AddForwardReference(hookup);
         if (NS_FAILED(rv)) return rv;
     }
 
     return NS_OK;
 }
 
 nsresult
-nsXULDocument::AddElementToDocumentPost(Element* aElement)
+XULDocument::AddElementToDocumentPost(Element* aElement)
 {
     // We need to pay special attention to the keyset tag to set up a listener
     if (aElement->NodeInfo()->Equals(nsGkAtoms::keyset, kNameSpaceID_XUL)) {
         // Create our XUL key listener and hook it up.
         nsXBLService::AttachGlobalKeyHandler(aElement);
     }
 
     // See if we need to attach a XUL template to this node
@@ -1683,17 +1688,17 @@ nsXULDocument::AddElementToDocumentPost(
                 return rv;
         }
     }
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXULDocument::AddSubtreeToDocument(nsIContent* aContent)
+XULDocument::AddSubtreeToDocument(nsIContent* aContent)
 {
     NS_ASSERTION(aContent->GetCurrentDoc() == this, "Element not in doc!");
     // From here on we only care about elements.
     if (!aContent->IsElement()) {
         return NS_OK;
     }
 
     Element* aElement = aContent->AsElement();
@@ -1712,17 +1717,17 @@ nsXULDocument::AddSubtreeToDocument(nsIC
             return rv;
     }
 
     // Do post-order addition magic
     return AddElementToDocumentPost(aElement);
 }
 
 NS_IMETHODIMP
-nsXULDocument::RemoveSubtreeFromDocument(nsIContent* aContent)
+XULDocument::RemoveSubtreeFromDocument(nsIContent* aContent)
 {
     // From here on we only care about elements.
     if (!aContent->IsElement()) {
         return NS_OK;
     }
 
     Element* aElement = aContent->AsElement();
 
@@ -1776,18 +1781,18 @@ nsXULDocument::RemoveSubtreeFromDocument
     if (rv == NS_FINDBROADCASTER_FOUND) {
         RemoveBroadcastListenerFor(broadcaster, listener, attribute);
     }
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXULDocument::SetTemplateBuilderFor(nsIContent* aContent,
-                                     nsIXULTemplateBuilder* aBuilder)
+XULDocument::SetTemplateBuilderFor(nsIContent* aContent,
+                                   nsIXULTemplateBuilder* aBuilder)
 {
     if (! mTemplateBuilderTable) {
         if (!aBuilder) {
             return NS_OK;
         }
         mTemplateBuilderTable = new BuilderTable;
         mTemplateBuilderTable->Init();
     }
@@ -1798,18 +1803,18 @@ nsXULDocument::SetTemplateBuilderFor(nsI
     else {
         mTemplateBuilderTable->Remove(aContent);
     }
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXULDocument::GetTemplateBuilderFor(nsIContent* aContent,
-                                     nsIXULTemplateBuilder** aResult)
+XULDocument::GetTemplateBuilderFor(nsIContent* aContent,
+                                   nsIXULTemplateBuilder** aResult)
 {
     if (mTemplateBuilderTable) {
         mTemplateBuilderTable->Get(aContent, aResult);
     }
     else
         *aResult = nullptr;
 
     return NS_OK;
@@ -1820,17 +1825,17 @@ GetRefMapAttribute(Element* aElement, ns
 {
     aElement->GetAttr(kNameSpaceID_None, nsGkAtoms::ref, *aValue);
     if (aValue->IsEmpty() && !aElement->GetIDAttributeName()) {
         aElement->GetAttr(kNameSpaceID_None, nsGkAtoms::id, *aValue);
     }
 }
 
 nsresult
-nsXULDocument::AddElementToRefMap(Element* aElement)
+XULDocument::AddElementToRefMap(Element* aElement)
 {
     // Look at the element's 'ref' attribute, and if set,
     // add an entry in the resource-to-element map to the element.
     nsAutoString value;
     GetRefMapAttribute(aElement, &value);
     if (!value.IsEmpty()) {
         nsRefMapEntry *entry = mRefMap.PutEntry(value);
         if (!entry)
@@ -1838,17 +1843,17 @@ nsXULDocument::AddElementToRefMap(Elemen
         if (!entry->AddElement(aElement))
             return NS_ERROR_OUT_OF_MEMORY;
     }
 
     return NS_OK;
 }
 
 void
-nsXULDocument::RemoveElementFromRefMap(Element* aElement)
+XULDocument::RemoveElementFromRefMap(Element* aElement)
 {
     // Remove the element from the resource-to-element map.
     nsAutoString value;
     GetRefMapAttribute(aElement, &value);
     if (!value.IsEmpty()) {
         nsRefMapEntry *entry = mRefMap.GetEntry(value);
         if (!entry)
             return;
@@ -1859,31 +1864,31 @@ nsXULDocument::RemoveElementFromRefMap(E
 }
 
 //----------------------------------------------------------------------
 //
 // nsIDOMNode interface
 //
 
 nsresult
-nsXULDocument::Clone(nsINodeInfo *aNodeInfo, nsINode **aResult) const
+XULDocument::Clone(nsINodeInfo *aNodeInfo, nsINode **aResult) const
 {
     // We don't allow cloning of a XUL document
     *aResult = nullptr;
     return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
 }
 
 
 //----------------------------------------------------------------------
 //
 // Implementation methods
 //
 
 nsresult
-nsXULDocument::Init()
+XULDocument::Init()
 {
     mRefMap.Init();
 
     nsresult rv = XMLDocument::Init();
     NS_ENSURE_SUCCESS(rv, rv);
 
     // Create our command dispatcher and hook it up.
     mCommandDispatcher = new nsXULCommandDispatcher(this);
@@ -1913,30 +1918,30 @@ nsXULDocument::Init()
         // null-checks in the rest of the class.
         nsXULPrototypeCache* cache = nsXULPrototypeCache::GetInstance();
         if (!cache) {
           NS_ERROR("Could not instantiate nsXULPrototypeCache");
           return NS_ERROR_FAILURE;
         }
     }
 
-    Preferences::RegisterCallback(nsXULDocument::DirectionChanged,
+    Preferences::RegisterCallback(XULDocument::DirectionChanged,
                                   "intl.uidirection.", this);
 
 #ifdef PR_LOGGING
     if (! gXULLog)
-        gXULLog = PR_NewLogModule("nsXULDocument");
+        gXULLog = PR_NewLogModule("XULDocument");
 #endif
 
     return NS_OK;
 }
 
 
 nsresult
-nsXULDocument::StartLayout(void)
+XULDocument::StartLayout(void)
 {
     mMayStartLayout = true;
     nsCOMPtr<nsIPresShell> shell = GetShell();
     if (shell) {
         // Resize-reflow this time
         nsPresContext *cx = shell->GetPresContext();
         NS_ASSERTION(cx != nullptr, "no pres context");
         if (! cx)
@@ -1958,20 +1963,20 @@ nsXULDocument::StartLayout(void)
         NS_ENSURE_SUCCESS(rv, rv);
     }
 
     return NS_OK;
 }
 
 /* static */
 bool
-nsXULDocument::MatchAttribute(nsIContent* aContent,
-                              int32_t aNamespaceID,
-                              nsIAtom* aAttrName,
-                              void* aData)
+XULDocument::MatchAttribute(nsIContent* aContent,
+                            int32_t aNamespaceID,
+                            nsIAtom* aAttrName,
+                            void* aData)
 {
     NS_PRECONDITION(aContent, "Must have content node to work with!");
     nsString* attrValue = static_cast<nsString*>(aData);
     if (aNamespaceID != kNameSpaceID_Unknown &&
         aNamespaceID != kNameSpaceID_Wildcard) {
         return attrValue->EqualsLiteral("*") ?
             aContent->HasAttr(aNamespaceID, aAttrName) :
             aContent->AttrValueIs(aNamespaceID, aAttrName, *attrValue,
@@ -1998,34 +2003,34 @@ nsXULDocument::MatchAttribute(nsIContent
                                       *attrValue, eCaseMatters);
         }
     }
 
     return false;
 }
 
 nsresult
-nsXULDocument::PrepareToLoad(nsISupports* aContainer,
-                             const char* aCommand,
-                             nsIChannel* aChannel,
-                             nsILoadGroup* aLoadGroup,
-                             nsIParser** aResult)
+XULDocument::PrepareToLoad(nsISupports* aContainer,
+                           const char* aCommand,
+                           nsIChannel* aChannel,
+                           nsILoadGroup* aLoadGroup,
+                           nsIParser** aResult)
 {
     // Get the document's principal
     nsCOMPtr<nsIPrincipal> principal;
     nsContentUtils::GetSecurityManager()->
         GetChannelPrincipal(aChannel, getter_AddRefs(principal));
     return PrepareToLoadPrototype(mDocumentURI, aCommand, principal, aResult);
 }
 
 
 nsresult
-nsXULDocument::PrepareToLoadPrototype(nsIURI* aURI, const char* aCommand,
-                                      nsIPrincipal* aDocumentPrincipal,
-                                      nsIParser** aResult)
+XULDocument::PrepareToLoadPrototype(nsIURI* aURI, const char* aCommand,
+                                    nsIPrincipal* aDocumentPrincipal,
+                                    nsIParser** aResult)
 {
     nsresult rv;
 
     // Create a new prototype document.
     rv = NS_NewXULPrototypeDocument(getter_AddRefs(mCurrentPrototype));
     if (NS_FAILED(rv)) return rv;
 
     rv = mCurrentPrototype->InitPrincipal(aURI, aDocumentPrincipal);
@@ -2063,17 +2068,17 @@ nsXULDocument::PrepareToLoadPrototype(ns
 
     *aResult = parser;
     NS_ADDREF(*aResult);
     return NS_OK;
 }
 
 
 nsresult
-nsXULDocument::ApplyPersistentAttributes()
+XULDocument::ApplyPersistentAttributes()
 {
     // For non-chrome documents, persistance is simply broken
     if (!nsContentUtils::IsSystemPrincipal(NodePrincipal()))
         return NS_ERROR_NOT_AVAILABLE;
 
     // Add all of the 'persisted' attributes into the content
     // model.
     if (!mLocalStore)
@@ -2083,17 +2088,17 @@ nsXULDocument::ApplyPersistentAttributes
     ApplyPersistentAttributesInternal();
     mApplyingPersistedAttrs = false;
 
     return NS_OK;
 }
 
 
 nsresult 
-nsXULDocument::ApplyPersistentAttributesInternal()
+XULDocument::ApplyPersistentAttributesInternal()
 {
     nsCOMArray<nsIContent> elements;
 
     nsAutoCString docurl;
     mDocumentURI->GetSpec(docurl);
 
     nsCOMPtr<nsIRDFResource> doc;
     gRDFService->GetResource(docurl, getter_AddRefs(doc));
@@ -2136,18 +2141,18 @@ nsXULDocument::ApplyPersistentAttributes
         ApplyPersistentAttributesToElements(resource, elements);
     }
 
     return NS_OK;
 }
 
 
 nsresult
-nsXULDocument::ApplyPersistentAttributesToElements(nsIRDFResource* aResource,
-                                                   nsCOMArray<nsIContent>& aElements)
+XULDocument::ApplyPersistentAttributesToElements(nsIRDFResource* aResource,
+                                                 nsCOMArray<nsIContent>& aElements)
 {
     nsresult rv;
 
     nsCOMPtr<nsISimpleEnumerator> attrs;
     rv = mLocalStore->ArcLabelsOut(aResource, getter_AddRefs(attrs));
     if (NS_FAILED(rv)) return rv;
 
     while (1) {
@@ -2208,47 +2213,47 @@ nsXULDocument::ApplyPersistentAttributes
                                   true);
         }
     }
 
     return NS_OK;
 }
 
 void
-nsXULDocument::TraceProtos(JSTracer* aTrc, uint32_t aGCNumber)
+XULDocument::TraceProtos(JSTracer* aTrc, uint32_t aGCNumber)
 {
     uint32_t i, count = mPrototypes.Length();
     for (i = 0; i < count; ++i) {
         mPrototypes[i]->TraceProtos(aTrc, aGCNumber);
     }
 }
 
 //----------------------------------------------------------------------
 //
-// nsXULDocument::ContextStack
+// XULDocument::ContextStack
 //
 
-nsXULDocument::ContextStack::ContextStack()
+XULDocument::ContextStack::ContextStack()
     : mTop(nullptr), mDepth(0)
 {
 }
 
-nsXULDocument::ContextStack::~ContextStack()
+XULDocument::ContextStack::~ContextStack()
 {
     while (mTop) {
         Entry* doomed = mTop;
         mTop = mTop->mNext;
         NS_IF_RELEASE(doomed->mElement);
         delete doomed;
     }
 }
 
 nsresult
-nsXULDocument::ContextStack::Push(nsXULPrototypeElement* aPrototype,
-                                  nsIContent* aElement)
+XULDocument::ContextStack::Push(nsXULPrototypeElement* aPrototype,
+                                nsIContent* aElement)
 {
     Entry* entry = new Entry;
     if (! entry)
         return NS_ERROR_OUT_OF_MEMORY;
 
     entry->mPrototype = aPrototype;
     entry->mElement   = aElement;
     NS_IF_ADDREF(entry->mElement);
@@ -2257,65 +2262,65 @@ nsXULDocument::ContextStack::Push(nsXULP
     entry->mNext = mTop;
     mTop = entry;
 
     ++mDepth;
     return NS_OK;
 }
 
 nsresult
-nsXULDocument::ContextStack::Pop()
+XULDocument::ContextStack::Pop()
 {
     if (mDepth == 0)
         return NS_ERROR_UNEXPECTED;
 
     Entry* doomed = mTop;
     mTop = mTop->mNext;
     --mDepth;
 
     NS_IF_RELEASE(doomed->mElement);
     delete doomed;
     return NS_OK;
 }
 
 nsresult
-nsXULDocument::ContextStack::Peek(nsXULPrototypeElement** aPrototype,
-                                           nsIContent** aElement,
-                                           int32_t* aIndex)
+XULDocument::ContextStack::Peek(nsXULPrototypeElement** aPrototype,
+                                nsIContent** aElement,
+                                int32_t* aIndex)
 {
     if (mDepth == 0)
         return NS_ERROR_UNEXPECTED;
 
     *aPrototype = mTop->mPrototype;
     *aElement   = mTop->mElement;
     NS_IF_ADDREF(*aElement);
     *aIndex     = mTop->mIndex;
 
     return NS_OK;
 }
 
 
 nsresult
-nsXULDocument::ContextStack::SetTopIndex(int32_t aIndex)
+XULDocument::ContextStack::SetTopIndex(int32_t aIndex)
 {
     if (mDepth == 0)
         return NS_ERROR_UNEXPECTED;
 
     mTop->mIndex = aIndex;
     return NS_OK;
 }
 
 
 //----------------------------------------------------------------------
 //
 // Content model walking routines
 //
 
 nsresult
-nsXULDocument::PrepareToWalk()
+XULDocument::PrepareToWalk()
 {
     // Prepare to walk the mCurrentPrototype
     nsresult rv;
 
     // Keep an owning reference to the prototype document so that its
     // elements aren't yanked from beneath us.
     mPrototypes.AppendElement(mCurrentPrototype);
 
@@ -2395,18 +2400,18 @@ nsXULDocument::PrepareToWalk()
 
     rv = mContextStack.Push(proto, root);
     if (NS_FAILED(rv)) return rv;
 
     return NS_OK;
 }
 
 nsresult
-nsXULDocument::CreateAndInsertPI(const nsXULPrototypePI* aProtoPI,
-                                 nsINode* aParent, uint32_t aIndex)
+XULDocument::CreateAndInsertPI(const nsXULPrototypePI* aProtoPI,
+                               nsINode* aParent, uint32_t aIndex)
 {
     NS_PRECONDITION(aProtoPI, "null ptr");
     NS_PRECONDITION(aParent, "null ptr");
 
     nsresult rv;
     nsCOMPtr<nsIContent> node;
 
     rv = NS_NewXMLProcessingInstruction(getter_AddRefs(node),
@@ -2423,20 +2428,20 @@ nsXULDocument::CreateAndInsertPI(const n
         // No special processing, just add the PI to the document.
         rv = aParent->InsertChildAt(node, aIndex, false);
     }
 
     return rv;
 }
 
 nsresult
-nsXULDocument::InsertXMLStylesheetPI(const nsXULPrototypePI* aProtoPI,
-                                     nsINode* aParent,
-                                     uint32_t aIndex,
-                                     nsIContent* aPINode)
+XULDocument::InsertXMLStylesheetPI(const nsXULPrototypePI* aProtoPI,
+                                   nsINode* aParent,
+                                   uint32_t aIndex,
+                                   nsIContent* aPINode)
 {
     nsCOMPtr<nsIStyleSheetLinkingElement> ssle(do_QueryInterface(aPINode));
     NS_ASSERTION(ssle, "passed XML Stylesheet node does not "
                        "implement nsIStyleSheetLinkingElement!");
 
     nsresult rv;
 
     ssle->InitStyleLinkElement(false);
@@ -2465,20 +2470,20 @@ nsXULDocument::InsertXMLStylesheetPI(con
     if (rv == NS_ERROR_OUT_OF_MEMORY) {
         return rv;
     }
     
     return NS_OK;
 }
 
 nsresult
-nsXULDocument::InsertXULOverlayPI(const nsXULPrototypePI* aProtoPI,
-                                  nsINode* aParent,
-                                  uint32_t aIndex,
-                                  nsIContent* aPINode)
+XULDocument::InsertXULOverlayPI(const nsXULPrototypePI* aProtoPI,
+                                nsINode* aParent,
+                                uint32_t aIndex,
+                                nsIContent* aPINode)
 {
     nsresult rv;
 
     rv = aParent->InsertChildAt(aPINode, aIndex, false);
     if (NS_FAILED(rv)) return rv;
 
     // xul-overlay PI is special only in prolog
     if (!nsContentUtils::InProlog(aPINode)) {
@@ -2514,17 +2519,17 @@ nsXULDocument::InsertXULOverlayPI(const 
         // XXX report this to the Error Console (bug 359846)
         rv = NS_OK;
     }
 
     return rv;
 }
 
 nsresult
-nsXULDocument::AddChromeOverlays()
+XULDocument::AddChromeOverlays()
 {
     nsresult rv;
 
     nsCOMPtr<nsIURI> docUri = mCurrentPrototype->GetURI();
 
     /* overlays only apply to chrome or about URIs */
     if (!IsOverlayAllowed(docUri)) return NS_OK;
 
@@ -2549,25 +2554,25 @@ nsXULDocument::AddChromeOverlays()
         if (NS_FAILED(rv) || !next) break;
 
         uri = do_QueryInterface(next);
         if (!uri) {
             NS_ERROR("Chrome registry handed me a non-nsIURI object!");
             continue;
         }
 
-        // Same comment as in nsXULDocument::InsertXULOverlayPI
+        // Same comment as in XULDocument::InsertXULOverlayPI
         mUnloadedOverlays.InsertElementAt(0, uri);
     }
 
     return rv;
 }
 
 NS_IMETHODIMP
-nsXULDocument::LoadOverlay(const nsAString& aURL, nsIObserver* aObserver)
+XULDocument::LoadOverlay(const nsAString& aURL, nsIObserver* aObserver)
 {
     nsresult rv;
 
     nsCOMPtr<nsIURI> uri;
     rv = NS_NewURI(getter_AddRefs(uri), aURL, nullptr);
     if (NS_FAILED(rv)) return rv;
 
     if (aObserver) {
@@ -2587,19 +2592,19 @@ nsXULDocument::LoadOverlay(const nsAStri
     bool shouldReturn, failureFromContent;
     rv = LoadOverlayInternal(uri, true, &shouldReturn, &failureFromContent);
     if (NS_FAILED(rv) && mOverlayLoadObservers.IsInitialized())
         mOverlayLoadObservers.Remove(uri); // remove the observer if LoadOverlayInternal generated an error
     return rv;
 }
 
 nsresult
-nsXULDocument::LoadOverlayInternal(nsIURI* aURI, bool aIsDynamic,
-                                   bool* aShouldReturn,
-                                   bool* aFailureFromContent)
+XULDocument::LoadOverlayInternal(nsIURI* aURI, bool aIsDynamic,
+                                 bool* aShouldReturn,
+                                 bool* aFailureFromContent)
 {
     nsresult rv;
 
     *aShouldReturn = false;
     *aFailureFromContent = false;
 
 #ifdef PR_LOGGING
     if (PR_LOG_TEST(gXULLog, PR_LOG_DEBUG)) {
@@ -2639,17 +2644,17 @@ nsXULDocument::LoadOverlayInternal(nsIUR
     // the specified overlay URI. Only use the cache if the containing
     // document is chrome otherwise it may not have a system principal and
     // the cached document will, see bug 565610.
     bool overlayIsChrome = IsChromeURI(aURI);
     mCurrentPrototype = overlayIsChrome && documentIsChrome ?
         nsXULPrototypeCache::GetInstance()->GetPrototype(aURI) : nullptr;
 
     // Same comment as nsChromeProtocolHandler::NewChannel and
-    // nsXULDocument::StartDocumentLoad
+    // XULDocument::StartDocumentLoad
     // - Ben Goodger
     //
     // We don't abort on failure here because there are too many valid
     // cases that can return failure, and the null-ness of |proto| is
     // enough to trigger the fail-safe parse-from-disk solution.
     // Example failure cases (for reference) include:
     //
     // NS_ERROR_NOT_AVAILABLE: the URI was not found in the FastLoad file,
@@ -2779,17 +2784,17 @@ FirePendingMergeNotification(nsIURI* aKe
     typedef nsInterfaceHashtable<nsURIHashKey,nsIObserver> table;
     table* observers = static_cast<table*>(aClosure);
     observers->Remove(aKey);
 
     return PL_DHASH_REMOVE;
 }
 
 nsresult
-nsXULDocument::ResumeWalk()
+XULDocument::ResumeWalk()
 {
     // Walk the prototype and build the delegate content model. The
     // walk is performed in a top-down, left-to-right fashion. That
     // is, a parent is built before any of its children; a node is
     // only built after all of its siblings to the left are fully
     // constructed.
     //
     // It is interruptable so that transcluded documents (e.g.,
@@ -3053,17 +3058,17 @@ nsXULDocument::ResumeWalk()
     mStillWalking = false;
     if (mPendingSheets == 0) {
         rv = DoneWalking();
     }
     return rv;
 }
 
 nsresult
-nsXULDocument::DoneWalking()
+XULDocument::DoneWalking()
 {
     NS_PRECONDITION(mPendingSheets == 0, "there are sheets to be loaded");
     NS_PRECONDITION(!mStillWalking, "walk not done");
 
     // XXXldb This is where we should really be setting the chromehidden
     // attribute.
 
     uint32_t count = mOverlaySheets.Length();
@@ -3172,19 +3177,19 @@ nsXULDocument::DoneWalking()
             }
         }
     }
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXULDocument::StyleSheetLoaded(nsCSSStyleSheet* aSheet,
-                                bool aWasAlternate,
-                                nsresult aStatus)
+XULDocument::StyleSheetLoaded(nsCSSStyleSheet* aSheet,
+                              bool aWasAlternate,
+                              nsresult aStatus)
 {
     if (!aWasAlternate) {
         // Don't care about when alternate sheets finish loading
 
         NS_ASSERTION(mPendingSheets > 0,
             "Unexpected StyleSheetLoaded notification");
 
         --mPendingSheets;
@@ -3193,26 +3198,26 @@ nsXULDocument::StyleSheetLoaded(nsCSSSty
             return DoneWalking();
         }
     }
 
     return NS_OK;
 }
 
 void
-nsXULDocument::MaybeBroadcast()
+XULDocument::MaybeBroadcast()
 {
     // Only broadcast when not in an update and when safe to run scripts.
     if (mUpdateNestLevel == 0 &&
         (mDelayedAttrChangeBroadcasts.Length() ||
          mDelayedBroadcasters.Length())) {
         if (!nsContentUtils::IsSafeToRunScript()) {
             if (!mInDestructor) {
                 nsContentUtils::AddScriptRunner(
-                    NS_NewRunnableMethod(this, &nsXULDocument::MaybeBroadcast));
+                    NS_NewRunnableMethod(this, &XULDocument::MaybeBroadcast));
             }
             return;
         }
         if (!mHandlingDelayedAttrChange) {
             mHandlingDelayedAttrChange = true;
             for (uint32_t i = 0; i < mDelayedAttrChangeBroadcasts.Length(); ++i) {
                 nsIAtom* attrName = mDelayedAttrChangeBroadcasts[i].mAttrName;
                 if (mDelayedAttrChangeBroadcasts[i].mNeedsAttrChange) {
@@ -3249,42 +3254,42 @@ nsXULDocument::MaybeBroadcast()
                                              delayedBroadcasters[i].mAttr);
             }
             mHandlingDelayedBroadcasters = oldValue;
         }
     }
 }
 
 void
-nsXULDocument::EndUpdate(nsUpdateType aUpdateType)
+XULDocument::EndUpdate(nsUpdateType aUpdateType)
 {
     XMLDocument::EndUpdate(aUpdateType);
 
     MaybeBroadcast();
 }
 
 void
-nsXULDocument::ReportMissingOverlay(nsIURI* aURI)
+XULDocument::ReportMissingOverlay(nsIURI* aURI)
 {
     NS_PRECONDITION(aURI, "Must have a URI");
     
     nsAutoCString spec;
     aURI->GetSpec(spec);
 
     NS_ConvertUTF8toUTF16 utfSpec(spec);
     const PRUnichar* params[] = { utfSpec.get() };
     nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
                                     "XUL Document", this,
                                     nsContentUtils::eXUL_PROPERTIES,
                                     "MissingOverlay",
                                     params, ArrayLength(params));
 }
 
 nsresult
-nsXULDocument::LoadScript(nsXULPrototypeScript* aScriptProto, bool* aBlock)
+XULDocument::LoadScript(nsXULPrototypeScript* aScriptProto, bool* aBlock)
 {
     // Load a transcluded script
     nsresult rv;
 
     bool isChromeDoc = IsChromeURI(mDocumentURI);
 
     if (isChromeDoc && aScriptProto->GetScriptObject()) {
         rv = ExecuteScript(aScriptProto);
@@ -3363,21 +3368,21 @@ nsXULDocument::LoadScript(nsXULPrototype
 
     // Block until OnStreamComplete resumes us.
     *aBlock = true;
     return NS_OK;
 }
 
 
 NS_IMETHODIMP
-nsXULDocument::OnStreamComplete(nsIStreamLoader* aLoader,
-                                nsISupports* context,
-                                nsresult aStatus,
-                                uint32_t stringLen,
-                                const uint8_t* string)
+XULDocument::OnStreamComplete(nsIStreamLoader* aLoader,
+                              nsISupports* context,
+                              nsresult aStatus,
+                              uint32_t stringLen,
+                              const uint8_t* string)
 {
     nsCOMPtr<nsIRequest> request;
     aLoader->GetRequest(getter_AddRefs(request));
     nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
 
 #ifdef DEBUG
     // print a load error on bad status
     if (NS_FAILED(aStatus)) {
@@ -3453,17 +3458,17 @@ nsXULDocument::OnStreamComplete(nsIStrea
             // the fillXULCache logic.
             //
             // A document such as about:config is free to load a script via
             // a URL such as chrome://global/content/config.js, and we must
             // not cache that script object without a prototype cache entry
             // containing a companion nsXULPrototypeScript node that owns a
             // GC root protecting the script object.  Otherwise, the script
             // cache entry will dangle once the uncached prototype document
-            // is released when its owning nsXULDocument is unloaded.
+            // is released when its owning XULDocument is unloaded.
             //
             // (See http://bugzilla.mozilla.org/show_bug.cgi?id=98207 for
             // the true crime story.)
             bool useXULCache = nsXULPrototypeCache::GetInstance()->IsEnabled();
   
             if (useXULCache && IsChromeURI(mDocumentURI)) {
                 nsXULPrototypeCache::GetInstance()->PutScript(
                                    scriptProto->mSrcURI,
@@ -3496,23 +3501,23 @@ nsXULDocument::OnStreamComplete(nsIStrea
                 }
             }
         }
         // ignore any evaluation errors
     }
 
     rv = ResumeWalk();
 
-    // Load a pointer to the prototype-script's list of nsXULDocuments who
+    // Load a pointer to the prototype-script's list of XULDocuments who
     // raced to load the same script
-    nsXULDocument** docp = &scriptProto->mSrcLoadWaiters;
+    XULDocument** docp = &scriptProto->mSrcLoadWaiters;
 
     // Resume walking other documents that waited for this one's load, first
     // executing the script we just compiled, in each doc's script context
-    nsXULDocument* doc;
+    XULDocument* doc;
     while ((doc = *docp) != nullptr) {
         NS_ASSERTION(doc->mCurrentScriptProto == scriptProto,
                      "waiting for wrong script to load?");
         doc->mCurrentScriptProto = nullptr;
 
         // Unlink doc from scriptProto's list before executing and resuming
         *docp = doc->mNextSrcLoadWaiter;
         doc->mNextSrcLoadWaiter = nullptr;
@@ -3525,31 +3530,31 @@ nsXULDocument::OnStreamComplete(nsIStrea
         NS_RELEASE(doc);
     }
 
     return rv;
 }
 
 
 nsresult
-nsXULDocument::ExecuteScript(nsIScriptContext * aContext, JSScript* aScriptObject)
+XULDocument::ExecuteScript(nsIScriptContext * aContext, JSScript* aScriptObject)
 {
     NS_PRECONDITION(aScriptObject != nullptr && aContext != nullptr, "null ptr");
     if (! aScriptObject || ! aContext)
         return NS_ERROR_NULL_POINTER;
 
     NS_ENSURE_TRUE(mScriptGlobalObject, NS_ERROR_NOT_INITIALIZED);
 
     // Execute the precompiled script with the given version
     JSObject* global = mScriptGlobalObject->GetGlobalJSObject();
     return aContext->ExecuteScript(aScriptObject, global);
 }
 
 nsresult
-nsXULDocument::ExecuteScript(nsXULPrototypeScript *aScript)
+XULDocument::ExecuteScript(nsXULPrototypeScript *aScript)
 {
     NS_PRECONDITION(aScript != nullptr, "null ptr");
     NS_ENSURE_TRUE(aScript, NS_ERROR_NULL_POINTER);
     NS_ENSURE_TRUE(mScriptGlobalObject, NS_ERROR_NOT_INITIALIZED);
 
     nsresult rv;
     rv = mScriptGlobalObject->EnsureScriptEnvironment();
     NS_ENSURE_SUCCESS(rv, rv);
@@ -3563,19 +3568,19 @@ nsXULDocument::ExecuteScript(nsXULProtot
         rv = ExecuteScript(context, aScript->GetScriptObject());
     else
         rv = NS_ERROR_UNEXPECTED;
     return rv;
 }
 
 
 nsresult
-nsXULDocument::CreateElementFromPrototype(nsXULPrototypeElement* aPrototype,
-                                          Element** aResult,
-                                          bool aIsRoot)
+XULDocument::CreateElementFromPrototype(nsXULPrototypeElement* aPrototype,
+                                        Element** aResult,
+                                        bool aIsRoot)
 {
     // Create a content model element from a prototype element.
     NS_PRECONDITION(aPrototype != nullptr, "null ptr");
     if (! aPrototype)
         return NS_ERROR_NULL_POINTER;
 
     *aResult = nullptr;
     nsresult rv = NS_OK;
@@ -3621,18 +3626,18 @@ nsXULDocument::CreateElementFromPrototyp
     }
 
     result.swap(*aResult);
 
     return NS_OK;
 }
 
 nsresult
-nsXULDocument::CreateOverlayElement(nsXULPrototypeElement* aPrototype,
-                                    Element** aResult)
+XULDocument::CreateOverlayElement(nsXULPrototypeElement* aPrototype,
+                                  Element** aResult)
 {
     nsresult rv;
 
     nsRefPtr<Element> element;
     rv = CreateElementFromPrototype(aPrototype, getter_AddRefs(element), false);
     if (NS_FAILED(rv)) return rv;
 
     OverlayForwardReference* fwdref =
@@ -3644,18 +3649,18 @@ nsXULDocument::CreateOverlayElement(nsXU
     rv = AddForwardReference(fwdref);
     if (NS_FAILED(rv)) return rv;
 
     NS_ADDREF(*aResult = element);
     return NS_OK;
 }
 
 nsresult
-nsXULDocument::AddAttributes(nsXULPrototypeElement* aPrototype,
-                             nsIContent* aElement)
+XULDocument::AddAttributes(nsXULPrototypeElement* aPrototype,
+                           nsIContent* aElement)
 {
     nsresult rv;
 
     for (uint32_t i = 0; i < aPrototype->mNumAttributes; ++i) {
         nsXULPrototypeAttribute* protoattr = &(aPrototype->mAttributes[i]);
         nsAutoString  valueStr;
         protoattr->mValue.ToString(valueStr);
 
@@ -3667,18 +3672,18 @@ nsXULDocument::AddAttributes(nsXULProtot
         if (NS_FAILED(rv)) return rv;
     }
 
     return NS_OK;
 }
 
 
 nsresult
-nsXULDocument::CheckTemplateBuilderHookup(nsIContent* aElement,
-                                          bool* aNeedsHookup)
+XULDocument::CheckTemplateBuilderHookup(nsIContent* aElement,
+                                        bool* aNeedsHookup)
 {
     // See if the element already has a `database' attribute. If it
     // does, then the template builder has already been created.
     //
     // XXX This approach will crash and burn (well, maybe not _that_
     // bad) if aElement is not a XUL element.
     //
     // XXXvarga Do we still want to support non XUL content?
@@ -3695,17 +3700,17 @@ nsXULDocument::CheckTemplateBuilderHooku
     // Check aElement for a 'datasources' attribute, if it has
     // one a XUL template builder needs to be hooked up.
     *aNeedsHookup = aElement->HasAttr(kNameSpaceID_None,
                                       nsGkAtoms::datasources);
     return NS_OK;
 }
 
 /* static */ nsresult
-nsXULDocument::CreateTemplateBuilder(nsIContent* aElement)
+XULDocument::CreateTemplateBuilder(nsIContent* aElement)
 {
     // Check if need to construct a tree builder or content builder.
     bool isTreeBuilder = false;
 
     // return successful if the element is not is a document, as an inline
     // script could have removed it
     nsIDocument *document = aElement->GetCurrentDoc();
     NS_ENSURE_TRUE(document, NS_OK);
@@ -3766,17 +3771,17 @@ nsXULDocument::CreateTemplateBuilder(nsI
         builder->CreateContents(aElement, false);
     }
 
     return NS_OK;
 }
 
 
 nsresult
-nsXULDocument::AddPrototypeSheets()
+XULDocument::AddPrototypeSheets()
 {
     nsresult rv;
 
     const nsCOMArray<nsIURI>& sheets = mCurrentPrototype->GetStyleSheetReferences();
 
     for (int32_t i = 0; i < sheets.Count(); i++) {
         nsCOMPtr<nsIURI> uri = sheets[i];
 
@@ -3798,21 +3803,21 @@ nsXULDocument::AddPrototypeSheets()
     }
 
     return NS_OK;
 }
 
 
 //----------------------------------------------------------------------
 //
-// nsXULDocument::OverlayForwardReference
+// XULDocument::OverlayForwardReference
 //
 
 nsForwardReference::Result
-nsXULDocument::OverlayForwardReference::Resolve()
+XULDocument::OverlayForwardReference::Resolve()
 {
     // Resolve a forward reference from an overlay element; attempt to
     // hook it up into the main document.
     nsresult rv;
     nsCOMPtr<nsIContent> target;
 
     nsIPresShell *shell = mDocument->GetShell();
     bool notify = shell && shell->DidInitialize();
@@ -3867,19 +3872,19 @@ nsXULDocument::OverlayForwardReference::
 
     mResolved = true;
     return eResolve_Succeeded;
 }
 
 
 
 nsresult
-nsXULDocument::OverlayForwardReference::Merge(nsIContent* aTargetNode,
-                                              nsIContent* aOverlayNode, 
-                                              bool aNotify)
+XULDocument::OverlayForwardReference::Merge(nsIContent* aTargetNode,
+                                            nsIContent* aOverlayNode,
+                                            bool aNotify)
 {
     // This function is given:
     // aTargetNode:  the node in the document whose 'id' attribute
     //               matches a toplevel node in our overlay.
     // aOverlayNode: the node in the overlay document that matches
     //               a node in the actual document.
     // aNotify:      whether or not content manipulation methods should
     //               use the aNotify parameter. After the initial 
@@ -4016,17 +4021,17 @@ nsXULDocument::OverlayForwardReference::
         if (NS_FAILED(rv)) return rv;
     }
 
     return NS_OK;
 }
 
 
 
-nsXULDocument::OverlayForwardReference::~OverlayForwardReference()
+XULDocument::OverlayForwardReference::~OverlayForwardReference()
 {
 #ifdef PR_LOGGING
     if (PR_LOG_TEST(gXULLog, PR_LOG_WARNING) && !mResolved) {
         nsAutoString id;
         mOverlay->GetAttr(kNameSpaceID_None, nsGkAtoms::id, id);
 
         nsAutoCString idC;
         idC.AssignWithConversion(id);
@@ -4045,33 +4050,33 @@ nsXULDocument::OverlayForwardReference::
                 urlspec.get(), idC.get(), parentDoc.get()));
     }
 #endif
 }
 
 
 //----------------------------------------------------------------------
 //
-// nsXULDocument::BroadcasterHookup
+// XULDocument::BroadcasterHookup
 //
 
 nsForwardReference::Result
-nsXULDocument::BroadcasterHookup::Resolve()
+XULDocument::BroadcasterHookup::Resolve()
 {
     nsresult rv;
 
     bool listener;
     rv = mDocument->CheckBroadcasterHookup(mObservesElement, &listener, &mResolved);
     if (NS_FAILED(rv)) return eResolve_Error;
 
     return mResolved ? eResolve_Succeeded : eResolve_Later;
 }
 
 
-nsXULDocument::BroadcasterHookup::~BroadcasterHookup()
+XULDocument::BroadcasterHookup::~BroadcasterHookup()
 {
 #ifdef PR_LOGGING
     if (PR_LOG_TEST(gXULLog, PR_LOG_WARNING) && !mResolved) {
         // Tell the world we failed
         nsIAtom *tag = mObservesElement->Tag();
 
         nsAutoString broadcasterID;
         nsAutoString attribute;
@@ -4095,21 +4100,21 @@ nsXULDocument::BroadcasterHookup::~Broad
                 broadcasteridC.get()));
     }
 #endif
 }
 
 
 //----------------------------------------------------------------------
 //
-// nsXULDocument::TemplateBuilderHookup
+// XULDocument::TemplateBuilderHookup
 //
 
 nsForwardReference::Result
-nsXULDocument::TemplateBuilderHookup::Resolve()
+XULDocument::TemplateBuilderHookup::Resolve()
 {
     bool needsHookup;
     nsresult rv = CheckTemplateBuilderHookup(mElement, &needsHookup);
     if (NS_FAILED(rv))
         return eResolve_Error;
 
     if (needsHookup) {
         rv = CreateTemplateBuilder(mElement);
@@ -4119,21 +4124,21 @@ nsXULDocument::TemplateBuilderHookup::Re
 
     return eResolve_Succeeded;
 }
 
 
 //----------------------------------------------------------------------
 
 nsresult
-nsXULDocument::BroadcastAttributeChangeFromOverlay(nsIContent* aNode,
-                                                   int32_t aNameSpaceID,
-                                                   nsIAtom* aAttribute,
-                                                   nsIAtom* aPrefix,
-                                                   const nsAString& aValue)
+XULDocument::BroadcastAttributeChangeFromOverlay(nsIContent* aNode,
+                                                 int32_t aNameSpaceID,
+                                                 nsIAtom* aAttribute,
+                                                 nsIAtom* aPrefix,
+                                                 const nsAString& aValue)
 {
     nsresult rv = NS_OK;
 
     if (!mBroadcasterMap || !CanBroadcast(aNameSpaceID, aAttribute))
         return rv;
 
     nsCOMPtr<nsIDOMElement> domele = do_QueryInterface(aNode);
     if (!domele)
@@ -4160,21 +4165,21 @@ nsXULDocument::BroadcastAttributeChangeF
                             aPrefix, aValue, false);
             if (NS_FAILED(rv)) return rv;
         }
     }
     return rv;
 }
 
 nsresult
-nsXULDocument::FindBroadcaster(Element* aElement,
-                               nsIDOMElement** aListener,
-                               nsString& aBroadcasterID,
-                               nsString& aAttribute,
-                               nsIDOMElement** aBroadcaster)
+XULDocument::FindBroadcaster(Element* aElement,
+                             nsIDOMElement** aListener,
+                             nsString& aBroadcasterID,
+                             nsString& aAttribute,
+                             nsIDOMElement** aBroadcaster)
 {
     nsresult rv;
     nsINodeInfo *ni = aElement->NodeInfo();
     *aListener = nullptr;
     *aBroadcaster = nullptr;
 
     if (ni->Equals(nsGkAtoms::observes, kNameSpaceID_XUL)) {
         // It's an <observes> element, which means that the actual
@@ -4249,19 +4254,19 @@ nsXULDocument::FindBroadcaster(Element* 
     if (! *aBroadcaster) {
         return NS_FINDBROADCASTER_AWAIT_OVERLAYS;
     }
 
     return NS_FINDBROADCASTER_FOUND;
 }
 
 nsresult
-nsXULDocument::CheckBroadcasterHookup(Element* aElement,
-                                      bool* aNeedsHookup,
-                                      bool* aDidResolve)
+XULDocument::CheckBroadcasterHookup(Element* aElement,
+                                    bool* aNeedsHookup,
+                                    bool* aDidResolve)
 {
     // Resolve a broadcaster hookup. Look at the element that we're
     // trying to resolve: it could be an '<observes>' element, or just
     // a vanilla element with an 'observes' attribute on it.
     nsresult rv;
 
     *aDidResolve = false;
 
@@ -4310,18 +4315,18 @@ nsXULDocument::CheckBroadcasterHookup(El
 #endif
 
     *aNeedsHookup = false;
     *aDidResolve = true;
     return NS_OK;
 }
 
 nsresult
-nsXULDocument::InsertElement(nsIContent* aParent, nsIContent* aChild,
-                             bool aNotify)
+XULDocument::InsertElement(nsIContent* aParent, nsIContent* aChild,
+                           bool aNotify)
 {
     // Insert aChild appropriately into aParent, accounting for a
     // 'pos' attribute set on aChild.
 
     nsAutoString posStr;
     bool wasInserted = false;
 
     // insert after an element of a given id
@@ -4391,97 +4396,97 @@ nsXULDocument::InsertElement(nsIContent*
 
     if (!wasInserted) {
         return aParent->AppendChildTo(aChild, aNotify);
     }
     return NS_OK;
 }
 
 nsresult
-nsXULDocument::RemoveElement(nsIContent* aParent, nsIContent* aChild)
+XULDocument::RemoveElement(nsIContent* aParent, nsIContent* aChild)
 {
     int32_t nodeOffset = aParent->IndexOf(aChild);
 
     aParent->RemoveChildAt(nodeOffset, true);
     return NS_OK;
 }
 
 //----------------------------------------------------------------------
 //
 // CachedChromeStreamListener
 //
 
-nsXULDocument::CachedChromeStreamListener::CachedChromeStreamListener(nsXULDocument* aDocument, bool aProtoLoaded)
+XULDocument::CachedChromeStreamListener::CachedChromeStreamListener(XULDocument* aDocument, bool aProtoLoaded)
     : mDocument(aDocument),
       mProtoLoaded(aProtoLoaded)
 {
     NS_ADDREF(mDocument);
 }
 
 
-nsXULDocument::CachedChromeStreamListener::~CachedChromeStreamListener()
+XULDocument::CachedChromeStreamListener::~CachedChromeStreamListener()
 {
     NS_RELEASE(mDocument);
 }
 
 
-NS_IMPL_ISUPPORTS2(nsXULDocument::CachedChromeStreamListener,
+NS_IMPL_ISUPPORTS2(XULDocument::CachedChromeStreamListener,
                    nsIRequestObserver, nsIStreamListener)
 
 NS_IMETHODIMP
-nsXULDocument::CachedChromeStreamListener::OnStartRequest(nsIRequest *request,
-                                                          nsISupports* acontext)
+XULDocument::CachedChromeStreamListener::OnStartRequest(nsIRequest *request,
+                                                        nsISupports* acontext)
 {
     return NS_ERROR_PARSED_DATA_CACHED;
 }
 
 
 NS_IMETHODIMP
-nsXULDocument::CachedChromeStreamListener::OnStopRequest(nsIRequest *request,
-                                                         nsISupports* aContext,
-                                                         nsresult aStatus)
+XULDocument::CachedChromeStreamListener::OnStopRequest(nsIRequest *request,
+                                                       nsISupports* aContext,
+                                                       nsresult aStatus)
 {
     if (! mProtoLoaded)
         return NS_OK;
 
     return mDocument->OnPrototypeLoadDone(true);
 }
 
 
 NS_IMETHODIMP
-nsXULDocument::CachedChromeStreamListener::OnDataAvailable(nsIRequest *request,
-                                                           nsISupports* aContext,
-                                                           nsIInputStream* aInStr,
-                                                           uint64_t aSourceOffset,
-                                                           uint32_t aCount)
+XULDocument::CachedChromeStreamListener::OnDataAvailable(nsIRequest *request,
+                                                         nsISupports* aContext,
+                                                         nsIInputStream* aInStr,
+                                                         uint64_t aSourceOffset,
+                                                         uint32_t aCount)
 {
     NS_NOTREACHED("CachedChromeStream doesn't receive data");
     return NS_ERROR_UNEXPECTED;
 }
 
 //----------------------------------------------------------------------
 //
 // ParserObserver
 //
 
-nsXULDocument::ParserObserver::ParserObserver(nsXULDocument* aDocument,
-                                              nsXULPrototypeDocument* aPrototype)
+XULDocument::ParserObserver::ParserObserver(XULDocument* aDocument,
+                                            nsXULPrototypeDocument* aPrototype)
     : mDocument(aDocument), mPrototype(aPrototype)
 {
 }
 
-nsXULDocument::ParserObserver::~ParserObserver()
+XULDocument::ParserObserver::~ParserObserver()
 {
 }
 
-NS_IMPL_ISUPPORTS1(nsXULDocument::ParserObserver, nsIRequestObserver)
+NS_IMPL_ISUPPORTS1(XULDocument::ParserObserver, nsIRequestObserver)
 
 NS_IMETHODIMP
-nsXULDocument::ParserObserver::OnStartRequest(nsIRequest *request,
-                                              nsISupports* aContext)
+XULDocument::ParserObserver::OnStartRequest(nsIRequest *request,
+                                            nsISupports* aContext)
 {
     // Guard against buggy channels calling OnStartRequest multiple times.
     if (mPrototype) {
         nsCOMPtr<nsIChannel> channel = do_QueryInterface(request);
         nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
         if (channel && secMan) {
             nsCOMPtr<nsIPrincipal> principal;
             secMan->GetChannelPrincipal(channel, getter_AddRefs(principal));
@@ -4493,19 +4498,19 @@ nsXULDocument::ParserObserver::OnStartRe
         // Make sure to avoid cycles
         mPrototype = nullptr;
     }
         
     return NS_OK;
 }
 
 NS_IMETHODIMP
-nsXULDocument::ParserObserver::OnStopRequest(nsIRequest *request,
-                                             nsISupports* aContext,
-                                             nsresult aStatus)
+XULDocument::ParserObserver::OnStopRequest(nsIRequest *request,
+                                           nsISupports* aContext,
+                                           nsresult aStatus)
 {
     nsresult rv = NS_OK;
 
     if (NS_FAILED(aStatus)) {
         // If an overlay load fails, we need to nudge the prototype
         // walk along.
         nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request);
         if (aChannel) {
@@ -4523,26 +4528,26 @@ nsXULDocument::ParserObserver::OnStopReq
     // document, the parser, the content sink, and the parser
     // observer.
     mDocument = nullptr;
 
     return rv;
 }
 
 already_AddRefed<nsPIWindowRoot>
-nsXULDocument::GetWindowRoot()
+XULDocument::GetWindowRoot()
 {
     nsCOMPtr<nsIInterfaceRequestor> ir = do_QueryReferent(mDocumentContainer);
     nsCOMPtr<nsIDOMWindow> window(do_GetInterface(ir));
     nsCOMPtr<nsPIDOMWindow> piWin(do_QueryInterface(window));
     return piWin ? piWin->GetTopWindowRoot() : nullptr;
 }
 
 bool
-nsXULDocument::IsDocumentRightToLeft()
+XULDocument::IsDocumentRightToLeft()
 {
     // setting the localedir attribute on the root element forces a
     // specific direction for the document.
     Element* element = GetRootElement();
     if (element) {
         static nsIContent::AttrValuesArray strings[] =
             {&nsGkAtoms::ltr, &nsGkAtoms::rtl, nullptr};
         switch (element->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::localedir,
@@ -4584,35 +4589,35 @@ nsXULDocument::IsDocumentRightToLeft()
     }
 
     bool isRTL = false;
     reg->IsLocaleRTL(package, &isRTL);
     return isRTL;
 }
 
 void
-nsXULDocument::ResetDocumentDirection()
+XULDocument::ResetDocumentDirection()
 {
     DocumentStatesChanged(NS_DOCUMENT_STATE_RTL_LOCALE);
 }
 
 int
-nsXULDocument::DirectionChanged(const char* aPrefName, void* aData)
+XULDocument::DirectionChanged(const char* aPrefName, void* aData)
 {
   // Reset the direction and restyle the document if necessary.
-  nsXULDocument* doc = (nsXULDocument *)aData;
+  XULDocument* doc = (XULDocument *)aData;
   if (doc) {
       doc->ResetDocumentDirection();
   }
 
   return 0;
 }
 
 int
-nsXULDocument::GetDocumentLWTheme()
+XULDocument::GetDocumentLWTheme()
 {
     if (mDocLWTheme == Doc_Theme_Uninitialized) {
         mDocLWTheme = Doc_Theme_None; // No lightweight theme by default
 
         Element* element = GetRootElement();
         nsAutoString hasLWTheme;
         if (element &&
             element->GetAttr(kNameSpaceID_None, nsGkAtoms::lwtheme, hasLWTheme) &&
@@ -4628,12 +4633,15 @@ nsXULDocument::GetDocumentLWTheme()
                     mDocLWTheme = Doc_Theme_Bright;
             }
         }
     }
     return mDocLWTheme;
 }
 
 NS_IMETHODIMP
-nsXULDocument::GetBoxObjectFor(nsIDOMElement* aElement, nsIBoxObject** aResult)
+XULDocument::GetBoxObjectFor(nsIDOMElement* aElement, nsIBoxObject** aResult)
 {
     return nsDocument::GetBoxObjectFor(aElement, aResult);
 }
+
+} // namespace dom
+} // namespace mozilla
rename from content/xul/document/src/nsXULDocument.h
rename to content/xul/document/src/XULDocument.h
--- a/content/xul/document/src/nsXULDocument.h
+++ b/content/xul/document/src/XULDocument.h
@@ -1,15 +1,15 @@
 /* -*- 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 nsXULDocument_h__
-#define nsXULDocument_h__
+#ifndef mozilla_dom_XULDocument_h
+#define mozilla_dom_XULDocument_h
 
 #include "nsCOMPtr.h"
 #include "nsXULPrototypeDocument.h"
 #include "nsXULPrototypeCache.h"
 #include "nsTArray.h"
 
 #include "mozilla/dom/XMLDocument.h"
 #include "nsForwardReference.h"
@@ -76,25 +76,29 @@ public:
 
 private:
   nsSmallVoidArray mRefContentList;
 };
 
 /**
  * The XUL document class
  */
-class nsXULDocument : public mozilla::dom::XMLDocument,
-                      public nsIXULDocument,
-                      public nsIDOMXULDocument,
-                      public nsIStreamLoaderObserver,
-                      public nsICSSLoaderObserver
+
+namespace mozilla {
+namespace dom {
+
+class XULDocument : public XMLDocument,
+                    public nsIXULDocument,
+                    public nsIDOMXULDocument,
+                    public nsIStreamLoaderObserver,
+                    public nsICSSLoaderObserver
 {
 public:
-    nsXULDocument();
-    virtual ~nsXULDocument();
+    XULDocument();
+    virtual ~XULDocument();
 
     // nsISupports interface
     NS_DECL_ISUPPORTS_INHERITED
     NS_DECL_NSISTREAMLOADEROBSERVER
 
     // nsIDocument interface
     virtual void Reset(nsIChannel* aChannel, nsILoadGroup* aLoadGroup);
     virtual void ResetToURI(nsIURI *aURI, nsILoadGroup* aLoadGroup,
@@ -135,27 +139,27 @@ public:
 
     // nsINode interface overrides
     virtual nsresult Clone(nsINodeInfo *aNodeInfo, nsINode **aResult) const MOZ_OVERRIDE;
 
     // nsIDOMNode interface
     NS_FORWARD_NSIDOMNODE_TO_NSINODE
 
     // nsIDOMDocument interface
-    NS_FORWARD_NSIDOMDOCUMENT(mozilla::dom::XMLDocument::)
+    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;
 
     // nsDocument interface overrides
-    virtual mozilla::dom::Element* GetElementById(const nsAString & elementId);
+    virtual Element* GetElementById(const nsAString & elementId);
 
     // nsIDOMXULDocument interface
     NS_DECL_NSIDOMXULDOCUMENT
 
     // nsICSSLoaderObserver
     NS_IMETHOD StyleSheetLoaded(nsCSSStyleSheet* aSheet,
                                 bool aWasAlternate,
                                 nsresult aStatus);
@@ -171,35 +175,34 @@ public:
     virtual void ResetDocumentLWTheme() { mDocLWTheme = Doc_Theme_Uninitialized; }
 
     static bool
     MatchAttribute(nsIContent* aContent,
                    int32_t aNameSpaceID,
                    nsIAtom* aAttrName,
                    void* aData);
 
-    NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(nsXULDocument,
-                                             mozilla::dom::XMLDocument)
+    NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(XULDocument, XMLDocument)
 
     virtual nsXPCClassInfo* GetClassInfo();
 
     void TraceProtos(JSTracer* aTrc, uint32_t aGCNumber);
 
 protected:
     // Implementation methods
     friend nsresult
-    NS_NewXULDocument(nsIXULDocument** aResult);
+    (::NS_NewXULDocument(nsIXULDocument** aResult));
 
     nsresult Init(void);
     nsresult StartLayout(void);
 
     nsresult
-    AddElementToRefMap(mozilla::dom::Element* aElement);
+    AddElementToRefMap(Element* aElement);
     void
-    RemoveElementFromRefMap(mozilla::dom::Element* aElement);
+    RemoveElementFromRefMap(Element* aElement);
 
     nsresult GetViewportSize(int32_t* aWidth, int32_t* aHeight);
 
     nsresult PrepareToLoad(nsISupports* aContainer,
                            const char* aCommand,
                            nsIChannel* aChannel,
                            nsILoadGroup* aLoadGroup,
                            nsIParser** aResult);
@@ -215,20 +218,20 @@ protected:
                         bool* aFailureFromContent);
 
     nsresult ApplyPersistentAttributes();
     nsresult ApplyPersistentAttributesInternal();
     nsresult ApplyPersistentAttributesToElements(nsIRDFResource* aResource,
                                                  nsCOMArray<nsIContent>& aElements);
 
     nsresult
-    AddElementToDocumentPre(mozilla::dom::Element* aElement);
+    AddElementToDocumentPre(Element* aElement);
 
     nsresult
-    AddElementToDocumentPost(mozilla::dom::Element* aElement);
+    AddElementToDocumentPost(Element* aElement);
 
     nsresult
     ExecuteOnBroadcastHandlerFor(nsIContent* aBroadcaster,
                                  nsIDOMElement* aListener,
                                  nsIAtom* aAttr);
 
     nsresult
     BroadcastAttributeChangeFromOverlay(nsIContent* aNode,
@@ -259,17 +262,17 @@ protected:
     // 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
 
-    nsXULDocument*             mNextSrcLoadWaiter;  // [OWNER] but not COMPtr
+    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<nsIRDFDataSource> mLocalStore;
     bool                       mApplyingPersistedAttrs;
     bool                       mIsWritingFastLoad;
     bool                       mDocumentLoaded;
@@ -371,25 +374,25 @@ protected:
      */
     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,
-                                        mozilla::dom::Element** aResult,
+                                        Element** aResult,
                                         bool aIsRoot);
 
     /**
      * Create a hook-up element to which content nodes can be attached for
      * later resolution.
      */
     nsresult CreateOverlayElement(nsXULPrototypeElement* aPrototype,
-                                  mozilla::dom::Element** aResult);
+                                  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
@@ -447,23 +450,23 @@ protected:
     nsresult ResolveForwardReferences();
 
     /**
      * Used to resolve broadcaster references
      */
     class BroadcasterHookup : public nsForwardReference
     {
     protected:
-        nsXULDocument* mDocument;              // [WEAK]
-        nsRefPtr<mozilla::dom::Element> mObservesElement; // [OWNER]
+        XULDocument* mDocument;              // [WEAK]
+        nsRefPtr<Element> mObservesElement; // [OWNER]
         bool mResolved;
 
     public:
-        BroadcasterHookup(nsXULDocument* aDocument,
-                          mozilla::dom::Element* aObservesElement)
+        BroadcasterHookup(XULDocument* aDocument,
+                          Element* aObservesElement)
             : mDocument(aDocument),
               mObservesElement(aObservesElement),
               mResolved(false)
         {
         }
 
         virtual ~BroadcasterHookup();
 
@@ -475,24 +478,24 @@ protected:
 
 
     /**
      * Used to hook up overlays
      */
     class OverlayForwardReference : public nsForwardReference
     {
     protected:
-        nsXULDocument* mDocument;      // [WEAK]
+        XULDocument* mDocument;      // [WEAK]
         nsCOMPtr<nsIContent> mOverlay; // [OWNER]
         bool mResolved;
 
         nsresult Merge(nsIContent* aTargetNode, nsIContent* aOverlayNode, bool aNotify);
 
     public:
-        OverlayForwardReference(nsXULDocument* aDocument, nsIContent* aOverlay)
+        OverlayForwardReference(XULDocument* aDocument, nsIContent* aOverlay)
             : mDocument(aDocument), mOverlay(aOverlay), mResolved(false) {}
 
         virtual ~OverlayForwardReference();
 
         virtual Phase GetPhase() { return eConstruction; }
         virtual Result Resolve();
     };
 
@@ -513,24 +516,24 @@ protected:
 
     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(mozilla::dom::Element* aElement,
+    FindBroadcaster(Element* aElement,
                     nsIDOMElement** aListener,
                     nsString& aBroadcasterID,
                     nsString& aAttribute,
                     nsIDOMElement** aBroadcaster);
 
     nsresult
-    CheckBroadcasterHookup(mozilla::dom::Element* aElement,
+    CheckBroadcasterHookup(Element* aElement,
                            bool* aNeedsHookup,
                            bool* aDidResolve);
 
     void
     SynchronizeBroadcastListener(nsIDOMElement   *aBroadcaster,
                                  nsIDOMElement   *aListener,
                                  const nsAString &aAttr);
 
@@ -620,41 +623,41 @@ protected:
     /**
      * 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:
-        nsXULDocument* mDocument;
-        bool           mProtoLoaded;
+        XULDocument* mDocument;
+        bool         mProtoLoaded;
 
         virtual ~CachedChromeStreamListener();
 
     public:
-        CachedChromeStreamListener(nsXULDocument* aDocument,
+        CachedChromeStreamListener(XULDocument* aDocument,
                                    bool aProtoLoaded);
 
         NS_DECL_ISUPPORTS
         NS_DECL_NSIREQUESTOBSERVER
         NS_DECL_NSISTREAMLISTENER
     };
 
     friend class CachedChromeStreamListener;
 
 
     class ParserObserver : public nsIRequestObserver {
     protected:
-        nsRefPtr<nsXULDocument> mDocument;
+        nsRefPtr<XULDocument> mDocument;
         nsRefPtr<nsXULPrototypeDocument> mPrototype;
         virtual ~ParserObserver();
 
     public:
-        ParserObserver(nsXULDocument* aDocument,
+        ParserObserver(XULDocument* aDocument,
                        nsXULPrototypeDocument* aPrototype);
 
         NS_DECL_ISUPPORTS
         NS_DECL_NSIREQUESTOBSERVER
     };
 
     friend class ParserObserver;
 
@@ -715,9 +718,12 @@ protected:
     bool                               mHandlingDelayedBroadcasters;
 
     void MaybeBroadcast();
 private:
     // helpers
 
 };
 
-#endif // nsXULDocument_h__
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_XULDocument_h
--- a/content/xul/document/src/nsXULPrototypeDocument.cpp
+++ b/content/xul/document/src/nsXULPrototypeDocument.cpp
@@ -1,16 +1,16 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* 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/. */
 
 
 #include "nsXULPrototypeDocument.h"
-#include "nsXULDocument.h"
+#include "XULDocument.h"
 
 #include "nsAString.h"
 #include "nsIObjectInputStream.h"
 #include "nsIObjectOutputStream.h"
 #include "nsIPrincipal.h"
 #include "nsJSPrincipals.h"
 #include "nsIScriptGlobalObject.h"
 #include "nsIScriptObjectPrincipal.h"
@@ -29,16 +29,17 @@
 #include "nsContentUtils.h"
 #include "nsCCUncollectableMarker.h"
 #include "nsDOMJSUtils.h" // for GetScriptContextFromJSContext
 #include "xpcpublic.h"
 #include "mozilla/dom/BindingUtils.h"
 
 using mozilla::dom::DestroyProtoAndIfaceCache;
 using mozilla::AutoPushJSContext;
+using mozilla::dom::XULDocument;
 
 static NS_DEFINE_CID(kDOMScriptObjectFactoryCID,
                      NS_DOM_SCRIPT_OBJECT_FACTORY_CID);
 
 
 class nsXULPDGlobalObject : public nsIScriptGlobalObject,
                             public nsIScriptObjectPrincipal
 {
@@ -632,17 +633,17 @@ nsXULPrototypeDocument::SetDocumentPrinc
 nsNodeInfoManager*
 nsXULPrototypeDocument::GetNodeInfoManager()
 {
     return mNodeInfoManager;
 }
 
 
 nsresult
-nsXULPrototypeDocument::AwaitLoadDone(nsXULDocument* aDocument, bool* aResult)
+nsXULPrototypeDocument::AwaitLoadDone(XULDocument* aDocument, bool* aResult)
 {
     nsresult rv = NS_OK;
 
     *aResult = mLoaded;
 
     if (!mLoaded) {
         rv = mPrototypeWaiters.AppendElement(aDocument)
               ? NS_OK : NS_ERROR_OUT_OF_MEMORY; // addrefs
--- a/content/xul/document/src/nsXULPrototypeDocument.h
+++ b/content/xul/document/src/nsXULPrototypeDocument.h
@@ -13,28 +13,33 @@
 #include "nsIScriptGlobalObjectOwner.h"
 #include "nsISerializable.h"
 #include "nsCycleCollectionParticipant.h"
 
 class nsIAtom;
 class nsIPrincipal;
 class nsIURI;
 class nsNodeInfoManager;
-class nsXULDocument;
 class nsXULPrototypeElement;
 class nsXULPrototypePI;
 class nsXULPDGlobalObject;
 struct JSTracer;
 
+namespace mozilla {
+namespace dom {
+class XULDocument;
+} // namespace dom
+} // namespace mozilla
+
 /**
  * A "prototype" document that stores shared document information
  * for the XUL cache.
  * Among other things, stores the tree of nsXULPrototype*
  * objects, from which the real DOM tree is built later in
- * nsXULDocument::ResumeWalk.
+ * XULDocument::ResumeWalk.
  */
 class nsXULPrototypeDocument : public nsIScriptGlobalObjectOwner,
                                public nsISerializable
 {
 public:
     static nsresult
     Create(nsIURI* aURI, nsXULPrototypeDocument** aResult);
 
@@ -88,20 +93,20 @@ public:
     NS_IMETHOD SetHeaderData(nsIAtom* aField, const nsAString& aData);
 
     nsIPrincipal *DocumentPrincipal();
     void SetDocumentPrincipal(nsIPrincipal *aPrincipal);
 
     /**
      * If current prototype document has not yet finished loading,
      * appends aDocument to the list of documents to notify (via
-     * nsXULDocument::OnPrototypeLoadDone()) and sets aLoaded to false.
+     * XULDocument::OnPrototypeLoadDone()) and sets aLoaded to false.
      * Otherwise sets aLoaded to true.
      */
-    nsresult AwaitLoadDone(nsXULDocument* aDocument, bool* aResult);
+    nsresult AwaitLoadDone(mozilla::dom::XULDocument* aDocument, bool* aResult);
 
     /**
      * Notifies each document registered via AwaitLoadDone on this
      * prototype document that the prototype has finished loading.
      * The notification is performed by calling
      * nsIXULDocument::OnPrototypeLoadDone on the registered documents.
      */
     nsresult NotifyLoadDone();
@@ -125,17 +130,17 @@ protected:
     nsCOMPtr<nsIURI> mURI;
     nsRefPtr<nsXULPrototypeElement> mRoot;
     nsTArray<nsRefPtr<nsXULPrototypePI> > mProcessingInstructions;
     nsCOMArray<nsIURI> mStyleSheetReferences;
 
     nsRefPtr<nsXULPDGlobalObject> mGlobalObject;
 
     bool mLoaded;
-    nsTArray< nsRefPtr<nsXULDocument> > mPrototypeWaiters;
+    nsTArray< nsRefPtr<mozilla::dom::XULDocument> > mPrototypeWaiters;
 
     nsRefPtr<nsNodeInfoManager> mNodeInfoManager;
 
     uint32_t mCCGeneration;
     uint32_t mGCNumber;
 
     nsXULPrototypeDocument();
     virtual ~nsXULPrototypeDocument();
--- a/xpcom/base/ErrorList.h
+++ b/xpcom/base/ErrorList.h
@@ -687,17 +687,17 @@
   /* Error code for XBL */
   ERROR(NS_ERROR_XBL_BLOCKED,                   FAILURE(15)),
 
   /* XXX this is not really used */
   ERROR(NS_HTML_STYLE_PROPERTY_NOT_THERE,   SUCCESS(2)),
   ERROR(NS_CONTENT_BLOCKED,                 SUCCESS(8)),
   ERROR(NS_CONTENT_BLOCKED_SHOW_ALT,        SUCCESS(9)),
   ERROR(NS_PROPTABLE_PROP_OVERWRITTEN,      SUCCESS(11)),
-  /* Error codes for FindBroadcaster in nsXULDocument.cpp */
+  /* Error codes for FindBroadcaster in XULDocument.cpp */
   ERROR(NS_FINDBROADCASTER_NOT_FOUND,       SUCCESS(12)),
   ERROR(NS_FINDBROADCASTER_FOUND,           SUCCESS(13)),
   ERROR(NS_FINDBROADCASTER_AWAIT_OVERLAYS,  SUCCESS(14)),
 #undef MODULE
 
 
   /* ======================================================================= */
   /* 27: NS_ERROR_MODULE_XSLT */