--- a/accessible/base/DocManager.cpp
+++ b/accessible/base/DocManager.cpp
@@ -237,17 +237,17 @@ DocManager::OnStateChange(nsIWebProgress
                           nsresult aStatus)
 {
   NS_ASSERTION(aStateFlags & STATE_IS_DOCUMENT, "Other notifications excluded");
 
   if (nsAccessibilityService::IsShutdown() || !aWebProgress ||
       (aStateFlags & (STATE_START | STATE_STOP)) == 0)
     return NS_OK;
 
-  nsCOMPtr<mozIDOMWindowProxy> DOMWindow;
+  nsCOMPtr<nsPIDOMWindowOuter> DOMWindow;
   aWebProgress->GetDOMWindow(getter_AddRefs(DOMWindow));
   NS_ENSURE_STATE(DOMWindow);
 
   nsPIDOMWindowOuter* piWindow = nsPIDOMWindowOuter::From(DOMWindow);
   MOZ_ASSERT(piWindow);
 
   nsCOMPtr<nsIDocument> document = piWindow->GetDoc();
   NS_ENSURE_STATE(document);

--- a/accessible/base/Logging.cpp
+++ b/accessible/base/Logging.cpp
@@ -395,17 +395,17 @@ static const char* sDocEventTitle = "DOC
 static const char* sFocusTitle = "FOCUS";
 
 void
 logging::DocLoad(const char* aMsg, nsIWebProgress* aWebProgress,
                  nsIRequest* aRequest, uint32_t aStateFlags)
 {
   MsgBegin(sDocLoadTitle, "%s", aMsg);
 
-  nsCOMPtr<mozIDOMWindowProxy> DOMWindow;
+  nsCOMPtr<nsPIDOMWindowOuter> DOMWindow;
   aWebProgress->GetDOMWindow(getter_AddRefs(DOMWindow));
   nsPIDOMWindowOuter* window = nsPIDOMWindowOuter::From(DOMWindow);
   if (!window) {
     MsgEnd();
     return;
   }
 
   nsCOMPtr<nsIDocument> documentNode = window->GetDoc();

--- a/accessible/interfaces/nsIAccessibleDocument.idl
+++ b/accessible/interfaces/nsIAccessibleDocument.idl
@@ -1,17 +1,17 @@
 /* -*- 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 "nsISupports.idl"
 
 interface nsIAccessiblePivot;
-interface mozIDOMWindowProxy;
+webidl WindowProxy;
 
 webidl Document;
 
 /**
  * An interface for in-process accessibility clients
  * that wish to retrieve information about a document.
  * When accessibility is turned on in Gecko,
  * there is an nsIAccessibleDocument for each document
@@ -46,17 +46,17 @@ interface nsIAccessibleDocument : nsISup
   /**
    * The Document interface associated with this document.
    */
   readonly attribute Document DOMDocument;
 
   /**
    * The nsIDOMWindow that the document resides in.
    */
-  readonly attribute mozIDOMWindowProxy window;
+  readonly attribute WindowProxy window;
 
   /**
    * Return the parent document accessible.
    */
   readonly attribute nsIAccessibleDocument parentDocument;
 
   /**
    * Return the count of child document accessibles.

--- a/accessible/xpcom/xpcAccessibleDocument.cpp
+++ b/accessible/xpcom/xpcAccessibleDocument.cpp
@@ -95,17 +95,17 @@ xpcAccessibleDocument::GetDOMDocument(ns
 
   if (Intl()->DocumentNode())
     NS_ADDREF(*aDOMDocument = Intl()->DocumentNode());
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessibleDocument::GetWindow(mozIDOMWindowProxy** aDOMWindow)
+xpcAccessibleDocument::GetWindow(nsPIDOMWindowOuter** aDOMWindow)
 {
   NS_ENSURE_ARG_POINTER(aDOMWindow);
   *aDOMWindow = nullptr;
 
   if (!Intl())
     return NS_ERROR_FAILURE;
 
   NS_IF_ADDREF(*aDOMWindow = Intl()->DocumentNode()->GetWindow());

--- a/accessible/xpcom/xpcAccessibleDocument.h
+++ b/accessible/xpcom/xpcAccessibleDocument.h
@@ -34,17 +34,17 @@ public:
   NS_DECL_ISUPPORTS_INHERITED
 
   // nsIAccessibleDocument
   NS_IMETHOD GetURL(nsAString& aURL) final;
   NS_IMETHOD GetTitle(nsAString& aTitle) final;
   NS_IMETHOD GetMimeType(nsAString& aType) final;
   NS_IMETHOD GetDocType(nsAString& aType) final;
   NS_IMETHOD GetDOMDocument(nsIDocument** aDOMDocument) final;
-  NS_IMETHOD GetWindow(mozIDOMWindowProxy** aDOMWindow) final;
+  NS_IMETHOD GetWindow(nsPIDOMWindowOuter** aDOMWindow) final;
   NS_IMETHOD GetParentDocument(nsIAccessibleDocument** aDocument)
     final;
   NS_IMETHOD GetChildDocumentCount(uint32_t* aCount) final;
   NS_IMETHOD GetChildDocumentAt(uint32_t aIndex,
                                 nsIAccessibleDocument** aDocument)
     final;
   NS_IMETHOD GetVirtualCursor(nsIAccessiblePivot** aVirtualCursor)
     final;

--- a/browser/modules/SiteDataManager.jsm
+++ b/browser/modules/SiteDataManager.jsm
@@ -366,17 +366,17 @@ var SiteDataManager = {
     return this.updateSites();
   },
 
   /**
    * In the specified window, shows a prompt for removing
    * all site data or the specified list of hosts, warning the
    * user that this may log them out of websites.
    *
-   * @param {mozIDOMWindowProxy} a parent DOM window to host the dialog.
+   * @param {Window} a parent DOM window to host the dialog.
    * @param {Array} [optional] an array of host name strings that will be removed.
    * @returns a boolean whether the user confirmed the prompt.
    */
   promptSiteDataRemoval(win, removals) {
     if (removals) {
       let args = {
         hosts: removals,
         allowed: false

--- a/chrome/nsChromeRegistry.cpp
+++ b/chrome/nsChromeRegistry.cpp
@@ -381,17 +381,17 @@ nsChromeRegistry::FlushSkinCaches()
 nsresult nsChromeRegistry::RefreshWindow(nsPIDOMWindowOuter* aWindow)
 {
   // Deal with our subframes first.
   nsCOMPtr<nsIDOMWindowCollection> frames = aWindow->GetFrames();
   uint32_t length;
   frames->GetLength(&length);
   uint32_t j;
   for (j = 0; j < length; j++) {
-    nsCOMPtr<mozIDOMWindowProxy> childWin;
+    nsCOMPtr<nsPIDOMWindowOuter> childWin;
     frames->Item(j, getter_AddRefs(childWin));
     nsCOMPtr<nsPIDOMWindowOuter> piWindow = nsPIDOMWindowOuter::From(childWin);
     RefreshWindow(piWindow);
   }
 
   nsresult rv;
   // Get the document.
   nsCOMPtr<nsIDocument> document = aWindow->GetDoc();

--- a/docshell/base/LoadContext.cpp
+++ b/docshell/base/LoadContext.cpp
@@ -38,26 +38,26 @@ LoadContext::LoadContext(nsIPrincipal* a
   MOZ_ALWAYS_SUCCEEDS(aOptionalBase->GetUseTrackingProtection(&mUseTrackingProtection));
 }
 
 //-----------------------------------------------------------------------------
 // LoadContext::nsILoadContext
 //-----------------------------------------------------------------------------
 
 NS_IMETHODIMP
-LoadContext::GetAssociatedWindow(mozIDOMWindowProxy**)
+LoadContext::GetAssociatedWindow(nsPIDOMWindowOuter**)
 {
   MOZ_ASSERT(mIsNotNull);
 
   // can't support this in the parent process
   return NS_ERROR_UNEXPECTED;
 }
 
 NS_IMETHODIMP
-LoadContext::GetTopWindow(mozIDOMWindowProxy**)
+LoadContext::GetTopWindow(nsPIDOMWindowOuter**)
 {
   MOZ_ASSERT(mIsNotNull);
 
   // can't support this in the parent process
   return NS_ERROR_UNEXPECTED;
 }
 
 NS_IMETHODIMP

--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -3257,17 +3257,17 @@ nsDocShell::CanAccessItem(nsIDocShellTre
   }
 
   nsCOMPtr<nsPIDOMWindowOuter> targetWindow = aTargetItem->GetWindow();
   if (!targetWindow) {
     NS_ERROR("This should not happen, really");
     return false;
   }
 
-  nsCOMPtr<mozIDOMWindowProxy> targetOpener = targetWindow->GetOpener();
+  nsCOMPtr<nsPIDOMWindowOuter> targetOpener = targetWindow->GetOpener();
   nsCOMPtr<nsIWebNavigation> openerWebNav(do_GetInterface(targetOpener));
   nsCOMPtr<nsIDocShellTreeItem> openerItem(do_QueryInterface(openerWebNav));
 
   if (!openerItem) {
     return false;
   }
 
   return CanAccessItem(openerItem, aAccessingItem, false);
@@ -12991,24 +12991,24 @@ nsDocShell::GetAuthPrompt(uint32_t aProm
                            reinterpret_cast<void**>(aResult));
 }
 
 //*****************************************************************************
 // nsDocShell::nsILoadContext
 //*****************************************************************************
 
 NS_IMETHODIMP
-nsDocShell::GetAssociatedWindow(mozIDOMWindowProxy** aWindow)
+nsDocShell::GetAssociatedWindow(nsPIDOMWindowOuter** aWindow)
 {
   CallGetInterface(this, aWindow);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsDocShell::GetTopWindow(mozIDOMWindowProxy** aWindow)
+nsDocShell::GetTopWindow(nsPIDOMWindowOuter** aWindow)
 {
   nsCOMPtr<nsPIDOMWindowOuter> win = GetWindow();
   if (win) {
     win = win->GetTop();
   }
   win.forget(aWindow);
   return NS_OK;
 }

--- a/docshell/base/nsDocShell.h
+++ b/docshell/base/nsDocShell.h
@@ -227,18 +227,18 @@ public:
                              nsIPrincipal* aTriggeringPrincipal = nullptr) override;
   NS_IMETHOD OnOverLink(nsIContent* aContent,
                         nsIURI* aURI,
                         const char16_t* aTargetSpec) override;
   NS_IMETHOD OnLeaveLink() override;
 
   // Don't use NS_DECL_NSILOADCONTEXT because some of nsILoadContext's methods
   // are shared with nsIDocShell (appID, etc.) and can't be declared twice.
-  NS_IMETHOD GetAssociatedWindow(mozIDOMWindowProxy**) override;
-  NS_IMETHOD GetTopWindow(mozIDOMWindowProxy**) override;
+  NS_IMETHOD GetAssociatedWindow(nsPIDOMWindowOuter**) override;
+  NS_IMETHOD GetTopWindow(nsPIDOMWindowOuter**) override;
   NS_IMETHOD GetTopFrameElement(mozilla::dom::Element**) override;
   NS_IMETHOD GetNestedFrameId(uint64_t*) override;
   NS_IMETHOD GetIsContent(bool*) override;
   NS_IMETHOD GetUsePrivateBrowsing(bool*) override;
   NS_IMETHOD SetUsePrivateBrowsing(bool) override;
   NS_IMETHOD SetPrivateBrowsing(bool) override;
   NS_IMETHOD GetUseRemoteTabs(bool*) override;
   NS_IMETHOD SetRemoteTabs(bool) override;

--- a/docshell/base/nsDocShellTreeOwner.cpp
+++ b/docshell/base/nsDocShellTreeOwner.cpp
@@ -66,17 +66,17 @@ using namespace mozilla::dom;
 // a |EventTarget| via the window root and chrome event handler.
 static nsresult
 GetDOMEventTarget(nsWebBrowser* aInBrowser, EventTarget** aTarget)
 {
   if (!aInBrowser) {
     return NS_ERROR_INVALID_POINTER;
   }
 
-  nsCOMPtr<mozIDOMWindowProxy> domWindow;
+  nsCOMPtr<nsPIDOMWindowOuter> domWindow;
   aInBrowser->GetContentDOMWindow(getter_AddRefs(domWindow));
   if (!domWindow) {
     return NS_ERROR_FAILURE;
   }
 
   auto* outerWindow = nsPIDOMWindowOuter::From(domWindow);
   nsPIDOMWindowOuter* rootWindow = outerWindow->GetPrivateRoot();
   NS_ENSURE_TRUE(rootWindow, NS_ERROR_FAILURE);
@@ -174,46 +174,46 @@ void
 nsDocShellTreeOwner::EnsurePrompter()
 {
   if (mPrompter) {
     return;
   }
 
   nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
   if (wwatch && mWebBrowser) {
-    nsCOMPtr<mozIDOMWindowProxy> domWindow;
+    nsCOMPtr<nsPIDOMWindowOuter> domWindow;
     mWebBrowser->GetContentDOMWindow(getter_AddRefs(domWindow));
     if (domWindow) {
       wwatch->GetNewPrompter(domWindow, getter_AddRefs(mPrompter));
     }
   }
 }
 
 void
 nsDocShellTreeOwner::EnsureAuthPrompter()
 {
   if (mAuthPrompter) {
     return;
   }
 
   nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
   if (wwatch && mWebBrowser) {
-    nsCOMPtr<mozIDOMWindowProxy> domWindow;
+    nsCOMPtr<nsPIDOMWindowOuter> domWindow;
     mWebBrowser->GetContentDOMWindow(getter_AddRefs(domWindow));
     if (domWindow) {
       wwatch->GetNewAuthPrompter(domWindow, getter_AddRefs(mAuthPrompter));
     }
   }
 }
 
 void
 nsDocShellTreeOwner::AddToWatcher()
 {
   if (mWebBrowser) {
-    nsCOMPtr<mozIDOMWindowProxy> domWindow;
+    nsCOMPtr<nsPIDOMWindowOuter> domWindow;
     mWebBrowser->GetContentDOMWindow(getter_AddRefs(domWindow));
     if (domWindow) {
       nsCOMPtr<nsPIWindowWatcher> wwatch(
         do_GetService(NS_WINDOWWATCHER_CONTRACTID));
       if (wwatch) {
         nsCOMPtr<nsIWebBrowserChrome> webBrowserChrome = GetWebBrowserChrome();
         if (webBrowserChrome) {
           wwatch->AddWindow(domWindow, webBrowserChrome);
@@ -222,17 +222,17 @@ nsDocShellTreeOwner::AddToWatcher()
     }
   }
 }
 
 void
 nsDocShellTreeOwner::RemoveFromWatcher()
 {
   if (mWebBrowser) {
-    nsCOMPtr<mozIDOMWindowProxy> domWindow;
+    nsCOMPtr<nsPIDOMWindowOuter> domWindow;
     mWebBrowser->GetContentDOMWindow(getter_AddRefs(domWindow));
     if (domWindow) {
       nsCOMPtr<nsPIWindowWatcher> wwatch(
         do_GetService(NS_WINDOWWATCHER_CONTRACTID));
       if (wwatch) {
         wwatch->RemoveWindow(domWindow);
       }
     }

--- a/docshell/base/nsILoadContext.idl
+++ b/docshell/base/nsILoadContext.idl
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  * vim: ft=cpp tw=78 sw=2 et ts=2 sts=2 cin
  * 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 "nsISupports.idl"
 
-interface mozIDOMWindowProxy;
+webidl WindowProxy;
 
 webidl Element;
 
 [ref] native OriginAttributes(mozilla::OriginAttributes);
 
 %{C++
 #ifdef MOZILLA_INTERNAL_API
 #include "mozilla/BasePrincipal.h" // for OriginAttributes
@@ -28,25 +28,25 @@ interface nsILoadContext : nsISupports
 {
   /**
    * associatedWindow is the window with which the load is associated, if any.
    * Note that the load may be triggered by a document which is different from
    * the document in associatedWindow, and in fact the source of the load need
    * not be same-origin with the document in associatedWindow.  This attribute
    * may be null if there is no associated window.
    */
-  readonly attribute mozIDOMWindowProxy associatedWindow;
+  readonly attribute WindowProxy associatedWindow;
 
   /**
    * topWindow is the top window which is of same type as associatedWindow.
    * This is equivalent to associatedWindow.top, but is provided here as a
    * convenience.  All the same caveats as associatedWindow of apply, of
    * course.  This attribute may be null if there is no associated window.
    */
-  readonly attribute mozIDOMWindowProxy topWindow;
+  readonly attribute WindowProxy topWindow;
 
   /**
    * topFrameElement is the <iframe>, <frame>, or <browser> element which
    * contains the topWindow with which the load is associated.
    *
    * Note that we may have a topFrameElement even when we don't have an
    * associatedWindow, if the topFrameElement's content lives out of process.
    * topFrameElement is available in single-process and multiprocess contexts.

--- a/dom/audiochannel/AudioChannelAgent.cpp
+++ b/dom/audiochannel/AudioChannelAgent.cpp
@@ -52,25 +52,25 @@ void
 AudioChannelAgent::Shutdown()
 {
   if (mIsRegToService) {
     NotifyStoppedPlaying();
   }
 }
 
 NS_IMETHODIMP
-AudioChannelAgent::Init(mozIDOMWindow* aWindow,
+AudioChannelAgent::Init(nsPIDOMWindowInner* aWindow,
                         nsIAudioChannelAgentCallback *aCallback)
 {
   return InitInternal(nsPIDOMWindowInner::From(aWindow),
                       aCallback, /* useWeakRef = */ false);
 }
 
 NS_IMETHODIMP
-AudioChannelAgent::InitWithWeakCallback(mozIDOMWindow* aWindow,
+AudioChannelAgent::InitWithWeakCallback(nsPIDOMWindowInner* aWindow,
                                         nsIAudioChannelAgentCallback *aCallback)
 {
   return InitInternal(nsPIDOMWindowInner::From(aWindow),
                       aCallback, /* useWeakRef = */ true);
 }
 
 nsresult
 AudioChannelAgent::FindCorrectWindow(nsPIDOMWindowInner* aWindow)

--- a/dom/audiochannel/nsIAudioChannelAgent.idl
+++ b/dom/audiochannel/nsIAudioChannelAgent.idl
@@ -1,15 +1,15 @@
 /* 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 "nsISupports.idl"
 
-interface mozIDOMWindow;
+webidl Window;
 
 typedef uint32_t nsSuspendedTypes;
 
 [scriptable, builtinclass, uuid(2822a840-f009-11e5-a837-0800200c9a66)]
 interface nsISuspendedTypes : nsISupports
 {
   /**
    * The suspended enum is used in three different situations,
@@ -110,26 +110,26 @@ interface nsIAudioChannelAgent : nsISupp
    * @param callback
    *    1. Once the playable status changes, agent uses this callback function
    *       to notify Gecko component.
    *    2. The callback is allowed to be null. Ex: telephony doesn't need to
    *       listen change of the playable status.
    *    3. The AudioChannelAgent keeps a strong reference to the callback
    *       object.
    */
-  void init(in mozIDOMWindow window, in nsIAudioChannelAgentCallback callback);
+  void init(in Window window, in nsIAudioChannelAgentCallback callback);
 
   /**
    * This method is just like init(), except the audio channel agent keeps a
    * weak reference to the callback object.
    *
    * In order for this to work, |callback| must implement
    * nsISupportsWeakReference.
    */
-  void initWithWeakCallback(in mozIDOMWindow window,
+  void initWithWeakCallback(in Window window,
                             in nsIAudioChannelAgentCallback callback);
 
   /**
    * Notify the agent that we want to start playing.
    * Note: Gecko component SHOULD call this function first then start to
    *          play audio stream only when return value is true.
    *
    * @param config

--- a/dom/base/DOMRequest.cpp
+++ b/dom/base/DOMRequest.cpp
@@ -198,17 +198,17 @@ DOMRequest::Then(JSContext* aCx, AnyCall
   JS::Rooted<JSObject*> global(aCx, mPromise->PromiseObj());
   global = js::GetGlobalForObjectCrossCompartment(global);
   mPromise->Then(aCx, global, aResolveCallback, aRejectCallback, aRetval, aRv);
 }
 
 NS_IMPL_ISUPPORTS(DOMRequestService, nsIDOMRequestService)
 
 NS_IMETHODIMP
-DOMRequestService::CreateRequest(mozIDOMWindow* aWindow,
+DOMRequestService::CreateRequest(nsPIDOMWindowInner* aWindow,
                                  DOMRequest** aRequest)
 {
   MOZ_ASSERT(NS_IsMainThread());
   NS_ENSURE_STATE(aWindow);
   auto* win = nsPIDOMWindowInner::From(aWindow);
   RefPtr<DOMRequest> req = new DOMRequest(win);
   req.forget(aRequest);
 

--- a/dom/base/TabGroup.cpp
+++ b/dom/base/TabGroup.cpp
@@ -84,17 +84,17 @@ TabGroup::GetChromeTabGroup()
   if (!sChromeTabGroup) {
     sChromeTabGroup = new TabGroup(true /* chrome tab group */);
     ClearOnShutdown(&sChromeTabGroup);
   }
   return sChromeTabGroup;
 }
 
 /* static */ TabGroup*
-TabGroup::GetFromWindow(mozIDOMWindowProxy* aWindow)
+TabGroup::GetFromWindow(nsPIDOMWindowOuter* aWindow)
 {
   if (TabChild* tabChild = TabChild::GetFrom(aWindow)) {
     return tabChild->TabGroup();
   }
 
   return nullptr;
 }
 

--- a/dom/base/TabGroup.h
+++ b/dom/base/TabGroup.h
@@ -12,17 +12,17 @@
 #include "nsIPrincipal.h"
 #include "nsTHashtable.h"
 #include "nsString.h"
 
 #include "mozilla/Atomics.h"
 #include "mozilla/SchedulerGroup.h"
 #include "mozilla/RefPtr.h"
 
-class mozIDOMWindowProxy;
+class nsPIDOMWindowOuter;
 class nsIDocShellTreeItem;
 class nsIDocument;
 class nsPIDOMWindowOuter;
 
 namespace mozilla {
 class AbstractThread;
 class ThrottledEventQueue;
 namespace dom {
@@ -71,17 +71,17 @@ public:
   GetChromeTabGroup();
 
   // Checks if the TabChild already has a TabGroup assigned to it in
   // IPDL. Returns this TabGroup if it does. This could happen if the parent
   // process created the PBrowser and we needed to assign a TabGroup immediately
   // upon receiving the IPDL message. This method is main thread only.
   static TabGroup* GetFromActor(TabChild* aTabChild);
 
-  static TabGroup* GetFromWindow(mozIDOMWindowProxy* aWindow);
+  static TabGroup* GetFromWindow(nsPIDOMWindowOuter* aWindow);
 
   explicit TabGroup(bool aIsChrome = false);
 
   // Get the docgroup for the corresponding doc group key.
   // Returns null if the given key hasn't been seen yet.
   already_AddRefed<DocGroup>
   GetDocGroup(const nsACString& aKey);
 

--- a/dom/base/TextInputProcessor.cpp
+++ b/dom/base/TextInputProcessor.cpp
@@ -326,46 +326,46 @@ TextInputProcessor::GetHasComposition(bo
   MOZ_RELEASE_ASSERT(aHasComposition, "aHasComposition must not be nullptr");
   MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
   *aHasComposition = IsComposing();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 TextInputProcessor::BeginInputTransaction(
-                      mozIDOMWindow* aWindow,
+                      nsPIDOMWindowInner* aWindow,
                       nsITextInputProcessorCallback* aCallback,
                       bool* aSucceeded)
 {
   MOZ_RELEASE_ASSERT(aSucceeded, "aSucceeded must not be nullptr");
   MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
   if (NS_WARN_IF(!aCallback)) {
     *aSucceeded = false;
     return NS_ERROR_INVALID_ARG;
   }
   return BeginInputTransactionInternal(aWindow, aCallback, false, *aSucceeded);
 }
 
 NS_IMETHODIMP
 TextInputProcessor::BeginInputTransactionForTests(
-                      mozIDOMWindow* aWindow,
+                      nsPIDOMWindowInner* aWindow,
                       nsITextInputProcessorCallback* aCallback,
                       uint8_t aOptionalArgc,
                       bool* aSucceeded)
 {
   MOZ_RELEASE_ASSERT(aSucceeded, "aSucceeded must not be nullptr");
   MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
   nsITextInputProcessorCallback* callback =
     aOptionalArgc >= 1 ? aCallback : nullptr;
   return BeginInputTransactionInternal(aWindow, callback, true, *aSucceeded);
 }
 
 nsresult
 TextInputProcessor::BeginInputTransactionInternal(
-                      mozIDOMWindow* aWindow,
+                      nsPIDOMWindowInner* aWindow,
                       nsITextInputProcessorCallback* aCallback,
                       bool aForTests,
                       bool& aSucceeded)
 {
   aSucceeded = false;
   if (NS_WARN_IF(!aWindow)) {
     return NS_ERROR_INVALID_ARG;
   }

--- a/dom/base/TextInputProcessor.h
+++ b/dom/base/TextInputProcessor.h
@@ -50,17 +50,17 @@ public:
                       void* aData) override;
 
 protected:
   virtual ~TextInputProcessor();
 
 private:
   bool IsComposing() const;
   nsresult BeginInputTransactionInternal(
-             mozIDOMWindow* aWindow,
+             nsPIDOMWindowInner* aWindow,
              nsITextInputProcessorCallback* aCallback,
              bool aForTests,
              bool& aSucceeded);
   nsresult CommitCompositionInternal(
              const WidgetKeyboardEvent* aKeyboardEvent = nullptr,
              uint32_t aKeyFlags = 0,
              const nsAString* aCommitString = nullptr,
              bool* aSucceeded = nullptr);

--- a/dom/base/ThirdPartyUtil.cpp
+++ b/dom/base/ThirdPartyUtil.cpp
@@ -60,17 +60,17 @@ ThirdPartyUtil::IsThirdPartyInternal(con
 
   // Check strict equality.
   *aResult = aFirstDomain != secondDomain;
   return NS_OK;
 }
 
 // Get the URI associated with a window.
 NS_IMETHODIMP
-ThirdPartyUtil::GetURIFromWindow(mozIDOMWindowProxy* aWin, nsIURI** result)
+ThirdPartyUtil::GetURIFromWindow(nsPIDOMWindowOuter* aWin, nsIURI** result)
 {
   nsresult rv;
   nsCOMPtr<nsIScriptObjectPrincipal> scriptObjPrin = do_QueryInterface(aWin);
   if (!scriptObjPrin) {
     return NS_ERROR_INVALID_ARG;
   }
 
   nsIPrincipal* prin = scriptObjPrin->GetPrincipal();
@@ -104,17 +104,17 @@ ThirdPartyUtil::IsThirdPartyURI(nsIURI* 
     return rv;
 
   return IsThirdPartyInternal(firstHost, aSecondURI, aResult);
 }
 
 // Determine if any URI of the window hierarchy of aWindow is foreign with
 // respect to aSecondURI. See docs for mozIThirdPartyUtil.
 NS_IMETHODIMP
-ThirdPartyUtil::IsThirdPartyWindow(mozIDOMWindowProxy* aWindow,
+ThirdPartyUtil::IsThirdPartyWindow(nsPIDOMWindowOuter* aWindow,
                                    nsIURI* aURI,
                                    bool* aResult)
 {
   NS_ENSURE_ARG(aWindow);
   NS_ASSERTION(aResult, "null outparam pointer");
 
   bool result;
 
@@ -247,28 +247,28 @@ ThirdPartyUtil::IsThirdPartyChannel(nsIC
     return NS_OK;
   }
 
   // Determine whether aURI is foreign with respect to channelURI.
   return IsThirdPartyInternal(channelDomain, aURI, aResult);
 }
 
 NS_IMETHODIMP
-ThirdPartyUtil::GetTopWindowForChannel(nsIChannel* aChannel, mozIDOMWindowProxy** aWin)
+ThirdPartyUtil::GetTopWindowForChannel(nsIChannel* aChannel, nsPIDOMWindowOuter** aWin)
 {
   NS_ENSURE_ARG(aWin);
 
   // Find the associated window and its parent window.
   nsCOMPtr<nsILoadContext> ctx;
   NS_QueryNotificationCallbacks(aChannel, ctx);
   if (!ctx) {
     return NS_ERROR_INVALID_ARG;
   }
 
-  nsCOMPtr<mozIDOMWindowProxy> window;
+  nsCOMPtr<nsPIDOMWindowOuter> window;
   ctx->GetAssociatedWindow(getter_AddRefs(window));
   if (!window) {
     return NS_ERROR_INVALID_ARG;
   }
 
   nsCOMPtr<nsPIDOMWindowOuter> top = nsPIDOMWindowOuter::From(window)->GetTop();
   top.forget(aWin);
   return NS_OK;

--- a/dom/base/nsContentPermissionHelper.cpp
+++ b/dom/base/nsContentPermissionHelper.cpp
@@ -620,17 +620,17 @@ nsContentPermissionRequestProxy::GetType
   if (mozilla::dom::nsContentPermissionUtils::ConvertPermissionRequestToArray(mPermissionRequests, types)) {
     types.forget(aTypes);
     return NS_OK;
   }
   return NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
-nsContentPermissionRequestProxy::GetWindow(mozIDOMWindow * *aRequestingWindow)
+nsContentPermissionRequestProxy::GetWindow(nsPIDOMWindowInner * *aRequestingWindow)
 {
   NS_ENSURE_ARG_POINTER(aRequestingWindow);
   *aRequestingWindow = nullptr; // ipc doesn't have a window
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsContentPermissionRequestProxy::GetPrincipal(nsIPrincipal * *aRequestingPrincipal)

--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -5654,17 +5654,17 @@ nsContentUtils::GetWindowProviderForCont
 }
 
 /* static */
 already_AddRefed<nsPIDOMWindowOuter>
 nsContentUtils::GetMostRecentNonPBWindow()
 {
   nsCOMPtr<nsIWindowMediator> wm = do_GetService(NS_WINDOWMEDIATOR_CONTRACTID);
 
-  nsCOMPtr<mozIDOMWindowProxy> window;
+  nsCOMPtr<nsPIDOMWindowOuter> window;
   wm->GetMostRecentNonPBWindow(u"navigator:browser",
                                getter_AddRefs(window));
   nsCOMPtr<nsPIDOMWindowOuter> pwindow;
   pwindow = do_QueryInterface(window);
 
   return pwindow.forget();
 }
 
@@ -7636,17 +7636,17 @@ nsContentUtils::GetInnerWindowID(nsILoad
     return 0;
   }
 
   nsCOMPtr<nsILoadContext> loadContext = do_GetInterface(callbacks);
   if (!loadContext) {
     return 0;
   }
 
-  nsCOMPtr<mozIDOMWindowProxy> window;
+  nsCOMPtr<nsPIDOMWindowOuter> window;
   rv = loadContext->GetAssociatedWindow(getter_AddRefs(window));
   if (NS_FAILED(rv) || !window) {
     return 0;
   }
 
   auto* pwindow = nsPIDOMWindowOuter::From(window);
   if (!pwindow) {
     return 0;
@@ -10163,17 +10163,17 @@ nsContentUtils::AttemptLargeAllocationLo
     return false;
   }
 
   nsCOMPtr<nsILoadContext> loadContext = do_GetInterface(callbacks);
   if (NS_WARN_IF(!loadContext)) {
     return false;
   }
 
-  nsCOMPtr<mozIDOMWindowProxy> window;
+  nsCOMPtr<nsPIDOMWindowOuter> window;
   rv = loadContext->GetAssociatedWindow(getter_AddRefs(window));
   if (NS_WARN_IF(NS_FAILED(rv) || !window)) {
     return false;
   }
 
   nsPIDOMWindowOuter* outer = nsPIDOMWindowOuter::From(window);
   if (NS_WARN_IF(!outer)) {
     return false;

--- a/dom/base/nsDOMWindowList.cpp
+++ b/dom/base/nsDOMWindowList.cpp
@@ -88,25 +88,25 @@ nsDOMWindowList::IndexedGetter(uint32_t 
 
   nsCOMPtr<nsPIDOMWindowOuter> window = item->GetWindow();
   MOZ_ASSERT(window);
 
   return window.forget();
 }
 
 NS_IMETHODIMP
-nsDOMWindowList::Item(uint32_t aIndex, mozIDOMWindowProxy** aReturn)
+nsDOMWindowList::Item(uint32_t aIndex, nsPIDOMWindowOuter** aReturn)
 {
   nsCOMPtr<nsPIDOMWindowOuter> window = IndexedGetter(aIndex);
   window.forget(aReturn);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsDOMWindowList::NamedItem(const nsAString& aName, mozIDOMWindowProxy** aReturn)
+nsDOMWindowList::NamedItem(const nsAString& aName, nsPIDOMWindowOuter** aReturn)
 {
   nsCOMPtr<nsIDocShellTreeItem> item;
 
   *aReturn = nullptr;
 
   EnsureFresh();
 
   if (mDocShellNode) {

--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -3427,17 +3427,17 @@ nsIDocument::HasFocus(ErrorResult& rv) c
 {
   nsIFocusManager* fm = nsFocusManager::GetFocusManager();
   if (!fm) {
     rv.Throw(NS_ERROR_NOT_AVAILABLE);
     return false;
   }
 
   // Is there a focused DOMWindow?
-  nsCOMPtr<mozIDOMWindowProxy> focusedWindow;
+  nsCOMPtr<nsPIDOMWindowOuter> focusedWindow;
   fm->GetFocusedWindow(getter_AddRefs(focusedWindow));
   if (!focusedWindow) {
     return false;
   }
 
   nsPIDOMWindowOuter* piWindow = nsPIDOMWindowOuter::From(focusedWindow);
 
   // Are we an ancestor of the focused DOMWindow?
@@ -10854,17 +10854,17 @@ IsInActiveTab(nsIDocument* aDoc)
     return false;
   }
 
   nsIFocusManager* fm = nsFocusManager::GetFocusManager();
   if (!fm) {
     return false;
   }
 
-  nsCOMPtr<mozIDOMWindowProxy> activeWindow;
+  nsCOMPtr<nsPIDOMWindowOuter> activeWindow;
   fm->GetActiveWindow(getter_AddRefs(activeWindow));
   if (!activeWindow) {
     return false;
   }
 
   return activeWindow == rootWin;
 }
 

--- a/dom/base/nsFocusManager.cpp
+++ b/dom/base/nsFocusManager.cpp
@@ -413,43 +413,43 @@ nsFocusManager::GetFocusMoveActionCause(
     return InputContextAction::CAUSE_MOUSE;
   } else if (aFlags & nsIFocusManager::FLAG_BYKEY) {
     return InputContextAction::CAUSE_KEY;
   }
   return InputContextAction::CAUSE_UNKNOWN;
 }
 
 NS_IMETHODIMP
-nsFocusManager::GetActiveWindow(mozIDOMWindowProxy** aWindow)
+nsFocusManager::GetActiveWindow(nsPIDOMWindowOuter** aWindow)
 {
   NS_IF_ADDREF(*aWindow = mActiveWindow);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsFocusManager::SetActiveWindow(mozIDOMWindowProxy* aWindow)
+nsFocusManager::SetActiveWindow(nsPIDOMWindowOuter* aWindow)
 {
   NS_ENSURE_STATE(aWindow);
 
   // only top-level windows can be made active
   nsCOMPtr<nsPIDOMWindowOuter> piWindow = nsPIDOMWindowOuter::From(aWindow);
   NS_ENSURE_TRUE(piWindow == piWindow->GetPrivateRoot(), NS_ERROR_INVALID_ARG);
 
   RaiseWindow(piWindow);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsFocusManager::GetFocusedWindow(mozIDOMWindowProxy** aFocusedWindow)
+nsFocusManager::GetFocusedWindow(nsPIDOMWindowOuter** aFocusedWindow)
 {
   NS_IF_ADDREF(*aFocusedWindow = mFocusedWindow);
   return NS_OK;
 }
 
-NS_IMETHODIMP nsFocusManager::SetFocusedWindow(mozIDOMWindowProxy* aWindowToFocus)
+NS_IMETHODIMP nsFocusManager::SetFocusedWindow(nsPIDOMWindowOuter* aWindowToFocus)
 {
   LOGFOCUS(("<<SetFocusedWindow begin>>"));
 
   nsCOMPtr<nsPIDOMWindowOuter> windowToFocus = nsPIDOMWindowOuter::From(aWindowToFocus);
   NS_ENSURE_TRUE(windowToFocus, NS_ERROR_FAILURE);
 
   windowToFocus = windowToFocus->GetOuterWindow();
 
@@ -484,17 +484,17 @@ NS_IMETHODIMP
 nsFocusManager::GetFocusedElement(Element** aFocusedElement)
 {
   RefPtr<Element> focusedElement = mFocusedElement;
   focusedElement.forget(aFocusedElement);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsFocusManager::GetLastFocusMethod(mozIDOMWindowProxy* aWindow, uint32_t* aLastFocusMethod)
+nsFocusManager::GetLastFocusMethod(nsPIDOMWindowOuter* aWindow, uint32_t* aLastFocusMethod)
 {
   // the focus method is stored on the inner window
   nsCOMPtr<nsPIDOMWindowOuter> window;
   if (aWindow) {
     window = nsPIDOMWindowOuter::From(aWindow);
   }
   if (!window)
     window = mFocusedWindow;
@@ -527,17 +527,17 @@ nsFocusManager::ElementIsFocusable(Eleme
   NS_ENSURE_TRUE(aElement, NS_ERROR_INVALID_ARG);
 
   *aIsFocusable = CheckIfFocusable(aElement, aFlags) != nullptr;
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsFocusManager::MoveFocus(mozIDOMWindowProxy* aWindow, Element* aStartElement,
+nsFocusManager::MoveFocus(nsPIDOMWindowOuter* aWindow, Element* aStartElement,
                           uint32_t aType, uint32_t aFlags, Element** aElement)
 {
   *aElement = nullptr;
 
   LOGFOCUS(("<<MoveFocus begin Type: %d Flags: %x>>", aType, aFlags));
 
   if (MOZ_LOG_TEST(gFocusLog, LogLevel::Debug) && mFocusedWindow) {
     nsIDocument* doc = mFocusedWindow->GetExtantDoc();
@@ -594,17 +594,17 @@ nsFocusManager::MoveFocus(mozIDOMWindowP
   }
 
   LOGFOCUS(("<<MoveFocus end>>"));
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsFocusManager::ClearFocus(mozIDOMWindowProxy* aWindow)
+nsFocusManager::ClearFocus(nsPIDOMWindowOuter* aWindow)
 {
   LOGFOCUS(("<<ClearFocus begin>>"));
 
   // if the window to clear is the focused window or an ancestor of the
   // focused window, then blur the existing focused content. Otherwise, the
   // focus is somewhere else so just update the current node.
   NS_ENSURE_TRUE(aWindow, NS_ERROR_INVALID_ARG);
   nsCOMPtr<nsPIDOMWindowOuter> window = nsPIDOMWindowOuter::From(aWindow);
@@ -623,19 +623,19 @@ nsFocusManager::ClearFocus(mozIDOMWindow
   }
 
   LOGFOCUS(("<<ClearFocus end>>"));
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsFocusManager::GetFocusedElementForWindow(mozIDOMWindowProxy* aWindow,
+nsFocusManager::GetFocusedElementForWindow(nsPIDOMWindowOuter* aWindow,
                                            bool aDeep,
-                                           mozIDOMWindowProxy** aFocusedWindow,
+                                           nsPIDOMWindowOuter** aFocusedWindow,
                                            Element** aElement)
 {
   *aElement = nullptr;
   if (aFocusedWindow)
     *aFocusedWindow = nullptr;
 
   NS_ENSURE_TRUE(aWindow, NS_ERROR_INVALID_ARG);
   nsCOMPtr<nsPIDOMWindowOuter> window = nsPIDOMWindowOuter::From(aWindow);
@@ -651,17 +651,17 @@ nsFocusManager::GetFocusedElementForWind
 
   if (aFocusedWindow)
     NS_IF_ADDREF(*aFocusedWindow = focusedWindow);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsFocusManager::MoveCaretToFocus(mozIDOMWindowProxy* aWindow)
+nsFocusManager::MoveCaretToFocus(nsPIDOMWindowOuter* aWindow)
 {
   nsCOMPtr<nsIWebNavigation> webnav = do_GetInterface(aWindow);
   nsCOMPtr<nsIDocShellTreeItem> dsti = do_QueryInterface(webnav);
   if (dsti) {
     if (dsti->ItemType() != nsIDocShellTreeItem::typeChrome) {
       nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(dsti);
       NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
 
@@ -680,17 +680,17 @@ nsFocusManager::MoveCaretToFocus(mozIDOM
         MoveCaretToFocus(presShell, content);
     }
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsFocusManager::WindowRaised(mozIDOMWindowProxy* aWindow)
+nsFocusManager::WindowRaised(nsPIDOMWindowOuter* aWindow)
 {
   NS_ENSURE_TRUE(aWindow, NS_ERROR_INVALID_ARG);
   nsCOMPtr<nsPIDOMWindowOuter> window = nsPIDOMWindowOuter::From(aWindow);
 
   if (MOZ_LOG_TEST(gFocusLog, LogLevel::Debug)) {
     LOGFOCUS(("Window %p Raised [Currently: %p %p]", aWindow, mActiveWindow.get(), mFocusedWindow.get()));
     nsIDocument* doc = window->GetExtantDoc();
     if (doc && doc->GetDocumentURI()) {
@@ -766,17 +766,17 @@ nsFocusManager::WindowRaised(mozIDOMWind
   // Pass false for aWindowRaised so that commands get updated.
   nsCOMPtr<nsIXULWindow> xulWin(do_GetInterface(baseWindow));
   Focus(currentWindow, currentFocus, 0, true, false, xulWin != nullptr, true);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsFocusManager::WindowLowered(mozIDOMWindowProxy* aWindow)
+nsFocusManager::WindowLowered(nsPIDOMWindowOuter* aWindow)
 {
   NS_ENSURE_TRUE(aWindow, NS_ERROR_INVALID_ARG);
   nsCOMPtr<nsPIDOMWindowOuter> window = nsPIDOMWindowOuter::From(aWindow);
 
   if (MOZ_LOG_TEST(gFocusLog, LogLevel::Debug)) {
     LOGFOCUS(("Window %p Lowered [Currently: %p %p]", aWindow, mActiveWindow.get(), mFocusedWindow.get()));
     nsIDocument* doc = window->GetExtantDoc();
     if (doc && doc->GetDocumentURI()) {
@@ -889,17 +889,17 @@ nsFocusManager::ContentRemoved(nsIDocume
 
     NotifyFocusStateChange(content, nullptr, shouldShowFocusRing, false);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsFocusManager::WindowShown(mozIDOMWindowProxy* aWindow, bool aNeedsFocus)
+nsFocusManager::WindowShown(nsPIDOMWindowOuter* aWindow, bool aNeedsFocus)
 {
   NS_ENSURE_TRUE(aWindow, NS_ERROR_INVALID_ARG);
   nsCOMPtr<nsPIDOMWindowOuter> window = nsPIDOMWindowOuter::From(aWindow);
 
   if (MOZ_LOG_TEST(gFocusLog, LogLevel::Debug)) {
     LOGFOCUS(("Window %p Shown [Currently: %p %p]", window.get(), mActiveWindow.get(), mFocusedWindow.get()));
     nsIDocument* doc = window->GetExtantDoc();
     if (doc && doc->GetDocumentURI()) {
@@ -940,17 +940,17 @@ nsFocusManager::WindowShown(mozIDOMWindo
     // When the window becomes visible, make sure the right widget is focused.
     EnsureCurrentWidgetFocused();
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsFocusManager::WindowHidden(mozIDOMWindowProxy* aWindow)
+nsFocusManager::WindowHidden(nsPIDOMWindowOuter* aWindow)
 {
   // if there is no window or it is not the same or an ancestor of the
   // currently focused window, just return, as the current focus will not
   // be affected.
 
   NS_ENSURE_TRUE(aWindow, NS_ERROR_INVALID_ARG);
   nsCOMPtr<nsPIDOMWindowOuter> window = nsPIDOMWindowOuter::From(aWindow);
 
@@ -1096,17 +1096,17 @@ NS_IMETHODIMP
 nsFocusManager::FocusPlugin(Element* aPlugin)
 {
   NS_ENSURE_ARG(aPlugin);
   SetFocusInner(aPlugin, 0, true, false);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsFocusManager::ParentActivated(mozIDOMWindowProxy* aWindow, bool aActive)
+nsFocusManager::ParentActivated(nsPIDOMWindowOuter* aWindow, bool aActive)
 {
   nsCOMPtr<nsPIDOMWindowOuter> window = nsPIDOMWindowOuter::From(aWindow);
   NS_ENSURE_TRUE(window, NS_ERROR_INVALID_ARG);
 
   ActivateOrDeactivate(window, aActive);
   return NS_OK;
 }
 

--- a/dom/base/nsGlobalWindowOuter.cpp
+++ b/dom/base/nsGlobalWindowOuter.cpp
@@ -4764,17 +4764,17 @@ nsGlobalWindowOuter::FocusOuter(ErrorRes
 
   // Enforce dom.disable_window_flip (for non-chrome), but still allow the
   // window which opened us to raise us at times when popups are allowed
   // (bugs 355482 and 369306).
   bool canFocus = CanSetProperty("dom.disable_window_flip") ||
                     (opener == callerOuter &&
                      RevisePopupAbuseLevel(GetPopupControlState()) < openBlocked);
 
-  nsCOMPtr<mozIDOMWindowProxy> activeDOMWindow;
+  nsCOMPtr<nsPIDOMWindowOuter> activeDOMWindow;
   fm->GetActiveWindow(getter_AddRefs(activeDOMWindow));
 
   nsCOMPtr<nsIDocShellTreeItem> rootItem;
   mDocShell->GetRootTreeItem(getter_AddRefs(rootItem));
   nsCOMPtr<nsPIDOMWindowOuter> rootWin = rootItem ? rootItem->GetWindow() : nullptr;
   auto* activeWindow = nsPIDOMWindowOuter::From(activeDOMWindow);
   bool isActive = (rootWin == activeWindow);
 
@@ -6986,17 +6986,17 @@ nsGlobalWindowOuter::OpenInternal(const 
         }
       }
 
       FireAbuseEvents(aUrl, aName, aOptions);
       return aDoJSFixups ? NS_OK : NS_ERROR_FAILURE;
     }
   }
 
-  nsCOMPtr<mozIDOMWindowProxy> domReturn;
+  nsCOMPtr<nsPIDOMWindowOuter> domReturn;
 
   nsCOMPtr<nsIWindowWatcher> wwatch =
     do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
   NS_ENSURE_TRUE(wwatch, rv);
 
   NS_ConvertUTF16toUTF8 options(aOptions);
   NS_ConvertUTF16toUTF8 name(aName);
 

--- a/dom/base/nsIDOMRequestService.idl
+++ b/dom/base/nsIDOMRequestService.idl
@@ -1,21 +1,21 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* 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 "nsISupports.idl"
 
-interface mozIDOMWindow;
+webidl Window;
 webidl DOMRequest;
 
 [scriptable, builtinclass, uuid(9a57e5de-ce93-45fa-8145-755722834f7c)]
 interface nsIDOMRequestService : nsISupports
 {
-  DOMRequest createRequest(in mozIDOMWindow window);
+  DOMRequest createRequest(in Window window);
 
   void fireSuccess(in DOMRequest request, in jsval result);
   void fireError(in DOMRequest request, in DOMString error);
   void fireSuccessAsync(in DOMRequest request, in jsval result);
   void fireErrorAsync(in DOMRequest request, in DOMString error);
 };

--- a/dom/base/nsObjectLoadingContent.cpp
+++ b/dom/base/nsObjectLoadingContent.cpp
@@ -1124,17 +1124,17 @@ nsObjectLoadingContent::OnDataAvailable(
 NS_IMETHODIMP_(already_AddRefed<nsFrameLoader>)
 nsObjectLoadingContent::GetFrameLoader()
 {
   RefPtr<nsFrameLoader> loader = mFrameLoader;
   return loader.forget();
 }
 
 void
-nsObjectLoadingContent::PresetOpenerWindow(mozIDOMWindowProxy* aWindow, mozilla::ErrorResult& aRv)
+nsObjectLoadingContent::PresetOpenerWindow(nsPIDOMWindowOuter* aWindow, mozilla::ErrorResult& aRv)
 {
   aRv.Throw(NS_ERROR_FAILURE);
 }
 
 void
 nsObjectLoadingContent::InternalSetFrameLoader(nsFrameLoader* aNewFrameLoader)
 {
   MOZ_CRASH("You shouldn't be calling this function, it doesn't make any sense on this type.");

--- a/dom/base/nsObjectLoadingContent.h
+++ b/dom/base/nsObjectLoadingContent.h
@@ -252,17 +252,17 @@ class nsObjectLoadingContent : public ns
     uint32_t GetRunID(mozilla::dom::SystemCallerGuarantee,
                       mozilla::ErrorResult& aRv);
 
     bool IsRewrittenYoutubeEmbed() const
     {
       return mRewrittenYoutubeEmbed;
     }
 
-    void PresetOpenerWindow(mozIDOMWindowProxy* aOpenerWindow, mozilla::ErrorResult& aRv);
+    void PresetOpenerWindow(nsPIDOMWindowOuter* aOpenerWindow, mozilla::ErrorResult& aRv);
 
   protected:
     /**
      * Begins loading the object when called
      *
      * Attributes of |this| QI'd to nsIContent will be inspected, depending on
      * the node type. This function currently assumes it is a <object> or
      * <embed> tag.

--- a/dom/base/nsWindowMemoryReporter.cpp
+++ b/dom/base/nsWindowMemoryReporter.cpp
@@ -70,17 +70,17 @@ AddNonJSSizeOfWindowAndItsDescendents(ns
   nsCOMPtr<nsIDOMWindowCollection> frames = aWindow->GetFrames();
 
   uint32_t length;
   nsresult rv = frames->GetLength(&length);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Measure this window's descendents.
   for (uint32_t i = 0; i < length; i++) {
-      nsCOMPtr<mozIDOMWindowProxy> child;
+      nsCOMPtr<nsPIDOMWindowOuter> child;
       rv = frames->Item(i, getter_AddRefs(child));
       NS_ENSURE_SUCCESS(rv, rv);
       NS_ENSURE_STATE(child);
 
       nsGlobalWindowOuter* childWin = nsGlobalWindowOuter::Cast(child);
 
       rv = AddNonJSSizeOfWindowAndItsDescendents(childWin, aSizes);
       NS_ENSURE_SUCCESS(rv, rv);
@@ -850,17 +850,17 @@ nsWindowMemoryReporter::CheckForGhostWin
 
   // Update mDetachedWindows and write the ghost window IDs into aOutGhostIDs,
   // if it's not null.
   uint32_t ghostTimeout = GetGhostTimeout();
   TimeStamp now = mLastCheckForGhostWindows;
   mGhostWindowCount = 0;
   for (auto iter = mDetachedWindows.Iter(); !iter.Done(); iter.Next()) {
     nsWeakPtr weakKey = do_QueryInterface(iter.Key());
-    nsCOMPtr<mozIDOMWindow> iwindow = do_QueryReferent(weakKey);
+    nsCOMPtr<nsPIDOMWindowInner> iwindow = do_QueryReferent(weakKey);
     if (!iwindow) {
       // The window object has been destroyed.  Stop tracking its weak ref in
       // our hashtable.
       iter.Remove();
       continue;
     }
 
     nsPIDOMWindowInner* window = nsPIDOMWindowInner::From(iwindow);

--- a/dom/base/test/chrome/test_bug1339722.html
+++ b/dom/base/test/chrome/test_bug1339722.html
@@ -25,17 +25,17 @@ https://bugzilla.mozilla.org/show_bug.cg
   const TOPIC = 'http-on-useragent-request';
   Services.obs.addObserver({
     observe(subject, topic, data) {
       info('Got ' + topic);
       Services.obs.removeObserver(this, TOPIC);
 
       // Query window proxy so it triggers DOMWindowCreated.
       let channel = subject.QueryInterface(Ci.nsIHttpChannel);
-      let win = channel.notificationCallbacks.getInterface(Ci.mozIDOMWindowProxy);
+      let win = channel.notificationCallbacks.getInterface(Ci.nsIDOMWindow);
     }
   }, TOPIC);
 
   let docShell = SpecialPowers.wrap(window)
                               .QueryInterface(Ci.nsIInterfaceRequestor)
                               .getInterface(Ci.nsIDocShell);
   docShell.chromeEventHandler.addEventListener('DOMWindowCreated', function handler(e) {
     docShell.chromeEventHandler.removeEventListener('DOMWindowCreated', handler);

--- a/dom/browser-element/BrowserElementParent.cpp
+++ b/dom/browser-element/BrowserElementParent.cpp
@@ -228,17 +228,17 @@ BrowserElementParent::OpenWindowOOP(TabP
 
 /* static */
 BrowserElementParent::OpenWindowResult
 BrowserElementParent::OpenWindowInProcess(nsPIDOMWindowOuter* aOpenerWindow,
                                           nsIURI* aURI,
                                           const nsAString& aName,
                                           const nsACString& aFeatures,
                                           bool aForceNoOpener,
-                                          mozIDOMWindowProxy** aReturnWindow)
+                                          nsPIDOMWindowOuter** aReturnWindow)
 {
   *aReturnWindow = nullptr;
 
   // If we call window.open from an <iframe> inside an <iframe mozbrowser>,
   // it's as though the top-level document inside the <iframe mozbrowser>
   // called window.open.  (Indeed, in the OOP case, the inner <iframe> lives
   // out-of-process, so we couldn't touch it if we tried.)
   //

--- a/dom/browser-element/BrowserElementParent.h
+++ b/dom/browser-element/BrowserElementParent.h
@@ -114,17 +114,17 @@ public:
    *         the platform from handling the open request
    */
   static OpenWindowResult
   OpenWindowInProcess(nsPIDOMWindowOuter* aOpenerWindow,
                       nsIURI* aURI,
                       const nsAString& aName,
                       const nsACString& aFeatures,
                       bool aForceNoOpener,
-                      mozIDOMWindowProxy** aReturnWindow);
+                      nsPIDOMWindowOuter** aReturnWindow);
 
 private:
   static OpenWindowResult
   DispatchOpenWindowEvent(dom::Element* aOpenerFrameElement,
                           dom::Element* aPopupFrameElement,
                           const nsAString& aURL,
                           const nsAString& aName,
                           const nsAString& aFeatures);

--- a/dom/clients/manager/ClientOpenWindowUtils.cpp
+++ b/dom/clients/manager/ClientOpenWindowUtils.cpp
@@ -210,17 +210,17 @@ OpenWindow(const ClientOpenWindowArgs& a
     NS_ENSURE_STATE(pwwatch);
 
     nsCString spec;
     rv = uri->GetSpec(spec);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
-    nsCOMPtr<mozIDOMWindowProxy> newWindow;
+    nsCOMPtr<nsPIDOMWindowOuter> newWindow;
     rv = pwwatch->OpenWindow2(nullptr,
                               spec.get(),
                               nullptr,
                               nullptr,
                               false, false, true, nullptr,
                               // Not a spammy popup; we got permission, we swear!
                               /* aIsPopupSpam = */ false,
                               // Don't force noopener.  We're not passing in an
@@ -255,17 +255,17 @@ OpenWindow(const ClientOpenWindowArgs& a
 
   nsCOMPtr<nsIBrowserDOMWindow> bwin;
   chromeWin->GetBrowserDOMWindow(getter_AddRefs(bwin));
 
   if (NS_WARN_IF(!bwin)) {
     return NS_ERROR_FAILURE;
   }
 
-  nsCOMPtr<mozIDOMWindowProxy> win;
+  nsCOMPtr<nsPIDOMWindowOuter> win;
   rv = bwin->OpenURI(uri, nullptr,
                      nsIBrowserDOMWindow::OPEN_DEFAULTWINDOW,
                      nsIBrowserDOMWindow::OPEN_NEW,
                      principal,
                      getter_AddRefs(win));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }

--- a/dom/commandhandler/nsCommandManager.cpp
+++ b/dom/commandhandler/nsCommandManager.cpp
@@ -55,17 +55,17 @@ NS_IMPL_CYCLE_COLLECTING_RELEASE(nsComma
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsCommandManager)
   NS_INTERFACE_MAP_ENTRY(nsICommandManager)
   NS_INTERFACE_MAP_ENTRY(nsPICommandUpdater)
   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsICommandManager)
 NS_INTERFACE_MAP_END
 
 NS_IMETHODIMP
-nsCommandManager::Init(mozIDOMWindowProxy* aWindow)
+nsCommandManager::Init(nsPIDOMWindowOuter* aWindow)
 {
   NS_ENSURE_ARG_POINTER(aWindow);
 
   mWindow = aWindow; // weak ptr
   return NS_OK;
 }
 
 NS_IMETHODIMP
@@ -132,31 +132,31 @@ nsCommandManager::RemoveCommandObserver(
 
   commandObservers->RemoveElement(aCommandObserver);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsCommandManager::IsCommandSupported(const char* aCommandName,
-                                     mozIDOMWindowProxy* aTargetWindow,
+                                     nsPIDOMWindowOuter* aTargetWindow,
                                      bool* aResult)
 {
   NS_ENSURE_ARG_POINTER(aResult);
 
   nsCOMPtr<nsIController> controller;
   GetControllerForCommand(aCommandName, aTargetWindow,
                           getter_AddRefs(controller));
   *aResult = (controller.get() != nullptr);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsCommandManager::IsCommandEnabled(const char* aCommandName,
-                                   mozIDOMWindowProxy* aTargetWindow,
+                                   nsPIDOMWindowOuter* aTargetWindow,
                                    bool* aResult)
 {
   NS_ENSURE_ARG_POINTER(aResult);
 
   bool commandEnabled = false;
 
   nsCOMPtr<nsIController> controller;
   GetControllerForCommand(aCommandName, aTargetWindow,
@@ -165,17 +165,17 @@ nsCommandManager::IsCommandEnabled(const
     controller->IsCommandEnabled(aCommandName, &commandEnabled);
   }
   *aResult = commandEnabled;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsCommandManager::GetCommandState(const char* aCommandName,
-                                  mozIDOMWindowProxy* aTargetWindow,
+                                  nsPIDOMWindowOuter* aTargetWindow,
                                   nsICommandParams* aCommandParams)
 {
   nsCOMPtr<nsIController> controller;
   nsAutoString tValue;
   nsresult rv = GetControllerForCommand(aCommandName, aTargetWindow,
                                         getter_AddRefs(controller));
   if (!controller) {
     return NS_ERROR_FAILURE;
@@ -190,17 +190,17 @@ nsCommandManager::GetCommandState(const 
     rv = NS_ERROR_NOT_IMPLEMENTED;
   }
   return rv;
 }
 
 NS_IMETHODIMP
 nsCommandManager::DoCommand(const char* aCommandName,
                             nsICommandParams* aCommandParams,
-                            mozIDOMWindowProxy* aTargetWindow)
+                            nsPIDOMWindowOuter* aTargetWindow)
 {
   nsCOMPtr<nsIController> controller;
   nsresult rv = GetControllerForCommand(aCommandName, aTargetWindow,
                                         getter_AddRefs(controller));
   if (!controller) {
     return NS_ERROR_FAILURE;
   }
 
@@ -211,17 +211,17 @@ nsCommandManager::DoCommand(const char* 
   } else {
     rv = controller->DoCommand(aCommandName);
   }
   return rv;
 }
 
 nsresult
 nsCommandManager::GetControllerForCommand(const char* aCommand,
-                                          mozIDOMWindowProxy* aTargetWindow,
+                                          nsPIDOMWindowOuter* aTargetWindow,
                                           nsIController** aResult)
 {
   nsresult rv = NS_ERROR_FAILURE;
   *aResult = nullptr;
 
   // check if we're in content or chrome
   // if we're not chrome we must have a target window or we bail
   if (!nsContentUtils::LegacyIsCallerChromeOrNativeCode()) {

--- a/dom/commandhandler/nsCommandManager.h
+++ b/dom/commandhandler/nsCommandManager.h
@@ -33,18 +33,18 @@ public:
 
   NS_DECL_NSICOMMANDMANAGER
   NS_DECL_NSPICOMMANDUPDATER
 
 protected:
   virtual ~nsCommandManager();
 
   nsresult GetControllerForCommand(const char* aCommand,
-                                   mozIDOMWindowProxy* aDirectedToThisWindow,
+                                   nsPIDOMWindowOuter* aDirectedToThisWindow,
                                    nsIController** aResult);
 
 protected:
   nsClassHashtable<nsCharPtrHashKey, ObserverList> mObserversTable;
 
-  mozIDOMWindowProxy* mWindow; // weak ptr. The window should always outlive us
+  nsPIDOMWindowOuter* mWindow; // weak ptr. The window should always outlive us
 };
 
 #endif // nsCommandManager_h__

--- a/dom/commandhandler/nsICommandManager.idl
+++ b/dom/commandhandler/nsICommandManager.idl
@@ -2,17 +2,17 @@
 /* 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 "nsISupports.idl"
 #include "nsIObserver.idl"
 #include "nsICommandParams.idl"
 
-interface mozIDOMWindowProxy;
+webidl WindowProxy;
 
 /*
  * nsICommandManager is an interface used to executing user-level commands,
  * and getting the state of available commands.
  *
  * Commands are identified by strings, which are documented elsewhere.
  * In addition, the list of required and optional parameters for
  * each command, that are passed in via the nsICommandParams, are
@@ -45,25 +45,25 @@ interface nsICommandManager : nsISupport
                                     in string aCommandObserved);
 
   /*
    * Ask the command manager if the specified command is supported.
    * If aTargetWindow is null, the focused window is used.
    *
    */
   boolean     isCommandSupported(in string aCommandName,
-                                 in mozIDOMWindowProxy aTargetWindow);
+                                 in WindowProxy aTargetWindow);
 
   /*
    * Ask the command manager if the specified command is currently.
    * enabled.
    * If aTargetWindow is null, the focused window is used.
    */
   boolean     isCommandEnabled(in string aCommandName,
-                               in mozIDOMWindowProxy aTargetWindow);
+                               in WindowProxy aTargetWindow);
 
   /*
    * Get the state of the specified commands.
    *
    * On input: aCommandParams filled in with values that the caller cares
    * about, most of which are command-specific (see the command documentation
    * for details). One boolean value, "enabled", applies to all commands,
    * and, in return will be set to indicate whether the command is enabled
@@ -71,31 +71,31 @@ interface nsICommandManager : nsISupport
    *
    * aCommandName is the name of the command that needs the state
    * aTargetWindow is the source of command controller 
    *      (null means use focus controller)
    * On output: aCommandParams: values set by the caller filled in with
    * state from the command.
    */
   void        getCommandState(in string aCommandName,
-                              in mozIDOMWindowProxy aTargetWindow,
+                              in WindowProxy aTargetWindow,
                   /* inout */ in nsICommandParams aCommandParams);
     
   /*
    * Execute the specified command.
    * The command will be executed in aTargetWindow if it is specified.
    * If aTargetWindow is null, it will go to the focused window.
    *
    * param: aCommandParams, a list of name-value pairs of command parameters,
    * may be null for parameter-less commands.
    *
    */
   void        doCommand(in string aCommandName,
                         in nsICommandParams aCommandParams,
-                        in mozIDOMWindowProxy aTargetWindow);
+                        in WindowProxy aTargetWindow);
 
 };
 
 
 /*
 
 Arguments to observers "Observe" method are as follows:
 

--- a/dom/commandhandler/nsPICommandUpdater.idl
+++ b/dom/commandhandler/nsPICommandUpdater.idl
@@ -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 "nsISupports.idl"
 
-interface mozIDOMWindowProxy;
+webidl WindowProxy;
 
 /*
 	The nsPICommandUpdater interface is used by modules that implement
 	commands, to tell the command manager that commands need updating.
 	This is a private interface; embedders should not use it.
 	
 	Command-implementing modules should get one of these by a QI
 	from an nsICommandManager.
@@ -20,17 +20,17 @@ interface mozIDOMWindowProxy;
 interface nsPICommandUpdater : nsISupports
 {
 
   /*
    * Init the command updater, passing an nsIDOMWindow which 
    * is the window that the command updater lives on.
    * 
    */
-  void    init(in mozIDOMWindowProxy aWindow);
+  void    init(in WindowProxy aWindow);
    
   /*
    * Notify the command manager that the status of a command
    * changed. It may have changed from enabled to disabled,
    * or vice versa, or become toggled etc.
    */
 	void		commandStatusChanged(in string aCommandName);
 	

--- a/dom/credentialmanagement/CredentialsContainer.cpp
+++ b/dom/credentialmanagement/CredentialsContainer.cpp
@@ -75,17 +75,17 @@ IsInActiveTab(nsPIDOMWindowInner* aParen
     return false;
   }
 
   nsIFocusManager* fm = nsFocusManager::GetFocusManager();
   if (!fm) {
     return false;
   }
 
-  nsCOMPtr<mozIDOMWindowProxy> activeWindow;
+  nsCOMPtr<nsPIDOMWindowOuter> activeWindow;
   fm->GetActiveWindow(getter_AddRefs(activeWindow));
   return activeWindow == rootWin;
 }
 
 static bool
 IsSameOriginWithAncestors(nsPIDOMWindowInner* aParent)
 {
   // This method returns true if aParent is either not in a frame / iframe, or

--- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -2179,17 +2179,17 @@ EventStateManager::GetContentViewer(nsIC
   nsCOMPtr<nsPIDOMWindowOuter> rootWindow = window->GetPrivateRoot();
   if (!rootWindow) return NS_ERROR_FAILURE;
 
   TabChild* tabChild = TabChild::GetFrom(rootWindow);
   if (!tabChild) {
     nsIFocusManager* fm = nsFocusManager::GetFocusManager();
     if (!fm) return NS_ERROR_FAILURE;
 
-    nsCOMPtr<mozIDOMWindowProxy> activeWindow;
+    nsCOMPtr<nsPIDOMWindowOuter> activeWindow;
     fm->GetActiveWindow(getter_AddRefs(activeWindow));
     if (rootWindow != activeWindow) return NS_OK;
   } else {
     if (!tabChild->ParentIsActive()) return NS_OK;
   }
 
   nsCOMPtr<nsPIDOMWindowOuter> contentWindow =
     nsGlobalWindowOuter::Cast(rootWindow)->GetContent();
@@ -3357,17 +3357,17 @@ EventStateManager::PostHandleEvent(nsPre
         StopTrackingDragGesture();
 
         // When the event was cancelled, there is currently a chrome document
         // focused and a mousedown just occurred on a content document, ensure
         // that the window that was clicked is focused.
         EnsureDocument(mPresContext);
         nsIFocusManager* fm = nsFocusManager::GetFocusManager();
         if (mDocument && fm) {
-          nsCOMPtr<mozIDOMWindowProxy> window;
+          nsCOMPtr<nsPIDOMWindowOuter> window;
           fm->GetFocusedWindow(getter_AddRefs(window));
           auto* currentWindow = nsPIDOMWindowOuter::From(window);
           if (currentWindow && mDocument->GetWindow() &&
               currentWindow != mDocument->GetWindow() &&
               !nsContentUtils::IsChromeDoc(mDocument)) {
             nsCOMPtr<nsPIDOMWindowOuter> currentTop;
             nsCOMPtr<nsPIDOMWindowOuter> newTop;
             currentTop = currentWindow->GetTop();

--- a/dom/geolocation/nsGeolocation.cpp
+++ b/dom/geolocation/nsGeolocation.cpp
@@ -380,17 +380,17 @@ nsGeolocationRequest::GetTypes(nsIArray*
   nsTArray<nsString> emptyOptions;
   return nsContentPermissionUtils::CreatePermissionArray(NS_LITERAL_CSTRING("geolocation"),
                                                          NS_LITERAL_CSTRING("unused"),
                                                          emptyOptions,
                                                          aTypes);
 }
 
 NS_IMETHODIMP
-nsGeolocationRequest::GetWindow(mozIDOMWindow** aRequestingWindow)
+nsGeolocationRequest::GetWindow(nsPIDOMWindowInner** aRequestingWindow)
 {
   NS_ENSURE_ARG_POINTER(aRequestingWindow);
 
   nsCOMPtr<nsPIDOMWindowInner> window = do_QueryReferent(mLocator->GetOwner());
   window.forget(aRequestingWindow);
 
   return NS_OK;
 }

--- a/dom/html/nsGenericHTMLElement.cpp
+++ b/dom/html/nsGenericHTMLElement.cpp
@@ -2108,17 +2108,17 @@ nsGenericHTMLFormElement::FocusState()
   // If the window is not active, do not allow the focus to bring the
   // window to the front.  We update the focus controller, but do
   // nothing else.
   if (nsPIDOMWindowOuter* win = doc->GetWindow()) {
     nsCOMPtr<nsPIDOMWindowOuter> rootWindow = win->GetPrivateRoot();
 
     nsCOMPtr<nsIFocusManager> fm = do_GetService(FOCUSMANAGER_CONTRACTID);
     if (fm && rootWindow) {
-      nsCOMPtr<mozIDOMWindowProxy> activeWindow;
+      nsCOMPtr<nsPIDOMWindowOuter> activeWindow;
       fm->GetActiveWindow(getter_AddRefs(activeWindow));
       if (activeWindow == rootWindow) {
         return eActiveWindow;
       }
     }
   }
 
   return eInactiveWindow;

--- a/dom/html/nsGenericHTMLFrameElement.cpp
+++ b/dom/html/nsGenericHTMLFrameElement.cpp
@@ -164,17 +164,17 @@ nsGenericHTMLFrameElement::CreateRemoteF
 NS_IMETHODIMP_(already_AddRefed<nsFrameLoader>)
 nsGenericHTMLFrameElement::GetFrameLoader()
 {
   RefPtr<nsFrameLoader> loader = mFrameLoader;
   return loader.forget();
 }
 
 void
-nsGenericHTMLFrameElement::PresetOpenerWindow(mozIDOMWindowProxy* aWindow, ErrorResult& aRv)
+nsGenericHTMLFrameElement::PresetOpenerWindow(nsPIDOMWindowOuter* aWindow, ErrorResult& aRv)
 {
   MOZ_ASSERT(!mFrameLoader);
   mOpenerWindow = nsPIDOMWindowOuter::From(aWindow);
 }
 
 void
 nsGenericHTMLFrameElement::InternalSetFrameLoader(nsFrameLoader* aNewFrameLoader)
 {

--- a/dom/html/nsGenericHTMLFrameElement.h
+++ b/dom/html/nsGenericHTMLFrameElement.h
@@ -74,17 +74,17 @@ public:
                         mozilla::ErrorResult& aError);
 
   void SwapFrameLoaders(nsXULElement& aOtherLoaderOwner,
                         mozilla::ErrorResult& aError);
 
   void SwapFrameLoaders(nsIFrameLoaderOwner* aOtherLoaderOwner,
                         mozilla::ErrorResult& rv);
 
-  void PresetOpenerWindow(mozIDOMWindowProxy* aOpenerWindow,
+  void PresetOpenerWindow(nsPIDOMWindowOuter* aOpenerWindow,
                           mozilla::ErrorResult& aRv);
 
   static void InitStatics();
   static bool BrowserFramesEnabled();
 
   /**
    * Helper method to map a HTML 'scrolling' attribute value to a nsIScrollable
    * enum value.  scrolling="no" (and its synonyms) maps to

--- a/dom/html/nsIFormSubmitObserver.idl
+++ b/dom/html/nsIFormSubmitObserver.idl
@@ -1,26 +1,26 @@
 /* -*- 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 "nsISupports.idl"
 
-interface mozIDOMWindow;
+webidl Window;
 interface nsIURI;
 interface nsIArray;
 
 webidl HTMLFormElement;
 
 [scriptable, uuid(867cb7e7-835d-408b-9788-d2834d284e03)]
 interface nsIFormSubmitObserver: nsISupports
 {
-  void notify(in HTMLFormElement formNode, in mozIDOMWindow window, in nsIURI actionURL, out boolean cancelSubmit);
+  void notify(in HTMLFormElement formNode, in Window window, in nsIURI actionURL, out boolean cancelSubmit);
 
   void notifyInvalidSubmit(in HTMLFormElement formNode,
                            in nsIArray invalidElements);
 };
 
 %{C++
 #define NS_FORMSUBMIT_SUBJECT "formsubmit"
 #define NS_EARLYFORMSUBMIT_SUBJECT "earlyformsubmit"

--- a/dom/interfaces/base/nsIBrowserDOMWindow.idl
+++ b/dom/interfaces/base/nsIBrowserDOMWindow.idl
@@ -1,16 +1,16 @@
 /* -*- Mode: IDL; 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 "nsISupports.idl"
 
-interface mozIDOMWindowProxy;
+webidl WindowProxy;
 interface nsIDOMWindow;
 interface nsIURI;
 interface nsIFrameLoaderOwner;
 interface nsIPrincipal;
 
 [scriptable, uuid(e774db14-79ac-4156-a7a3-aa3fd0a22c10)]
 interface nsIOpenURIInFrameParams : nsISupports
 {
@@ -102,18 +102,18 @@ interface nsIBrowserDOMWindow : nsISuppo
    * @param aOpener window requesting the creation (can be null).
    * @param aFlags flags which control the behavior of the load. The
    *               OPEN_EXTERNAL/OPEN_NEW flag is only used when
    *               aWhere == OPEN_DEFAULTWINDOW.
    * @param aTriggeringPrincipal the principal that would trigger the potential
    *        load of aURI.
    * @return the window into which the URI would have been opened.
   */
-  mozIDOMWindowProxy
-  createContentWindow(in nsIURI aURI, in mozIDOMWindowProxy aOpener,
+  WindowProxy
+  createContentWindow(in nsIURI aURI, in WindowProxy aOpener,
                       in short aWhere, in long aFlags,
                       in nsIPrincipal aTriggeringPrincipal);
 
   /**
    * As above, but return the nsIFrameLoaderOwner for the new window.
    *
    * Additional Parameters:
    * @param aNextTabParentId The TabParent to associate the window with.
@@ -134,18 +134,18 @@ interface nsIBrowserDOMWindow : nsISuppo
    * @param aWhere see possible values described above.
    * @param aOpener window requesting the open (can be null).
    * @param aFlags flags which control the behavior of the load. The
    *               OPEN_EXTERNAL/OPEN_NEW flag is only used when
    *               aWhere == OPEN_DEFAULTWINDOW.
    * @param aTriggeringPrincipal the principal that triggered the load of aURI.
    * @return the window into which the URI was opened.
   */
-  mozIDOMWindowProxy
-  openURI(in nsIURI aURI, in mozIDOMWindowProxy aOpener,
+  WindowProxy
+  openURI(in nsIURI aURI, in WindowProxy aOpener,
           in short aWhere, in long aFlags, in nsIPrincipal aTriggeringPrincipal);
 
   /**
    * As above, but return the nsIFrameLoaderOwner for the new window.
    *
    * Additional Parameters:
    * @param aNextTabParentId The TabParent to associate the window with.
    * @param aName The name to give the window opened in the new tab.

--- a/dom/interfaces/base/nsIContentPermissionPrompt.idl
+++ b/dom/interfaces/base/nsIContentPermissionPrompt.idl
@@ -1,16 +1,16 @@
 /* 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 "nsISupports.idl"
 
 interface nsIPrincipal;
-interface mozIDOMWindow;
+webidl Window;
 interface nsIArray;
 
 webidl Element;
 
 /**
  *  Interface provides the request type and its access.
  */
 [scriptable, uuid(ef4db3b8-ca9c-4b1d-8f81-fd88ec32af13)]
@@ -80,17 +80,17 @@ interface nsIContentPermissionRequest : 
   readonly attribute nsIPrincipal principal;
 
   /**
    *  The window or element that the permission request was
    *  originated in.  Typically the element will be non-null
    *  in when using out of process content.  window or
    *  element can be null but not both.
    */
-  readonly attribute mozIDOMWindow window;
+  readonly attribute Window window;
   readonly attribute Element element;
 
   readonly attribute boolean isHandlingUserInput;
 
   /**
    *  The requester to get the required information of
    *  the window.
    */

--- a/dom/interfaces/base/nsIDOMChromeWindow.idl
+++ b/dom/interfaces/base/nsIDOMChromeWindow.idl
@@ -1,17 +1,17 @@
 /* -*- Mode: IDL; 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 "domstubs.idl"
 
 interface nsIBrowserDOMWindow;
-interface mozIDOMWindowProxy;
+webidl WindowProxy;
 
 // Scriptable only so Components.interfaces.nsIDOMChromeWindow works.
 [scriptable, builtinclass, uuid(78bdcb41-1efa-409f-aaba-70842213f80f)]
 interface nsIDOMChromeWindow : nsISupports
 {
   /**
    * browserDOMWindow provides access to yet another layer of
    * utility functions implemented by chrome script. It will be null

--- a/dom/interfaces/base/nsIDOMGlobalPropertyInitializer.idl
+++ b/dom/interfaces/base/nsIDOMGlobalPropertyInitializer.idl
@@ -1,21 +1,21 @@
 /* -*- Mode: IDL; 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 "nsISupports.idl"
 
-interface mozIDOMWindow;
+webidl Window;
 
 [scriptable, uuid(5842e275-797f-4afb-b7e0-e29f0cb312ae)]
 interface nsIDOMGlobalPropertyInitializer : nsISupports
 {
   /*
    * Initialize the global property.
    *
    * @param window the global object on which the property is being retrieved.
    *
    * @returns a JS Object to use use as the property's value.
    */
-  jsval init(in mozIDOMWindow window);
+  jsval init(in Window window);
 };

--- a/dom/interfaces/base/nsIDOMWindowCollection.idl
+++ b/dom/interfaces/base/nsIDOMWindowCollection.idl
@@ -1,16 +1,16 @@
 /* -*- Mode: IDL; 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 "domstubs.idl"
 
-interface mozIDOMWindowProxy;
+webidl WindowProxy;
 
 /**
  * The nsIDOMWindowCollection interface is an interface for a
  * collection of DOM window objects.
  */
 
 [uuid(8d64f457-fb8c-49ea-a359-cef30eed9774)]
 interface nsIDOMWindowCollection : nsISupports
@@ -18,15 +18,15 @@ interface nsIDOMWindowCollection : nsISu
   /**
    * Accessor for the number of windows in this collection.
    */
   readonly attribute unsigned long    length;
 
   /**
    * Method for accessing an item in this collection by index.
    */
-  mozIDOMWindowProxy        item(in unsigned long index);
+  WindowProxy        item(in unsigned long index);
 
   /**
    * Method for accessing an item in this collection by window name.
    */
-  mozIDOMWindowProxy        namedItem(in DOMString name);
+  WindowProxy        namedItem(in DOMString name);
 };

--- a/dom/interfaces/base/nsIFocusManager.idl
+++ b/dom/interfaces/base/nsIFocusManager.idl
@@ -1,16 +1,16 @@
 /* -*- Mode: IDL; 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 "domstubs.idl"
 
-interface mozIDOMWindowProxy;
+webidl WindowProxy;
 interface nsIDocument;
 
 webidl Element;
 
 [scriptable, uuid(86e1f1e1-365d-493b-b52a-a649f3f311dc)]
 /**
  * The focus manager deals with all focus related behaviour. Only one element
  * in the entire application may have the focus at a time; this element
@@ -43,45 +43,45 @@ interface nsIFocusManager : nsISupports
 {
   /**
    * The most active (frontmost) window, or null if no window that is part of
    * the application is active. Setting the activeWindow raises it, and
    * focuses the current child window's current element, if any. Setting this
    * to null or to a non-top-level window throws an NS_ERROR_INVALID_ARG
    * exception.
    */
-  attribute mozIDOMWindowProxy activeWindow;
+  attribute WindowProxy activeWindow;
 
   /**
    * The child window within the activeWindow that is focused. This will
    * always be activeWindow, a child window of activeWindow or null if no
    * child window is focused. Setting the focusedWindow changes the focused
    * window and raises the toplevel window it is in. If the current focus
    * within the new focusedWindow is a frame element, then the focusedWindow
    * will actually be set to the child window and the current element within
    * that set as the focused element. This process repeats downwards until a
    * non-frame element is found.
    */
-  attribute mozIDOMWindowProxy focusedWindow;
+  attribute WindowProxy focusedWindow;
 
   /**
    * The element that is currently focused. This will always be an element
    * within the document loaded in focusedWindow or null if no element in that
    * document is focused.
    */
   readonly attribute Element focusedElement;
 
   /**
    * Returns the method that was used to focus the element in window. This
    * will either be 0, FLAG_BYMOUSE or FLAG_BYKEY. If window is null, then
    * the current focusedWindow will be used by default. This has the result
    * of retrieving the method that was used to focus the currently focused
    * element.
    */
-  uint32_t getLastFocusMethod(in mozIDOMWindowProxy window);
+  uint32_t getLastFocusMethod(in WindowProxy window);
 
   /**
    * Changes the focused element reference within the window containing
    * aElement to aElement.
    */
   void setFocus(in Element aElement, in unsigned long aFlags);
 
   /**
@@ -97,27 +97,27 @@ interface nsIFocusManager : nsISupports
    *
    * If no element is found, and aType is either MOVEFOCUS_ROOT or
    * MOVEFOCUS_CARET, then the focus is cleared. If aType is any other value,
    * the focus is not changed.
    *
    * Returns the element that was focused. The return value may be null if focus
    * was moved into a child process.
    */
-  Element moveFocus(in mozIDOMWindowProxy aWindow,
+  Element moveFocus(in WindowProxy aWindow,
                     in Element aStartElement,
                     in unsigned long aType, in unsigned long aFlags);
 
   /**
    * Clears the focused element within aWindow. If the current focusedWindow
    * is a descendant of aWindow, sets the current focusedWindow to aWindow.
    *
    * @throws NS_ERROR_INVALID_ARG if aWindow is null
    */
-  void clearFocus(in mozIDOMWindowProxy aWindow);
+  void clearFocus(in WindowProxy aWindow);
 
   /**
    * Returns the currently focused element within aWindow. If aWindow is equal
    * to the current value of focusedWindow, then the returned element will be
    * the application-wide focused element (the value of focusedElement). The
    * return value will be null if no element is focused.
    *
    * If aDeep is true, then child frames are traversed and the return value
@@ -126,24 +126,24 @@ interface nsIFocusManager : nsISupports
    * focus is in a child frame.
    *
    * aFocusedWindow will be set to the currently focused descendant window of
    * aWindow, or to aWindow if aDeep is false. This will be set even if no
    * element is focused.
    *
    * @throws NS_ERROR_INVALID_ARG if aWindow is null
    */
-  Element getFocusedElementForWindow(in mozIDOMWindowProxy aWindow,
+  Element getFocusedElementForWindow(in WindowProxy aWindow,
                                      in boolean aDeep,
-                                     out mozIDOMWindowProxy aFocusedWindow);
+                                     out WindowProxy aFocusedWindow);
 
   /**
    * Moves the selection caret within aWindow to the current focus.
    */
-  void moveCaretToFocus(in mozIDOMWindowProxy aWindow);
+  void moveCaretToFocus(in WindowProxy aWindow);
 
   /***
    * Check if given element is focusable.
    */
   boolean elementIsFocusable(in Element aElement, in unsigned long aFlags);
 
   /*
    * Raise the window when switching focus
@@ -229,37 +229,37 @@ interface nsIFocusManager : nsISupports
   /** move focus to the first focusable document */
   const unsigned long MOVEFOCUS_FIRSTDOC = 9;
   /** move focus to the last focusable document */
   const unsigned long MOVEFOCUS_LASTDOC = 10;
 
   /**
    * Called when a window has been raised.
    */
-  [noscript] void windowRaised(in mozIDOMWindowProxy aWindow);
+  [noscript] void windowRaised(in WindowProxy aWindow);
 
   /**
    * Called when a window has been lowered.
    */
-  [noscript] void windowLowered(in mozIDOMWindowProxy aWindow);
+  [noscript] void windowLowered(in WindowProxy aWindow);
 
   /**
    * Called when a new document in a window is shown.
    *
    * If aNeedsFocus is true, then focus events are expected to be fired on the
    * window if this window is in the focused window chain.
    */
-  [noscript] void windowShown(in mozIDOMWindowProxy aWindow,
+  [noscript] void windowShown(in WindowProxy aWindow,
                               in boolean aNeedsFocus);
 
   /**
    * Called when a document in a window has been hidden or otherwise can no
    * longer accept focus.
    */
-  [noscript] void windowHidden(in mozIDOMWindowProxy aWindow);
+  [noscript] void windowHidden(in WindowProxy aWindow);
 
   /**
    * Fire any events that have been delayed due to synchronized actions.
    */
   [noscript] void fireDelayedEvents(in nsIDocument aDocument);
 
   /**
    * Indicate that a plugin wishes to take the focus. This is similar to a
@@ -267,11 +267,11 @@ interface nsIFocusManager : nsISupports
    * widget focus state is the responsibility of the caller.
    */
   [noscript] void focusPlugin(in Element aPlugin);
 
   /**
    * Used in a child process to indicate that the parent window is now
    * active or deactive.
    */
-  [noscript] void parentActivated(in mozIDOMWindowProxy aWindow,
+  [noscript] void parentActivated(in WindowProxy aWindow,
                                   in bool active);
 };

--- a/dom/interfaces/base/nsIServiceWorkerManager.idl
+++ b/dom/interfaces/base/nsIServiceWorkerManager.idl
@@ -1,19 +1,19 @@
 /* -*- Mode: IDL; 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 "domstubs.idl"
 #include "nsIRequest.idl"
 
-interface mozIDOMWindow;
+webidl Window;
 interface nsPIDOMWindowInner;
-interface mozIDOMWindowProxy;
+webidl WindowProxy;
 interface nsIArray;
 interface nsIDocument;
 interface nsIInterceptedChannel;
 interface nsIPrincipal;
 interface nsIRunnable;
 interface nsIURI;
 %{C++
 namespace mozilla {

--- a/dom/interfaces/base/nsITextInputProcessor.idl
+++ b/dom/interfaces/base/nsITextInputProcessor.idl
@@ -1,16 +1,16 @@
 /* -*- Mode: IDL; 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 "nsISupports.idl"
 
-interface mozIDOMWindow;
+webidl Window;
 interface nsITextInputProcessorCallback;
 
 webidl Event;
 
 /**
  * An nsITextInputProcessor instance is associated with a top level widget which
  * handles native IME.  It's associated by calling beginInputTransaction() or
  * beginInputTransactionForTests().  While an instance has composition, nobody
@@ -274,29 +274,29 @@ interface nsITextInputProcessor : nsISup
    *                        IME and notifications to IME.  This must not be
    *                        null.
    * @return                If somebody uses internal text input service for a
    *                        composition, this returns false.  Otherwise, returns
    *                        true.  I.e., only your TIP can create composition
    *                        when this returns true.  If this returns false,
    *                        your TIP should wait next chance.
    */
-  boolean beginInputTransaction(in mozIDOMWindow aWindow,
+  boolean beginInputTransaction(in Window aWindow,
                                 in nsITextInputProcessorCallback aCallback);
 
   /**
    * When you create an instance for automated test, you must call
    * beginInputTransaction(), first.  See beginInputTransaction() for more
    * detail of this.
    * Note that aCallback can be null.  If it's null, nsITextInputProcessor
    * implementation will handle them automatically.
    */
   [optional_argc] boolean
     beginInputTransactionForTests(
-      in mozIDOMWindow aWindow,
+      in Window aWindow,
       [optional] in nsITextInputProcessorCallback aCallback);
 
   /**
    * startComposition() dispatches compositionstart event explicitly.
    * IME does NOT need to call this typically since compositionstart event
    * is automatically dispatched by sendPendingComposition() if
    * compositionstart event hasn't been dispatched yet.  If this is called
    * when compositionstart has already been dispatched, this throws an

--- a/dom/interfaces/storage/nsIDOMStorageManager.idl
+++ b/dom/interfaces/storage/nsIDOMStorageManager.idl
@@ -2,17 +2,17 @@
 /* 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 "nsISupports.idl"
 
 interface nsIDOMStorage;
 interface nsIPrincipal;
-interface mozIDOMWindow;
+webidl Window;
 
 /**
  * General purpose interface that has two implementations, for localStorage
  * resp. sessionStorage with "@mozilla.org/dom/localStorage-manager;1" resp.
  * "@mozilla.org/dom/sessionStorage-manager;1" contract IDs.
  */
 [scriptable, uuid(a20c742e-3ed1-44fb-b897-4080a75b1662)]
 interface nsIDOMStorageManager : nsISupports
@@ -39,34 +39,34 @@ interface nsIDOMStorageManager : nsISupp
    *    The parent window.
    * @param aPrincipal
    *    Principal to bound storage to.
    * @param aDocumentURI
    *    URL of the demanding document, used for DOM storage event only.
    * @param aPrivate
    *    Whether the demanding document is running in Private Browsing mode or not.
    */
-  nsIDOMStorage createStorage(in mozIDOMWindow aWindow,
+  nsIDOMStorage createStorage(in Window aWindow,
                               in nsIPrincipal aPrincipal,
                               in DOMString aDocumentURI,
                               [optional] in bool aPrivate);
   /**
    * Returns instance of DOM storage object for given principal.
    * If there is no storage managed for the scope, then null is returned and
    * no object is created.  Otherwise, an object (new) for the existing storage
    * scope is returned.
    *
    * @param aWindow
    *    The parent window.
    * @param aPrincipal
    *    Principal to bound storage to.
    * @param aPrivate
    *    Whether the demanding document is running in Private Browsing mode or not.
    */
-  nsIDOMStorage getStorage(in mozIDOMWindow aWindow,
+  nsIDOMStorage getStorage(in Window aWindow,
                            in nsIPrincipal aPrincipal,
                            [optional] in bool aPrivate);
 
   /**
    * Clones given storage into this storage manager.
    *
    * @param aStorageToCloneFrom
    *    The storage to copy all items from into this manager.  Manager will then

--- a/dom/interfaces/xul/nsIDOMXULCommandDispatcher.idl
+++ b/dom/interfaces/xul/nsIDOMXULCommandDispatcher.idl
@@ -2,25 +2,25 @@
 /* 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 "nsISupports.idl"
 
 interface nsIController;
 interface nsIControllers;
-interface mozIDOMWindowProxy;
+webidl WindowProxy;
 
 webidl Element;
 
 [scriptable, uuid(a9fa9fd3-8d62-4f94-9ed8-3ea9c3cf0773)]
 interface nsIDOMXULCommandDispatcher : nsISupports
 {
             attribute Element focusedElement;
-            attribute mozIDOMWindowProxy focusedWindow;
+            attribute WindowProxy focusedWindow;
 
   void                      addCommandUpdater(in Element updater,
                                               in DOMString events,
                                               in DOMString targets);
   void                      removeCommandUpdater(in Element updater);
 
   void                      updateCommands(in DOMString eventName);
 

--- a/dom/ipc/ContentChild.cpp
+++ b/dom/ipc/ContentChild.cpp
@@ -738,37 +738,37 @@ ContentChild::SetProcessName(const nsASt
 #endif
   }
 
   mProcessName = aName;
   mozilla::ipc::SetThisProcessName(NS_LossyConvertUTF16toASCII(aName).get());
 }
 
 NS_IMETHODIMP
-ContentChild::ProvideWindow(mozIDOMWindowProxy* aParent,
+ContentChild::ProvideWindow(nsPIDOMWindowOuter* aParent,
                             uint32_t aChromeFlags,
                             bool aCalledFromJS,
                             bool aPositionSpecified,
                             bool aSizeSpecified,
                             nsIURI* aURI,
                             const nsAString& aName,
                             const nsACString& aFeatures,
                             bool aForceNoOpener,
                             nsIDocShellLoadInfo* aLoadInfo,
                             bool* aWindowIsNew,
-                            mozIDOMWindowProxy** aReturn)
+                            nsPIDOMWindowOuter** aReturn)
 {
   return ProvideWindowCommon(nullptr, aParent, false, aChromeFlags,
                              aCalledFromJS, aPositionSpecified,
                              aSizeSpecified, aURI, aName, aFeatures,
                              aForceNoOpener, aLoadInfo, aWindowIsNew, aReturn);
 }
 
 static nsresult
-GetCreateWindowParams(mozIDOMWindowProxy* aParent,
+GetCreateWindowParams(nsPIDOMWindowOuter* aParent,
                       nsIDocShellLoadInfo* aLoadInfo,
                       nsACString& aBaseURIString, float* aFullZoom,
                       uint32_t* aReferrerPolicy,
                       nsIPrincipal** aTriggeringPrincipal)
 {
   *aFullZoom = 1.0f;
   auto* opener = nsPIDOMWindowOuter::From(aParent);
   if (!opener) {
@@ -809,29 +809,29 @@ GetCreateWindowParams(mozIDOMWindowProxy
     cv->GetFullZoom(aFullZoom);
   }
 
   return NS_OK;
 }
 
 nsresult
 ContentChild::ProvideWindowCommon(TabChild* aTabOpener,
-                                  mozIDOMWindowProxy* aParent,
+                                  nsPIDOMWindowOuter* aParent,
                                   bool aIframeMoz,
                                   uint32_t aChromeFlags,
                                   bool aCalledFromJS,
                                   bool aPositionSpecified,
                                   bool aSizeSpecified,
                                   nsIURI* aURI,
                                   const nsAString& aName,
                                   const nsACString& aFeatures,
                                   bool aForceNoOpener,
                                   nsIDocShellLoadInfo* aLoadInfo,
                                   bool* aWindowIsNew,
-                                  mozIDOMWindowProxy** aReturn)
+                                  nsPIDOMWindowOuter** aReturn)
 {
   *aReturn = nullptr;
 
   nsAutoPtr<IPCTabContext> ipcContext;
   TabId openerTabId = TabId(0);
   nsAutoCString features(aFeatures);
   nsAutoString name(aName);
 
@@ -1016,17 +1016,17 @@ ContentChild::ProvideWindowCommon(TabChi
     }
 
     newChild->SetMaxTouchPoints(maxTouchPoints);
 
     // Set the opener window for this window before we start loading the document
     // inside of it. We have to do this before loading the remote scripts, because
     // they can poke at the document and cause the nsDocument to be created before
     // the openerwindow
-    nsCOMPtr<mozIDOMWindowProxy> windowProxy = do_GetInterface(newChild->WebNavigation());
+    nsCOMPtr<nsPIDOMWindowOuter> windowProxy = do_GetInterface(newChild->WebNavigation());
     if (!aForceNoOpener && windowProxy && aParent) {
       nsPIDOMWindowOuter* outer = nsPIDOMWindowOuter::From(windowProxy);
       nsPIDOMWindowOuter* parent = nsPIDOMWindowOuter::From(aParent);
       outer->SetOpenerWindow(parent, *aWindowIsNew);
     }
 
     // Unfortunately we don't get a window unless we've shown the frame.  That's
     // pretty bogus; see bug 763602.
@@ -1041,17 +1041,17 @@ ContentChild::ProvideWindowCommon(TabChi
         MOZ_CRASH();
       }
     }
 
     if (!urlToLoad.IsEmpty()) {
       newChild->RecvLoadURL(urlToLoad, showInfo);
     }
 
-    nsCOMPtr<mozIDOMWindowProxy> win = do_GetInterface(newChild->WebNavigation());
+    nsCOMPtr<nsPIDOMWindowOuter> win = do_GetInterface(newChild->WebNavigation());
     win.forget(aReturn);
   };
 
   // NOTE: Capturing by reference here is safe, as this function won't return
   // until one of these callbacks is called.
   auto reject = [&] (ResponseRejectReason) {
     MOZ_RELEASE_ASSERT(NS_IsMainThread());
     NS_WARNING("windowCreated promise rejected");

--- a/dom/ipc/ContentChild.h
+++ b/dom/ipc/ContentChild.h
@@ -99,29 +99,29 @@ public:
     nsCString name;
     nsCString UAName;
     nsCString ID;
     nsCString vendor;
   };
 
   nsresult
   ProvideWindowCommon(TabChild* aTabOpener,
-                      mozIDOMWindowProxy* aOpener,
+                      nsPIDOMWindowOuter* aOpener,
                       bool aIframeMoz,
                       uint32_t aChromeFlags,
                       bool aCalledFromJS,
                       bool aPositionSpecified,
                       bool aSizeSpecified,
                       nsIURI* aURI,
                       const nsAString& aName,
                       const nsACString& aFeatures,
                       bool aForceNoOpener,
                       nsIDocShellLoadInfo* aLoadInfo,
                       bool* aWindowIsNew,
-                      mozIDOMWindowProxy** aReturn);
+                      nsPIDOMWindowOuter** aReturn);
 
   bool Init(MessageLoop* aIOLoop,
             base::ProcessId aParentPid,
             const char* aParentBuildID,
             IPC::Channel* aChannel,
             uint64_t aChildID,
             bool aIsForBrowser);
 

--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -4835,27 +4835,27 @@ ContentParent::CommonCreateWindow(PBrows
   // If we send it down in the non-async case, then we might set the
   // OriginAttributes after the document has already navigated.
   if (!aSetOpener) {
     Unused << TabParent::GetFrom(aNewTabParent)
       ->SendSetOriginAttributes(openerOriginAttributes);
   }
 
   if (aURIToLoad && aLoadURI) {
-    nsCOMPtr<mozIDOMWindowProxy> openerWindow;
+    nsCOMPtr<nsPIDOMWindowOuter> openerWindow;
     if (aSetOpener && thisTabParent) {
       openerWindow = thisTabParent->GetParentWindowOuter();
     }
     nsCOMPtr<nsIBrowserDOMWindow> newBrowserDOMWin =
       TabParent::GetFrom(aNewTabParent)->GetBrowserDOMWindow();
     if (NS_WARN_IF(!newBrowserDOMWin)) {
       aResult = NS_ERROR_ABORT;
       return IPC_OK();
     }
-    nsCOMPtr<mozIDOMWindowProxy> win;
+    nsCOMPtr<nsPIDOMWindowOuter> win;
     aResult = newBrowserDOMWin->OpenURI(aURIToLoad, openerWindow,
                                         nsIBrowserDOMWindow::OPEN_CURRENTWINDOW,
                                         nsIBrowserDOMWindow::OPEN_NEW,
                                         aTriggeringPrincipal,
                                         getter_AddRefs(win));
   }
 
   return IPC_OK();

--- a/dom/ipc/FilePickerParent.cpp
+++ b/dom/ipc/FilePickerParent.cpp
@@ -240,17 +240,17 @@ FilePickerParent::CreateFilePicker()
     return false;
   }
 
   Element* element = TabParent::GetFrom(Manager())->GetOwnerElement();
   if (!element) {
     return false;
   }
 
-  nsCOMPtr<mozIDOMWindowProxy> window = element->OwnerDoc()->GetWindow();
+  nsCOMPtr<nsPIDOMWindowOuter> window = element->OwnerDoc()->GetWindow();
   if (!window) {
     return false;
   }
 
   return NS_SUCCEEDED(mFilePicker->Init(window, mTitle, mMode));
 }
 
 mozilla::ipc::IPCResult

--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -991,24 +991,24 @@ TabChild::GetInterface(const nsIID & aII
     }
 
     // XXXbz should we restrict the set of interfaces we hand out here?
     // See bug 537429
     return QueryInterface(aIID, aSink);
 }
 
 NS_IMETHODIMP
-TabChild::ProvideWindow(mozIDOMWindowProxy* aParent,
+TabChild::ProvideWindow(nsPIDOMWindowOuter* aParent,
                         uint32_t aChromeFlags,
                         bool aCalledFromJS,
                         bool aPositionSpecified, bool aSizeSpecified,
                         nsIURI* aURI, const nsAString& aName,
                         const nsACString& aFeatures, bool aForceNoOpener,
                         nsIDocShellLoadInfo* aLoadInfo, bool* aWindowIsNew,
-                        mozIDOMWindowProxy** aReturn)
+                        nsPIDOMWindowOuter** aReturn)
 {
     *aReturn = nullptr;
 
     // If aParent is inside an <iframe mozbrowser> and this isn't a request to
     // open a modal-type window, we're going to create a new <iframe mozbrowser>
     // and return its window here.
     nsCOMPtr<nsIDocShell> docshell = do_GetInterface(aParent);
     bool iframeMoz = (docshell && docshell->GetIsInMozBrowser() &&

--- a/dom/ipc/TabChild.h
+++ b/dom/ipc/TabChild.h
@@ -515,25 +515,25 @@ public:
       return nullptr;
     }
 
     nsCOMPtr<nsITabChild> tc = aDocShell->GetTabChild();
     return static_cast<TabChild*>(tc.get());
   }
 
   static inline TabChild*
-  GetFrom(mozIDOMWindow* aWindow)
+  GetFrom(nsPIDOMWindowInner* aWindow)
   {
     nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(aWindow);
     nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(webNav);
     return GetFrom(docShell);
   }
 
   static inline TabChild*
-  GetFrom(mozIDOMWindowProxy* aWindow)
+  GetFrom(nsPIDOMWindowOuter* aWindow)
   {
     nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(aWindow);
     nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(webNav);
     return GetFrom(docShell);
   }
 
   static TabChild* GetFrom(nsIPresShell* aPresShell);
   static TabChild* GetFrom(layers::LayersId aLayersId);

--- a/dom/ipc/TabParent.cpp
+++ b/dom/ipc/TabParent.cpp
@@ -867,17 +867,17 @@ void
 TabParent::Deactivate()
 {
   if (!mIsDestroyed) {
     Unused << Manager()->SendDeactivate(this);
   }
 }
 
 NS_IMETHODIMP
-TabParent::Init(mozIDOMWindowProxy *window)
+TabParent::Init(nsPIDOMWindowOuter *window)
 {
   return NS_OK;
 }
 
 NS_IMETHODIMP
 TabParent::GetState(uint32_t *aState)
 {
   NS_ENSURE_ARG(aState);
@@ -3234,18 +3234,18 @@ public:
   NS_IMETHOD SetContentDispositionFilename(const nsAString&) NO_IMPL
   NS_IMETHOD GetContentDispositionHeader(nsACString&) NO_IMPL
   NS_IMETHOD OnAuthAvailable(nsISupports *aContext, nsIAuthInformation *aAuthInfo) override;
   NS_IMETHOD OnAuthCancelled(nsISupports *aContext, bool userCancel) override;
   NS_IMETHOD GetInterface(const nsIID & uuid, void **result) override
   {
     return QueryInterface(uuid, result);
   }
-  NS_IMETHOD GetAssociatedWindow(mozIDOMWindowProxy**) NO_IMPL
-  NS_IMETHOD GetTopWindow(mozIDOMWindowProxy**) NO_IMPL
+  NS_IMETHOD GetAssociatedWindow(nsPIDOMWindowOuter**) NO_IMPL
+  NS_IMETHOD GetTopWindow(nsPIDOMWindowOuter**) NO_IMPL
   NS_IMETHOD GetTopFrameElement(Element** aElement) override
   {
     nsCOMPtr<Element> elem = mElement;
     elem.forget(aElement);
     return NS_OK;
   }
   NS_IMETHOD GetNestedFrameId(uint64_t*) NO_IMPL
   NS_IMETHOD GetIsContent(bool*) NO_IMPL

--- a/dom/media/webrtc/MediaEngineTabVideoSource.cpp
+++ b/dom/media/webrtc/MediaEngineTabVideoSource.cpp
@@ -83,17 +83,17 @@ MediaEngineTabVideoSource::InitRunnable:
       }
     }
   }
   if (!mVideoSource->mWindow && !mVideoSource->mBlackedoutWindow) {
     nsresult rv;
     mVideoSource->mTabSource = do_GetService(NS_TABSOURCESERVICE_CONTRACTID, &rv);
     NS_ENSURE_SUCCESS(rv, rv);
 
-    nsCOMPtr<mozIDOMWindowProxy> win;
+    nsCOMPtr<nsPIDOMWindowOuter> win;
     rv = mVideoSource->mTabSource->GetTabToStream(getter_AddRefs(win));
     NS_ENSURE_SUCCESS(rv, rv);
     if (!win)
       return NS_OK;
 
     mVideoSource->mWindow = nsPIDOMWindowOuter::From(win);
     MOZ_ASSERT(mVideoSource->mWindow);
   }

--- a/dom/media/webrtc/nsITabSource.idl
+++ b/dom/media/webrtc/nsITabSource.idl
@@ -1,20 +1,20 @@
 /* -*- Mode: IDL; 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 "nsISupports.idl"
 
-interface mozIDOMWindowProxy;
+webidl WindowProxy;
 
 [scriptable,uuid(0feba7f2-800d-4fe5-b28d-e3f17a7a7322)]
 interface nsITabSource : nsISupports
 {
-  mozIDOMWindowProxy getTabToStream();
-  void notifyStreamStart(in mozIDOMWindowProxy window);
-  void notifyStreamStop(in mozIDOMWindowProxy window);
+  WindowProxy getTabToStream();
+  void notifyStreamStart(in WindowProxy window);
+  void notifyStreamStop(in WindowProxy window);
 };
 
 %{C++
 #define NS_TABSOURCESERVICE_CONTRACTID "@mozilla.org/tab-source-service;1"
 %}

--- a/dom/media/webvtt/nsIWebVTTParserWrapper.idl
+++ b/dom/media/webvtt/nsIWebVTTParserWrapper.idl
@@ -1,16 +1,16 @@
 /* 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 "nsISupports.idl"
 
 interface nsIWebVTTListener;
-interface mozIDOMWindow;
+webidl Window;
 interface nsIVariant;
 
 webidl DocumentFragment;
 
 /**
  * Interface for a wrapper of a JS WebVTT parser (vtt.js).
  */
 [scriptable, uuid(8dfe016e-1701-4618-9f5e-9a6154e853f0)]
@@ -20,17 +20,17 @@ interface nsIWebVTTParserWrapper : nsISu
    * Loads the JS WebVTTParser and sets it to use the passed window to create
    * VTTRegions and VTTCues. This function must be called before calling
    * parse, flush, or watch.
    *
    * @param window The window that the parser will use to create VTTCues and
    *               VTTRegions.
    *
    */
-  void loadParser(in mozIDOMWindow window);
+  void loadParser(in Window window);
 
   /**
    * Attempts to parse the stream's data as WebVTT format. When it successfully
    * parses a WebVTT region or WebVTT cue it will create a VTTRegion or VTTCue
    * object and pass it back to the callee through its callbacks.
    *
    * @param data   The buffer that contains the WebVTT data received by the
    *               Necko consumer so far.
@@ -56,17 +56,17 @@ interface nsIWebVTTParserWrapper : nsISu
    * Convert the text content of a WebVTT cue to a document fragment so that
    * we can display it on the page.
    *
    * @param window A window object with which the document fragment will be
    *               created.
    * @param cue    The cue whose content will be converted to a document
    *               fragment.
    */
-  DocumentFragment convertCueToDOMTree(in mozIDOMWindow window,
+  DocumentFragment convertCueToDOMTree(in Window window,
 				       in nsISupports cue);
 
 
   /**
    * Compute the display state of the VTTCues in cues along with any VTTRegions
    * that they might be in. First, it computes the positioning and styling of
    * the cues and regions passed and converts them into a DOM tree rooted at
    * a containing HTMLDivElement. It then adjusts those computed divs for
@@ -75,15 +75,15 @@ interface nsIWebVTTParserWrapper : nsISu
    *
    * @param window  A window object with which it will create the DOM tree
    *                and containing div element.
    * @param cues    An array of VTTCues who need there display state to be
    *                computed.
    * @param overlay The HTMLElement that the cues will be displayed within.
    * @param controls The video control element that will affect cues position.
    */
-  void processCues(in mozIDOMWindow window, in nsIVariant cues,
+  void processCues(in Window window, in nsIVariant cues,
                    in nsISupports overlay, in nsISupports controls);
 };
 
 %{C++
 #define NS_WEBVTTPARSERWRAPPER_CONTRACTID "@mozilla.org/webvttParserWrapper;1"
 %}

--- a/dom/midi/MIDIPermissionRequest.cpp
+++ b/dom/midi/MIDIPermissionRequest.cpp
@@ -78,17 +78,17 @@ NS_IMETHODIMP
 MIDIPermissionRequest::GetPrincipal(nsIPrincipal** aRequestingPrincipal)
 {
   NS_ENSURE_ARG_POINTER(aRequestingPrincipal);
   NS_IF_ADDREF(*aRequestingPrincipal = mPrincipal);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-MIDIPermissionRequest::GetWindow(mozIDOMWindow** aRequestingWindow)
+MIDIPermissionRequest::GetWindow(nsPIDOMWindowInner** aRequestingWindow)
 {
   NS_ENSURE_ARG_POINTER(aRequestingWindow);
   NS_IF_ADDREF(*aRequestingWindow = mWindow);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 MIDIPermissionRequest::GetElement(Element** aRequestingElement)

--- a/dom/notification/Notification.cpp
+++ b/dom/notification/Notification.cpp
@@ -582,17 +582,17 @@ NotificationPermissionRequest::Run()
 NS_IMETHODIMP
 NotificationPermissionRequest::GetPrincipal(nsIPrincipal** aRequestingPrincipal)
 {
   NS_ADDREF(*aRequestingPrincipal = mPrincipal);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-NotificationPermissionRequest::GetWindow(mozIDOMWindow** aRequestingWindow)
+NotificationPermissionRequest::GetWindow(nsPIDOMWindowInner** aRequestingWindow)
 {
   NS_ADDREF(*aRequestingWindow = mWindow);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 NotificationPermissionRequest::GetElement(Element** aElement)
 {

--- a/dom/plugins/ipc/PluginHangUIParent.cpp
+++ b/dom/plugins/ipc/PluginHangUIParent.cpp
@@ -385,17 +385,17 @@ PluginHangUIParent::GetHangUIOwnerWindow
 {
   windowHandle = nullptr;
 
   nsresult rv;
   nsCOMPtr<nsIWindowMediator> winMediator(do_GetService(NS_WINDOWMEDIATOR_CONTRACTID,
                                                         &rv));
   NS_ENSURE_SUCCESS(rv, rv);
 
-  nsCOMPtr<mozIDOMWindowProxy> navWin;
+  nsCOMPtr<nsPIDOMWindowOuter> navWin;
   rv = winMediator->GetMostRecentWindow(u"navigator:browser",
                                         getter_AddRefs(navWin));
   NS_ENSURE_SUCCESS(rv, rv);
   if (!navWin) {
     return NS_ERROR_FAILURE;
   }
 
   nsPIDOMWindowOuter* win = nsPIDOMWindowOuter::From(navWin);

--- a/dom/power/PowerManagerService.cpp
+++ b/dom/power/PowerManagerService.cpp
@@ -133,17 +133,17 @@ PowerManagerService::NewWakeLock(const n
     return nullptr;
   }
 
   return wakelock.forget();
 }
 
 NS_IMETHODIMP
 PowerManagerService::NewWakeLock(const nsAString &aTopic,
-                                 mozIDOMWindow *aWindow,
+                                 nsPIDOMWindowInner *aWindow,
                                  nsISupports **aWakeLock)
 {
   mozilla::ErrorResult rv;
   RefPtr<WakeLock> wakelock =
     NewWakeLock(aTopic, nsPIDOMWindowInner::From(aWindow), rv);
   if (rv.Failed()) {
     return rv.StealNSResult();
   }

--- a/dom/power/nsIPowerManagerService.idl
+++ b/dom/power/nsIPowerManagerService.idl
@@ -6,27 +6,27 @@
 #include "nsISupports.idl"
 
 %{C++
 #define NS_POWERMANAGERSERVICE_CID { 0x18c2e238, 0x3a0a, 0x4153, {0x89, 0xfc, 0x16, 0x6b, 0x3b, 0x14, 0x65, 0xa1 } }
 #define POWERMANAGERSERVICE_CONTRACTID "@mozilla.org/power/powermanagerservice;1"
 %}
 
 interface nsIDOMMozWakeLockListener;
-interface mozIDOMWindow;
+webidl Window;
 
 /**
  * For use with non-content code.
  */
 [scriptable, builtinclass, uuid(ba7ca4c1-9d92-4425-a83b-85dd7fa953f7)]
 interface nsIPowerManagerService : nsISupports
 {
   void              addWakeLockListener(in nsIDOMMozWakeLockListener aListener);
   void              removeWakeLockListener(in nsIDOMMozWakeLockListener aListener);
   DOMString         getWakeLockState(in DOMString aTopic);
 
   /**
    * Return a wake lock (MozWakeLock) object of aTopic associated with aWindow.
    * A wake lock without associated window, e.g. used in chrome, is
    * always considered invisible.
    */
-  nsISupports newWakeLock(in DOMString aTopic, [optional] in mozIDOMWindow aWindow);
+  nsISupports newWakeLock(in DOMString aTopic, [optional] in Window aWindow);
 };

--- a/dom/presentation/interfaces/nsIPresentationSessionTransportBuilder.idl
+++ b/dom/presentation/interfaces/nsIPresentationSessionTransportBuilder.idl
@@ -1,17 +1,17 @@
 /* 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 "nsISupports.idl"
 
 interface nsIPresentationChannelDescription;
 interface nsISocketTransport;
-interface mozIDOMWindow;
+webidl Window;
 interface nsIPresentationControlChannel;
 interface nsIPresentationSessionTransport;
 
 [scriptable, uuid(673f6de1-e253-41b8-9be8-b7ff161fa8dc)]
 interface nsIPresentationSessionTransportBuilderListener : nsISupports
 {
   // Should set |transport.callback| in |onSessionTransport|.
   void onSessionTransport(in nsIPresentationSessionTransport transport);
@@ -64,17 +64,17 @@ interface nsIPresentationDataChannelSess
   /**
    * The following creation function will trigger |listener.onSessionTransport|
    * if the session transport is successfully built, |listener.onError| if some
    * error occurs during creating session transport. The |notifyConnected| of
    * |aControlChannel| should be called before calling
    * |buildDataChannelTransport|.
    */
   void buildDataChannelTransport(in uint8_t aRole,
-                                 in mozIDOMWindow aWindow,
+                                 in Window aWindow,
                                  in nsIPresentationSessionTransportBuilderListener aListener);
 
   // Bug 1275150 - Merge TCP builder with the following APIs
   void onOffer(in nsIPresentationChannelDescription offer);
   void onAnswer(in nsIPresentationChannelDescription answer);
   void onIceCandidate(in DOMString candidate);
   void notifyDisconnected(in nsresult reason);
 };

--- a/dom/presentation/ipc/PresentationBuilderParent.cpp
+++ b/dom/presentation/ipc/PresentationBuilderParent.cpp
@@ -117,17 +117,17 @@ PresentationBuilderParent::~Presentation
   if (mNeedDestroyActor) {
     Unused << NS_WARN_IF(!Send__delete__(this));
   }
 }
 
 NS_IMETHODIMP
 PresentationBuilderParent::BuildDataChannelTransport(
                       uint8_t aRole,
-                      mozIDOMWindow* aWindow, /* unused */
+                      nsPIDOMWindowInner* aWindow, /* unused */
                       nsIPresentationSessionTransportBuilderListener* aListener)
 {
   mBuilderListener = aListener;
 
   RefPtr<PresentationSessionInfo> info = static_cast<PresentationSessionInfo*>(aListener);
   nsAutoString sessionId(info->GetSessionId());
   if (NS_WARN_IF(!mParent->SendPPresentationBuilderConstructor(this,
                                                                sessionId,

--- a/dom/quota/StorageManager.cpp
+++ b/dom/quota/StorageManager.cpp
@@ -725,17 +725,17 @@ PersistentStoragePermissionRequest::GetP
 NS_IMETHODIMP
 PersistentStoragePermissionRequest::GetIsHandlingUserInput(bool* aIsHandlingUserInput)
 {
   *aIsHandlingUserInput = mIsHandlingUserInput;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-PersistentStoragePermissionRequest::GetWindow(mozIDOMWindow** aRequestingWindow)
+PersistentStoragePermissionRequest::GetWindow(nsPIDOMWindowInner** aRequestingWindow)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(aRequestingWindow);
   MOZ_ASSERT(mWindow);
 
   NS_ADDREF(*aRequestingWindow = mWindow);
 
   return NS_OK;