The Tor Browser: comparison dom/base/nsPIDOMWindow.h

--1:000000000000
+:5cd69a802e36
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 sw=2 et 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/. */
+#ifndef nsPIDOMWindow_h__
+#define nsPIDOMWindow_h__
+#include "nsIDOMWindow.h"
+#include "nsCOMPtr.h"
+#include "nsAutoPtr.h"
+#include "nsTArray.h"
+#include "mozilla/dom/EventTarget.h"
+#include "js/TypeDecls.h"
+#define DOM_WINDOW_DESTROYED_TOPIC "dom-window-destroyed"
+#define DOM_WINDOW_FROZEN_TOPIC "dom-window-frozen"
+#define DOM_WINDOW_THAWED_TOPIC "dom-window-thawed"
+class nsIArray;
+class nsIContent;
+class nsIDocShell;
+class nsIDocument;
+class nsIIdleObserver;
+class nsIPrincipal;
+class nsIScriptTimeoutHandler;
+class nsIURI;
+class nsPerformance;
+class nsPIWindowRoot;
+class nsXBLPrototypeHandler;
+struct nsTimeout;
+namespace mozilla {
+namespace dom {
+class AudioContext;
+class Element;
+}
+}
+// Popup control state enum. The values in this enum must go from most
+// permissive to least permissive so that it's safe to push state in
+// all situations. Pushing popup state onto the stack never makes the
+// current popup state less permissive (see
+// nsGlobalWindow::PushPopupControlState()).
+enum PopupControlState {
+openAllowed = 0,  // open that window without worries
+openControlled,   // it's a popup, but allow it
+openAbused,       // it's a popup. disallow it, but allow domain override.
+openOverridden    // disallow window open
+};
+enum UIStateChangeType
+{
+UIStateChangeType_NoChange,
+UIStateChangeType_Set,
+UIStateChangeType_Clear
+};
+#define NS_PIDOMWINDOW_IID \
+{ 0xf26953de, 0xa799, 0x4a92, \
+{ 0x87, 0x49, 0x7c, 0x37, 0xe5, 0x90, 0x3f, 0x37 } }
+class nsPIDOMWindow : public nsIDOMWindowInternal
+{
+public:
+NS_DECLARE_STATIC_IID_ACCESSOR(NS_PIDOMWINDOW_IID)
+virtual nsPIDOMWindow* GetPrivateRoot() = 0;
+// Outer windows only.
+virtual void ActivateOrDeactivate(bool aActivate) = 0;
+// this is called GetTopWindowRoot to avoid conflicts with nsIDOMWindow::GetWindowRoot
+virtual already_AddRefed<nsPIWindowRoot> GetTopWindowRoot() = 0;
+// Inner windows only.
+virtual nsresult RegisterIdleObserver(nsIIdleObserver* aIdleObserver) = 0;
+virtual nsresult UnregisterIdleObserver(nsIIdleObserver* aIdleObserver) = 0;
+// Outer windows only.
+virtual void SetActive(bool aActive)
+{
+MOZ_ASSERT(IsOuterWindow());
+mIsActive = aActive;
+}
+bool IsActive()
+{
+MOZ_ASSERT(IsOuterWindow());
+return mIsActive;
+}
+// Outer windows only.
+virtual void SetIsBackground(bool aIsBackground)
+{
+MOZ_ASSERT(IsOuterWindow());
+mIsBackground = aIsBackground;
+}
+bool IsBackground()
+{
+MOZ_ASSERT(IsOuterWindow());
+return mIsBackground;
+}
+mozilla::dom::EventTarget* GetChromeEventHandler() const
+{
+return mChromeEventHandler;
+}
+// Outer windows only.
+virtual void SetChromeEventHandler(mozilla::dom::EventTarget* aChromeEventHandler) = 0;
+mozilla::dom::EventTarget* GetParentTarget()
+{
+if (!mParentTarget) {
+UpdateParentTarget();
+}
+return mParentTarget;
+}
+bool HasMutationListeners(uint32_t aMutationEventType) const
+{
+const nsPIDOMWindow *win;
+if (IsOuterWindow()) {
+win = GetCurrentInnerWindow();
+if (!win) {
+NS_ERROR("No current inner window available!");
+return false;
+}
+} else {
+if (!mOuterWindow) {
+NS_ERROR("HasMutationListeners() called on orphan inner window!");
+return false;
+}
+win = this;
+}
+return (win->mMutationBits & aMutationEventType) != 0;
+}
+void SetMutationListeners(uint32_t aType)
+{
+nsPIDOMWindow *win;
+if (IsOuterWindow()) {
+win = GetCurrentInnerWindow();
+if (!win) {
+NS_ERROR("No inner window available to set mutation bits on!");
+return;
+}
+} else {
+if (!mOuterWindow) {
+NS_ERROR("HasMutationListeners() called on orphan inner window!");
+return;
+}
+win = this;
+}
+win->mMutationBits |= aType;
+}
+virtual void MaybeUpdateTouchState() {}
+virtual void UpdateTouchState() {}
+nsIDocument* GetExtantDoc() const
+{
+return mDoc;
+}
+nsIURI* GetDocumentURI() const;
+nsIURI* GetDocBaseURI() const;
+nsIDocument* GetDoc()
+{
+if (!mDoc) {
+MaybeCreateDoc();
+}
+return mDoc;
+}
+virtual NS_HIDDEN_(bool) IsRunningTimeout() = 0;
+// Audio API
+bool GetAudioMuted() const;
+void SetAudioMuted(bool aMuted);
+float GetAudioVolume() const;
+nsresult SetAudioVolume(float aVolume);
+float GetAudioGlobalVolume();
+protected:
+// Lazily instantiate an about:blank document if necessary, and if
+// we have what it takes to do so.
+void MaybeCreateDoc();
+float GetAudioGlobalVolumeInternal(float aVolume);
+void RefreshMediaElements();
+public:
+// Internal getter/setter for the frame element, this version of the
+// getter crosses chrome boundaries whereas the public scriptable
+// one doesn't for security reasons.
+mozilla::dom::Element* GetFrameElementInternal() const;
+void SetFrameElementInternal(mozilla::dom::Element* aFrameElement);
+bool IsLoadingOrRunningTimeout() const
+{
+const nsPIDOMWindow *win = GetCurrentInnerWindow();
+if (!win) {
+win = this;
+}
+return !win->mIsDocumentLoaded || win->mRunningTimeout;
+}
+// Check whether a document is currently loading
+bool IsLoading() const
+{
+const nsPIDOMWindow *win;
+if (IsOuterWindow()) {
+win = GetCurrentInnerWindow();
+if (!win) {
+NS_ERROR("No current inner window available!");
+return false;
+}
+} else {
+if (!mOuterWindow) {
+NS_ERROR("IsLoading() called on orphan inner window!");
+return false;
+}
+win = this;
+}
+return !win->mIsDocumentLoaded;
+}
+bool IsHandlingResizeEvent() const
+{
+const nsPIDOMWindow *win;
+if (IsOuterWindow()) {
+win = GetCurrentInnerWindow();
+if (!win) {
+NS_ERROR("No current inner window available!");
+return false;
+}
+} else {
+if (!mOuterWindow) {
+NS_ERROR("IsHandlingResizeEvent() called on orphan inner window!");
+return false;
+}
+win = this;
+}
+return win->mIsHandlingResizeEvent;
+}
+// Set the window up with an about:blank document with the current subject
+// principal.
+virtual void SetInitialPrincipalToSubject() = 0;
+virtual PopupControlState PushPopupControlState(PopupControlState aState,
+bool aForce) const = 0;
+virtual void PopPopupControlState(PopupControlState state) const = 0;
+virtual PopupControlState GetPopupControlState() const = 0;
+// Returns an object containing the window's state.  This also suspends
+// all running timeouts in the window.
+virtual already_AddRefed<nsISupports> SaveWindowState() = 0;
+// Restore the window state from aState.
+virtual nsresult RestoreWindowState(nsISupports *aState) = 0;
+// Suspend timeouts in this window and in child windows.
+virtual void SuspendTimeouts(uint32_t aIncrease = 1,
+bool aFreezeChildren = true) = 0;
+// Resume suspended timeouts in this window and in child windows.
+virtual nsresult ResumeTimeouts(bool aThawChildren = true) = 0;
+virtual uint32_t TimeoutSuspendCount() = 0;
+// Fire any DOM notification events related to things that happened while
+// the window was frozen.
+virtual nsresult FireDelayedDOMEvents() = 0;
+virtual bool IsFrozen() const = 0;
+// Add a timeout to this window.
+virtual nsresult SetTimeoutOrInterval(nsIScriptTimeoutHandler *aHandler,
+int32_t interval,
+bool aIsInterval, int32_t *aReturn) = 0;
+// Clear a timeout from this window.
+virtual nsresult ClearTimeoutOrInterval(int32_t aTimerID) = 0;
+nsPIDOMWindow *GetOuterWindow()
+{
+return mIsInnerWindow ? mOuterWindow.get() : this;
+}
+nsPIDOMWindow *GetCurrentInnerWindow() const
+{
+return mInnerWindow;
+}
+nsPIDOMWindow *EnsureInnerWindow()
+{
+NS_ASSERTION(IsOuterWindow(), "EnsureInnerWindow called on inner window");
+// GetDoc forces inner window creation if there isn't one already
+GetDoc();
+return GetCurrentInnerWindow();
+}
+bool IsInnerWindow() const
+{
+return mIsInnerWindow;
+}
+// Returns true if this object has an outer window and it is the current inner
+// window of that outer. Only call this on inner windows.
+bool IsCurrentInnerWindow() const
+{
+MOZ_ASSERT(IsInnerWindow(),
+"It doesn't make sense to call this on outer windows.");
+return mOuterWindow && mOuterWindow->GetCurrentInnerWindow() == this;
+}
+// Returns true if the document of this window is the active document.  This
+// is not identical to IsCurrentInnerWindow() because document.open() will
+// keep the same document active but create a new window.
+bool HasActiveDocument()
+{
+MOZ_ASSERT(IsInnerWindow());
+return IsCurrentInnerWindow() ||
+(mOuterWindow &&
+mOuterWindow->GetCurrentInnerWindow() &&
+mOuterWindow->GetCurrentInnerWindow()->GetDoc() == mDoc);
+}
+bool IsOuterWindow() const
+{
+return !IsInnerWindow();
+}
+virtual bool WouldReuseInnerWindow(nsIDocument *aNewDocument) = 0;
+/**
+* Get the docshell in this window.
+*/
+nsIDocShell *GetDocShell()
+{
+if (mOuterWindow) {
+return mOuterWindow->mDocShell;
+}
+return mDocShell;
+}
+/**
+* Set the docshell in the window.  Must not be called with a null docshell
+* (use DetachFromDocShell for that).
+*/
+virtual void SetDocShell(nsIDocShell *aDocShell) = 0;
+/**
+* Detach an outer window from its docshell.
+*/
+virtual void DetachFromDocShell() = 0;
+/**
+* Set a new document in the window. Calling this method will in
+* most cases create a new inner window. If this method is called on
+* an inner window the call will be forewarded to the outer window,
+* if the inner window is not the current inner window an
+* NS_ERROR_NOT_AVAILABLE error code will be returned. This may be
+* called with a pointer to the current document, in that case the
+* document remains unchanged, but a new inner window will be
+* created.
+*
+* aDocument must not be null.
+*/
+virtual nsresult SetNewDocument(nsIDocument *aDocument,
+nsISupports *aState,
+bool aForceReuseInnerWindow) = 0;
+/**
+* Set the opener window.  aOriginalOpener is true if and only if this is the
+* original opener for the window.  That is, it can only be true at most once
+* during the life cycle of a window, and then only the first time
+* SetOpenerWindow is called.  It might never be true, of course, if the
+* window does not have an opener when it's created.
+*/
+virtual void SetOpenerWindow(nsIDOMWindow* aOpener,
+bool aOriginalOpener) = 0;
+virtual void EnsureSizeUpToDate() = 0;
+/**
+* Callback for notifying a window about a modal dialog being
+* opened/closed with the window as a parent.
+*/
+virtual void EnterModalState() = 0;
+virtual void LeaveModalState() = 0;
+virtual bool CanClose() = 0;
+virtual nsresult ForceClose() = 0;
+bool IsModalContentWindow() const
+{
+return mIsModalContentWindow;
+}
+/**
+* Call this to indicate that some node (this window, its document,
+* or content in that document) has a paint event listener.
+*/
+void SetHasPaintEventListeners()
+{
+mMayHavePaintEventListener = true;
+}
+/**
+* Call this to check whether some node (this window, its document,
+* or content in that document) has a paint event listener.
+*/
+bool HasPaintEventListeners()
+{
+return mMayHavePaintEventListener;
+}
+/**
+* Call this to indicate that some node (this window, its document,
+* or content in that document) has a touch event listener.
+*/
+void SetHasTouchEventListeners()
+{
+mMayHaveTouchEventListener = true;
+MaybeUpdateTouchState();
+}
+bool HasTouchEventListeners()
+{
+return mMayHaveTouchEventListener;
+}
+/**
+* Moves the top-level window into fullscreen mode if aIsFullScreen is true,
+* otherwise exits fullscreen. If aRequireTrust is true, this method only
+* changes window state in a context trusted for write.
+*/
+virtual nsresult SetFullScreenInternal(bool aIsFullScreen, bool aRequireTrust) = 0;
+/**
+* Call this to check whether some node (this window, its document,
+* or content in that document) has a mouseenter/leave event listener.
+*/
+bool HasMouseEnterLeaveEventListeners()
+{
+return mMayHaveMouseEnterLeaveEventListener;
+}
+/**
+* Call this to indicate that some node (this window, its document,
+* or content in that document) has a mouseenter/leave event listener.
+*/
+void SetHasMouseEnterLeaveEventListeners()
+{
+mMayHaveMouseEnterLeaveEventListener = true;
+}
+/**
+* Call this to check whether some node (this window, its document,
+* or content in that document) has a Pointerenter/leave event listener.
+*/
+bool HasPointerEnterLeaveEventListeners()
+{
+return mMayHavePointerEnterLeaveEventListener;
+}
+/**
+* Call this to indicate that some node (this window, its document,
+* or content in that document) has a Pointerenter/leave event listener.
+*/
+void SetHasPointerEnterLeaveEventListeners()
+{
+mMayHavePointerEnterLeaveEventListener = true;
+}
+virtual JSObject* GetCachedXBLPrototypeHandler(nsXBLPrototypeHandler* aKey) = 0;
+virtual void CacheXBLPrototypeHandler(nsXBLPrototypeHandler* aKey,
+JS::Handle<JSObject*> aHandler) = 0;
+/*
+* Get and set the currently focused element within the document. If
+* aNeedsFocus is true, then set mNeedsFocus to true to indicate that a
+* document focus event is needed.
+*
+* DO NOT CALL EITHER OF THESE METHODS DIRECTLY. USE THE FOCUS MANAGER
+* INSTEAD.
+*/
+nsIContent* GetFocusedNode()
+{
+if (IsOuterWindow()) {
+return mInnerWindow ? mInnerWindow->mFocusedNode.get() : nullptr;
+}
+return mFocusedNode;
+}
+virtual void SetFocusedNode(nsIContent* aNode,
+uint32_t aFocusMethod = 0,
+bool aNeedsFocus = false) = 0;
+/**
+* Retrieves the method that was used to focus the current node.
+*/
+virtual uint32_t GetFocusMethod() = 0;
+/*
+* Tells the window that it now has focus or has lost focus, based on the
+* state of aFocus. If this method returns true, then the document loaded
+* in the window has never received a focus event and expects to receive
+* one. If false is returned, the document has received a focus event before
+* and should only receive one if the window is being focused.
+*
+* aFocusMethod may be set to one of the focus method constants in
+* nsIFocusManager to indicate how focus was set.
+*/
+virtual bool TakeFocus(bool aFocus, uint32_t aFocusMethod) = 0;
+/**
+* Indicates that the window may now accept a document focus event. This
+* should be called once a document has been loaded into the window.
+*/
+virtual void SetReadyForFocus() = 0;
+/**
+* Whether the focused content within the window should show a focus ring.
+*/
+virtual bool ShouldShowFocusRing() = 0;
+/**
+* Set the keyboard indicator state for accelerators and focus rings.
+*/
+virtual void SetKeyboardIndicators(UIStateChangeType aShowAccelerators,
+UIStateChangeType aShowFocusRings) = 0;
+/**
+* Get the keyboard indicator state for accelerators and focus rings.
+*/
+virtual void GetKeyboardIndicators(bool* aShowAccelerators,
+bool* aShowFocusRings) = 0;
+/**
+* Indicates that the page in the window has been hidden. This is used to
+* reset the focus state.
+*/
+virtual void PageHidden() = 0;
+/**
+* Instructs this window to asynchronously dispatch a hashchange event.  This
+* method must be called on an inner window.
+*/
+virtual nsresult DispatchAsyncHashchange(nsIURI *aOldURI,
+nsIURI *aNewURI) = 0;
+/**
+* Instructs this window to synchronously dispatch a popState event.
+*/
+virtual nsresult DispatchSyncPopState() = 0;
+/**
+* Tell this window that it should listen for sensor changes of the given
+* type.
+*
+* Inner windows only.
+*/
+virtual void EnableDeviceSensor(uint32_t aType) = 0;
+/**
+* Tell this window that it should remove itself from sensor change
+* notifications.
+*
+* Inner windows only.
+*/
+virtual void DisableDeviceSensor(uint32_t aType) = 0;
+virtual void EnableTimeChangeNotifications() = 0;
+virtual void DisableTimeChangeNotifications() = 0;
+#ifdef MOZ_B2G
+/**
+* Tell the window that it should start to listen to the network event of the
+* given aType.
+*
+* Inner windows only.
+*/
+virtual void EnableNetworkEvent(uint32_t aType) = 0;
+/**
+* Tell the window that it should stop to listen to the network event of the
+* given aType.
+*
+* Inner windows only.
+*/
+virtual void DisableNetworkEvent(uint32_t aType) = 0;
+#endif // MOZ_B2G
+/**
+* Tell this window that there is an observer for gamepad input
+*/
+virtual void SetHasGamepadEventListener(bool aHasGamepad = true) = 0;
+/**
+* Set a arguments for this window. This will be set on the window
+* right away (if there's an existing document) and it will also be
+* installed on the window when the next document is loaded.
+*
+* This function serves double-duty for passing both |arguments| and
+* |dialogArguments| back from nsWindowWatcher to nsGlobalWindow. For the
+* latter, the array is an array of length 0 whose only element is a
+* DialogArgumentsHolder representing the JS value passed to showModalDialog.
+*/
+virtual nsresult SetArguments(nsIArray *aArguments) = 0;
+/**
+* NOTE! This function *will* be called on multiple threads so the
+* implementation must not do any AddRef/Release or other actions that will
+* mutate internal state.
+*/
+virtual uint32_t GetSerial() = 0;
+/**
+* Return the window id of this window
+*/
+uint64_t WindowID() const { return mWindowID; }
+/**
+* Dispatch a custom event with name aEventName targeted at this window.
+* Returns whether the default action should be performed.
+*/
+virtual bool DispatchCustomEvent(const char *aEventName) = 0;
+/**
+* Notify the active inner window that the document principal may have changed
+* and that the compartment principal needs to be updated.
+*/
+virtual void RefreshCompartmentPrincipal() = 0;
+/**
+* Like nsIDOMWindow::Open, except that we don't navigate to the given URL.
+*/
+virtual nsresult
+OpenNoNavigate(const nsAString& aUrl, const nsAString& aName,
+const nsAString& aOptions, nsIDOMWindow **_retval) = 0;
+void AddAudioContext(mozilla::dom::AudioContext* aAudioContext);
+void RemoveAudioContext(mozilla::dom::AudioContext* aAudioContext);
+void MuteAudioContexts();
+void UnmuteAudioContexts();
+// Given an inner window, return its outer if the inner is the current inner.
+// Otherwise (argument null or not an inner or not current) return null.
+static nsPIDOMWindow* GetOuterFromCurrentInner(nsPIDOMWindow* aInner)
+{
+if (!aInner) {
+return nullptr;
+}
+nsPIDOMWindow* outer = aInner->GetOuterWindow();
+if (!outer || outer->GetCurrentInnerWindow() != aInner) {
+return nullptr;
+}
+return outer;
+}
+// WebIDL-ish APIs
+nsPerformance* GetPerformance();
+void MarkUncollectableForCCGeneration(uint32_t aGeneration)
+{
+mMarkedCCGeneration = aGeneration;
+}
+uint32_t GetMarkedCCGeneration()
+{
+return mMarkedCCGeneration;
+}
+protected:
+// The nsPIDOMWindow constructor. The aOuterWindow argument should
+// be null if and only if the created window itself is an outer
+// window. In all other cases aOuterWindow should be the outer
+// window for the inner window that is being created.
+nsPIDOMWindow(nsPIDOMWindow *aOuterWindow);
+~nsPIDOMWindow();
+void SetChromeEventHandlerInternal(mozilla::dom::EventTarget* aChromeEventHandler) {
+mChromeEventHandler = aChromeEventHandler;
+// mParentTarget will be set when the next event is dispatched.
+mParentTarget = nullptr;
+}
+virtual void UpdateParentTarget() = 0;
+// Helper for creating performance objects.
+void CreatePerformanceObjectIfNeeded();
+// These two variables are special in that they're set to the same
+// value on both the outer window and the current inner window. Make
+// sure you keep them in sync!
+nsCOMPtr<mozilla::dom::EventTarget> mChromeEventHandler; // strong
+nsCOMPtr<nsIDocument> mDoc; // strong
+// Cache the URI when mDoc is cleared.
+nsCOMPtr<nsIURI> mDocumentURI; // strong
+nsCOMPtr<nsIURI> mDocBaseURI; // strong
+nsCOMPtr<mozilla::dom::EventTarget> mParentTarget; // strong
+// These members are only used on outer windows.
+nsCOMPtr<mozilla::dom::Element> mFrameElement;
+nsIDocShell           *mDocShell;  // Weak Reference
+// mPerformance is only used on inner windows.
+nsRefPtr<nsPerformance>       mPerformance;
+uint32_t               mModalStateDepth;
+// These variables are only used on inner windows.
+nsTimeout             *mRunningTimeout;
+uint32_t               mMutationBits;
+bool                   mIsDocumentLoaded;
+bool                   mIsHandlingResizeEvent;
+bool                   mIsInnerWindow;
+bool                   mMayHavePaintEventListener;
+bool                   mMayHaveTouchEventListener;
+bool                   mMayHaveMouseEnterLeaveEventListener;
+bool                   mMayHavePointerEnterLeaveEventListener;
+// This variable is used on both inner and outer windows (and they
+// should match).
+bool                   mIsModalContentWindow;
+// Tracks activation state that's used for :-moz-window-inactive.
+// Only used on outer windows.
+bool                   mIsActive;
+// Tracks whether our docshell is active.  If it is, mIsBackground
+// is false.  Too bad we have so many different concepts of
+// "active".  Only used on outer windows.
+bool                   mIsBackground;
+bool                   mAudioMuted;
+float                  mAudioVolume;
+// And these are the references between inner and outer windows.
+nsPIDOMWindow         *mInnerWindow;
+nsCOMPtr<nsPIDOMWindow> mOuterWindow;
+// the element within the document that is currently focused when this
+// window is active
+nsCOMPtr<nsIContent> mFocusedNode;
+// The AudioContexts created for the current document, if any.
+nsTArray<mozilla::dom::AudioContext*> mAudioContexts; // Weak
+// A unique (as long as our 64-bit counter doesn't roll over) id for
+// this window.
+uint64_t mWindowID;
+// This is only used by the inner window. Set to true once we've sent
+// the (chrome|content)-document-global-created notification.
+bool mHasNotifiedGlobalCreated;
+uint32_t mMarkedCCGeneration;
+};
+NS_DEFINE_STATIC_IID_ACCESSOR(nsPIDOMWindow, NS_PIDOMWINDOW_IID)
+#ifdef MOZILLA_INTERNAL_API
+PopupControlState
+PushPopupControlState(PopupControlState aState, bool aForce);
+void
+PopPopupControlState(PopupControlState aState);
+#define NS_AUTO_POPUP_STATE_PUSHER nsAutoPopupStatePusherInternal
+#else
+#define NS_AUTO_POPUP_STATE_PUSHER nsAutoPopupStatePusherExternal
+#endif
+// Helper class that helps with pushing and popping popup control
+// state. Note that this class looks different from within code that's
+// part of the layout library than it does in code outside the layout
+// library.  We give the two object layouts different names so the symbols
+// don't conflict, but code should always use the name
+// |nsAutoPopupStatePusher|.
+class NS_AUTO_POPUP_STATE_PUSHER
+{
+public:
+#ifdef MOZILLA_INTERNAL_API
+NS_AUTO_POPUP_STATE_PUSHER(PopupControlState aState, bool aForce = false)
+: mOldState(::PushPopupControlState(aState, aForce))
+{
+}
+~NS_AUTO_POPUP_STATE_PUSHER()
+{
+PopPopupControlState(mOldState);
+}
+#else
+NS_AUTO_POPUP_STATE_PUSHER(nsPIDOMWindow *aWindow, PopupControlState aState)
+: mWindow(aWindow), mOldState(openAbused)
+{
+if (aWindow) {
+mOldState = aWindow->PushPopupControlState(aState, false);
+}
+}
+~NS_AUTO_POPUP_STATE_PUSHER()
+{
+if (mWindow) {
+mWindow->PopPopupControlState(mOldState);
+}
+}
+#endif
+protected:
+#ifndef MOZILLA_INTERNAL_API
+nsCOMPtr<nsPIDOMWindow> mWindow;
+#endif
+PopupControlState mOldState;
+private:
+// Hide so that this class can only be stack-allocated
+static void* operator new(size_t /*size*/) CPP_THROW_NEW { return nullptr; }
+static void operator delete(void* /*memory*/) {}
+};
+#define nsAutoPopupStatePusher NS_AUTO_POPUP_STATE_PUSHER
+#endif // nsPIDOMWindow_h__

The Tor Browser / file comparison

comparison: dom/base/nsPIDOMWindow.h

dom/base/nsPIDOMWindow.h