diff options
Diffstat (limited to 'dom/base/nsGlobalWindow.h')
| -rw-r--r-- | dom/base/nsGlobalWindow.h | 2141 |
1 files changed, 2141 insertions, 0 deletions
diff --git a/dom/base/nsGlobalWindow.h b/dom/base/nsGlobalWindow.h new file mode 100644 index 000000000..eab91c2e4 --- /dev/null +++ b/dom/base/nsGlobalWindow.h @@ -0,0 +1,2141 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=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/. */ + +#ifndef nsGlobalWindow_h___ +#define nsGlobalWindow_h___ + +#include "nsPIDOMWindow.h" + +#include "nsTHashtable.h" +#include "nsHashKeys.h" +#include "nsRefPtrHashtable.h" +#include "nsInterfaceHashtable.h" + +// Local Includes +// Helper Classes +#include "nsCOMPtr.h" +#include "nsAutoPtr.h" +#include "nsWeakReference.h" +#include "nsDataHashtable.h" +#include "nsJSThingHashtable.h" +#include "nsCycleCollectionParticipant.h" + +// Interfaces Needed +#include "nsIBrowserDOMWindow.h" +#include "nsIDOMEventTarget.h" +#include "nsIInterfaceRequestor.h" +#include "nsIDOMChromeWindow.h" +#include "nsIScriptGlobalObject.h" +#include "nsIScriptObjectPrincipal.h" +#include "nsITimer.h" +#include "nsIDOMModalContentWindow.h" +#include "mozilla/EventListenerManager.h" +#include "nsIPrincipal.h" +#include "nsSize.h" +#include "mozFlushType.h" +#include "prclist.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/dom/StorageEvent.h" +#include "mozilla/dom/StorageEventBinding.h" +#include "mozilla/dom/UnionTypes.h" +#include "mozilla/ErrorResult.h" +#include "nsFrameMessageManager.h" +#include "mozilla/Attributes.h" +#include "mozilla/GuardObjects.h" +#include "mozilla/LinkedList.h" +#include "mozilla/TimeStamp.h" +#include "nsWrapperCacheInlines.h" +#include "nsIIdleObserver.h" +#include "nsIDocument.h" +#include "mozilla/dom/EventTarget.h" +#include "mozilla/dom/WindowBinding.h" +#include "Units.h" +#include "nsComponentManagerUtils.h" +#include "nsSize.h" +#include "nsCheapSets.h" +#include "mozilla/dom/ImageBitmapSource.h" +#include "mozilla/dom/Timeout.h" + +#define DEFAULT_HOME_PAGE "www.mozilla.org" +#define PREF_BROWSER_STARTUP_HOMEPAGE "browser.startup.homepage" + +// Amount of time allowed between alert/prompt/confirm before enabling +// the stop dialog checkbox. +#define DEFAULT_SUCCESSIVE_DIALOG_TIME_LIMIT 3 // 3 sec + +// Maximum number of successive dialogs before we prompt users to disable +// dialogs for this window. +#define MAX_SUCCESSIVE_DIALOG_COUNT 5 + +// Idle fuzz time upper limit +#define MAX_IDLE_FUZZ_TIME_MS 90000 + +// Min idle notification time in seconds. +#define MIN_IDLE_NOTIFICATION_TIME_S 1 + +class nsIArray; +class nsIBaseWindow; +class nsIContent; +class nsICSSDeclaration; +class nsIDocShellTreeOwner; +class nsIDOMOfflineResourceList; +class nsIScrollableFrame; +class nsIControllers; +class nsIJSID; +class nsIScriptContext; +class nsIScriptTimeoutHandler; +class nsITimeoutHandler; +class nsIWebBrowserChrome; +class mozIDOMWindowProxy; + +class nsDOMWindowList; +class nsScreen; +class nsHistory; +class nsGlobalWindowObserver; +class nsGlobalWindow; +class nsDOMWindowUtils; +class nsIIdleService; +struct nsRect; + +class nsWindowSizes; + +namespace mozilla { +class DOMEventTargetHelper; +class ThrottledEventQueue; +namespace dom { +class BarProp; +struct ChannelPixelLayout; +class Console; +class Crypto; +class CustomElementRegistry; +class DocGroup; +class External; +class Function; +class Gamepad; +enum class ImageBitmapFormat : uint32_t; +class IdleRequest; +class IdleRequestCallback; +class Location; +class MediaQueryList; +class MozSelfSupport; +class Navigator; +class OwningExternalOrWindowProxy; +class Promise; +class PostMessageEvent; +struct RequestInit; +class RequestOrUSVString; +class Selection; +class SpeechSynthesis; +class TabGroup; +class Timeout; +class U2F; +class VRDisplay; +class VREventObserver; +class WakeLock; +#if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GONK) +class WindowOrientationObserver; +#endif +class Worklet; +namespace cache { +class CacheStorage; +} // namespace cache +class IDBFactory; +} // namespace dom +} // namespace mozilla + +extern already_AddRefed<nsIScriptTimeoutHandler> +NS_CreateJSTimeoutHandler(JSContext* aCx, nsGlobalWindow *aWindow, + mozilla::dom::Function& aFunction, + const mozilla::dom::Sequence<JS::Value>& aArguments, + mozilla::ErrorResult& aError); + +extern already_AddRefed<nsIScriptTimeoutHandler> +NS_CreateJSTimeoutHandler(JSContext* aCx, nsGlobalWindow *aWindow, + const nsAString& aExpression, + mozilla::ErrorResult& aError); + +extern const js::Class OuterWindowProxyClass; + +struct IdleObserverHolder +{ + nsCOMPtr<nsIIdleObserver> mIdleObserver; + uint32_t mTimeInS; + bool mPrevNotificationIdle; + + IdleObserverHolder() + : mTimeInS(0), mPrevNotificationIdle(false) + { + MOZ_COUNT_CTOR(IdleObserverHolder); + } + + IdleObserverHolder(const IdleObserverHolder& aOther) + : mIdleObserver(aOther.mIdleObserver), mTimeInS(aOther.mTimeInS), + mPrevNotificationIdle(aOther.mPrevNotificationIdle) + { + MOZ_COUNT_CTOR(IdleObserverHolder); + } + + bool operator==(const IdleObserverHolder& aOther) const { + return + mIdleObserver == aOther.mIdleObserver && + mTimeInS == aOther.mTimeInS; + } + + ~IdleObserverHolder() + { + MOZ_COUNT_DTOR(IdleObserverHolder); + } +}; + +// Helper class to manage modal dialog arguments and all their quirks. +// +// Given our clunky embedding APIs, modal dialog arguments need to be passed +// as an nsISupports parameter to WindowWatcher, get stuck inside an array of +// length 1, and then passed back to the newly-created dialog. +// +// However, we need to track both the caller-passed value as well as the +// caller's, so that we can do an origin check (even for primitives) when the +// value is accessed. This class encapsulates that magic. +// +// We also use the same machinery for |returnValue|, which needs similar origin +// checks. +class DialogValueHolder final : public nsISupports +{ +public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_CLASS(DialogValueHolder) + + DialogValueHolder(nsIPrincipal* aSubject, nsIVariant* aValue) + : mOrigin(aSubject) + , mValue(aValue) {} + nsresult Get(nsIPrincipal* aSubject, nsIVariant** aResult); + void Get(JSContext* aCx, JS::Handle<JSObject*> aScope, nsIPrincipal* aSubject, + JS::MutableHandle<JS::Value> aResult, mozilla::ErrorResult& aError); +private: + virtual ~DialogValueHolder() {} + + nsCOMPtr<nsIPrincipal> mOrigin; + nsCOMPtr<nsIVariant> mValue; +}; + +//***************************************************************************** +// nsGlobalWindow: Global Object for Scripting +//***************************************************************************** +// Beware that all scriptable interfaces implemented by +// nsGlobalWindow will be reachable from JS, if you make this class +// implement new interfaces you better know what you're +// doing. Security wise this is very sensitive code. -- +// jst@netscape.com + +// nsGlobalWindow inherits PRCList for maintaining a list of all inner +// windows still in memory for any given outer window. This list is +// needed to ensure that mOuterWindow doesn't end up dangling. The +// nature of PRCList means that the window itself is always in the +// list, and an outer window's list will also contain all inner window +// objects that are still in memory (and in reality all inner window +// object's lists also contain its outer and all other inner windows +// belonging to the same outer window, but that's an unimportant +// side effect of inheriting PRCList). + +// NB: Currently nsPIDOMWindowInner and nsPIDOMWindowOuter are identical classes +// with identical member variables and identical vtables, that only differ in +// type name. nsGlobalWindow doesn't want to doubly inherit (and have two +// copies of everything), and it also doesn't want to privilege one over +// the other by making it possible to convert types through the C++ type system +// instead of our accessor methods (AsInner and AsOuter) that do dynamic +// checking. So we inherit from nsPIDOMWindow<nsISupports>, which is also +// identical to both nsPIDOMWindowInner and nsPIDOMWindowOuter, but not +// convertible to either. + +class nsGlobalWindow : public mozilla::dom::EventTarget, + public nsPIDOMWindow<nsISupports>, + private nsIDOMWindowInternal, + public nsIScriptGlobalObject, + public nsIScriptObjectPrincipal, + public nsSupportsWeakReference, + public nsIInterfaceRequestor, + public PRCListStr +{ +public: + typedef mozilla::TimeStamp TimeStamp; + typedef mozilla::TimeDuration TimeDuration; + typedef nsDataHashtable<nsUint64HashKey, nsGlobalWindow*> WindowByIdTable; + + static void + AssertIsOnMainThread() +#ifdef DEBUG + ; +#else + { } +#endif + + static nsGlobalWindow* Cast(nsPIDOMWindowInner* aPIWin) { + return static_cast<nsGlobalWindow*>( + reinterpret_cast<nsPIDOMWindow<nsISupports>*>(aPIWin)); + } + static const nsGlobalWindow* Cast(const nsPIDOMWindowInner* aPIWin) { + return static_cast<const nsGlobalWindow*>( + reinterpret_cast<const nsPIDOMWindow<nsISupports>*>(aPIWin)); + } + static nsGlobalWindow* Cast(mozIDOMWindow* aWin) { + return Cast(nsPIDOMWindowInner::From(aWin)); + } + static nsGlobalWindow* Cast(nsPIDOMWindowOuter* aPIWin) { + return static_cast<nsGlobalWindow*>( + reinterpret_cast<nsPIDOMWindow<nsISupports>*>(aPIWin)); + } + static nsGlobalWindow* Cast(mozIDOMWindowProxy* aWin) { + return Cast(nsPIDOMWindowOuter::From(aWin)); + } + + // public methods + nsPIDOMWindowOuter* GetPrivateParent(); + + // callback for close event + void ReallyCloseWindow(); + + // nsISupports + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + + // nsWrapperCache + virtual JSObject *WrapObject(JSContext *cx, JS::Handle<JSObject*> aGivenProto) override + { + return IsInnerWindow() || AsOuter()->EnsureInnerWindow() ? GetWrapper() : nullptr; + } + + // nsIGlobalJSObjectHolder + virtual JSObject* GetGlobalJSObject() override; + + // nsIScriptGlobalObject + JSObject *FastGetGlobalJSObject() const + { + return GetWrapperPreserveColor(); + } + + void TraceGlobalJSObject(JSTracer* aTrc); + + virtual nsresult EnsureScriptEnvironment() override; + + virtual nsIScriptContext *GetScriptContext() override; + + void PoisonOuterWindowProxy(JSObject *aObject); + + virtual bool IsBlackForCC(bool aTracingNeeded = true) override; + + // nsIScriptObjectPrincipal + virtual nsIPrincipal* GetPrincipal() override; + + // nsIDOMWindow + NS_DECL_NSIDOMWINDOW + + nsresult + OpenJS(const nsAString& aUrl, const nsAString& aName, + const nsAString& aOptions, nsPIDOMWindowOuter **_retval); + void CaptureEvents(); + void ReleaseEvents(); + void Dump(const nsAString& aStr); + void SetResizable(bool aResizable) const; + nsresult GetScriptableContent(JSContext* aCx, + JS::MutableHandle<JS::Value> aVal); + + // nsIDOMEventTarget + NS_DECL_NSIDOMEVENTTARGET + + virtual mozilla::EventListenerManager* + GetExistingListenerManager() const override; + + virtual mozilla::EventListenerManager* + GetOrCreateListenerManager() override; + + using mozilla::dom::EventTarget::RemoveEventListener; + virtual void AddEventListener(const nsAString& aType, + mozilla::dom::EventListener* aListener, + const mozilla::dom::AddEventListenerOptionsOrBoolean& aOptions, + const mozilla::dom::Nullable<bool>& aWantsUntrusted, + mozilla::ErrorResult& aRv) override; + virtual nsPIDOMWindowOuter* GetOwnerGlobalForBindings() override; + + virtual nsIGlobalObject* GetOwnerGlobal() const override + { + if (IsOuterWindow()) { + return GetCurrentInnerWindowInternal(); + } + + return const_cast<nsGlobalWindow*>(this); + } + + // nsPIDOMWindow + virtual nsPIDOMWindowOuter* GetPrivateRoot() override; + + // Outer windows only. + virtual void ActivateOrDeactivate(bool aActivate) override; + virtual void SetActive(bool aActive) override; + virtual bool IsTopLevelWindowActive() override; + virtual void SetIsBackground(bool aIsBackground) override; + virtual void SetChromeEventHandler(mozilla::dom::EventTarget* aChromeEventHandler) override; + + // Outer windows only. + virtual void SetInitialPrincipalToSubject() override; + + virtual PopupControlState PushPopupControlState(PopupControlState state, bool aForce) const override; + virtual void PopPopupControlState(PopupControlState state) const override; + virtual PopupControlState GetPopupControlState() const override; + + virtual already_AddRefed<nsISupports> SaveWindowState() override; + virtual nsresult RestoreWindowState(nsISupports *aState) override; + + virtual void Suspend(); + virtual void Resume(); + virtual bool IsSuspended() const override; + virtual void Freeze(); + virtual void Thaw(); + virtual bool IsFrozen() const override; + virtual void SyncStateFromParentWindow(); + + virtual nsresult FireDelayedDOMEvents() override; + virtual bool IsRunningTimeout() override { return mTimeoutFiringDepth > 0; } + + // Outer windows only. + virtual bool WouldReuseInnerWindow(nsIDocument* aNewDocument) override; + + virtual void SetDocShell(nsIDocShell* aDocShell) override; + virtual void DetachFromDocShell() override; + virtual nsresult SetNewDocument(nsIDocument *aDocument, + nsISupports *aState, + bool aForceReuseInnerWindow) override; + + // Outer windows only. + void DispatchDOMWindowCreated(); + + virtual void SetOpenerWindow(nsPIDOMWindowOuter* aOpener, + bool aOriginalOpener) override; + + // Outer windows only. + virtual void EnsureSizeUpToDate() override; + + virtual void EnterModalState() override; + virtual void LeaveModalState() override; + + // Outer windows only. + virtual bool CanClose() override; + virtual void ForceClose() override; + + virtual void MaybeUpdateTouchState() override; + + // Outer windows only. + virtual bool DispatchCustomEvent(const nsAString& aEventName) override; + bool DispatchResizeEvent(const mozilla::CSSIntSize& aSize); + + // Inner windows only. + void RefreshCompartmentPrincipal(); + + // For accessing protected field mFullScreen + friend class FullscreenTransitionTask; + + // Outer windows only. + virtual nsresult SetFullscreenInternal( + FullscreenReason aReason, bool aIsFullscreen) override final; + virtual void FinishFullscreenChange(bool aIsFullscreen) override final; + bool SetWidgetFullscreen(FullscreenReason aReason, bool aIsFullscreen, + nsIWidget* aWidget, nsIScreen* aScreen); + bool FullScreen() const; + + // Inner windows only. + virtual void SetHasGamepadEventListener(bool aHasGamepad = true) override; + void NotifyVREventListenerAdded(); + virtual void EventListenerAdded(nsIAtom* aType) override; + + // nsIInterfaceRequestor + NS_DECL_NSIINTERFACEREQUESTOR + + // WebIDL interface. + already_AddRefed<nsPIDOMWindowOuter> IndexedGetterOuter(uint32_t aIndex); + already_AddRefed<nsPIDOMWindowOuter> IndexedGetter(uint32_t aIndex); + + static bool IsPrivilegedChromeWindow(JSContext* /* unused */, JSObject* aObj); + + static bool IsShowModalDialogEnabled(JSContext* /* unused */ = nullptr, + JSObject* /* unused */ = nullptr); + + bool DoResolve(JSContext* aCx, JS::Handle<JSObject*> aObj, + JS::Handle<jsid> aId, + JS::MutableHandle<JS::PropertyDescriptor> aDesc); + // The return value is whether DoResolve might end up resolving the given id. + // If in doubt, return true. + static bool MayResolve(jsid aId); + + void GetOwnPropertyNames(JSContext* aCx, nsTArray<nsString>& aNames, + mozilla::ErrorResult& aRv); + + // Object Management + static already_AddRefed<nsGlobalWindow> Create(nsGlobalWindow *aOuterWindow); + + static nsGlobalWindow *FromSupports(nsISupports *supports) + { + // Make sure this matches the casts we do in QueryInterface(). + return (nsGlobalWindow *)(mozilla::dom::EventTarget *)supports; + } + static nsGlobalWindow *FromWrapper(nsIXPConnectWrappedNative *wrapper) + { + return FromSupports(wrapper->Native()); + } + already_AddRefed<nsPIDOMWindowOuter> GetTop() override; + nsPIDOMWindowOuter* GetScriptableTop() override; + inline nsGlobalWindow *GetTopInternal() + { + nsGlobalWindow* outer = IsOuterWindow() ? this : GetOuterWindowInternal(); + nsCOMPtr<nsPIDOMWindowOuter> top = outer ? outer->GetTop() : nullptr; + if (top) { + return nsGlobalWindow::Cast(top); + } + return nullptr; + } + + inline nsGlobalWindow* GetScriptableTopInternal() + { + nsPIDOMWindowOuter* top = GetScriptableTop(); + return nsGlobalWindow::Cast(top); + } + + nsPIDOMWindowOuter* GetChildWindow(const nsAString& aName); + + // These return true if we've reached the state in this top level window + // where we ask the user if further dialogs should be blocked. + // + // DialogsAreBeingAbused must be called on the scriptable top inner window. + // + // ShouldPromptToBlockDialogs is implemented in terms of + // DialogsAreBeingAbused, and will get the scriptable top inner window + // automatically. + // Outer windows only. + bool ShouldPromptToBlockDialogs(); + // Inner windows only. + bool DialogsAreBeingAbused(); + + // These functions are used for controlling and determining whether dialogs + // (alert, prompt, confirm) are currently allowed in this window. If you want + // to temporarily disable dialogs, please use TemporarilyDisableDialogs, not + // EnableDialogs/DisableDialogs, because correctly determining whether to + // re-enable dialogs is actually quite difficult. + void EnableDialogs(); + void DisableDialogs(); + // Outer windows only. + bool AreDialogsEnabled(); + + class MOZ_RAII TemporarilyDisableDialogs + { + public: + // Takes an inner _or_ outer window. + explicit TemporarilyDisableDialogs(nsGlobalWindow* aWindow + MOZ_GUARD_OBJECT_NOTIFIER_PARAM); + ~TemporarilyDisableDialogs(); + + private: + MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER + + // Always an inner window; this is the window whose dialog state we messed + // with. We just want to keep it alive, because we plan to poke at its + // members in our destructor. + RefPtr<nsGlobalWindow> mTopWindow; + // This is not a AutoRestore<bool> because that would require careful + // member destructor ordering, which is a bit fragile. This way we can + // explicitly restore things before we drop our ref to mTopWindow. + bool mSavedDialogsEnabled; + }; + friend class TemporarilyDisableDialogs; + + nsIScriptContext *GetContextInternal() + { + if (mOuterWindow) { + return GetOuterWindowInternal()->mContext; + } + + return mContext; + } + + nsGlobalWindow *GetOuterWindowInternal() + { + return nsGlobalWindow::Cast(GetOuterWindow()); + } + + nsGlobalWindow* GetCurrentInnerWindowInternal() const + { + MOZ_ASSERT(IsOuterWindow()); + return nsGlobalWindow::Cast(mInnerWindow); + } + + nsGlobalWindow* EnsureInnerWindowInternal() + { + return nsGlobalWindow::Cast(AsOuter()->EnsureInnerWindow()); + } + + bool IsCreatingInnerWindow() const + { + return mCreatingInnerWindow; + } + + bool IsChromeWindow() const + { + return mIsChrome; + } + + using nsPIDOMWindow::IsModalContentWindow; + static bool IsModalContentWindow(JSContext* aCx, JSObject* aGlobal); + + // GetScrollFrame does not flush. Callers should do it themselves as needed, + // depending on which info they actually want off the scrollable frame. + nsIScrollableFrame *GetScrollFrame(); + + nsresult Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData); + + // Outer windows only. + void UnblockScriptedClosing(); + + static void Init(); + static void ShutDown(); + static void CleanupCachedXBLHandlers(nsGlobalWindow* aWindow); + static bool IsCallerChrome(); + + friend class WindowStateHolder; + + NS_DECL_CYCLE_COLLECTION_SKIPPABLE_SCRIPT_HOLDER_CLASS_AMBIGUOUS(nsGlobalWindow, + nsIDOMEventTarget) + +#ifdef DEBUG + // Call Unlink on this window. This may cause bad things to happen, so use + // with caution. + void RiskyUnlink(); +#endif + + virtual JSObject* + GetCachedXBLPrototypeHandler(nsXBLPrototypeHandler* aKey) override; + + virtual void + CacheXBLPrototypeHandler(nsXBLPrototypeHandler* aKey, + JS::Handle<JSObject*> aHandler) override; + + virtual bool TakeFocus(bool aFocus, uint32_t aFocusMethod) override; + virtual void SetReadyForFocus() override; + virtual void PageHidden() override; + virtual nsresult DispatchAsyncHashchange(nsIURI *aOldURI, nsIURI *aNewURI) override; + virtual nsresult DispatchSyncPopState() override; + + // Inner windows only. + virtual void EnableDeviceSensor(uint32_t aType) override; + virtual void DisableDeviceSensor(uint32_t aType) override; + +#if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GONK) + virtual void EnableOrientationChangeListener() override; + virtual void DisableOrientationChangeListener() override; +#endif + + virtual void EnableTimeChangeNotifications() override; + virtual void DisableTimeChangeNotifications() override; + +#ifdef MOZ_B2G + // Inner windows only. + virtual void EnableNetworkEvent(mozilla::EventMessage aEventMessage) override; + virtual void DisableNetworkEvent( + mozilla::EventMessage aEventMessage) override; +#endif // MOZ_B2G + + virtual nsresult SetArguments(nsIArray* aArguments) override; + + void MaybeForgiveSpamCount(); + bool IsClosedOrClosing() { + return (mIsClosed || + mInClose || + mHavePendingClose || + mCleanedUp); + } + + bool + HadOriginalOpener() const + { + MOZ_ASSERT(IsOuterWindow()); + return mHadOriginalOpener; + } + + bool + IsTopLevelWindow() + { + MOZ_ASSERT(IsOuterWindow()); + nsPIDOMWindowOuter* parentWindow = GetScriptableTop(); + return parentWindow == this->AsOuter(); + } + + virtual void + FirePopupBlockedEvent(nsIDocument* aDoc, + nsIURI* aPopupURI, + const nsAString& aPopupWindowName, + const nsAString& aPopupWindowFeatures) override; + + virtual uint32_t GetSerial() override { + return mSerial; + } + + static nsGlobalWindow* GetOuterWindowWithId(uint64_t aWindowID) { + AssertIsOnMainThread(); + + if (!sWindowsById) { + return nullptr; + } + + nsGlobalWindow* outerWindow = sWindowsById->Get(aWindowID); + return outerWindow && !outerWindow->IsInnerWindow() ? outerWindow : nullptr; + } + + static nsGlobalWindow* GetInnerWindowWithId(uint64_t aInnerWindowID) { + AssertIsOnMainThread(); + + if (!sWindowsById) { + return nullptr; + } + + nsGlobalWindow* innerWindow = sWindowsById->Get(aInnerWindowID); + return innerWindow && innerWindow->IsInnerWindow() ? innerWindow : nullptr; + } + + static WindowByIdTable* GetWindowsTable() { + AssertIsOnMainThread(); + + return sWindowsById; + } + + void AddSizeOfIncludingThis(nsWindowSizes* aWindowSizes) const; + + void UnmarkGrayTimers(); + + // Inner windows only. + void AddEventTargetObject(mozilla::DOMEventTargetHelper* aObject); + void RemoveEventTargetObject(mozilla::DOMEventTargetHelper* aObject); + + void NotifyIdleObserver(IdleObserverHolder* aIdleObserverHolder, + bool aCallOnidle); + nsresult HandleIdleActiveEvent(); + bool ContainsIdleObserver(nsIIdleObserver* aIdleObserver, uint32_t timeInS); + void HandleIdleObserverCallback(); + + void AllowScriptsToClose() + { + mAllowScriptsToClose = true; + } + + enum SlowScriptResponse { + ContinueSlowScript = 0, + ContinueSlowScriptAndKeepNotifying, + AlwaysContinueSlowScript, + KillSlowScript + }; + SlowScriptResponse ShowSlowScriptDialog(); + +#ifdef MOZ_GAMEPAD + // Inner windows only. + void AddGamepad(uint32_t aIndex, mozilla::dom::Gamepad* aGamepad); + void RemoveGamepad(uint32_t aIndex); + void GetGamepads(nsTArray<RefPtr<mozilla::dom::Gamepad> >& aGamepads); + already_AddRefed<mozilla::dom::Gamepad> GetGamepad(uint32_t aIndex); + void SetHasSeenGamepadInput(bool aHasSeen); + bool HasSeenGamepadInput(); + void SyncGamepadState(); +#endif + + // Inner windows only. + // Enable/disable updates for gamepad input. + void EnableGamepadUpdates(); + void DisableGamepadUpdates(); + + // Inner windows only. + // Enable/disable updates for VR + void EnableVRUpdates(); + void DisableVRUpdates(); + + // Update the VR displays for this window + bool UpdateVRDisplays(nsTArray<RefPtr<mozilla::dom::VRDisplay>>& aDisplays); + + // Inner windows only. + // Called to inform that the set of active VR displays has changed. + void NotifyActiveVRDisplaysChanged(); + +#define EVENT(name_, id_, type_, struct_) \ + mozilla::dom::EventHandlerNonNull* GetOn##name_() \ + { \ + mozilla::EventListenerManager* elm = GetExistingListenerManager(); \ + return elm ? elm->GetEventHandler(nsGkAtoms::on##name_, EmptyString()) \ + : nullptr; \ + } \ + void SetOn##name_(mozilla::dom::EventHandlerNonNull* handler) \ + { \ + mozilla::EventListenerManager* elm = GetOrCreateListenerManager(); \ + if (elm) { \ + elm->SetEventHandler(nsGkAtoms::on##name_, EmptyString(), handler); \ + } \ + } +#define ERROR_EVENT(name_, id_, type_, struct_) \ + mozilla::dom::OnErrorEventHandlerNonNull* GetOn##name_() \ + { \ + mozilla::EventListenerManager* elm = GetExistingListenerManager(); \ + return elm ? elm->GetOnErrorEventHandler() : nullptr; \ + } \ + void SetOn##name_(mozilla::dom::OnErrorEventHandlerNonNull* handler) \ + { \ + mozilla::EventListenerManager* elm = GetOrCreateListenerManager(); \ + if (elm) { \ + elm->SetEventHandler(handler); \ + } \ + } +#define BEFOREUNLOAD_EVENT(name_, id_, type_, struct_) \ + mozilla::dom::OnBeforeUnloadEventHandlerNonNull* GetOn##name_() \ + { \ + mozilla::EventListenerManager* elm = GetExistingListenerManager(); \ + return elm ? elm->GetOnBeforeUnloadEventHandler() : nullptr; \ + } \ + void SetOn##name_(mozilla::dom::OnBeforeUnloadEventHandlerNonNull* handler) \ + { \ + mozilla::EventListenerManager* elm = GetOrCreateListenerManager(); \ + if (elm) { \ + elm->SetEventHandler(handler); \ + } \ + } +#define WINDOW_ONLY_EVENT EVENT +#define TOUCH_EVENT EVENT +#include "mozilla/EventNameList.h" +#undef TOUCH_EVENT +#undef WINDOW_ONLY_EVENT +#undef BEFOREUNLOAD_EVENT +#undef ERROR_EVENT +#undef EVENT + + nsISupports* GetParentObject() + { + return nullptr; + } + + static JSObject* + CreateNamedPropertiesObject(JSContext *aCx, JS::Handle<JSObject*> aProto); + + nsGlobalWindow* Window(); + nsGlobalWindow* Self(); + nsIDocument* GetDocument() + { + return GetDoc(); + } + void GetNameOuter(nsAString& aName); + void GetName(nsAString& aName, mozilla::ErrorResult& aError); + void SetNameOuter(const nsAString& aName, mozilla::ErrorResult& aError); + void SetName(const nsAString& aName, mozilla::ErrorResult& aError); + mozilla::dom::Location* GetLocation(mozilla::ErrorResult& aError); + nsIDOMLocation* GetLocation() override; + nsHistory* GetHistory(mozilla::ErrorResult& aError); + mozilla::dom::CustomElementRegistry* CustomElements() override; + mozilla::dom::BarProp* GetLocationbar(mozilla::ErrorResult& aError); + mozilla::dom::BarProp* GetMenubar(mozilla::ErrorResult& aError); + mozilla::dom::BarProp* GetPersonalbar(mozilla::ErrorResult& aError); + mozilla::dom::BarProp* GetScrollbars(mozilla::ErrorResult& aError); + mozilla::dom::BarProp* GetStatusbar(mozilla::ErrorResult& aError); + mozilla::dom::BarProp* GetToolbar(mozilla::ErrorResult& aError); + void GetStatusOuter(nsAString& aStatus); + void GetStatus(nsAString& aStatus, mozilla::ErrorResult& aError); + void SetStatusOuter(const nsAString& aStatus); + void SetStatus(const nsAString& aStatus, mozilla::ErrorResult& aError); + void CloseOuter(bool aTrustedCaller); + void Close(mozilla::ErrorResult& aError); + nsresult Close() override; + bool GetClosedOuter(); + bool GetClosed(mozilla::ErrorResult& aError); + bool Closed() override; + void StopOuter(mozilla::ErrorResult& aError); + void Stop(mozilla::ErrorResult& aError); + void FocusOuter(mozilla::ErrorResult& aError); + void Focus(mozilla::ErrorResult& aError); + nsresult Focus() override; + void BlurOuter(); + void Blur(mozilla::ErrorResult& aError); + already_AddRefed<nsPIDOMWindowOuter> GetFramesOuter(); + already_AddRefed<nsIDOMWindowCollection> GetFrames() override; + already_AddRefed<nsPIDOMWindowOuter> GetFrames(mozilla::ErrorResult& aError); + uint32_t Length(); + already_AddRefed<nsPIDOMWindowOuter> GetTopOuter(); + already_AddRefed<nsPIDOMWindowOuter> GetTop(mozilla::ErrorResult& aError); + + nsresult GetPrompter(nsIPrompt** aPrompt) override; +protected: + explicit nsGlobalWindow(nsGlobalWindow *aOuterWindow); + nsPIDOMWindowOuter* GetOpenerWindowOuter(); + // Initializes the mWasOffline member variable + void InitWasOffline(); +public: + nsPIDOMWindowOuter* + GetSanitizedOpener(nsPIDOMWindowOuter* aOpener); + + nsPIDOMWindowOuter* GetOpenerWindow(mozilla::ErrorResult& aError); + void GetOpener(JSContext* aCx, JS::MutableHandle<JS::Value> aRetval, + mozilla::ErrorResult& aError); + already_AddRefed<nsPIDOMWindowOuter> GetOpener() override; + void SetOpener(JSContext* aCx, JS::Handle<JS::Value> aOpener, + mozilla::ErrorResult& aError); + already_AddRefed<nsPIDOMWindowOuter> GetParentOuter(); + already_AddRefed<nsPIDOMWindowOuter> GetParent(mozilla::ErrorResult& aError); + already_AddRefed<nsPIDOMWindowOuter> GetParent() override; + nsPIDOMWindowOuter* GetScriptableParent() override; + nsPIDOMWindowOuter* GetScriptableParentOrNull() override; + mozilla::dom::Element* + GetFrameElementOuter(nsIPrincipal& aSubjectPrincipal); + mozilla::dom::Element* + GetFrameElement(nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + already_AddRefed<nsIDOMElement> GetFrameElement() override; + already_AddRefed<nsPIDOMWindowOuter> + OpenOuter(const nsAString& aUrl, + const nsAString& aName, + const nsAString& aOptions, + mozilla::ErrorResult& aError); + already_AddRefed<nsPIDOMWindowOuter> + Open(const nsAString& aUrl, + const nsAString& aName, + const nsAString& aOptions, + mozilla::ErrorResult& aError); + nsresult Open(const nsAString& aUrl, const nsAString& aName, + const nsAString& aOptions, + nsIDocShellLoadInfo* aLoadInfo, + bool aForceNoOpener, + nsPIDOMWindowOuter **_retval) override; + mozilla::dom::Navigator* GetNavigator(mozilla::ErrorResult& aError); + nsIDOMNavigator* GetNavigator() override; + nsIDOMOfflineResourceList* GetApplicationCache(mozilla::ErrorResult& aError); + already_AddRefed<nsIDOMOfflineResourceList> GetApplicationCache() override; + +#if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GONK) + int16_t Orientation(mozilla::dom::CallerType aCallerType) const; +#endif + + mozilla::dom::Console* GetConsole(mozilla::ErrorResult& aRv); + + // https://w3c.github.io/webappsec-secure-contexts/#dom-window-issecurecontext + bool IsSecureContext() const; + bool IsSecureContextIfOpenerIgnored() const; + + void GetSidebar(mozilla::dom::OwningExternalOrWindowProxy& aResult, + mozilla::ErrorResult& aRv); + already_AddRefed<mozilla::dom::External> GetExternal(mozilla::ErrorResult& aRv); + + // Exposed only for testing + static bool + TokenizeDialogOptions(nsAString& aToken, nsAString::const_iterator& aIter, + nsAString::const_iterator aEnd); + static void + ConvertDialogOptions(const nsAString& aOptions, nsAString& aResult); + + // Exposed only for testing + already_AddRefed<mozilla::dom::Worklet> + CreateWorklet(mozilla::ErrorResult& aRv); + +protected: + bool AlertOrConfirm(bool aAlert, const nsAString& aMessage, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + +public: + void Alert(nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + void AlertOuter(const nsAString& aMessage, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + void Alert(const nsAString& aMessage, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + bool ConfirmOuter(const nsAString& aMessage, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + bool Confirm(const nsAString& aMessage, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + void PromptOuter(const nsAString& aMessage, const nsAString& aInitial, + nsAString& aReturn, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + void Prompt(const nsAString& aMessage, const nsAString& aInitial, + nsAString& aReturn, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + already_AddRefed<mozilla::dom::cache::CacheStorage> GetCaches(mozilla::ErrorResult& aRv); + already_AddRefed<mozilla::dom::Promise> Fetch(const mozilla::dom::RequestOrUSVString& aInput, + const mozilla::dom::RequestInit& aInit, + mozilla::ErrorResult& aRv); + void PrintOuter(mozilla::ErrorResult& aError); + void Print(mozilla::ErrorResult& aError); + void ShowModalDialog(JSContext* aCx, const nsAString& aUrl, + JS::Handle<JS::Value> aArgument, + const nsAString& aOptions, + JS::MutableHandle<JS::Value> aRetval, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + void PostMessageMoz(JSContext* aCx, JS::Handle<JS::Value> aMessage, + const nsAString& aTargetOrigin, + const mozilla::dom::Optional<mozilla::dom::Sequence<JS::Value > >& aTransfer, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + int32_t SetTimeout(JSContext* aCx, mozilla::dom::Function& aFunction, + int32_t aTimeout, + const mozilla::dom::Sequence<JS::Value>& aArguments, + mozilla::ErrorResult& aError); + int32_t SetTimeout(JSContext* aCx, const nsAString& aHandler, + int32_t aTimeout, + const mozilla::dom::Sequence<JS::Value>& /* unused */, + mozilla::ErrorResult& aError); + void ClearTimeout(int32_t aHandle); + int32_t SetInterval(JSContext* aCx, mozilla::dom::Function& aFunction, + const mozilla::dom::Optional<int32_t>& aTimeout, + const mozilla::dom::Sequence<JS::Value>& aArguments, + mozilla::ErrorResult& aError); + int32_t SetInterval(JSContext* aCx, const nsAString& aHandler, + const mozilla::dom::Optional<int32_t>& aTimeout, + const mozilla::dom::Sequence<JS::Value>& /* unused */, + mozilla::ErrorResult& aError); + void ClearInterval(int32_t aHandle); + void Atob(const nsAString& aAsciiBase64String, nsAString& aBinaryData, + mozilla::ErrorResult& aError); + void Btoa(const nsAString& aBinaryData, nsAString& aAsciiBase64String, + mozilla::ErrorResult& aError); + mozilla::dom::DOMStorage* GetSessionStorage(mozilla::ErrorResult& aError); + mozilla::dom::DOMStorage* + GetLocalStorage(mozilla::ErrorResult& aError); + mozilla::dom::Selection* GetSelectionOuter(); + mozilla::dom::Selection* GetSelection(mozilla::ErrorResult& aError); + already_AddRefed<nsISelection> GetSelection() override; + mozilla::dom::IDBFactory* GetIndexedDB(mozilla::ErrorResult& aError); + already_AddRefed<nsICSSDeclaration> + GetComputedStyle(mozilla::dom::Element& aElt, const nsAString& aPseudoElt, + mozilla::ErrorResult& aError) override; + already_AddRefed<mozilla::dom::MediaQueryList> MatchMediaOuter(const nsAString& aQuery); + already_AddRefed<mozilla::dom::MediaQueryList> MatchMedia(const nsAString& aQuery, + mozilla::ErrorResult& aError); + nsScreen* GetScreen(mozilla::ErrorResult& aError); + nsIDOMScreen* GetScreen() override; + void MoveToOuter(int32_t aXPos, int32_t aYPos, mozilla::ErrorResult& aError, bool aCallerIsChrome); + void MoveTo(int32_t aXPos, int32_t aYPos, mozilla::ErrorResult& aError); + void MoveByOuter(int32_t aXDif, int32_t aYDif, mozilla::ErrorResult& aError, bool aCallerIsChrome); + void MoveBy(int32_t aXDif, int32_t aYDif, mozilla::ErrorResult& aError); + nsresult MoveBy(int32_t aXDif, int32_t aYDif) override; + void ResizeToOuter(int32_t aWidth, int32_t aHeight, mozilla::ErrorResult& aError, bool aCallerIsChrome); + void ResizeTo(int32_t aWidth, int32_t aHeight, + mozilla::ErrorResult& aError); + void ResizeByOuter(int32_t aWidthDif, int32_t aHeightDif, mozilla::ErrorResult& aError, bool aCallerIsChrome); + void ResizeBy(int32_t aWidthDif, int32_t aHeightDif, + mozilla::ErrorResult& aError); + void Scroll(double aXScroll, double aYScroll); + void Scroll(const mozilla::dom::ScrollToOptions& aOptions); + void ScrollTo(double aXScroll, double aYScroll); + void ScrollTo(const mozilla::dom::ScrollToOptions& aOptions); + void ScrollBy(double aXScrollDif, double aYScrollDif); + void ScrollBy(const mozilla::dom::ScrollToOptions& aOptions); + void ScrollByLines(int32_t numLines, + const mozilla::dom::ScrollOptions& aOptions); + void ScrollByPages(int32_t numPages, + const mozilla::dom::ScrollOptions& aOptions); + void MozScrollSnap(); + void GetInnerWidth(JSContext* aCx, JS::MutableHandle<JS::Value> aValue, + mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + void SetInnerWidth(JSContext* aCx, JS::Handle<JS::Value> aValue, + mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + void GetInnerHeight(JSContext* aCx, JS::MutableHandle<JS::Value> aValue, + mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + void SetInnerHeight(JSContext* aCx, JS::Handle<JS::Value> aValue, + mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + int32_t GetScrollXOuter(); + int32_t GetScrollX(mozilla::ErrorResult& aError); + int32_t GetPageXOffset(mozilla::ErrorResult& aError) + { + return GetScrollX(aError); + } + int32_t GetScrollYOuter(); + int32_t GetScrollY(mozilla::ErrorResult& aError); + int32_t GetPageYOffset(mozilla::ErrorResult& aError) + { + return GetScrollY(aError); + } + void MozRequestOverfill(mozilla::dom::OverfillCallback& aCallback, mozilla::ErrorResult& aError); + void GetScreenX(JSContext* aCx, JS::MutableHandle<JS::Value> aValue, + mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + void SetScreenX(JSContext* aCx, JS::Handle<JS::Value> aValue, + mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + void GetScreenY(JSContext* aCx, JS::MutableHandle<JS::Value> aValue, + mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + void SetScreenY(JSContext* aCx, JS::Handle<JS::Value> aValue, + mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + void GetOuterWidth(JSContext* aCx, JS::MutableHandle<JS::Value> aValue, + mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + void SetOuterWidth(JSContext* aCx, JS::Handle<JS::Value> aValue, + mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + void GetOuterHeight(JSContext* aCx, JS::MutableHandle<JS::Value> aValue, + mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + void SetOuterHeight(JSContext* aCx, JS::Handle<JS::Value> aValue, + mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + int32_t RequestAnimationFrame(mozilla::dom::FrameRequestCallback& aCallback, + mozilla::ErrorResult& aError); + void CancelAnimationFrame(int32_t aHandle, mozilla::ErrorResult& aError); + + uint32_t RequestIdleCallback(JSContext* aCx, + mozilla::dom::IdleRequestCallback& aCallback, + const mozilla::dom::IdleRequestOptions& aOptions, + mozilla::ErrorResult& aError); + void CancelIdleCallback(uint32_t aHandle); + + +#ifdef MOZ_WEBSPEECH + mozilla::dom::SpeechSynthesis* + GetSpeechSynthesis(mozilla::ErrorResult& aError); + bool HasActiveSpeechSynthesis(); +#endif + already_AddRefed<nsICSSDeclaration> + GetDefaultComputedStyle(mozilla::dom::Element& aElt, + const nsAString& aPseudoElt, + mozilla::ErrorResult& aError); + void SizeToContentOuter(mozilla::ErrorResult& aError, bool aCallerIsChrome); + void SizeToContent(mozilla::ErrorResult& aError); + mozilla::dom::Crypto* GetCrypto(mozilla::ErrorResult& aError); + mozilla::dom::U2F* GetU2f(mozilla::ErrorResult& aError); + nsIControllers* GetControllersOuter(mozilla::ErrorResult& aError); + nsIControllers* GetControllers(mozilla::ErrorResult& aError); + nsresult GetControllers(nsIControllers** aControllers) override; + mozilla::dom::Element* GetRealFrameElementOuter(); + mozilla::dom::Element* GetRealFrameElement(mozilla::ErrorResult& aError); + float GetMozInnerScreenXOuter(mozilla::dom::CallerType aCallerType); + float GetMozInnerScreenX(mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + float GetMozInnerScreenYOuter(mozilla::dom::CallerType aCallerType); + float GetMozInnerScreenY(mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + float GetDevicePixelRatioOuter(mozilla::dom::CallerType aCallerType); + float GetDevicePixelRatio(mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + int32_t GetScrollMinX(mozilla::ErrorResult& aError); + int32_t GetScrollMinY(mozilla::ErrorResult& aError); + int32_t GetScrollMaxX(mozilla::ErrorResult& aError); + int32_t GetScrollMaxY(mozilla::ErrorResult& aError); + bool GetFullScreenOuter(); + bool GetFullScreen(mozilla::ErrorResult& aError); + bool GetFullScreen() override; + void SetFullScreenOuter(bool aFullScreen, mozilla::ErrorResult& aError); + void SetFullScreen(bool aFullScreen, mozilla::ErrorResult& aError); + nsresult SetFullScreen(bool aFullScreen) override; + void BackOuter(mozilla::ErrorResult& aError); + void Back(mozilla::ErrorResult& aError); + void ForwardOuter(mozilla::ErrorResult& aError); + void Forward(mozilla::ErrorResult& aError); + void HomeOuter(mozilla::ErrorResult& aError); + void Home(mozilla::ErrorResult& aError); + bool FindOuter(const nsAString& aString, bool aCaseSensitive, bool aBackwards, + bool aWrapAround, bool aWholeWord, bool aSearchInFrames, + bool aShowDialog, mozilla::ErrorResult& aError); + bool Find(const nsAString& aString, bool aCaseSensitive, bool aBackwards, + bool aWrapAround, bool aWholeWord, bool aSearchInFrames, + bool aShowDialog, mozilla::ErrorResult& aError); + uint64_t GetMozPaintCountOuter(); + uint64_t GetMozPaintCount(mozilla::ErrorResult& aError); + + bool ShouldResistFingerprinting(); + + mozilla::dom::MozSelfSupport* GetMozSelfSupport(mozilla::ErrorResult& aError); + + already_AddRefed<nsPIDOMWindowOuter> + OpenDialogOuter(JSContext* aCx, + const nsAString& aUrl, + const nsAString& aName, + const nsAString& aOptions, + const mozilla::dom::Sequence<JS::Value>& aExtraArgument, + mozilla::ErrorResult& aError); + already_AddRefed<nsPIDOMWindowOuter> + OpenDialog(JSContext* aCx, + const nsAString& aUrl, + const nsAString& aName, + const nsAString& aOptions, + const mozilla::dom::Sequence<JS::Value>& aExtraArgument, + mozilla::ErrorResult& aError); + nsresult OpenDialog(const nsAString& aUrl, const nsAString& aName, + const nsAString& aOptions, + nsISupports* aExtraArgument, + nsPIDOMWindowOuter** _retval) override; + nsresult UpdateCommands(const nsAString& anAction, nsISelection* aSel, int16_t aReason) override; + + mozilla::ThrottledEventQueue* GetThrottledEventQueue() override; + + already_AddRefed<nsPIDOMWindowOuter> + GetContentInternal(mozilla::ErrorResult& aError, bool aUnprivilegedCaller); + void GetContentOuter(JSContext* aCx, + JS::MutableHandle<JSObject*> aRetval, + mozilla::ErrorResult& aError); + void GetContent(JSContext* aCx, + JS::MutableHandle<JSObject*> aRetval, + mozilla::ErrorResult& aError); + already_AddRefed<nsPIDOMWindowOuter> GetContent() + { + MOZ_ASSERT(IsOuterWindow()); + mozilla::ErrorResult ignored; + nsCOMPtr<nsPIDOMWindowOuter> win = + GetContentInternal(ignored, /* aUnprivilegedCaller = */ false); + ignored.SuppressException(); + return win.forget(); + } + + void Get_content(JSContext* aCx, + JS::MutableHandle<JSObject*> aRetval, + mozilla::ErrorResult& aError) + { + if (mDoc) { + mDoc->WarnOnceAbout(nsIDocument::eWindow_Content); + } + GetContent(aCx, aRetval, aError); + } + + already_AddRefed<mozilla::dom::Promise> + CreateImageBitmap(const mozilla::dom::ImageBitmapSource& aImage, + mozilla::ErrorResult& aRv); + + already_AddRefed<mozilla::dom::Promise> + CreateImageBitmap(const mozilla::dom::ImageBitmapSource& aImage, + int32_t aSx, int32_t aSy, int32_t aSw, int32_t aSh, + mozilla::ErrorResult& aRv); + + already_AddRefed<mozilla::dom::Promise> + CreateImageBitmap(const mozilla::dom::ImageBitmapSource& aImage, + int32_t aOffset, int32_t aLength, + mozilla::dom::ImageBitmapFormat aFormat, + const mozilla::dom::Sequence<mozilla::dom::ChannelPixelLayout>& aLayout, + mozilla::ErrorResult& aRv); + + + // ChromeWindow bits. Do NOT call these unless your window is in + // fact an nsGlobalChromeWindow. + uint16_t WindowState(); + nsIBrowserDOMWindow* GetBrowserDOMWindowOuter(); + nsIBrowserDOMWindow* GetBrowserDOMWindow(mozilla::ErrorResult& aError); + void SetBrowserDOMWindowOuter(nsIBrowserDOMWindow* aBrowserWindow); + void SetBrowserDOMWindow(nsIBrowserDOMWindow* aBrowserWindow, + mozilla::ErrorResult& aError); + void GetAttention(mozilla::ErrorResult& aError); + void GetAttentionWithCycleCount(int32_t aCycleCount, + mozilla::ErrorResult& aError); + void SetCursorOuter(const nsAString& aCursor, mozilla::ErrorResult& aError); + void SetCursor(const nsAString& aCursor, mozilla::ErrorResult& aError); + void Maximize(); + void Minimize(); + void Restore(); + void NotifyDefaultButtonLoaded(mozilla::dom::Element& aDefaultButton, + mozilla::ErrorResult& aError); + nsIMessageBroadcaster* GetMessageManager(mozilla::ErrorResult& aError); + nsIMessageBroadcaster* GetGroupMessageManager(const nsAString& aGroup, + mozilla::ErrorResult& aError); + void BeginWindowMove(mozilla::dom::Event& aMouseDownEvent, + mozilla::dom::Element* aPanel, + mozilla::ErrorResult& aError); + + void GetDialogArgumentsOuter(JSContext* aCx, JS::MutableHandle<JS::Value> aRetval, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + void GetDialogArguments(JSContext* aCx, JS::MutableHandle<JS::Value> aRetval, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + void GetReturnValueOuter(JSContext* aCx, JS::MutableHandle<JS::Value> aReturnValue, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + void GetReturnValue(JSContext* aCx, JS::MutableHandle<JS::Value> aReturnValue, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + void SetReturnValueOuter(JSContext* aCx, JS::Handle<JS::Value> aReturnValue, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + void SetReturnValue(JSContext* aCx, JS::Handle<JS::Value> aReturnValue, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + + void GetInterface(JSContext* aCx, nsIJSID* aIID, + JS::MutableHandle<JS::Value> aRetval, + mozilla::ErrorResult& aError); + + already_AddRefed<nsWindowRoot> GetWindowRootOuter(); + already_AddRefed<nsWindowRoot> GetWindowRoot(mozilla::ErrorResult& aError); + + mozilla::dom::Performance* GetPerformance(); +protected: + // Web IDL helpers + + // Redefine the property called aPropName on this window object to be a value + // property with the value aValue, much like we would do for a [Replaceable] + // property in IDL. + void RedefineProperty(JSContext* aCx, const char* aPropName, + JS::Handle<JS::Value> aValue, + mozilla::ErrorResult& aError); + + // Implementation guts for our writable IDL attributes that are really + // supposed to be readonly replaceable. + typedef int32_t + (nsGlobalWindow::*WindowCoordGetter)(mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult&); + typedef void (nsGlobalWindow::*WindowCoordSetter)(int32_t, + mozilla::ErrorResult&); + void GetReplaceableWindowCoord(JSContext* aCx, WindowCoordGetter aGetter, + JS::MutableHandle<JS::Value> aRetval, + mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + void SetReplaceableWindowCoord(JSContext* aCx, WindowCoordSetter aSetter, + JS::Handle<JS::Value> aValue, + const char* aPropName, + mozilla::ErrorResult& aError); + // And the implementations of WindowCoordGetter/WindowCoordSetter. +public: + int32_t GetInnerWidthOuter(mozilla::ErrorResult& aError); +protected: + int32_t GetInnerWidth(mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + nsresult GetInnerWidth(int32_t* aWidth) override; + void SetInnerWidthOuter(int32_t aInnerWidth, mozilla::ErrorResult& aError, bool aCallerIsChrome); + void SetInnerWidth(int32_t aInnerWidth, mozilla::ErrorResult& aError); +public: + int32_t GetInnerHeightOuter(mozilla::ErrorResult& aError); +protected: + int32_t GetInnerHeight(mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + nsresult GetInnerHeight(int32_t* aHeight) override; + void SetInnerHeightOuter(int32_t aInnerHeight, mozilla::ErrorResult& aError, bool aCallerIsChrome); + void SetInnerHeight(int32_t aInnerHeight, mozilla::ErrorResult& aError); + int32_t GetScreenXOuter(mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + int32_t GetScreenX(mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + void SetScreenXOuter(int32_t aScreenX, mozilla::ErrorResult& aError, bool aCallerIsChrome); + void SetScreenX(int32_t aScreenX, mozilla::ErrorResult& aError); + int32_t GetScreenYOuter(mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + int32_t GetScreenY(mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + void SetScreenYOuter(int32_t aScreenY, mozilla::ErrorResult& aError, bool aCallerIsChrome); + void SetScreenY(int32_t aScreenY, mozilla::ErrorResult& aError); + int32_t GetOuterWidthOuter(mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + int32_t GetOuterWidth(mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + void SetOuterWidthOuter(int32_t aOuterWidth, mozilla::ErrorResult& aError, bool aCallerIsChrome); + void SetOuterWidth(int32_t aOuterWidth, mozilla::ErrorResult& aError); + int32_t GetOuterHeightOuter(mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + int32_t GetOuterHeight(mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + void SetOuterHeightOuter(int32_t aOuterHeight, mozilla::ErrorResult& aError, bool aCallerIsChrome); + void SetOuterHeight(int32_t aOuterHeight, mozilla::ErrorResult& aError); + + // Array of idle observers that are notified of idle events. + nsTObserverArray<IdleObserverHolder> mIdleObservers; + + // Idle timer used for function callbacks to notify idle observers. + nsCOMPtr<nsITimer> mIdleTimer; + + // Idle fuzz time added to idle timer callbacks. + uint32_t mIdleFuzzFactor; + + // Index in mArrayIdleObservers + // Next idle observer to notify user idle status + int32_t mIdleCallbackIndex; + + // If false then the topic is "active" + // If true then the topic is "idle" + bool mCurrentlyIdle; + + // Set to true when a fuzz time needs to be applied + // to active notifications to the idle observer. + bool mAddActiveEventFuzzTime; + + nsCOMPtr <nsIIdleService> mIdleService; + + RefPtr<mozilla::dom::WakeLock> mWakeLock; + + static bool sIdleObserversAPIFuzzTimeDisabled; + + friend class HashchangeCallback; + friend class mozilla::dom::BarProp; + + // Object Management + virtual ~nsGlobalWindow(); + void DropOuterWindowDocs(); + void CleanUp(); + void ClearControllers(); + // Outer windows only. + void FinalClose(); + + inline void MaybeClearInnerWindow(nsGlobalWindow* aExpectedInner) + { + if(mInnerWindow == aExpectedInner->AsInner()) { + mInnerWindow = nullptr; + } + } + + void FreeInnerObjects(); + nsGlobalWindow *CallerInnerWindow(); + + // Only to be called on an inner window. + // aDocument must not be null. + void InnerSetNewDocument(JSContext* aCx, nsIDocument* aDocument); + + // Inner windows only. + nsresult DefineArgumentsProperty(nsIArray *aArguments); + + // Get the parent, returns null if this is a toplevel window + nsPIDOMWindowOuter* GetParentInternal(); + +public: + // popup tracking + bool IsPopupSpamWindow() + { + if (IsInnerWindow() && !mOuterWindow) { + return false; + } + + return GetOuterWindowInternal()->mIsPopupSpam; + } + + // Outer windows only. + void SetIsPopupSpamWindow(bool aIsPopupSpam); + +protected: + // Window Control Functions + + // Outer windows only. + virtual nsresult + OpenNoNavigate(const nsAString& aUrl, + const nsAString& aName, + const nsAString& aOptions, + nsPIDOMWindowOuter** _retval) override; + +private: + /** + * @param aUrl the URL we intend to load into the window. If aNavigate is + * true, we'll actually load this URL into the window. Otherwise, + * aUrl is advisory; OpenInternal will not load the URL into the + * new window. + * + * @param aName the name to use for the new window + * + * @param aOptions the window options to use for the new window + * + * @param aDialog true when called from variants of OpenDialog. If this is + * true, this method will skip popup blocking checks. The aDialog + * argument is passed on to the window watcher. + * + * @param aCalledNoScript true when called via the [noscript] open() + * and openDialog() methods. When this is true, we do NOT want to use + * the JS stack for things like caller determination. + * + * @param aDoJSFixups true when this is the content-accessible JS version of + * window opening. When true, popups do not cause us to throw, we save + * the caller's principal in the new window for later consumption, and + * we make sure that there is a document in the newly-opened window. + * Note that this last will only be done if the newly-opened window is + * non-chrome. + * + * @param aNavigate true if we should navigate to the provided URL, false + * otherwise. When aNavigate is false, we also skip our can-load + * security check, on the assumption that whoever *actually* loads this + * page will do their own security check. + * + * @param argv The arguments to pass to the new window. The first + * three args, if present, will be aUrl, aName, and aOptions. So this + * param only matters if there are more than 3 arguments. + * + * @param aExtraArgument Another way to pass arguments in. This is mutually + * exclusive with the argv approach. + * + * @param aLoadInfo to be passed on along to the windowwatcher. + * + * @param aForceNoOpener if true, will act as if "noopener" were passed in + * aOptions, but without affecting any other window + * features. + * + * @param aReturn [out] The window that was opened, if any. Will be null if + * aForceNoOpener is true of if aOptions contains + * "noopener". + * + * Outer windows only. + */ + nsresult OpenInternal(const nsAString& aUrl, + const nsAString& aName, + const nsAString& aOptions, + bool aDialog, + bool aContentModal, + bool aCalledNoScript, + bool aDoJSFixups, + bool aNavigate, + nsIArray *argv, + nsISupports *aExtraArgument, + nsIDocShellLoadInfo* aLoadInfo, + bool aForceNoOpener, + nsPIDOMWindowOuter **aReturn); + + template<typename Method> + void CallOnChildren(Method aMethod); + + void FreezeInternal(); + void ThawInternal(); + +public: + // Timeout Functions + // Language agnostic timeout function (all args passed). + // |interval| is in milliseconds. + nsresult SetTimeoutOrInterval(nsITimeoutHandler* aHandler, + int32_t interval, bool aIsInterval, + mozilla::dom::Timeout::Reason aReason, + int32_t* aReturn); + int32_t SetTimeoutOrInterval(JSContext* aCx, + mozilla::dom::Function& aFunction, + int32_t aTimeout, + const mozilla::dom::Sequence<JS::Value>& aArguments, + bool aIsInterval, mozilla::ErrorResult& aError); + int32_t SetTimeoutOrInterval(JSContext* aCx, const nsAString& aHandler, + int32_t aTimeout, bool aIsInterval, + mozilla::ErrorResult& aError); + void ClearTimeoutOrInterval(int32_t aTimerId, + mozilla::dom::Timeout::Reason aReason); + + // The timeout implementation functions. + void RunTimeout(mozilla::dom::Timeout* aTimeout); + void RunTimeout() { RunTimeout(nullptr); } + // Return true if |aTimeout| was cleared while its handler ran. + bool RunTimeoutHandler(mozilla::dom::Timeout* aTimeout, nsIScriptContext* aScx); + // Return true if |aTimeout| needs to be reinserted into the timeout list. + bool RescheduleTimeout(mozilla::dom::Timeout* aTimeout, const TimeStamp& now, + bool aRunningPendingTimeouts); + + void ClearAllTimeouts(); + // Insert aTimeout into the list, before all timeouts that would + // fire after it, but no earlier than mTimeoutInsertionPoint, if any. + void InsertTimeoutIntoList(mozilla::dom::Timeout* aTimeout); + uint32_t GetTimeoutId(mozilla::dom::Timeout::Reason aReason); + + // Helper Functions + already_AddRefed<nsIDocShellTreeOwner> GetTreeOwner(); + already_AddRefed<nsIBaseWindow> GetTreeOwnerWindow(); + already_AddRefed<nsIWebBrowserChrome> GetWebBrowserChrome(); + nsresult SecurityCheckURL(const char *aURL); + bool IsPrivateBrowsing(); + + bool PopupWhitelisted(); + PopupControlState RevisePopupAbuseLevel(PopupControlState); + void FireAbuseEvents(const nsAString &aPopupURL, + const nsAString &aPopupWindowName, + const nsAString &aPopupWindowFeatures); + void FireOfflineStatusEventIfChanged(); + + bool GetIsPrerendered(); + + // Inner windows only. + nsresult ScheduleNextIdleObserverCallback(); + uint32_t GetFuzzTimeMS(); + nsresult ScheduleActiveTimerCallback(); + uint32_t FindInsertionIndex(IdleObserverHolder* aIdleObserver); + virtual nsresult RegisterIdleObserver(nsIIdleObserver* aIdleObserverPtr) override; + nsresult FindIndexOfElementToRemove(nsIIdleObserver* aIdleObserver, + int32_t* aRemoveElementIndex); + virtual nsresult UnregisterIdleObserver(nsIIdleObserver* aIdleObserverPtr) override; + + // Inner windows only. + nsresult FireHashchange(const nsAString &aOldURL, const nsAString &aNewURL); + + void FlushPendingNotifications(mozFlushType aType); + + // Outer windows only. + void EnsureReflowFlushAndPaint(); + void CheckSecurityWidthAndHeight(int32_t* width, int32_t* height, bool aCallerIsChrome); + void CheckSecurityLeftAndTop(int32_t* left, int32_t* top, bool aCallerIsChrome); + + // Outer windows only. + // Arguments to this function should have values in app units + void SetCSSViewportWidthAndHeight(nscoord width, nscoord height); + // Arguments to this function should have values in device pixels + nsresult SetDocShellWidthAndHeight(int32_t width, int32_t height); + + static bool CanSetProperty(const char *aPrefName); + + static void MakeScriptDialogTitle(nsAString& aOutTitle, + nsIPrincipal* aSubjectPrincipal); + + // Outer windows only. + bool CanMoveResizeWindows(bool aCallerIsChrome); + + // If aDoFlush is true, we'll flush our own layout; otherwise we'll try to + // just flush our parent and only flush ourselves if we think we need to. + // Outer windows only. + mozilla::CSSIntPoint GetScrollXY(bool aDoFlush); + + int32_t GetScrollBoundaryOuter(mozilla::Side aSide); + + // Outer windows only. + nsresult GetInnerSize(mozilla::CSSIntSize& aSize); + nsIntSize GetOuterSize(mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + void SetOuterSize(int32_t aLengthCSSPixels, bool aIsWidth, + mozilla::ErrorResult& aError, bool aCallerIsChrome); + nsRect GetInnerScreenRect(); + + void ScrollTo(const mozilla::CSSIntPoint& aScroll, + const mozilla::dom::ScrollOptions& aOptions); + + bool IsFrame() + { + return GetParentInternal() != nullptr; + } + + // Outer windows only. + // If aLookForCallerOnJSStack is true, this method will look at the JS stack + // to determine who the caller is. If it's false, it'll use |this| as the + // caller. + bool WindowExists(const nsAString& aName, bool aForceNoOpener, + bool aLookForCallerOnJSStack); + + already_AddRefed<nsIWidget> GetMainWidget(); + nsIWidget* GetNearestWidget() const; + + bool IsInModalState(); + + // Convenience functions for the many methods that need to scale + // from device to CSS pixels or vice versa. Note: if a presentation + // context is not available, they will assume a 1:1 ratio. + int32_t DevToCSSIntPixels(int32_t px); + int32_t CSSToDevIntPixels(int32_t px); + nsIntSize DevToCSSIntPixels(nsIntSize px); + nsIntSize CSSToDevIntPixels(nsIntSize px); + + virtual void SetFocusedNode(nsIContent* aNode, + uint32_t aFocusMethod = 0, + bool aNeedsFocus = false) override; + + virtual uint32_t GetFocusMethod() override; + + virtual bool ShouldShowFocusRing() override; + + virtual void SetKeyboardIndicators(UIStateChangeType aShowAccelerators, + UIStateChangeType aShowFocusRings) override; + + // Inner windows only. + void UpdateCanvasFocus(bool aFocusChanged, nsIContent* aNewContent); + +public: + virtual already_AddRefed<nsPIWindowRoot> GetTopWindowRoot() override; + +protected: + static void NotifyDOMWindowDestroyed(nsGlobalWindow* aWindow); + void NotifyWindowIDDestroyed(const char* aTopic); + + static void NotifyDOMWindowFrozen(nsGlobalWindow* aWindow); + static void NotifyDOMWindowThawed(nsGlobalWindow* aWindow); + + void ClearStatus(); + + virtual void UpdateParentTarget() override; + + inline int32_t DOMMinTimeoutValue() const; + + void InitializeShowFocusRings(); + + // Clear the document-dependent slots on our JS wrapper. Inner windows only. + void ClearDocumentDependentSlots(JSContext* aCx); + + // Inner windows only. + already_AddRefed<mozilla::dom::StorageEvent> + CloneStorageEvent(const nsAString& aType, + const RefPtr<mozilla::dom::StorageEvent>& aEvent, + mozilla::ErrorResult& aRv); + +public: + // Outer windows only. + nsDOMWindowList* GetWindowList(); + +protected: + // Helper for getComputedStyle and getDefaultComputedStyle + already_AddRefed<nsICSSDeclaration> + GetComputedStyleHelperOuter(mozilla::dom::Element& aElt, + const nsAString& aPseudoElt, + bool aDefaultStylesOnly); + already_AddRefed<nsICSSDeclaration> + GetComputedStyleHelper(mozilla::dom::Element& aElt, + const nsAString& aPseudoElt, + bool aDefaultStylesOnly, + mozilla::ErrorResult& aError); + nsresult GetComputedStyleHelper(nsIDOMElement* aElt, + const nsAString& aPseudoElt, + bool aDefaultStylesOnly, + nsIDOMCSSStyleDeclaration** aReturn); + + // Outer windows only. + void PreloadLocalStorage(); + + // Returns CSS pixels based on primary screen. Outer windows only. + mozilla::CSSIntPoint GetScreenXY(mozilla::dom::CallerType aCallerType, + mozilla::ErrorResult& aError); + + nsGlobalWindow* InnerForSetTimeoutOrInterval(mozilla::ErrorResult& aError); + + void PostMessageMozOuter(JSContext* aCx, JS::Handle<JS::Value> aMessage, + const nsAString& aTargetOrigin, + JS::Handle<JS::Value> aTransfer, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + void PostMessageMoz(JSContext* aCx, JS::Handle<JS::Value> aMessage, + const nsAString& aTargetOrigin, + JS::Handle<JS::Value> aTransfer, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + + already_AddRefed<nsIVariant> + ShowModalDialogOuter(const nsAString& aUrl, nsIVariant* aArgument, + const nsAString& aOptions, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + + already_AddRefed<nsIVariant> + ShowModalDialog(const nsAString& aUrl, nsIVariant* aArgument, + const nsAString& aOptions, + nsIPrincipal& aSubjectPrincipal, + mozilla::ErrorResult& aError); + + // Ask the user if further dialogs should be blocked, if dialogs are currently + // being abused. This is used in the cases where we have no modifiable UI to + // show, in that case we show a separate dialog to ask this question. + bool ConfirmDialogIfNeeded(); + + // Helper called after moving/resizing, to update docShell's presContext + // if we have caused a resolution change by moving across monitors. + void CheckForDPIChange(); + +private: + // Fire the JS engine's onNewGlobalObject hook. Only used on inner windows. + void FireOnNewGlobalObject(); + + void DisconnectEventTargetObjects(); + + + enum class SecureContextFlags { + eDefault, + eIgnoreOpener + }; + // Called only on outer windows to compute the value that will be returned by + // IsSecureContext() for the inner window that corresponds to aDocument. + bool ComputeIsSecureContext(nsIDocument* aDocument, + SecureContextFlags aFlags = + SecureContextFlags::eDefault); + + // nsPIDOMWindow<T> should be able to see these helper methods. + friend class nsPIDOMWindow<mozIDOMWindowProxy>; + friend class nsPIDOMWindow<mozIDOMWindow>; + friend class nsPIDOMWindow<nsISupports>; + + // Apply back pressure to the window if the TabGroup ThrottledEventQueue + // exists and has too many runnables waiting to run. For example, increase + // the minimum timer delay, etc. + void + MaybeApplyBackPressure(); + + // Check the current ThrottledEventQueue depth and update the back pressure + // state. If the queue has drained back pressure may be canceled. + void + CancelOrUpdateBackPressure(); + + // When timers are being throttled and we reduce the thottle delay we must + // reschedule. The amount of the old throttle delay must be provided in + // order to bound how many timers must be examined. + nsresult ResetTimersForThrottleReduction(int32_t aPreviousThrottleDelayMS); + + mozilla::dom::TabGroup* TabGroupInner(); + mozilla::dom::TabGroup* TabGroupOuter(); + +protected: + // These members are only used on outer window objects. Make sure + // you never set any of these on an inner object! + bool mFullScreen : 1; + bool mFullscreenMode : 1; + bool mIsClosed : 1; + bool mInClose : 1; + // mHavePendingClose means we've got a termination function set to + // close us when the JS stops executing or that we have a close + // event posted. If this is set, just ignore window.close() calls. + bool mHavePendingClose : 1; + bool mHadOriginalOpener : 1; + bool mOriginalOpenerWasSecureContext : 1; + bool mIsSecureContextIfOpenerIgnored : 1; + bool mIsPopupSpam : 1; + + // Indicates whether scripts are allowed to close this window. + bool mBlockScriptedClosingFlag : 1; + + // Window offline status. Checked to see if we need to fire offline event + bool mWasOffline : 1; + + // Represents whether the inner window's page has had a slow script notice. + // Only used by inner windows; will always be false for outer windows. + // This is used to implement Telemetry measures such as SLOW_SCRIPT_PAGE_COUNT. + bool mHasHadSlowScript : 1; + + // Track what sorts of events we need to fire when thawed + bool mNotifyIdleObserversIdleOnThaw : 1; + bool mNotifyIdleObserversActiveOnThaw : 1; + + // Indicates whether we're in the middle of creating an initializing + // a new inner window object. + bool mCreatingInnerWindow : 1; + + // Fast way to tell if this is a chrome window (without having to QI). + bool mIsChrome : 1; + + // Hack to indicate whether a chrome window needs its message manager + // to be disconnected, since clean up code is shared in the global + // window superclass. + bool mCleanMessageManager : 1; + + // Indicates that the current document has never received a document focus + // event. + bool mNeedsFocus : 1; + bool mHasFocus : 1; + + // when true, show focus rings for the current focused content only. + // This will be reset when another element is focused + bool mShowFocusRingForContent : 1; + + // true if tab navigation has occurred for this window. Focus rings + // should be displayed. + bool mFocusByKeyOccurred : 1; + + // Inner windows only. + // Indicates whether this window wants gamepad input events + bool mHasGamepad : 1; + + // Inner windows only. + // Indicates whether this window wants VR events + bool mHasVREvents : 1; +#ifdef MOZ_GAMEPAD + nsCheapSet<nsUint32HashKey> mGamepadIndexSet; + nsRefPtrHashtable<nsUint32HashKey, mozilla::dom::Gamepad> mGamepads; + bool mHasSeenGamepadInput; +#endif + + // whether we've sent the destroy notification for our window id + bool mNotifiedIDDestroyed : 1; + // whether scripts may close the window, + // even if "dom.allow_scripts_to_close_windows" is false. + bool mAllowScriptsToClose : 1; + + nsCOMPtr<nsIScriptContext> mContext; + nsWeakPtr mOpener; + nsCOMPtr<nsIControllers> mControllers; + + // For |window.arguments|, via |openDialog|. + nsCOMPtr<nsIArray> mArguments; + + // For |window.dialogArguments|, via |showModalDialog|. + RefPtr<DialogValueHolder> mDialogArguments; + + // Only used in the outer. + RefPtr<DialogValueHolder> mReturnValue; + + RefPtr<mozilla::dom::Navigator> mNavigator; + RefPtr<nsScreen> mScreen; + RefPtr<nsDOMWindowList> mFrames; + // All BarProps are inner window only. + RefPtr<mozilla::dom::BarProp> mMenubar; + RefPtr<mozilla::dom::BarProp> mToolbar; + RefPtr<mozilla::dom::BarProp> mLocationbar; + RefPtr<mozilla::dom::BarProp> mPersonalbar; + RefPtr<mozilla::dom::BarProp> mStatusbar; + RefPtr<mozilla::dom::BarProp> mScrollbars; + RefPtr<nsDOMWindowUtils> mWindowUtils; + nsString mStatus; + nsString mDefaultStatus; + RefPtr<nsGlobalWindowObserver> mObserver; // Inner windows only. + RefPtr<mozilla::dom::Crypto> mCrypto; + RefPtr<mozilla::dom::U2F> mU2F; + RefPtr<mozilla::dom::cache::CacheStorage> mCacheStorage; + RefPtr<mozilla::dom::Console> mConsole; + // We need to store an nsISupports pointer to this object because the + // mozilla::dom::External class doesn't exist on b2g and using the type + // forward declared here means that ~nsGlobalWindow wouldn't compile because + // it wouldn't see the ~External function's declaration. + nsCOMPtr<nsISupports> mExternal; + + RefPtr<mozilla::dom::MozSelfSupport> mMozSelfSupport; + + RefPtr<mozilla::dom::DOMStorage> mLocalStorage; + RefPtr<mozilla::dom::DOMStorage> mSessionStorage; + + // These member variable are used only on inner windows. + RefPtr<mozilla::EventListenerManager> mListenerManager; + // mTimeouts is generally sorted by mWhen, unless mTimeoutInsertionPoint is + // non-null. In that case, the dummy timeout pointed to by + // mTimeoutInsertionPoint may have a later mWhen than some of the timeouts + // that come after it. + mozilla::LinkedList<mozilla::dom::Timeout> mTimeouts; + // If mTimeoutInsertionPoint is non-null, insertions should happen after it. + // This is a dummy timeout at the moment; if that ever changes, the logic in + // ResetTimersForThrottleReduction needs to change. + mozilla::dom::Timeout* mTimeoutInsertionPoint; + uint32_t mTimeoutIdCounter; + uint32_t mTimeoutFiringDepth; + RefPtr<mozilla::dom::Location> mLocation; + RefPtr<nsHistory> mHistory; + RefPtr<mozilla::dom::CustomElementRegistry> mCustomElements; + + // These member variables are used on both inner and the outer windows. + nsCOMPtr<nsIPrincipal> mDocumentPrincipal; + + typedef nsTArray<RefPtr<mozilla::dom::StorageEvent>> nsDOMStorageEventArray; + nsDOMStorageEventArray mPendingStorageEvents; + + uint32_t mSuspendDepth; + uint32_t mFreezeDepth; + + int32_t mBackPressureDelayMS; + + // the method that was used to focus mFocusedNode + uint32_t mFocusMethod; + + uint32_t mSerial; + + void DisableIdleCallbackRequests(); + void UnthrottleIdleCallbackRequests(); + + void PostThrottledIdleCallback(); + + typedef mozilla::LinkedList<mozilla::dom::IdleRequest> IdleRequests; + static void InsertIdleCallbackIntoList(mozilla::dom::IdleRequest* aRequest, + IdleRequests& aList); + + // The current idle request callback timeout handle + uint32_t mIdleCallbackTimeoutCounter; + // The current idle request callback handle + uint32_t mIdleRequestCallbackCounter; + IdleRequests mIdleRequestCallbacks; + IdleRequests mThrottledIdleRequestCallbacks; + +#ifdef DEBUG + bool mSetOpenerWindowCalled; + nsCOMPtr<nsIURI> mLastOpenedURI; +#endif + +#ifdef MOZ_B2G + bool mNetworkUploadObserverEnabled; + bool mNetworkDownloadObserverEnabled; +#endif // MOZ_B2G + + bool mCleanedUp; + + nsCOMPtr<nsIDOMOfflineResourceList> mApplicationCache; + + using XBLPrototypeHandlerTable = nsJSThingHashtable<nsPtrHashKey<nsXBLPrototypeHandler>, JSObject*>; + nsAutoPtr<XBLPrototypeHandlerTable> mCachedXBLPrototypeHandlers; + + // mSuspendedDoc is only set on outer windows. It's useful when we get matched + // EnterModalState/LeaveModalState calls, in which case the outer window is + // responsible for unsuspending events on the document. If we don't (for + // example, if the outer window is closed before the LeaveModalState call), + // then the inner window whose mDoc is our mSuspendedDoc is responsible for + // unsuspending it. + nsCOMPtr<nsIDocument> mSuspendedDoc; + + RefPtr<mozilla::dom::IDBFactory> mIndexedDB; + + // This counts the number of windows that have been opened in rapid succession + // (i.e. within dom.successive_dialog_time_limit of each other). It is reset + // to 0 once a dialog is opened after dom.successive_dialog_time_limit seconds + // have elapsed without any other dialogs. + uint32_t mDialogAbuseCount; + + // This holds the time when the last modal dialog was shown. If more than + // MAX_DIALOG_LIMIT dialogs are shown within the time span defined by + // dom.successive_dialog_time_limit, we show a checkbox or confirmation prompt + // to allow disabling of further dialogs from this window. + TimeStamp mLastDialogQuitTime; + + // This flag keeps track of whether dialogs are + // currently enabled on this window. + bool mAreDialogsEnabled; + + nsTHashtable<nsPtrHashKey<mozilla::DOMEventTargetHelper> > mEventTargetObjects; + + nsTArray<uint32_t> mEnabledSensors; + +#if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GONK) + nsAutoPtr<mozilla::dom::WindowOrientationObserver> mOrientationChangeObserver; +#endif + +#ifdef MOZ_WEBSPEECH + // mSpeechSynthesis is only used on inner windows. + RefPtr<mozilla::dom::SpeechSynthesis> mSpeechSynthesis; +#endif + +#ifdef DEBUG + // This member is used in the debug only assertions in TabGroup() + // to catch cyclic parent/opener trees and not overflow the stack. + bool mIsValidatingTabGroup; +#endif + + // This is the CC generation the last time we called CanSkip. + uint32_t mCanSkipCCGeneration; + + // The VR Displays for this window + nsTArray<RefPtr<mozilla::dom::VRDisplay>> mVRDisplays; + + nsAutoPtr<mozilla::dom::VREventObserver> mVREventObserver; + + friend class nsDOMScriptableHelper; + friend class nsDOMWindowUtils; + friend class mozilla::dom::PostMessageEvent; + friend class DesktopNotification; + + static WindowByIdTable* sWindowsById; + static bool sWarnedAboutWindowInternal; +}; + +inline nsISupports* +ToSupports(nsGlobalWindow *p) +{ + return static_cast<nsIDOMEventTarget*>(p); +} + +inline nsISupports* +ToCanonicalSupports(nsGlobalWindow *p) +{ + return static_cast<nsIDOMEventTarget*>(p); +} + +/* + * nsGlobalChromeWindow inherits from nsGlobalWindow. It is the global + * object created for a Chrome Window only. + */ +class nsGlobalChromeWindow : public nsGlobalWindow, + public nsIDOMChromeWindow +{ +public: + // nsISupports + NS_DECL_ISUPPORTS_INHERITED + + // nsIDOMChromeWindow interface + NS_DECL_NSIDOMCHROMEWINDOW + + static already_AddRefed<nsGlobalChromeWindow> Create(nsGlobalWindow *aOuterWindow); + + void DisconnectAndClearGroupMessageManagers() + { + for (auto iter = mGroupMessageManagers.Iter(); !iter.Done(); iter.Next()) { + nsIMessageBroadcaster* mm = iter.UserData(); + if (mm) { + static_cast<nsFrameMessageManager*>(mm)->Disconnect(); + } + } + mGroupMessageManagers.Clear(); + } + +protected: + explicit nsGlobalChromeWindow(nsGlobalWindow *aOuterWindow) + : nsGlobalWindow(aOuterWindow), + mGroupMessageManagers(1) + { + mIsChrome = true; + mCleanMessageManager = true; + } + + ~nsGlobalChromeWindow() + { + MOZ_ASSERT(mCleanMessageManager, + "chrome windows may always disconnect the msg manager"); + + DisconnectAndClearGroupMessageManagers(); + + if (mMessageManager) { + static_cast<nsFrameMessageManager *>( + mMessageManager.get())->Disconnect(); + } + + mCleanMessageManager = false; + } + +public: + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(nsGlobalChromeWindow, + nsGlobalWindow) + + using nsGlobalWindow::GetBrowserDOMWindow; + using nsGlobalWindow::SetBrowserDOMWindow; + using nsGlobalWindow::GetAttention; + using nsGlobalWindow::GetAttentionWithCycleCount; + using nsGlobalWindow::SetCursor; + using nsGlobalWindow::Maximize; + using nsGlobalWindow::Minimize; + using nsGlobalWindow::Restore; + using nsGlobalWindow::NotifyDefaultButtonLoaded; + using nsGlobalWindow::GetMessageManager; + using nsGlobalWindow::GetGroupMessageManager; + using nsGlobalWindow::BeginWindowMove; + + nsCOMPtr<nsIBrowserDOMWindow> mBrowserDOMWindow; + nsCOMPtr<nsIMessageBroadcaster> mMessageManager; + nsInterfaceHashtable<nsStringHashKey, nsIMessageBroadcaster> mGroupMessageManagers; + // A weak pointer to the nsPresShell that we are doing fullscreen for. + // The pointer being set indicates we've set the IsInFullscreenChange + // flag on this pres shell. + nsWeakPtr mFullscreenPresShell; + nsCOMPtr<mozIDOMWindowProxy> mOpenerForInitialContentBrowser; +}; + +/* + * nsGlobalModalWindow inherits from nsGlobalWindow. It is the global + * object created for a modal content windows only (i.e. not modal + * chrome dialogs). + */ +class nsGlobalModalWindow : public nsGlobalWindow, + public nsIDOMModalContentWindow +{ +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSIDOMMODALCONTENTWINDOW + + static already_AddRefed<nsGlobalModalWindow> Create(nsGlobalWindow *aOuterWindow); + +protected: + explicit nsGlobalModalWindow(nsGlobalWindow *aOuterWindow) + : nsGlobalWindow(aOuterWindow) + { + mIsModalContentWindow = true; + } + + ~nsGlobalModalWindow() {} +}; + +/* factory function */ +inline already_AddRefed<nsGlobalWindow> +NS_NewScriptGlobalObject(bool aIsChrome, bool aIsModalContentWindow) +{ + RefPtr<nsGlobalWindow> global; + + if (aIsChrome) { + global = nsGlobalChromeWindow::Create(nullptr); + } else if (aIsModalContentWindow) { + global = nsGlobalModalWindow::Create(nullptr); + } else { + global = nsGlobalWindow::Create(nullptr); + } + + return global.forget(); +} + +#endif /* nsGlobalWindow_h___ */ |