mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-07 21:43:24 +00:00
c0a1cf9b49
This avoids a lot of mismatches between nsAString and char16_t*, thus removing many getter_Copies() and ToNewUnicode() and get() calls, and generally making things simpler. Note: the patch removes GetDefaultPrinterNameFromGlobalPrinters() by simply inlining it at its two callsites, which is easy with the changed types. --HG-- extra : rebase_source : 9ab9b3694f093fc9b22c7f8e2394a98674d76c11
15049 lines
441 KiB
C++
15049 lines
441 KiB
C++
/* -*- 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/. */
|
|
|
|
#include "nsGlobalWindow.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#include "mozilla/MemoryReporting.h"
|
|
|
|
// Local Includes
|
|
#include "Navigator.h"
|
|
#include "nsContentSecurityManager.h"
|
|
#include "nsScreen.h"
|
|
#include "nsHistory.h"
|
|
#include "nsDOMNavigationTiming.h"
|
|
#include "nsIDOMStorageManager.h"
|
|
#include "mozilla/dom/LocalStorage.h"
|
|
#include "mozilla/dom/Storage.h"
|
|
#include "mozilla/dom/IdleRequest.h"
|
|
#include "mozilla/dom/Performance.h"
|
|
#include "mozilla/dom/StorageEvent.h"
|
|
#include "mozilla/dom/StorageEventBinding.h"
|
|
#include "mozilla/dom/StorageNotifierService.h"
|
|
#include "mozilla/dom/StorageUtils.h"
|
|
#include "mozilla/dom/Timeout.h"
|
|
#include "mozilla/dom/TimeoutHandler.h"
|
|
#include "mozilla/dom/TimeoutManager.h"
|
|
#include "mozilla/IntegerPrintfMacros.h"
|
|
#if defined(MOZ_WIDGET_ANDROID)
|
|
#include "mozilla/dom/WindowOrientationObserver.h"
|
|
#endif
|
|
#include "nsDOMOfflineResourceList.h"
|
|
#include "nsError.h"
|
|
#include "nsIIdleService.h"
|
|
#include "nsISizeOfEventTarget.h"
|
|
#include "nsDOMJSUtils.h"
|
|
#include "nsArrayUtils.h"
|
|
#include "nsIDOMWindowCollection.h"
|
|
#include "nsDOMWindowList.h"
|
|
#include "mozilla/dom/WakeLock.h"
|
|
#include "mozilla/dom/power/PowerManagerService.h"
|
|
#include "nsIDocShellTreeOwner.h"
|
|
#include "nsIInterfaceRequestorUtils.h"
|
|
#include "nsIPermissionManager.h"
|
|
#include "nsIScriptContext.h"
|
|
#include "nsIScriptTimeoutHandler.h"
|
|
#include "nsITimeoutHandler.h"
|
|
#include "nsIController.h"
|
|
#include "nsScriptNameSpaceManager.h"
|
|
#include "nsISlowScriptDebug.h"
|
|
#include "nsWindowMemoryReporter.h"
|
|
#include "nsWindowSizes.h"
|
|
#include "WindowNamedPropertiesHandler.h"
|
|
#include "nsFrameSelection.h"
|
|
#include "nsNetUtil.h"
|
|
#include "nsVariant.h"
|
|
#include "nsPrintfCString.h"
|
|
#include "mozilla/intl/LocaleService.h"
|
|
|
|
// Helper Classes
|
|
#include "nsJSUtils.h"
|
|
#include "jsapi.h" // for JSAutoRequest
|
|
#include "jswrapper.h"
|
|
#include "nsCharSeparatedTokenizer.h"
|
|
#include "nsReadableUtils.h"
|
|
#include "nsDOMClassInfo.h"
|
|
#include "nsJSEnvironment.h"
|
|
#include "mozilla/dom/ScriptSettings.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "mozilla/Likely.h"
|
|
#include "mozilla/Sprintf.h"
|
|
#include "mozilla/Unused.h"
|
|
|
|
// Other Classes
|
|
#include "mozilla/dom/BarProps.h"
|
|
#include "nsContentCID.h"
|
|
#include "nsLayoutStatics.h"
|
|
#include "nsCCUncollectableMarker.h"
|
|
#include "mozilla/dom/workers/Workers.h"
|
|
#include "mozilla/dom/ToJSValue.h"
|
|
#include "nsJSPrincipals.h"
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/Debug.h"
|
|
#include "mozilla/EventListenerManager.h"
|
|
#include "mozilla/EventStates.h"
|
|
#include "mozilla/MouseEvents.h"
|
|
#include "mozilla/ProcessHangMonitor.h"
|
|
#include "mozilla/ThrottledEventQueue.h"
|
|
#include "AudioChannelService.h"
|
|
#include "nsAboutProtocolUtils.h"
|
|
#include "nsCharTraits.h" // NS_IS_HIGH/LOW_SURROGATE
|
|
#include "PostMessageEvent.h"
|
|
#include "mozilla/dom/DocGroup.h"
|
|
#include "mozilla/dom/TabGroup.h"
|
|
|
|
// Interfaces Needed
|
|
#include "nsIFrame.h"
|
|
#include "nsCanvasFrame.h"
|
|
#include "nsIWidget.h"
|
|
#include "nsIWidgetListener.h"
|
|
#include "nsIBaseWindow.h"
|
|
#include "nsIDeviceSensors.h"
|
|
#include "nsIContent.h"
|
|
#include "nsIDocShell.h"
|
|
#include "nsIDocCharset.h"
|
|
#include "nsIDocument.h"
|
|
#include "Crypto.h"
|
|
#include "nsIDOMDocument.h"
|
|
#include "nsIDOMElement.h"
|
|
#include "nsIDOMEvent.h"
|
|
#include "nsIDOMOfflineResourceList.h"
|
|
#include "nsDOMString.h"
|
|
#include "nsIEmbeddingSiteWindow.h"
|
|
#include "nsThreadUtils.h"
|
|
#include "nsILoadContext.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsIScrollableFrame.h"
|
|
#include "nsView.h"
|
|
#include "nsViewManager.h"
|
|
#include "nsISelectionController.h"
|
|
#include "nsISelection.h"
|
|
#include "nsIPrompt.h"
|
|
#include "nsIPromptService.h"
|
|
#include "nsIPromptFactory.h"
|
|
#include "nsIAddonPolicyService.h"
|
|
#include "nsIWritablePropertyBag2.h"
|
|
#include "nsIWebNavigation.h"
|
|
#include "nsIWebBrowserChrome.h"
|
|
#include "nsIWebBrowserFind.h" // For window.find()
|
|
#include "nsIWindowMediator.h" // For window.find()
|
|
#include "nsComputedDOMStyle.h"
|
|
#include "nsDOMCID.h"
|
|
#include "nsDOMWindowUtils.h"
|
|
#include "nsIWindowWatcher.h"
|
|
#include "nsPIWindowWatcher.h"
|
|
#include "nsIContentViewer.h"
|
|
#include "nsIScriptError.h"
|
|
#include "nsIControllers.h"
|
|
#include "nsIControllerContext.h"
|
|
#include "nsGlobalWindowCommands.h"
|
|
#include "nsQueryObject.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsCSSProps.h"
|
|
#include "nsIDOMFileList.h"
|
|
#include "nsIURIFixup.h"
|
|
#ifndef DEBUG
|
|
#include "nsIAppStartup.h"
|
|
#include "nsToolkitCompsCID.h"
|
|
#endif
|
|
#include "nsCDefaultURIFixup.h"
|
|
#include "mozilla/EventDispatcher.h"
|
|
#include "mozilla/EventStateManager.h"
|
|
#include "nsIObserverService.h"
|
|
#include "nsFocusManager.h"
|
|
#include "nsIXULWindow.h"
|
|
#include "nsITimedChannel.h"
|
|
#include "nsServiceManagerUtils.h"
|
|
#ifdef MOZ_XUL
|
|
#include "nsIDOMXULControlElement.h"
|
|
#include "nsMenuPopupFrame.h"
|
|
#endif
|
|
#include "mozilla/dom/CustomEvent.h"
|
|
#include "nsIJARChannel.h"
|
|
#include "nsIScreenManager.h"
|
|
#include "nsIEffectiveTLDService.h"
|
|
|
|
#include "xpcprivate.h"
|
|
|
|
#ifdef NS_PRINTING
|
|
#include "nsIPrintSettings.h"
|
|
#include "nsIPrintSettingsService.h"
|
|
#include "nsIWebBrowserPrint.h"
|
|
#endif
|
|
|
|
#include "nsWindowRoot.h"
|
|
#include "nsNetCID.h"
|
|
#include "nsIArray.h"
|
|
|
|
// XXX An unfortunate dependency exists here (two XUL files).
|
|
#include "nsIDOMXULDocument.h"
|
|
#include "nsIDOMXULCommandDispatcher.h"
|
|
|
|
#include "nsBindingManager.h"
|
|
#include "nsXBLService.h"
|
|
|
|
// used for popup blocking, needs to be converted to something
|
|
// belonging to the back-end like nsIContentPolicy
|
|
#include "nsIPopupWindowManager.h"
|
|
|
|
#include "nsIDragService.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "mozilla/dom/Selection.h"
|
|
#include "nsFrameLoader.h"
|
|
#include "nsISupportsPrimitives.h"
|
|
#include "nsXPCOMCID.h"
|
|
#include "mozilla/Logging.h"
|
|
#include "prenv.h"
|
|
|
|
#include "mozilla/dom/IDBFactory.h"
|
|
#include "mozilla/dom/MessageChannel.h"
|
|
#include "mozilla/dom/Promise.h"
|
|
|
|
#include "mozilla/dom/Gamepad.h"
|
|
#include "mozilla/dom/GamepadManager.h"
|
|
|
|
#include "gfxVR.h"
|
|
#include "mozilla/dom/VRDisplay.h"
|
|
#include "mozilla/dom/VRDisplayEvent.h"
|
|
#include "mozilla/dom/VRDisplayEventBinding.h"
|
|
#include "mozilla/dom/VREventObserver.h"
|
|
|
|
#include "nsRefreshDriver.h"
|
|
#include "Layers.h"
|
|
|
|
#include "mozilla/AddonPathService.h"
|
|
#include "mozilla/BasePrincipal.h"
|
|
#include "mozilla/Services.h"
|
|
#include "mozilla/Telemetry.h"
|
|
#include "mozilla/dom/Location.h"
|
|
#include "nsHTMLDocument.h"
|
|
#include "nsWrapperCacheInlines.h"
|
|
#include "mozilla/DOMEventTargetHelper.h"
|
|
#include "prrng.h"
|
|
#include "nsSandboxFlags.h"
|
|
#include "TimeChangeObserver.h"
|
|
#include "mozilla/dom/AudioContext.h"
|
|
#include "mozilla/dom/BrowserElementDictionariesBinding.h"
|
|
#include "mozilla/dom/cache/CacheStorage.h"
|
|
#include "mozilla/dom/Console.h"
|
|
#include "mozilla/dom/Fetch.h"
|
|
#include "mozilla/dom/FunctionBinding.h"
|
|
#include "mozilla/dom/HashChangeEvent.h"
|
|
#include "mozilla/dom/IntlUtils.h"
|
|
#include "mozilla/dom/MozSelfSupportBinding.h"
|
|
#include "mozilla/dom/PopStateEvent.h"
|
|
#include "mozilla/dom/PopupBlockedEvent.h"
|
|
#include "mozilla/dom/PrimitiveConversions.h"
|
|
#include "mozilla/dom/WindowBinding.h"
|
|
#include "nsITabChild.h"
|
|
#include "mozilla/dom/MediaQueryList.h"
|
|
#include "mozilla/dom/ScriptSettings.h"
|
|
#include "mozilla/dom/NavigatorBinding.h"
|
|
#include "mozilla/dom/ImageBitmap.h"
|
|
#include "mozilla/dom/ImageBitmapBinding.h"
|
|
#include "mozilla/dom/ServiceWorkerRegistration.h"
|
|
#include "mozilla/dom/U2F.h"
|
|
#include "mozilla/dom/WebIDLGlobalNameHash.h"
|
|
#include "mozilla/dom/Worklet.h"
|
|
#ifdef HAVE_SIDEBAR
|
|
#include "mozilla/dom/ExternalBinding.h"
|
|
#endif
|
|
|
|
#ifdef MOZ_WEBSPEECH
|
|
#include "mozilla/dom/SpeechSynthesis.h"
|
|
#endif
|
|
|
|
// Apple system headers seem to have a check() macro. <sigh>
|
|
#ifdef check
|
|
class nsIScriptTimeoutHandler;
|
|
#undef check
|
|
#endif // check
|
|
#include "AccessCheck.h"
|
|
|
|
#ifdef ANDROID
|
|
#include <android/log.h>
|
|
#endif
|
|
|
|
#ifdef XP_WIN
|
|
#include <process.h>
|
|
#define getpid _getpid
|
|
#else
|
|
#include <unistd.h> // for getpid()
|
|
#endif
|
|
|
|
static const char kStorageEnabled[] = "dom.storage.enabled";
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
using namespace mozilla::dom::ipc;
|
|
using mozilla::BasePrincipal;
|
|
using mozilla::OriginAttributes;
|
|
using mozilla::TimeStamp;
|
|
using mozilla::TimeDuration;
|
|
using mozilla::dom::cache::CacheStorage;
|
|
|
|
static LazyLogModule gDOMLeakPRLog("DOMLeak");
|
|
|
|
nsGlobalWindow::WindowByIdTable *nsGlobalWindow::sWindowsById = nullptr;
|
|
bool nsGlobalWindow::sIdleObserversAPIFuzzTimeDisabled = false;
|
|
|
|
static int32_t gRefCnt = 0;
|
|
static int32_t gOpenPopupSpamCount = 0;
|
|
static PopupControlState gPopupControlState = openAbused;
|
|
static bool gMouseDown = false;
|
|
static bool gDragServiceDisabled = false;
|
|
static FILE *gDumpFile = nullptr;
|
|
static uint32_t gSerialCounter = 0;
|
|
|
|
#ifdef DEBUG_jst
|
|
int32_t gTimeoutCnt = 0;
|
|
#endif
|
|
|
|
#if defined(DEBUG_bryner) || defined(DEBUG_chb)
|
|
#define DEBUG_PAGE_CACHE
|
|
#endif
|
|
|
|
#define DOM_TOUCH_LISTENER_ADDED "dom-touch-listener-added"
|
|
|
|
#define MEMORY_PRESSURE_OBSERVER_TOPIC "memory-pressure"
|
|
|
|
// The interval at which we execute idle callbacks
|
|
static uint32_t gThrottledIdlePeriodLength;
|
|
|
|
#define DEFAULT_THROTTLED_IDLE_PERIOD_LENGTH 10000
|
|
|
|
#define FORWARD_TO_OUTER(method, args, err_rval) \
|
|
PR_BEGIN_MACRO \
|
|
if (IsInnerWindow()) { \
|
|
nsGlobalWindow *outer = GetOuterWindowInternal(); \
|
|
if (!AsInner()->HasActiveDocument()) { \
|
|
NS_WARNING(outer ? \
|
|
"Inner window does not have active document." : \
|
|
"No outer window available!"); \
|
|
return err_rval; \
|
|
} \
|
|
return outer->method args; \
|
|
} \
|
|
PR_END_MACRO
|
|
|
|
#define FORWARD_TO_OUTER_OR_THROW(method, args, errorresult, err_rval) \
|
|
PR_BEGIN_MACRO \
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow()); \
|
|
nsGlobalWindow *outer = GetOuterWindowInternal(); \
|
|
if (MOZ_LIKELY(AsInner()->HasActiveDocument())) { \
|
|
return outer->method args; \
|
|
} \
|
|
if (!outer) { \
|
|
NS_WARNING("No outer window available!"); \
|
|
errorresult.Throw(NS_ERROR_NOT_INITIALIZED); \
|
|
} else { \
|
|
errorresult.Throw(NS_ERROR_XPC_SECURITY_MANAGER_VETO); \
|
|
} \
|
|
return err_rval; \
|
|
PR_END_MACRO
|
|
|
|
#define FORWARD_TO_OUTER_VOID(method, args) \
|
|
PR_BEGIN_MACRO \
|
|
if (IsInnerWindow()) { \
|
|
nsGlobalWindow *outer = GetOuterWindowInternal(); \
|
|
if (!AsInner()->HasActiveDocument()) { \
|
|
NS_WARNING(outer ? \
|
|
"Inner window does not have active document." : \
|
|
"No outer window available!"); \
|
|
return; \
|
|
} \
|
|
outer->method args; \
|
|
return; \
|
|
} \
|
|
PR_END_MACRO
|
|
|
|
#define FORWARD_TO_OUTER_MODAL_CONTENT_WINDOW(method, args, err_rval) \
|
|
PR_BEGIN_MACRO \
|
|
if (IsInnerWindow()) { \
|
|
nsGlobalWindow *outer = GetOuterWindowInternal(); \
|
|
if (!AsInner()->HasActiveDocument()) { \
|
|
NS_WARNING(outer ? \
|
|
"Inner window does not have active document." : \
|
|
"No outer window available!"); \
|
|
return err_rval; \
|
|
} \
|
|
return ((nsGlobalModalWindow *)outer)->method args; \
|
|
} \
|
|
PR_END_MACRO
|
|
|
|
#define FORWARD_TO_INNER(method, args, err_rval) \
|
|
PR_BEGIN_MACRO \
|
|
if (IsOuterWindow()) { \
|
|
if (!mInnerWindow) { \
|
|
NS_WARNING("No inner window available!"); \
|
|
return err_rval; \
|
|
} \
|
|
return GetCurrentInnerWindowInternal()->method args; \
|
|
} \
|
|
PR_END_MACRO
|
|
|
|
#define FORWARD_TO_INNER_MODAL_CONTENT_WINDOW(method, args, err_rval) \
|
|
PR_BEGIN_MACRO \
|
|
if (IsOuterWindow()) { \
|
|
if (!mInnerWindow) { \
|
|
NS_WARNING("No inner window available!"); \
|
|
return err_rval; \
|
|
} \
|
|
return ((nsGlobalModalWindow*)GetCurrentInnerWindowInternal())->method args; \
|
|
} \
|
|
PR_END_MACRO
|
|
|
|
#define FORWARD_TO_INNER_VOID(method, args) \
|
|
PR_BEGIN_MACRO \
|
|
if (IsOuterWindow()) { \
|
|
if (!mInnerWindow) { \
|
|
NS_WARNING("No inner window available!"); \
|
|
return; \
|
|
} \
|
|
GetCurrentInnerWindowInternal()->method args; \
|
|
return; \
|
|
} \
|
|
PR_END_MACRO
|
|
|
|
// Same as FORWARD_TO_INNER, but this will create a fresh inner if an
|
|
// inner doesn't already exists.
|
|
#define FORWARD_TO_INNER_CREATE(method, args, err_rval) \
|
|
PR_BEGIN_MACRO \
|
|
if (IsOuterWindow()) { \
|
|
if (!mInnerWindow) { \
|
|
if (mIsClosed) { \
|
|
return err_rval; \
|
|
} \
|
|
nsCOMPtr<nsIDocument> kungFuDeathGrip = GetDoc(); \
|
|
::mozilla::Unused << kungFuDeathGrip; \
|
|
if (!mInnerWindow) { \
|
|
return err_rval; \
|
|
} \
|
|
} \
|
|
return GetCurrentInnerWindowInternal()->method args; \
|
|
} \
|
|
PR_END_MACRO
|
|
|
|
// CIDs
|
|
static NS_DEFINE_CID(kXULControllersCID, NS_XULCONTROLLERS_CID);
|
|
|
|
#define NETWORK_UPLOAD_EVENT_NAME NS_LITERAL_STRING("moznetworkupload")
|
|
#define NETWORK_DOWNLOAD_EVENT_NAME NS_LITERAL_STRING("moznetworkdownload")
|
|
|
|
/**
|
|
* An indirect observer object that means we don't have to implement nsIObserver
|
|
* on nsGlobalWindow, where any script could see it.
|
|
*/
|
|
class nsGlobalWindowObserver final : public nsIObserver
|
|
, public nsIInterfaceRequestor
|
|
, public StorageNotificationObserver
|
|
{
|
|
public:
|
|
explicit nsGlobalWindowObserver(nsGlobalWindow* aWindow) : mWindow(aWindow) {}
|
|
NS_DECL_ISUPPORTS
|
|
NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic, const char16_t* aData) override
|
|
{
|
|
if (!mWindow)
|
|
return NS_OK;
|
|
return mWindow->Observe(aSubject, aTopic, aData);
|
|
}
|
|
void Forget() { mWindow = nullptr; }
|
|
NS_IMETHOD GetInterface(const nsIID& aIID, void** aResult) override
|
|
{
|
|
if (mWindow && aIID.Equals(NS_GET_IID(nsIDOMWindow)) && mWindow) {
|
|
return mWindow->QueryInterface(aIID, aResult);
|
|
}
|
|
return NS_NOINTERFACE;
|
|
}
|
|
|
|
void
|
|
ObserveStorageNotification(StorageEvent* aEvent,
|
|
const char16_t* aStorageType,
|
|
bool aPrivateBrowsing) override
|
|
{
|
|
if (mWindow) {
|
|
mWindow->ObserveStorageNotification(aEvent, aStorageType,
|
|
aPrivateBrowsing);
|
|
}
|
|
}
|
|
|
|
nsIPrincipal*
|
|
GetPrincipal() const override
|
|
{
|
|
return mWindow ? mWindow->GetPrincipal() : nullptr;
|
|
}
|
|
|
|
bool
|
|
IsPrivateBrowsing() const override
|
|
{
|
|
return mWindow ? mWindow->IsPrivateBrowsing() : false;
|
|
}
|
|
|
|
nsIEventTarget*
|
|
GetEventTarget() const override
|
|
{
|
|
return mWindow ? mWindow->EventTargetFor(TaskCategory::Other) : nullptr;
|
|
}
|
|
|
|
private:
|
|
~nsGlobalWindowObserver() = default;
|
|
|
|
// This reference is non-owning and safe because it's cleared by
|
|
// nsGlobalWindow::CleanUp().
|
|
nsGlobalWindow* MOZ_NON_OWNING_REF mWindow;
|
|
};
|
|
|
|
NS_IMPL_ISUPPORTS(nsGlobalWindowObserver, nsIObserver, nsIInterfaceRequestor)
|
|
|
|
static already_AddRefed<nsIVariant>
|
|
CreateVoidVariant()
|
|
{
|
|
RefPtr<nsVariantCC> writable = new nsVariantCC();
|
|
writable->SetAsVoid();
|
|
return writable.forget();
|
|
}
|
|
|
|
nsresult
|
|
DialogValueHolder::Get(nsIPrincipal* aSubject, nsIVariant** aResult)
|
|
{
|
|
nsCOMPtr<nsIVariant> result;
|
|
if (aSubject->SubsumesConsideringDomain(mOrigin)) {
|
|
result = mValue;
|
|
} else {
|
|
result = CreateVoidVariant();
|
|
}
|
|
result.forget(aResult);
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
DialogValueHolder::Get(JSContext* aCx, JS::Handle<JSObject*> aScope,
|
|
nsIPrincipal* aSubject,
|
|
JS::MutableHandle<JS::Value> aResult,
|
|
mozilla::ErrorResult& aError)
|
|
{
|
|
if (aSubject->Subsumes(mOrigin)) {
|
|
aError = nsContentUtils::XPConnect()->VariantToJS(aCx, aScope,
|
|
mValue, aResult);
|
|
} else {
|
|
aResult.setUndefined();
|
|
}
|
|
}
|
|
|
|
class IdleRequestExecutor;
|
|
|
|
class IdleRequestExecutorTimeoutHandler final : public TimeoutHandler
|
|
{
|
|
public:
|
|
explicit IdleRequestExecutorTimeoutHandler(IdleRequestExecutor* aExecutor)
|
|
: mExecutor(aExecutor)
|
|
{
|
|
}
|
|
|
|
NS_DECL_ISUPPORTS_INHERITED
|
|
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(IdleRequestExecutorTimeoutHandler,
|
|
TimeoutHandler)
|
|
|
|
nsresult Call() override;
|
|
|
|
private:
|
|
~IdleRequestExecutorTimeoutHandler() override {}
|
|
RefPtr<IdleRequestExecutor> mExecutor;
|
|
};
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_INHERITED(IdleRequestExecutorTimeoutHandler, TimeoutHandler, mExecutor)
|
|
|
|
NS_IMPL_ADDREF_INHERITED(IdleRequestExecutorTimeoutHandler, TimeoutHandler)
|
|
NS_IMPL_RELEASE_INHERITED(IdleRequestExecutorTimeoutHandler, TimeoutHandler)
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(IdleRequestExecutorTimeoutHandler)
|
|
NS_INTERFACE_MAP_END_INHERITING(TimeoutHandler)
|
|
|
|
|
|
class IdleRequestExecutor final : public nsIRunnable
|
|
, public nsICancelableRunnable
|
|
, public nsINamed
|
|
, public nsIIdleRunnable
|
|
{
|
|
public:
|
|
explicit IdleRequestExecutor(nsGlobalWindow* aWindow)
|
|
: mDispatched(false)
|
|
, mDeadline(TimeStamp::Now())
|
|
, mWindow(aWindow)
|
|
{
|
|
MOZ_DIAGNOSTIC_ASSERT(mWindow);
|
|
MOZ_DIAGNOSTIC_ASSERT(mWindow->IsInnerWindow());
|
|
|
|
mIdlePeriodLimit = { mDeadline, mWindow->LastIdleRequestHandle() };
|
|
mDelayedExecutorDispatcher = new IdleRequestExecutorTimeoutHandler(this);
|
|
}
|
|
|
|
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
|
|
NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(IdleRequestExecutor, nsIRunnable)
|
|
|
|
NS_DECL_NSIRUNNABLE
|
|
NS_DECL_NSINAMED
|
|
nsresult Cancel() override;
|
|
void SetDeadline(TimeStamp aDeadline) override;
|
|
|
|
bool IsCancelled() const { return !mWindow || mWindow->AsInner()->InnerObjectsFreed(); }
|
|
// Checks if aRequest shouldn't execute in the current idle period
|
|
// since it has been queued from a chained call to
|
|
// requestIdleCallback from within a running idle callback.
|
|
bool IneligibleForCurrentIdlePeriod(IdleRequest* aRequest) const
|
|
{
|
|
return aRequest->Handle() >= mIdlePeriodLimit.mLastRequestIdInIdlePeriod &&
|
|
TimeStamp::Now() <= mIdlePeriodLimit.mEndOfIdlePeriod;
|
|
}
|
|
|
|
void MaybeUpdateIdlePeriodLimit();
|
|
|
|
// Maybe dispatch the IdleRequestExecutor. MabyeDispatch will
|
|
// schedule a delayed dispatch if the associated window is in the
|
|
// background or if given a time to wait until dispatching.
|
|
void MaybeDispatch(TimeStamp aDelayUntil = TimeStamp());
|
|
void ScheduleDispatch();
|
|
private:
|
|
struct IdlePeriodLimit
|
|
{
|
|
TimeStamp mEndOfIdlePeriod;
|
|
uint32_t mLastRequestIdInIdlePeriod;
|
|
};
|
|
|
|
void DelayedDispatch(uint32_t aDelay);
|
|
|
|
~IdleRequestExecutor() override {}
|
|
|
|
bool mDispatched;
|
|
TimeStamp mDeadline;
|
|
IdlePeriodLimit mIdlePeriodLimit;
|
|
RefPtr<nsGlobalWindow> mWindow;
|
|
// The timeout handler responsible for dispatching this executor in
|
|
// the case of immediate dispatch to the idle queue isn't
|
|
// desirable. This is used if we've dispatched all idle callbacks
|
|
// that are allowed to run in the current idle period, or if the
|
|
// associated window is currently in the background.
|
|
nsCOMPtr<nsITimeoutHandler> mDelayedExecutorDispatcher;
|
|
// If not Nothing() then this value is the handle to the currently
|
|
// scheduled delayed executor dispatcher. This is needed to be able
|
|
// to cancel the timeout handler in case of the executor being
|
|
// cancelled.
|
|
Maybe<int32_t> mDelayedExecutorHandle;
|
|
};
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(IdleRequestExecutor)
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(IdleRequestExecutor)
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(IdleRequestExecutor)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(IdleRequestExecutor)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mWindow)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mDelayedExecutorDispatcher)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(IdleRequestExecutor)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindow)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDelayedExecutorDispatcher)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(IdleRequestExecutor)
|
|
NS_INTERFACE_MAP_ENTRY(nsIRunnable)
|
|
NS_INTERFACE_MAP_ENTRY(nsICancelableRunnable)
|
|
NS_INTERFACE_MAP_ENTRY(nsINamed)
|
|
NS_INTERFACE_MAP_ENTRY(nsIIdleRunnable)
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIRunnable)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
NS_IMETHODIMP
|
|
IdleRequestExecutor::GetName(nsACString& aName)
|
|
{
|
|
aName.AssignASCII("IdleRequestExecutor");
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
IdleRequestExecutor::Run()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
mDispatched = false;
|
|
if (mWindow) {
|
|
return mWindow->ExecuteIdleRequest(mDeadline);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
IdleRequestExecutor::Cancel()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (mDelayedExecutorHandle && mWindow) {
|
|
mWindow->AsInner()->TimeoutManager().ClearTimeout(
|
|
mDelayedExecutorHandle.value(),
|
|
Timeout::Reason::eIdleCallbackTimeout);
|
|
}
|
|
|
|
mWindow = nullptr;
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
IdleRequestExecutor::SetDeadline(TimeStamp aDeadline)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (!mWindow) {
|
|
return;
|
|
}
|
|
|
|
mDeadline = aDeadline;
|
|
}
|
|
|
|
void
|
|
IdleRequestExecutor::MaybeUpdateIdlePeriodLimit()
|
|
{
|
|
if (TimeStamp::Now() > mIdlePeriodLimit.mEndOfIdlePeriod) {
|
|
mIdlePeriodLimit = { mDeadline, mWindow->LastIdleRequestHandle() };
|
|
}
|
|
}
|
|
|
|
void
|
|
IdleRequestExecutor::MaybeDispatch(TimeStamp aDelayUntil)
|
|
{
|
|
// If we've already dispatched the executor we don't want to do it
|
|
// again. Also, if we've called IdleRequestExecutor::Cancel mWindow
|
|
// will be null, which indicates that we shouldn't dispatch this
|
|
// executor either.
|
|
if (mDispatched || IsCancelled()) {
|
|
return;
|
|
}
|
|
|
|
mDispatched = true;
|
|
|
|
nsPIDOMWindowOuter* outer = mWindow->GetOuterWindow();
|
|
if (outer && outer->AsOuter()->IsBackground()) {
|
|
// Set a timeout handler with a timeout of 0 ms to throttle idle
|
|
// callback requests coming from a backround window using
|
|
// background timeout throttling.
|
|
DelayedDispatch(0);
|
|
return;
|
|
}
|
|
|
|
TimeStamp now = TimeStamp::Now();
|
|
if (!aDelayUntil || aDelayUntil < now) {
|
|
ScheduleDispatch();
|
|
return;
|
|
}
|
|
|
|
TimeDuration delay = aDelayUntil - now;
|
|
DelayedDispatch(static_cast<uint32_t>(delay.ToMilliseconds()));
|
|
}
|
|
|
|
void
|
|
IdleRequestExecutor::ScheduleDispatch()
|
|
{
|
|
MOZ_ASSERT(mWindow);
|
|
mDelayedExecutorHandle = Nothing();
|
|
RefPtr<IdleRequestExecutor> request = this;
|
|
NS_IdleDispatchToCurrentThread(request.forget());
|
|
}
|
|
|
|
void
|
|
IdleRequestExecutor::DelayedDispatch(uint32_t aDelay)
|
|
{
|
|
MOZ_ASSERT(mWindow);
|
|
MOZ_ASSERT(mDelayedExecutorHandle.isNothing());
|
|
int32_t handle;
|
|
mWindow->AsInner()->TimeoutManager().SetTimeout(
|
|
mDelayedExecutorDispatcher, aDelay, false, Timeout::Reason::eIdleCallbackTimeout, &handle);
|
|
mDelayedExecutorHandle = Some(handle);
|
|
}
|
|
|
|
nsresult
|
|
IdleRequestExecutorTimeoutHandler::Call()
|
|
{
|
|
if (!mExecutor->IsCancelled()) {
|
|
mExecutor->ScheduleDispatch();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ScheduleIdleRequestDispatch()
|
|
{
|
|
AssertIsOnMainThread();
|
|
|
|
if (!mIdleRequestExecutor) {
|
|
mIdleRequestExecutor = new IdleRequestExecutor(this);
|
|
}
|
|
|
|
mIdleRequestExecutor->MaybeDispatch();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SuspendIdleRequests()
|
|
{
|
|
if (mIdleRequestExecutor) {
|
|
mIdleRequestExecutor->Cancel();
|
|
mIdleRequestExecutor = nullptr;
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ResumeIdleRequests()
|
|
{
|
|
MOZ_ASSERT(!mIdleRequestExecutor);
|
|
|
|
ScheduleIdleRequestDispatch();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::InsertIdleCallback(IdleRequest* aRequest)
|
|
{
|
|
AssertIsOnMainThread();
|
|
mIdleRequestCallbacks.insertBack(aRequest);
|
|
aRequest->AddRef();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::RemoveIdleCallback(mozilla::dom::IdleRequest* aRequest)
|
|
{
|
|
AssertIsOnMainThread();
|
|
|
|
if (aRequest->HasTimeout()) {
|
|
mTimeoutManager->ClearTimeout(aRequest->GetTimeoutHandle(),
|
|
Timeout::Reason::eIdleCallbackTimeout);
|
|
}
|
|
|
|
aRequest->removeFrom(mIdleRequestCallbacks);
|
|
aRequest->Release();
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::RunIdleRequest(IdleRequest* aRequest,
|
|
DOMHighResTimeStamp aDeadline,
|
|
bool aDidTimeout)
|
|
{
|
|
AssertIsOnMainThread();
|
|
RefPtr<IdleRequest> request(aRequest);
|
|
RemoveIdleCallback(request);
|
|
return request->IdleRun(AsInner(), aDeadline, aDidTimeout);
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::ExecuteIdleRequest(TimeStamp aDeadline)
|
|
{
|
|
AssertIsOnMainThread();
|
|
RefPtr<IdleRequest> request = mIdleRequestCallbacks.getFirst();
|
|
|
|
if (!request) {
|
|
// There are no more idle requests, so stop scheduling idle
|
|
// request callbacks.
|
|
return NS_OK;
|
|
}
|
|
|
|
// If the request that we're trying to execute has been queued
|
|
// during the current idle period, then dispatch it again at the end
|
|
// of the idle period.
|
|
if (mIdleRequestExecutor->IneligibleForCurrentIdlePeriod(request)) {
|
|
mIdleRequestExecutor->MaybeDispatch(aDeadline);
|
|
return NS_OK;
|
|
}
|
|
|
|
DOMHighResTimeStamp deadline = 0.0;
|
|
|
|
if (Performance* perf = GetPerformance()) {
|
|
deadline = perf->GetDOMTiming()->TimeStampToDOMHighRes(aDeadline);
|
|
}
|
|
|
|
mIdleRequestExecutor->MaybeUpdateIdlePeriodLimit();
|
|
nsresult result = RunIdleRequest(request, deadline, false);
|
|
|
|
// Running the idle callback could've suspended the window, in which
|
|
// case mIdleRequestExecutor will be null.
|
|
if (mIdleRequestExecutor) {
|
|
mIdleRequestExecutor->MaybeDispatch();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
class IdleRequestTimeoutHandler final : public TimeoutHandler
|
|
{
|
|
public:
|
|
IdleRequestTimeoutHandler(JSContext* aCx,
|
|
IdleRequest* aIdleRequest,
|
|
nsPIDOMWindowInner* aWindow)
|
|
: TimeoutHandler(aCx)
|
|
, mIdleRequest(aIdleRequest)
|
|
, mWindow(aWindow)
|
|
{
|
|
}
|
|
|
|
NS_DECL_ISUPPORTS_INHERITED
|
|
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(IdleRequestTimeoutHandler,
|
|
TimeoutHandler)
|
|
|
|
nsresult Call() override
|
|
{
|
|
return nsGlobalWindow::Cast(mWindow)->RunIdleRequest(mIdleRequest, 0.0, true);
|
|
}
|
|
|
|
private:
|
|
~IdleRequestTimeoutHandler() override {}
|
|
|
|
RefPtr<IdleRequest> mIdleRequest;
|
|
nsCOMPtr<nsPIDOMWindowInner> mWindow;
|
|
};
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_INHERITED(IdleRequestTimeoutHandler,
|
|
TimeoutHandler,
|
|
mIdleRequest,
|
|
mWindow)
|
|
|
|
NS_IMPL_ADDREF_INHERITED(IdleRequestTimeoutHandler, TimeoutHandler)
|
|
NS_IMPL_RELEASE_INHERITED(IdleRequestTimeoutHandler, TimeoutHandler)
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(IdleRequestTimeoutHandler)
|
|
NS_INTERFACE_MAP_END_INHERITING(TimeoutHandler)
|
|
|
|
uint32_t
|
|
nsGlobalWindow::RequestIdleCallback(JSContext* aCx,
|
|
IdleRequestCallback& aCallback,
|
|
const IdleRequestOptions& aOptions,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
AssertIsOnMainThread();
|
|
|
|
uint32_t handle = mIdleRequestCallbackCounter++;
|
|
|
|
RefPtr<IdleRequest> request =
|
|
new IdleRequest(&aCallback, handle);
|
|
|
|
if (aOptions.mTimeout.WasPassed()) {
|
|
int32_t timeoutHandle;
|
|
nsCOMPtr<nsITimeoutHandler> handler(new IdleRequestTimeoutHandler(aCx, request, AsInner()));
|
|
|
|
nsresult rv = mTimeoutManager->SetTimeout(
|
|
handler, aOptions.mTimeout.Value(), false,
|
|
Timeout::Reason::eIdleCallbackTimeout, &timeoutHandle);
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return 0;
|
|
}
|
|
|
|
request->SetTimeoutHandle(timeoutHandle);
|
|
}
|
|
|
|
// mIdleRequestCallbacks now owns request
|
|
InsertIdleCallback(request);
|
|
|
|
if (!IsSuspended()) {
|
|
ScheduleIdleRequestDispatch();
|
|
}
|
|
|
|
return handle;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::CancelIdleCallback(uint32_t aHandle)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
for (IdleRequest* r : mIdleRequestCallbacks) {
|
|
if (r->Handle() == aHandle) {
|
|
RemoveIdleCallback(r);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::DisableIdleCallbackRequests()
|
|
{
|
|
if (mIdleRequestExecutor) {
|
|
mIdleRequestExecutor->Cancel();
|
|
mIdleRequestExecutor = nullptr;
|
|
}
|
|
|
|
while (!mIdleRequestCallbacks.isEmpty()) {
|
|
RefPtr<IdleRequest> request = mIdleRequestCallbacks.getFirst();
|
|
RemoveIdleCallback(request);
|
|
}
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::IsBackgroundInternal() const
|
|
{
|
|
return !mOuterWindow || mOuterWindow->IsBackground();
|
|
}
|
|
namespace mozilla {
|
|
namespace dom {
|
|
extern uint64_t
|
|
NextWindowID();
|
|
} // namespace dom
|
|
} // namespace mozilla
|
|
|
|
template<class T>
|
|
nsPIDOMWindow<T>::nsPIDOMWindow(nsPIDOMWindowOuter *aOuterWindow)
|
|
: mFrameElement(nullptr), mDocShell(nullptr), mModalStateDepth(0),
|
|
mMutationBits(0), mActivePeerConnections(0), mIsDocumentLoaded(false),
|
|
mIsHandlingResizeEvent(false), mIsInnerWindow(aOuterWindow != nullptr),
|
|
mMayHavePaintEventListener(false), mMayHaveTouchEventListener(false),
|
|
mMayHaveSelectionChangeEventListener(false),
|
|
mMayHaveMouseEnterLeaveEventListener(false),
|
|
mMayHavePointerEnterLeaveEventListener(false),
|
|
mInnerObjectsFreed(false),
|
|
mIsActive(false), mIsBackground(false),
|
|
mMediaSuspend(Preferences::GetBool("media.block-autoplay-until-in-foreground", true) ?
|
|
nsISuspendedTypes::SUSPENDED_BLOCK : nsISuspendedTypes::NONE_SUSPENDED),
|
|
mAudioMuted(false), mAudioVolume(1.0), mAudioCaptured(false),
|
|
mDesktopModeViewport(false), mIsRootOuterWindow(false), mInnerWindow(nullptr),
|
|
mOuterWindow(aOuterWindow),
|
|
// Make sure no actual window ends up with mWindowID == 0
|
|
mWindowID(NextWindowID()), mHasNotifiedGlobalCreated(false),
|
|
mMarkedCCGeneration(0), mServiceWorkersTestingEnabled(false),
|
|
mLargeAllocStatus(LargeAllocStatus::NONE),
|
|
mHasTriedToCacheTopInnerWindow(false),
|
|
mNumOfIndexedDBDatabases(0),
|
|
mNumOfOpenWebSockets(0)
|
|
{
|
|
if (aOuterWindow) {
|
|
mTimeoutManager =
|
|
MakeUnique<mozilla::dom::TimeoutManager>(*nsGlobalWindow::Cast(AsInner()));
|
|
}
|
|
}
|
|
|
|
template<class T>
|
|
nsPIDOMWindow<T>::~nsPIDOMWindow() {}
|
|
|
|
/* static */
|
|
nsPIDOMWindowOuter*
|
|
nsPIDOMWindowOuter::GetFromCurrentInner(nsPIDOMWindowInner* aInner)
|
|
{
|
|
if (!aInner) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsPIDOMWindowOuter* outer = aInner->GetOuterWindow();
|
|
if (!outer || outer->GetCurrentInnerWindow() != aInner) {
|
|
return nullptr;
|
|
}
|
|
|
|
return outer;
|
|
}
|
|
|
|
// DialogValueHolder CC goop.
|
|
NS_IMPL_CYCLE_COLLECTION(DialogValueHolder, mValue)
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DialogValueHolder)
|
|
NS_INTERFACE_MAP_ENTRY(nsISupports)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(DialogValueHolder)
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(DialogValueHolder)
|
|
|
|
//*****************************************************************************
|
|
// nsOuterWindowProxy: Outer Window Proxy
|
|
//*****************************************************************************
|
|
|
|
class nsOuterWindowProxy : public js::Wrapper
|
|
{
|
|
public:
|
|
constexpr nsOuterWindowProxy() : js::Wrapper(0) { }
|
|
|
|
bool finalizeInBackground(const JS::Value& priv) const override {
|
|
return false;
|
|
}
|
|
|
|
// Standard internal methods
|
|
bool getOwnPropertyDescriptor(JSContext* cx,
|
|
JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id,
|
|
JS::MutableHandle<JS::PropertyDescriptor> desc)
|
|
const override;
|
|
bool defineProperty(JSContext* cx,
|
|
JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id,
|
|
JS::Handle<JS::PropertyDescriptor> desc,
|
|
JS::ObjectOpResult &result) const override;
|
|
bool ownPropertyKeys(JSContext *cx,
|
|
JS::Handle<JSObject*> proxy,
|
|
JS::AutoIdVector &props) const override;
|
|
bool delete_(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id,
|
|
JS::ObjectOpResult &result) const override;
|
|
|
|
bool getPrototypeIfOrdinary(JSContext* cx,
|
|
JS::Handle<JSObject*> proxy,
|
|
bool* isOrdinary,
|
|
JS::MutableHandle<JSObject*> protop) const override;
|
|
|
|
JSObject* enumerate(JSContext *cx, JS::Handle<JSObject*> proxy) const override;
|
|
bool preventExtensions(JSContext* cx,
|
|
JS::Handle<JSObject*> proxy,
|
|
JS::ObjectOpResult& result) const override;
|
|
bool isExtensible(JSContext *cx, JS::Handle<JSObject*> proxy, bool *extensible)
|
|
const override;
|
|
bool has(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id, bool *bp) const override;
|
|
bool get(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::Handle<JS::Value> receiver,
|
|
JS::Handle<jsid> id,
|
|
JS::MutableHandle<JS::Value> vp) const override;
|
|
bool set(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id, JS::Handle<JS::Value> v,
|
|
JS::Handle<JS::Value> receiver,
|
|
JS::ObjectOpResult &result) const override;
|
|
|
|
// SpiderMonkey extensions
|
|
bool getPropertyDescriptor(JSContext* cx,
|
|
JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id,
|
|
JS::MutableHandle<JS::PropertyDescriptor> desc)
|
|
const override;
|
|
bool hasOwn(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id, bool *bp) const override;
|
|
bool getOwnEnumerablePropertyKeys(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::AutoIdVector &props) const override;
|
|
const char *className(JSContext *cx,
|
|
JS::Handle<JSObject*> wrapper) const override;
|
|
|
|
void finalize(JSFreeOp *fop, JSObject *proxy) const override;
|
|
size_t objectMoved(JSObject* proxy, JSObject* old) const override;
|
|
|
|
bool isCallable(JSObject *obj) const override {
|
|
return false;
|
|
}
|
|
bool isConstructor(JSObject *obj) const override {
|
|
return false;
|
|
}
|
|
|
|
bool watch(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id, JS::Handle<JSObject*> callable) const override;
|
|
bool unwatch(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id) const override;
|
|
|
|
static const nsOuterWindowProxy singleton;
|
|
|
|
protected:
|
|
static nsGlobalWindow* GetOuterWindow(JSObject *proxy)
|
|
{
|
|
nsGlobalWindow* outerWindow = nsGlobalWindow::FromSupports(
|
|
static_cast<nsISupports*>(js::GetProxyReservedSlot(proxy, 0).toPrivate()));
|
|
MOZ_ASSERT_IF(outerWindow, outerWindow->IsOuterWindow());
|
|
return outerWindow;
|
|
}
|
|
|
|
// False return value means we threw an exception. True return value
|
|
// but false "found" means we didn't have a subframe at that index.
|
|
bool GetSubframeWindow(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id,
|
|
JS::MutableHandle<JS::Value> vp,
|
|
bool &found) const;
|
|
|
|
// Returns a non-null window only if id is an index and we have a
|
|
// window at that index.
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
GetSubframeWindow(JSContext *cx,
|
|
JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id) const;
|
|
|
|
bool AppendIndexedPropertyNames(JSContext *cx, JSObject *proxy,
|
|
JS::AutoIdVector &props) const;
|
|
};
|
|
|
|
// Give OuterWindowProxyClass 2 reserved slots, like the other wrappers, so
|
|
// JSObject::swap can swap it with CrossCompartmentWrappers without requiring
|
|
// malloc.
|
|
const js::Class OuterWindowProxyClass = PROXY_CLASS_DEF(
|
|
"Proxy",
|
|
JSCLASS_HAS_RESERVED_SLOTS(2)); /* additional class flags */
|
|
|
|
const char *
|
|
nsOuterWindowProxy::className(JSContext *cx, JS::Handle<JSObject*> proxy) const
|
|
{
|
|
MOZ_ASSERT(js::IsProxy(proxy));
|
|
|
|
return "Window";
|
|
}
|
|
|
|
void
|
|
nsOuterWindowProxy::finalize(JSFreeOp *fop, JSObject *proxy) const
|
|
{
|
|
nsGlobalWindow* outerWindow = GetOuterWindow(proxy);
|
|
if (outerWindow) {
|
|
outerWindow->ClearWrapper(proxy);
|
|
|
|
// Ideally we would use OnFinalize here, but it's possible that
|
|
// EnsureScriptEnvironment will later be called on the window, and we don't
|
|
// want to create a new script object in that case. Therefore, we need to
|
|
// write a non-null value that will reliably crash when dereferenced.
|
|
outerWindow->PoisonOuterWindowProxy(proxy);
|
|
}
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::getPropertyDescriptor(JSContext* cx,
|
|
JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id,
|
|
JS::MutableHandle<JS::PropertyDescriptor> desc) const
|
|
{
|
|
// The only thing we can do differently from js::Wrapper is shadow stuff with
|
|
// our indexed properties, so we can just try getOwnPropertyDescriptor and if
|
|
// that gives us nothing call on through to js::Wrapper.
|
|
desc.object().set(nullptr);
|
|
if (!getOwnPropertyDescriptor(cx, proxy, id, desc)) {
|
|
return false;
|
|
}
|
|
|
|
if (desc.object()) {
|
|
return true;
|
|
}
|
|
|
|
return js::Wrapper::getPropertyDescriptor(cx, proxy, id, desc);
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::getOwnPropertyDescriptor(JSContext* cx,
|
|
JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id,
|
|
JS::MutableHandle<JS::PropertyDescriptor> desc)
|
|
const
|
|
{
|
|
bool found;
|
|
if (!GetSubframeWindow(cx, proxy, id, desc.value(), found)) {
|
|
return false;
|
|
}
|
|
if (found) {
|
|
FillPropertyDescriptor(desc, proxy, true);
|
|
return true;
|
|
}
|
|
// else fall through to js::Wrapper
|
|
|
|
return js::Wrapper::getOwnPropertyDescriptor(cx, proxy, id, desc);
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::defineProperty(JSContext* cx,
|
|
JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id,
|
|
JS::Handle<JS::PropertyDescriptor> desc,
|
|
JS::ObjectOpResult &result) const
|
|
{
|
|
if (IsArrayIndex(GetArrayIndexFromId(cx, id))) {
|
|
// Spec says to Reject whether this is a supported index or not,
|
|
// since we have no indexed setter or indexed creator. It is up
|
|
// to the caller to decide whether to throw a TypeError.
|
|
return result.failCantDefineWindowElement();
|
|
}
|
|
|
|
return js::Wrapper::defineProperty(cx, proxy, id, desc, result);
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::ownPropertyKeys(JSContext *cx,
|
|
JS::Handle<JSObject*> proxy,
|
|
JS::AutoIdVector &props) const
|
|
{
|
|
// Just our indexed stuff followed by our "normal" own property names.
|
|
if (!AppendIndexedPropertyNames(cx, proxy, props)) {
|
|
return false;
|
|
}
|
|
|
|
JS::AutoIdVector innerProps(cx);
|
|
if (!js::Wrapper::ownPropertyKeys(cx, proxy, innerProps)) {
|
|
return false;
|
|
}
|
|
return js::AppendUnique(cx, props, innerProps);
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::delete_(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id, JS::ObjectOpResult &result) const
|
|
{
|
|
if (nsCOMPtr<nsPIDOMWindowOuter> frame = GetSubframeWindow(cx, proxy, id)) {
|
|
// Fail (which means throw if strict, else return false).
|
|
return result.failCantDeleteWindowElement();
|
|
}
|
|
|
|
if (IsArrayIndex(GetArrayIndexFromId(cx, id))) {
|
|
// Indexed, but not supported. Spec says return true.
|
|
return result.succeed();
|
|
}
|
|
|
|
return js::Wrapper::delete_(cx, proxy, id, result);
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::getPrototypeIfOrdinary(JSContext* cx,
|
|
JS::Handle<JSObject*> proxy,
|
|
bool* isOrdinary,
|
|
JS::MutableHandle<JSObject*> protop) const
|
|
{
|
|
// Window's [[GetPrototypeOf]] trap isn't the ordinary definition:
|
|
//
|
|
// https://html.spec.whatwg.org/multipage/browsers.html#windowproxy-getprototypeof
|
|
//
|
|
// We nonetheless can implement it with a static [[Prototype]], because
|
|
// wrapper-class handlers (particularly, XOW in FilteringWrapper.cpp) supply
|
|
// all non-ordinary behavior.
|
|
//
|
|
// But from a spec point of view, it's the exact same object in both cases --
|
|
// only the observer's changed. So this getPrototypeIfOrdinary trap on the
|
|
// non-wrapper object *must* report non-ordinary, even if static [[Prototype]]
|
|
// usually means ordinary.
|
|
*isOrdinary = false;
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::preventExtensions(JSContext* cx,
|
|
JS::Handle<JSObject*> proxy,
|
|
JS::ObjectOpResult& result) const
|
|
{
|
|
// If [[Extensible]] could be false, then navigating a window could navigate
|
|
// to a window that's [[Extensible]] after being at one that wasn't: an
|
|
// invariant violation. So never change a window's extensibility.
|
|
return result.failCantPreventExtensions();
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::isExtensible(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
bool *extensible) const
|
|
{
|
|
// See above.
|
|
*extensible = true;
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::has(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id, bool *bp) const
|
|
{
|
|
if (nsCOMPtr<nsPIDOMWindowOuter> frame = GetSubframeWindow(cx, proxy, id)) {
|
|
*bp = true;
|
|
return true;
|
|
}
|
|
|
|
return js::Wrapper::has(cx, proxy, id, bp);
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::hasOwn(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id, bool *bp) const
|
|
{
|
|
if (nsCOMPtr<nsPIDOMWindowOuter> frame = GetSubframeWindow(cx, proxy, id)) {
|
|
*bp = true;
|
|
return true;
|
|
}
|
|
|
|
return js::Wrapper::hasOwn(cx, proxy, id, bp);
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::get(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::Handle<JS::Value> receiver,
|
|
JS::Handle<jsid> id,
|
|
JS::MutableHandle<JS::Value> vp) const
|
|
{
|
|
if (id == nsDOMClassInfo::sWrappedJSObject_id &&
|
|
xpc::AccessCheck::isChrome(js::GetContextCompartment(cx))) {
|
|
vp.set(JS::ObjectValue(*proxy));
|
|
return true;
|
|
}
|
|
|
|
bool found;
|
|
if (!GetSubframeWindow(cx, proxy, id, vp, found)) {
|
|
return false;
|
|
}
|
|
if (found) {
|
|
return true;
|
|
}
|
|
// Else fall through to js::Wrapper
|
|
|
|
return js::Wrapper::get(cx, proxy, receiver, id, vp);
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::set(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id,
|
|
JS::Handle<JS::Value> v,
|
|
JS::Handle<JS::Value> receiver,
|
|
JS::ObjectOpResult &result) const
|
|
{
|
|
if (IsArrayIndex(GetArrayIndexFromId(cx, id))) {
|
|
// Reject the set. It's up to the caller to decide whether to throw a
|
|
// TypeError. If the caller is strict mode JS code, it'll throw.
|
|
return result.failReadOnly();
|
|
}
|
|
|
|
return js::Wrapper::set(cx, proxy, id, v, receiver, result);
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::getOwnEnumerablePropertyKeys(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::AutoIdVector &props) const
|
|
{
|
|
// Like ownPropertyKeys, our indexed stuff followed by our "normal" enumerable
|
|
// own property names.
|
|
//
|
|
// Note that this does not match current spec per
|
|
// https://github.com/whatwg/html/issues/2753 but as that issue says I believe
|
|
// the spec is wrong.
|
|
if (!AppendIndexedPropertyNames(cx, proxy, props)) {
|
|
return false;
|
|
}
|
|
|
|
JS::AutoIdVector innerProps(cx);
|
|
if (!js::Wrapper::getOwnEnumerablePropertyKeys(cx, proxy, innerProps)) {
|
|
return false;
|
|
}
|
|
return js::AppendUnique(cx, props, innerProps);
|
|
}
|
|
|
|
JSObject*
|
|
nsOuterWindowProxy::enumerate(JSContext *cx, JS::Handle<JSObject*> proxy) const
|
|
{
|
|
// BaseProxyHandler::enumerate seems to do what we want here: fall
|
|
// back on the property names returned from js::GetPropertyKeys()
|
|
return js::BaseProxyHandler::enumerate(cx, proxy);
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::GetSubframeWindow(JSContext *cx,
|
|
JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id,
|
|
JS::MutableHandle<JS::Value> vp,
|
|
bool& found) const
|
|
{
|
|
nsCOMPtr<nsPIDOMWindowOuter> frame = GetSubframeWindow(cx, proxy, id);
|
|
if (!frame) {
|
|
found = false;
|
|
return true;
|
|
}
|
|
|
|
found = true;
|
|
// Just return the window's global
|
|
nsGlobalWindow* global = nsGlobalWindow::Cast(frame);
|
|
frame->EnsureInnerWindow();
|
|
JSObject* obj = global->FastGetGlobalJSObject();
|
|
// This null check fixes a hard-to-reproduce crash that occurs when we
|
|
// get here when we're mid-call to nsDocShell::Destroy. See bug 640904
|
|
// comment 105.
|
|
if (MOZ_UNLIKELY(!obj)) {
|
|
return xpc::Throw(cx, NS_ERROR_FAILURE);
|
|
}
|
|
JS::ExposeObjectToActiveJS(obj);
|
|
vp.setObject(*obj);
|
|
return JS_WrapValue(cx, vp);
|
|
}
|
|
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsOuterWindowProxy::GetSubframeWindow(JSContext *cx,
|
|
JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id) const
|
|
{
|
|
uint32_t index = GetArrayIndexFromId(cx, id);
|
|
if (!IsArrayIndex(index)) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsGlobalWindow* win = GetOuterWindow(proxy);
|
|
MOZ_ASSERT(win->IsOuterWindow());
|
|
return win->IndexedGetterOuter(index);
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::AppendIndexedPropertyNames(JSContext *cx, JSObject *proxy,
|
|
JS::AutoIdVector &props) const
|
|
{
|
|
uint32_t length = GetOuterWindow(proxy)->Length();
|
|
MOZ_ASSERT(int32_t(length) >= 0);
|
|
if (!props.reserve(props.length() + length)) {
|
|
return false;
|
|
}
|
|
for (int32_t i = 0; i < int32_t(length); ++i) {
|
|
if (!props.append(INT_TO_JSID(i))) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::watch(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id, JS::Handle<JSObject*> callable) const
|
|
{
|
|
return js::WatchGuts(cx, proxy, id, callable);
|
|
}
|
|
|
|
bool
|
|
nsOuterWindowProxy::unwatch(JSContext *cx, JS::Handle<JSObject*> proxy,
|
|
JS::Handle<jsid> id) const
|
|
{
|
|
return js::UnwatchGuts(cx, proxy, id);
|
|
}
|
|
|
|
size_t
|
|
nsOuterWindowProxy::objectMoved(JSObject *obj, JSObject *old) const
|
|
{
|
|
nsGlobalWindow* outerWindow = GetOuterWindow(obj);
|
|
if (outerWindow) {
|
|
outerWindow->UpdateWrapper(obj, old);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
const nsOuterWindowProxy
|
|
nsOuterWindowProxy::singleton;
|
|
|
|
class nsChromeOuterWindowProxy : public nsOuterWindowProxy
|
|
{
|
|
public:
|
|
constexpr nsChromeOuterWindowProxy() : nsOuterWindowProxy() { }
|
|
|
|
const char *className(JSContext *cx, JS::Handle<JSObject*> wrapper) const override;
|
|
|
|
static const nsChromeOuterWindowProxy singleton;
|
|
};
|
|
|
|
const char *
|
|
nsChromeOuterWindowProxy::className(JSContext *cx,
|
|
JS::Handle<JSObject*> proxy) const
|
|
{
|
|
MOZ_ASSERT(js::IsProxy(proxy));
|
|
|
|
return "ChromeWindow";
|
|
}
|
|
|
|
const nsChromeOuterWindowProxy
|
|
nsChromeOuterWindowProxy::singleton;
|
|
|
|
static JSObject*
|
|
NewOuterWindowProxy(JSContext *cx, JS::Handle<JSObject*> global, bool isChrome)
|
|
{
|
|
JSAutoCompartment ac(cx, global);
|
|
MOZ_ASSERT(js::GetGlobalForObjectCrossCompartment(global) == global);
|
|
|
|
js::WrapperOptions options;
|
|
options.setClass(&OuterWindowProxyClass);
|
|
options.setSingleton(true);
|
|
JSObject *obj = js::Wrapper::New(cx, global,
|
|
isChrome ? &nsChromeOuterWindowProxy::singleton
|
|
: &nsOuterWindowProxy::singleton,
|
|
options);
|
|
MOZ_ASSERT_IF(obj, js::IsWindowProxy(obj));
|
|
return obj;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
//*** nsGlobalWindow: Object Management
|
|
//*****************************************************************************
|
|
|
|
nsGlobalWindow::nsGlobalWindow(nsGlobalWindow *aOuterWindow)
|
|
: nsPIDOMWindow<nsISupports>(aOuterWindow ? aOuterWindow->AsOuter() : nullptr),
|
|
mIdleFuzzFactor(0),
|
|
mIdleCallbackIndex(-1),
|
|
mCurrentlyIdle(false),
|
|
mAddActiveEventFuzzTime(true),
|
|
mFullScreen(false),
|
|
mFullscreenMode(false),
|
|
mIsClosed(false),
|
|
mInClose(false),
|
|
mHavePendingClose(false),
|
|
mHadOriginalOpener(false),
|
|
mOriginalOpenerWasSecureContext(false),
|
|
mIsPopupSpam(false),
|
|
mBlockScriptedClosingFlag(false),
|
|
mWasOffline(false),
|
|
mHasHadSlowScript(false),
|
|
mNotifyIdleObserversIdleOnThaw(false),
|
|
mNotifyIdleObserversActiveOnThaw(false),
|
|
mCreatingInnerWindow(false),
|
|
mIsChrome(false),
|
|
mCleanMessageManager(false),
|
|
mNeedsFocus(true),
|
|
mHasFocus(false),
|
|
mShowFocusRingForContent(false),
|
|
mFocusByKeyOccurred(false),
|
|
mHasGamepad(false),
|
|
mHasVREvents(false),
|
|
mHasVRDisplayActivateEvents(false),
|
|
mHasSeenGamepadInput(false),
|
|
mNotifiedIDDestroyed(false),
|
|
mAllowScriptsToClose(false),
|
|
mTopLevelOuterContentWindow(false),
|
|
mSuspendDepth(0),
|
|
mFreezeDepth(0),
|
|
mFocusMethod(0),
|
|
mSerial(0),
|
|
mIdleRequestCallbackCounter(1),
|
|
mIdleRequestExecutor(nullptr),
|
|
#ifdef DEBUG
|
|
mSetOpenerWindowCalled(false),
|
|
#endif
|
|
mCleanedUp(false),
|
|
mDialogAbuseCount(0),
|
|
mAreDialogsEnabled(true),
|
|
#ifdef DEBUG
|
|
mIsValidatingTabGroup(false),
|
|
#endif
|
|
mCanSkipCCGeneration(0),
|
|
mAutoActivateVRDisplayID(0),
|
|
mBeforeUnloadListenerCount(0)
|
|
{
|
|
AssertIsOnMainThread();
|
|
|
|
nsLayoutStatics::AddRef();
|
|
|
|
// Initialize the PRCList (this).
|
|
PR_INIT_CLIST(this);
|
|
|
|
if (aOuterWindow) {
|
|
// |this| is an inner window, add this inner window to the outer
|
|
// window list of inners.
|
|
PR_INSERT_AFTER(this, aOuterWindow);
|
|
|
|
mObserver = new nsGlobalWindowObserver(this);
|
|
if (mObserver) {
|
|
nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
|
|
if (os) {
|
|
// Watch for online/offline status changes so we can fire events. Use
|
|
// a strong reference.
|
|
os->AddObserver(mObserver, NS_IOSERVICE_OFFLINE_STATUS_TOPIC,
|
|
false);
|
|
|
|
os->AddObserver(mObserver, MEMORY_PRESSURE_OBSERVER_TOPIC, false);
|
|
}
|
|
|
|
Preferences::AddStrongObserver(mObserver, "intl.accept_languages");
|
|
|
|
// Watch for storage notifications so we can fire storage events.
|
|
RefPtr<StorageNotifierService> sns =
|
|
StorageNotifierService::GetOrCreate();
|
|
if (sns) {
|
|
sns->Register(mObserver);
|
|
}
|
|
}
|
|
} else {
|
|
// |this| is an outer window. Outer windows start out frozen and
|
|
// remain frozen until they get an inner window.
|
|
MOZ_ASSERT(IsFrozen());
|
|
}
|
|
|
|
if (XRE_IsContentProcess()) {
|
|
nsCOMPtr<nsIDocShell> docShell = GetDocShell();
|
|
if (docShell) {
|
|
mTabChild = docShell->GetTabChild();
|
|
}
|
|
}
|
|
|
|
// We could have failed the first time through trying
|
|
// to create the entropy collector, so we should
|
|
// try to get one until we succeed.
|
|
|
|
gRefCnt++;
|
|
|
|
static bool sFirstTime = true;
|
|
if (sFirstTime) {
|
|
TimeoutManager::Initialize();
|
|
Preferences::AddBoolVarCache(&sIdleObserversAPIFuzzTimeDisabled,
|
|
"dom.idle-observers-api.fuzz_time.disabled",
|
|
false);
|
|
|
|
Preferences::AddUintVarCache(&gThrottledIdlePeriodLength,
|
|
"dom.idle_period.throttled_length",
|
|
DEFAULT_THROTTLED_IDLE_PERIOD_LENGTH);
|
|
sFirstTime = false;
|
|
}
|
|
|
|
if (gDumpFile == nullptr) {
|
|
nsAutoCString fname;
|
|
Preferences::GetCString("browser.dom.window.dump.file", fname);
|
|
if (!fname.IsEmpty()) {
|
|
// If this fails to open, Dump() knows to just go to stdout on null.
|
|
gDumpFile = fopen(fname.get(), "wb+");
|
|
} else {
|
|
gDumpFile = stdout;
|
|
}
|
|
}
|
|
|
|
mSerial = ++gSerialCounter;
|
|
|
|
#ifdef DEBUG
|
|
if (!PR_GetEnv("MOZ_QUIET")) {
|
|
printf_stderr("++DOMWINDOW == %d (%p) [pid = %d] [serial = %d] [outer = %p]\n",
|
|
gRefCnt,
|
|
static_cast<void*>(ToCanonicalSupports(this)),
|
|
getpid(),
|
|
gSerialCounter,
|
|
static_cast<void*>(ToCanonicalSupports(aOuterWindow)));
|
|
}
|
|
#endif
|
|
|
|
MOZ_LOG(gDOMLeakPRLog, LogLevel::Debug,
|
|
("DOMWINDOW %p created outer=%p", this, aOuterWindow));
|
|
|
|
NS_ASSERTION(sWindowsById, "Windows hash table must be created!");
|
|
NS_ASSERTION(!sWindowsById->Get(mWindowID),
|
|
"This window shouldn't be in the hash table yet!");
|
|
// We seem to see crashes in release builds because of null |sWindowsById|.
|
|
if (sWindowsById) {
|
|
sWindowsById->Put(mWindowID, this);
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
|
|
/* static */
|
|
void
|
|
nsGlobalWindow::AssertIsOnMainThread()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
}
|
|
|
|
#endif // DEBUG
|
|
|
|
/* static */
|
|
void
|
|
nsGlobalWindow::Init()
|
|
{
|
|
AssertIsOnMainThread();
|
|
|
|
NS_ASSERTION(gDOMLeakPRLog, "gDOMLeakPRLog should have been initialized!");
|
|
|
|
sWindowsById = new WindowByIdTable();
|
|
}
|
|
|
|
nsGlobalWindow::~nsGlobalWindow()
|
|
{
|
|
AssertIsOnMainThread();
|
|
|
|
if (IsChromeWindow()) {
|
|
MOZ_ASSERT(mCleanMessageManager,
|
|
"chrome windows may always disconnect the msg manager");
|
|
|
|
DisconnectAndClearGroupMessageManagers();
|
|
|
|
if (mChromeFields.mMessageManager) {
|
|
static_cast<nsFrameMessageManager *>(
|
|
mChromeFields.mMessageManager.get())->Disconnect();
|
|
}
|
|
|
|
mCleanMessageManager = false;
|
|
}
|
|
|
|
DisconnectEventTargetObjects();
|
|
|
|
// We have to check if sWindowsById isn't null because ::Shutdown might have
|
|
// been called.
|
|
if (sWindowsById) {
|
|
NS_ASSERTION(sWindowsById->Get(mWindowID),
|
|
"This window should be in the hash table");
|
|
sWindowsById->Remove(mWindowID);
|
|
}
|
|
|
|
--gRefCnt;
|
|
|
|
#ifdef DEBUG
|
|
if (!PR_GetEnv("MOZ_QUIET")) {
|
|
nsAutoCString url;
|
|
if (mLastOpenedURI) {
|
|
url = mLastOpenedURI->GetSpecOrDefault();
|
|
|
|
// Data URLs can be very long, so truncate to avoid flooding the log.
|
|
const uint32_t maxURLLength = 1000;
|
|
if (url.Length() > maxURLLength) {
|
|
url.Truncate(maxURLLength);
|
|
}
|
|
}
|
|
|
|
nsGlobalWindow* outer = nsGlobalWindow::Cast(mOuterWindow);
|
|
printf_stderr("--DOMWINDOW == %d (%p) [pid = %d] [serial = %d] [outer = %p] [url = %s]\n",
|
|
gRefCnt,
|
|
static_cast<void*>(ToCanonicalSupports(this)),
|
|
getpid(),
|
|
mSerial,
|
|
static_cast<void*>(ToCanonicalSupports(outer)),
|
|
url.get());
|
|
}
|
|
#endif
|
|
|
|
MOZ_LOG(gDOMLeakPRLog, LogLevel::Debug, ("DOMWINDOW %p destroyed", this));
|
|
|
|
if (IsOuterWindow()) {
|
|
JSObject *proxy = GetWrapperMaybeDead();
|
|
if (proxy) {
|
|
js::SetProxyReservedSlot(proxy, 0, js::PrivateValue(nullptr));
|
|
}
|
|
|
|
// An outer window is destroyed with inner windows still possibly
|
|
// alive, iterate through the inner windows and null out their
|
|
// back pointer to this outer, and pull them out of the list of
|
|
// inner windows.
|
|
|
|
nsGlobalWindow *w;
|
|
while ((w = (nsGlobalWindow *)PR_LIST_HEAD(this)) != this) {
|
|
PR_REMOVE_AND_INIT_LINK(w);
|
|
}
|
|
|
|
DropOuterWindowDocs();
|
|
} else {
|
|
Telemetry::Accumulate(Telemetry::INNERWINDOWS_WITH_MUTATION_LISTENERS,
|
|
mMutationBits ? 1 : 0);
|
|
|
|
if (mListenerManager) {
|
|
mListenerManager->Disconnect();
|
|
mListenerManager = nullptr;
|
|
}
|
|
|
|
// An inner window is destroyed, pull it out of the outer window's
|
|
// list if inner windows.
|
|
|
|
PR_REMOVE_LINK(this);
|
|
|
|
// If our outer window's inner window is this window, null out the
|
|
// outer window's reference to this window that's being deleted.
|
|
nsGlobalWindow *outer = GetOuterWindowInternal();
|
|
if (outer) {
|
|
outer->MaybeClearInnerWindow(this);
|
|
}
|
|
}
|
|
|
|
// We don't have to leave the tab group if we are an inner window.
|
|
if (mTabGroup && IsOuterWindow()) {
|
|
mTabGroup->Leave(AsOuter());
|
|
}
|
|
|
|
// Outer windows are always supposed to call CleanUp before letting themselves
|
|
// be destroyed. And while CleanUp generally seems to be intended to clean up
|
|
// outers, we've historically called it for both. Changing this would probably
|
|
// involve auditing all of the references that inners and outers can have, and
|
|
// separating the handling into CleanUp() and FreeInnerObjects.
|
|
if (IsInnerWindow()) {
|
|
CleanUp();
|
|
} else {
|
|
MOZ_ASSERT(mCleanedUp);
|
|
}
|
|
|
|
nsCOMPtr<nsIDeviceSensors> ac = do_GetService(NS_DEVICE_SENSORS_CONTRACTID);
|
|
if (ac)
|
|
ac->RemoveWindowAsListener(this);
|
|
|
|
nsLayoutStatics::Release();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::AddEventTargetObject(DOMEventTargetHelper* aObject)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
mEventTargetObjects.PutEntry(aObject);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::RemoveEventTargetObject(DOMEventTargetHelper* aObject)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
mEventTargetObjects.RemoveEntry(aObject);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::DisconnectEventTargetObjects()
|
|
{
|
|
for (auto iter = mEventTargetObjects.ConstIter(); !iter.Done();
|
|
iter.Next()) {
|
|
RefPtr<DOMEventTargetHelper> target = iter.Get()->GetKey();
|
|
target->DisconnectFromOwner();
|
|
}
|
|
mEventTargetObjects.Clear();
|
|
}
|
|
|
|
// static
|
|
void
|
|
nsGlobalWindow::ShutDown()
|
|
{
|
|
AssertIsOnMainThread();
|
|
|
|
if (gDumpFile && gDumpFile != stdout) {
|
|
fclose(gDumpFile);
|
|
}
|
|
gDumpFile = nullptr;
|
|
|
|
delete sWindowsById;
|
|
sWindowsById = nullptr;
|
|
}
|
|
|
|
// static
|
|
void
|
|
nsGlobalWindow::CleanupCachedXBLHandlers(nsGlobalWindow* aWindow)
|
|
{
|
|
if (aWindow->mCachedXBLPrototypeHandlers &&
|
|
aWindow->mCachedXBLPrototypeHandlers->Count() > 0) {
|
|
aWindow->mCachedXBLPrototypeHandlers->Clear();
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::MaybeForgiveSpamCount()
|
|
{
|
|
if (IsOuterWindow() &&
|
|
IsPopupSpamWindow()) {
|
|
SetIsPopupSpamWindow(false);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetIsPopupSpamWindow(bool aIsPopupSpam)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
mIsPopupSpam = aIsPopupSpam;
|
|
if (aIsPopupSpam) {
|
|
++gOpenPopupSpamCount;
|
|
} else {
|
|
--gOpenPopupSpamCount;
|
|
NS_ASSERTION(gOpenPopupSpamCount >= 0,
|
|
"Unbalanced decrement of gOpenPopupSpamCount");
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::DropOuterWindowDocs()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
MOZ_ASSERT_IF(mDoc, !mDoc->EventHandlingSuppressed());
|
|
mDoc = nullptr;
|
|
mSuspendedDoc = nullptr;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::CleanUp()
|
|
{
|
|
// Guarantee idempotence.
|
|
if (mCleanedUp)
|
|
return;
|
|
mCleanedUp = true;
|
|
|
|
StartDying();
|
|
|
|
DisconnectEventTargetObjects();
|
|
|
|
if (mObserver) {
|
|
nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
|
|
if (os) {
|
|
os->RemoveObserver(mObserver, NS_IOSERVICE_OFFLINE_STATUS_TOPIC);
|
|
os->RemoveObserver(mObserver, MEMORY_PRESSURE_OBSERVER_TOPIC);
|
|
}
|
|
|
|
RefPtr<StorageNotifierService> sns = StorageNotifierService::GetOrCreate();
|
|
if (sns) {
|
|
sns->Unregister(mObserver);
|
|
}
|
|
|
|
if (mIdleService) {
|
|
mIdleService->RemoveIdleObserver(mObserver, MIN_IDLE_NOTIFICATION_TIME_S);
|
|
}
|
|
|
|
Preferences::RemoveObserver(mObserver, "intl.accept_languages");
|
|
|
|
// Drop its reference to this dying window, in case for some bogus reason
|
|
// the object stays around.
|
|
mObserver->Forget();
|
|
}
|
|
|
|
if (mNavigator) {
|
|
mNavigator->Invalidate();
|
|
mNavigator = nullptr;
|
|
}
|
|
|
|
mScreen = nullptr;
|
|
mMenubar = nullptr;
|
|
mToolbar = nullptr;
|
|
mLocationbar = nullptr;
|
|
mPersonalbar = nullptr;
|
|
mStatusbar = nullptr;
|
|
mScrollbars = nullptr;
|
|
mHistory = nullptr;
|
|
mCustomElements = nullptr;
|
|
mFrames = nullptr;
|
|
mWindowUtils = nullptr;
|
|
mApplicationCache = nullptr;
|
|
mIndexedDB = nullptr;
|
|
|
|
mConsole = nullptr;
|
|
|
|
mAudioWorklet = nullptr;
|
|
mPaintWorklet = nullptr;
|
|
|
|
mExternal = nullptr;
|
|
|
|
mMozSelfSupport = nullptr;
|
|
|
|
mPerformance = nullptr;
|
|
|
|
#ifdef MOZ_WEBSPEECH
|
|
mSpeechSynthesis = nullptr;
|
|
#endif
|
|
|
|
#if defined(MOZ_WIDGET_ANDROID)
|
|
mOrientationChangeObserver = nullptr;
|
|
#endif
|
|
|
|
ClearControllers();
|
|
|
|
mOpener = nullptr; // Forces Release
|
|
if (mContext) {
|
|
mContext = nullptr; // Forces Release
|
|
}
|
|
mChromeEventHandler = nullptr; // Forces Release
|
|
mParentTarget = nullptr;
|
|
|
|
if (IsOuterWindow()) {
|
|
nsGlobalWindow* inner = GetCurrentInnerWindowInternal();
|
|
if (inner) {
|
|
inner->CleanUp();
|
|
}
|
|
}
|
|
|
|
if (IsInnerWindow()) {
|
|
DisableGamepadUpdates();
|
|
mHasGamepad = false;
|
|
DisableVRUpdates();
|
|
mHasVREvents = false;
|
|
mHasVRDisplayActivateEvents = false;
|
|
DisableIdleCallbackRequests();
|
|
} else {
|
|
MOZ_ASSERT(!mHasGamepad);
|
|
MOZ_ASSERT(!mHasVREvents);
|
|
MOZ_ASSERT(!mHasVRDisplayActivateEvents);
|
|
}
|
|
|
|
if (mCleanMessageManager) {
|
|
MOZ_ASSERT(mIsChrome, "only chrome should have msg manager cleaned");
|
|
if (mChromeFields.mMessageManager) {
|
|
static_cast<nsFrameMessageManager*>(
|
|
mChromeFields.mMessageManager.get())->Disconnect();
|
|
}
|
|
}
|
|
|
|
mArguments = nullptr;
|
|
|
|
CleanupCachedXBLHandlers(this);
|
|
|
|
for (uint32_t i = 0; i < mAudioContexts.Length(); ++i) {
|
|
mAudioContexts[i]->Shutdown();
|
|
}
|
|
mAudioContexts.Clear();
|
|
|
|
if (mIdleTimer) {
|
|
mIdleTimer->Cancel();
|
|
mIdleTimer = nullptr;
|
|
}
|
|
|
|
mServiceWorkerRegistrationTable.Clear();
|
|
|
|
mIntlUtils = nullptr;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ClearControllers()
|
|
{
|
|
if (mControllers) {
|
|
uint32_t count;
|
|
mControllers->GetControllerCount(&count);
|
|
|
|
while (count--) {
|
|
nsCOMPtr<nsIController> controller;
|
|
mControllers->GetControllerAt(count, getter_AddRefs(controller));
|
|
|
|
nsCOMPtr<nsIControllerContext> context = do_QueryInterface(controller);
|
|
if (context)
|
|
context->SetCommandContext(nullptr);
|
|
}
|
|
|
|
mControllers = nullptr;
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::FreeInnerObjects()
|
|
{
|
|
NS_ASSERTION(IsInnerWindow(), "Don't free inner objects on an outer window");
|
|
|
|
// Make sure that this is called before we null out the document and
|
|
// other members that the window destroyed observers could
|
|
// re-create.
|
|
NotifyDOMWindowDestroyed(this);
|
|
if (auto* reporter = nsWindowMemoryReporter::Get()) {
|
|
reporter->ObserveDOMWindowDetached(this);
|
|
}
|
|
|
|
mInnerObjectsFreed = true;
|
|
|
|
// Kill all of the workers for this window.
|
|
mozilla::dom::workers::CancelWorkersForWindow(AsInner());
|
|
|
|
if (mTimeoutManager) {
|
|
mTimeoutManager->ClearAllTimeouts();
|
|
}
|
|
|
|
if (mIdleTimer) {
|
|
mIdleTimer->Cancel();
|
|
mIdleTimer = nullptr;
|
|
}
|
|
|
|
mIdleObservers.Clear();
|
|
|
|
DisableIdleCallbackRequests();
|
|
|
|
mChromeEventHandler = nullptr;
|
|
|
|
if (mListenerManager) {
|
|
mListenerManager->Disconnect();
|
|
mListenerManager = nullptr;
|
|
}
|
|
|
|
mHistory = nullptr;
|
|
mCustomElements = nullptr;
|
|
|
|
if (mNavigator) {
|
|
mNavigator->OnNavigation();
|
|
mNavigator->Invalidate();
|
|
mNavigator = nullptr;
|
|
}
|
|
|
|
if (mScreen) {
|
|
mScreen = nullptr;
|
|
}
|
|
|
|
#if defined(MOZ_WIDGET_ANDROID)
|
|
mOrientationChangeObserver = nullptr;
|
|
#endif
|
|
|
|
if (mDoc) {
|
|
// Remember the document's principal and URI.
|
|
mDocumentPrincipal = mDoc->NodePrincipal();
|
|
mDocumentURI = mDoc->GetDocumentURI();
|
|
mDocBaseURI = mDoc->GetDocBaseURI();
|
|
|
|
while (mDoc->EventHandlingSuppressed()) {
|
|
mDoc->UnsuppressEventHandlingAndFireEvents(false);
|
|
}
|
|
}
|
|
|
|
// Remove our reference to the document and the document principal.
|
|
mFocusedNode = nullptr;
|
|
|
|
if (mApplicationCache) {
|
|
static_cast<nsDOMOfflineResourceList*>(mApplicationCache.get())->Disconnect();
|
|
mApplicationCache = nullptr;
|
|
}
|
|
|
|
mIndexedDB = nullptr;
|
|
|
|
UnlinkHostObjectURIs();
|
|
|
|
NotifyWindowIDDestroyed("inner-window-destroyed");
|
|
|
|
CleanupCachedXBLHandlers(this);
|
|
|
|
for (uint32_t i = 0; i < mAudioContexts.Length(); ++i) {
|
|
mAudioContexts[i]->Shutdown();
|
|
}
|
|
mAudioContexts.Clear();
|
|
|
|
DisableGamepadUpdates();
|
|
mHasGamepad = false;
|
|
mGamepads.Clear();
|
|
DisableVRUpdates();
|
|
mHasVREvents = false;
|
|
mHasVRDisplayActivateEvents = false;
|
|
mVRDisplays.Clear();
|
|
|
|
if (mTabChild) {
|
|
while (mBeforeUnloadListenerCount-- > 0) {
|
|
mTabChild->BeforeUnloadRemoved();
|
|
}
|
|
}
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// nsGlobalWindow::nsISupports
|
|
//*****************************************************************************
|
|
|
|
// QueryInterface implementation for nsGlobalWindow
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsGlobalWindow)
|
|
NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
|
|
// Make sure this matches the cast in nsGlobalWindow::FromWrapper()
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMEventTarget)
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMWindow)
|
|
NS_INTERFACE_MAP_ENTRY(nsIGlobalObject)
|
|
NS_INTERFACE_MAP_ENTRY(nsIScriptGlobalObject)
|
|
NS_INTERFACE_MAP_ENTRY(nsIScriptObjectPrincipal)
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMEventTarget)
|
|
NS_INTERFACE_MAP_ENTRY(mozilla::dom::EventTarget)
|
|
if (aIID.Equals(NS_GET_IID(nsPIDOMWindowInner))) {
|
|
foundInterface = AsInner();
|
|
} else
|
|
if (aIID.Equals(NS_GET_IID(mozIDOMWindow)) && IsInnerWindow()) {
|
|
foundInterface = AsInner();
|
|
} else
|
|
if (aIID.Equals(NS_GET_IID(nsPIDOMWindowOuter))) {
|
|
foundInterface = AsOuter();
|
|
} else
|
|
if (aIID.Equals(NS_GET_IID(mozIDOMWindowProxy)) && IsOuterWindow()) {
|
|
foundInterface = AsOuter();
|
|
} else
|
|
if (aIID.Equals(NS_GET_IID(nsIDOMChromeWindow)) && IsChromeWindow()) {
|
|
foundInterface = static_cast<nsIDOMChromeWindow*>(this);
|
|
} else
|
|
NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
|
|
NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(nsGlobalWindow)
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(nsGlobalWindow)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsGlobalWindow)
|
|
if (tmp->IsBlackForCC(false)) {
|
|
if (nsCCUncollectableMarker::InGeneration(tmp->mCanSkipCCGeneration)) {
|
|
return true;
|
|
}
|
|
tmp->mCanSkipCCGeneration = nsCCUncollectableMarker::sGeneration;
|
|
if (tmp->mCachedXBLPrototypeHandlers) {
|
|
for (auto iter = tmp->mCachedXBLPrototypeHandlers->Iter();
|
|
!iter.Done();
|
|
iter.Next()) {
|
|
iter.Data().exposeToActiveJS();
|
|
}
|
|
}
|
|
if (EventListenerManager* elm = tmp->GetExistingListenerManager()) {
|
|
elm->MarkForCC();
|
|
}
|
|
if (tmp->mTimeoutManager) {
|
|
tmp->mTimeoutManager->UnmarkGrayTimers();
|
|
}
|
|
return true;
|
|
}
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(nsGlobalWindow)
|
|
return tmp->IsBlackForCC(true);
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(nsGlobalWindow)
|
|
return tmp->IsBlackForCC(false);
|
|
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
|
|
|
|
inline void
|
|
ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
|
|
IdleObserverHolder& aField,
|
|
const char* aName,
|
|
unsigned aFlags)
|
|
{
|
|
CycleCollectionNoteChild(aCallback, aField.mIdleObserver.get(), aName, aFlags);
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(nsGlobalWindow)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INTERNAL(nsGlobalWindow)
|
|
if (MOZ_UNLIKELY(cb.WantDebugInfo())) {
|
|
char name[512];
|
|
nsAutoCString uri;
|
|
if (tmp->mDoc && tmp->mDoc->GetDocumentURI()) {
|
|
uri = tmp->mDoc->GetDocumentURI()->GetSpecOrDefault();
|
|
}
|
|
SprintfLiteral(name, "nsGlobalWindow # %" PRIu64 " %s %s", tmp->mWindowID,
|
|
tmp->IsInnerWindow() ? "inner" : "outer", uri.get());
|
|
cb.DescribeRefCountedNode(tmp->mRefCnt.get(), name);
|
|
} else {
|
|
NS_IMPL_CYCLE_COLLECTION_DESCRIBE(nsGlobalWindow, tmp->mRefCnt.get())
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mContext)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mControllers)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mArguments)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mReturnValue)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mNavigator)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPerformance)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mServiceWorkerRegistrationTable)
|
|
|
|
#ifdef MOZ_WEBSPEECH
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSpeechSynthesis)
|
|
#endif
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOuterWindow)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTopInnerWindow)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mListenerManager)
|
|
|
|
if (tmp->mTimeoutManager) {
|
|
tmp->mTimeoutManager->ForEachUnorderedTimeout([&cb](Timeout* timeout) {
|
|
cb.NoteNativeChild(timeout, NS_CYCLE_COLLECTION_PARTICIPANT(Timeout));
|
|
});
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLocation)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mHistory)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCustomElements)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLocalStorage)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSessionStorage)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mApplicationCache)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSuspendedDoc)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIndexedDB)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocumentPrincipal)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTabChild)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDoc)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIdleService)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWakeLock)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIdleRequestExecutor)
|
|
for (IdleRequest* request : tmp->mIdleRequestCallbacks) {
|
|
cb.NoteNativeChild(request, NS_CYCLE_COLLECTION_PARTICIPANT(IdleRequest));
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIdleObservers)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mGamepads)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCacheStorage)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mVRDisplays)
|
|
|
|
// Traverse stuff from nsPIDOMWindow
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChromeEventHandler)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParentTarget)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFrameElement)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFocusedNode)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMenubar)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mToolbar)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLocationbar)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPersonalbar)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStatusbar)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mScrollbars)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCrypto)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mU2F)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mConsole)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAudioWorklet)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPaintWorklet)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mExternal)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMozSelfSupport)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIntlUtils)
|
|
|
|
tmp->TraverseHostObjectURIs(cb);
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChromeFields.mBrowserDOMWindow)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChromeFields.mMessageManager)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChromeFields.mGroupMessageManagers)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChromeFields.mOpenerForInitialContentBrowser)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsGlobalWindow)
|
|
nsGlobalWindow::CleanupCachedXBLHandlers(tmp);
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mContext)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mControllers)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mArguments)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mReturnValue)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mNavigator)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mPerformance)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mServiceWorkerRegistrationTable)
|
|
|
|
#ifdef MOZ_WEBSPEECH
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mSpeechSynthesis)
|
|
#endif
|
|
|
|
if (tmp->mOuterWindow) {
|
|
nsGlobalWindow::Cast(tmp->mOuterWindow)->MaybeClearInnerWindow(tmp);
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mOuterWindow)
|
|
}
|
|
|
|
if (tmp->mListenerManager) {
|
|
tmp->mListenerManager->Disconnect();
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mListenerManager)
|
|
}
|
|
|
|
tmp->UpdateTopInnerWindow();
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mTopInnerWindow)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mLocation)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mHistory)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mCustomElements)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mLocalStorage)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mSessionStorage)
|
|
if (tmp->mApplicationCache) {
|
|
static_cast<nsDOMOfflineResourceList*>(tmp->mApplicationCache.get())->Disconnect();
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mApplicationCache)
|
|
}
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mSuspendedDoc)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mIndexedDB)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocumentPrincipal)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mTabChild)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mDoc)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mIdleService)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mWakeLock)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mIdleObservers)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mGamepads)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mCacheStorage)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mVRDisplays)
|
|
|
|
// Unlink stuff from nsPIDOMWindow
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mChromeEventHandler)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mParentTarget)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mFrameElement)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mFocusedNode)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mMenubar)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mToolbar)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mLocationbar)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mPersonalbar)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mStatusbar)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mScrollbars)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mCrypto)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mU2F)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mConsole)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mAudioWorklet)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mPaintWorklet)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mExternal)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mMozSelfSupport)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mIntlUtils)
|
|
|
|
tmp->UnlinkHostObjectURIs();
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mIdleRequestExecutor)
|
|
tmp->DisableIdleCallbackRequests();
|
|
|
|
if (tmp->IsChromeWindow()) {
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mChromeFields.mBrowserDOMWindow)
|
|
if (tmp->mChromeFields.mMessageManager) {
|
|
static_cast<nsFrameMessageManager*>(
|
|
tmp->mChromeFields.mMessageManager.get())->Disconnect();
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mChromeFields.mMessageManager)
|
|
}
|
|
tmp->DisconnectAndClearGroupMessageManagers();
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mChromeFields.mGroupMessageManagers)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mChromeFields.mOpenerForInitialContentBrowser)
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
#ifdef DEBUG
|
|
void
|
|
nsGlobalWindow::RiskyUnlink()
|
|
{
|
|
NS_CYCLE_COLLECTION_INNERNAME.Unlink(this);
|
|
}
|
|
#endif
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(nsGlobalWindow)
|
|
if (tmp->mCachedXBLPrototypeHandlers) {
|
|
for (auto iter = tmp->mCachedXBLPrototypeHandlers->Iter();
|
|
!iter.Done();
|
|
iter.Next()) {
|
|
aCallbacks.Trace(&iter.Data(), "Cached XBL prototype handler", aClosure);
|
|
}
|
|
}
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_END
|
|
|
|
bool
|
|
nsGlobalWindow::IsBlackForCC(bool aTracingNeeded)
|
|
{
|
|
if (!nsCCUncollectableMarker::sGeneration) {
|
|
return false;
|
|
}
|
|
|
|
return (nsCCUncollectableMarker::InGeneration(GetMarkedCCGeneration()) ||
|
|
HasKnownLiveWrapper()) &&
|
|
(!aTracingNeeded ||
|
|
HasNothingToTrace(static_cast<nsIDOMEventTarget*>(this)));
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// nsGlobalWindow::nsIScriptGlobalObject
|
|
//*****************************************************************************
|
|
|
|
nsresult
|
|
nsGlobalWindow::EnsureScriptEnvironment()
|
|
{
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
if (!outer) {
|
|
NS_WARNING("No outer window available!");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (outer->GetWrapperPreserveColor()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_ASSERTION(!outer->GetCurrentInnerWindowInternal(),
|
|
"No cached wrapper, but we have an inner window?");
|
|
|
|
// If this window is a [i]frame, don't bother GC'ing when the frame's context
|
|
// is destroyed since a GC will happen when the frameset or host document is
|
|
// destroyed anyway.
|
|
nsCOMPtr<nsIScriptContext> context = new nsJSContext(!IsFrame(), outer);
|
|
|
|
NS_ASSERTION(!outer->mContext, "Will overwrite mContext!");
|
|
|
|
// should probably assert the context is clean???
|
|
context->WillInitializeContext();
|
|
|
|
nsresult rv = context->InitContext();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
outer->mContext = context;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsIScriptContext *
|
|
nsGlobalWindow::GetScriptContext()
|
|
{
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
if (!outer) {
|
|
return nullptr;
|
|
}
|
|
return outer->mContext;
|
|
}
|
|
|
|
JSObject *
|
|
nsGlobalWindow::GetGlobalJSObject()
|
|
{
|
|
return FastGetGlobalJSObject();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::TraceGlobalJSObject(JSTracer* aTrc)
|
|
{
|
|
TraceWrapper(aTrc, "active window global");
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::WouldReuseInnerWindow(nsIDocument* aNewDocument)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
// We reuse the inner window when:
|
|
// a. We are currently at our original document.
|
|
// b. At least one of the following conditions are true:
|
|
// -- The new document is the same as the old document. This means that we're
|
|
// getting called from document.open().
|
|
// -- The new document has the same origin as what we have loaded right now.
|
|
|
|
if (!mDoc || !aNewDocument) {
|
|
return false;
|
|
}
|
|
|
|
if (!mDoc->IsInitialDocument()) {
|
|
return false;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
{
|
|
nsCOMPtr<nsIURI> uri;
|
|
mDoc->GetDocumentURI()->CloneIgnoringRef(getter_AddRefs(uri));
|
|
NS_ASSERTION(NS_IsAboutBlank(uri), "How'd this happen?");
|
|
}
|
|
#endif
|
|
|
|
// Great, we're the original document, check for one of the other
|
|
// conditions.
|
|
|
|
if (mDoc == aNewDocument) {
|
|
return true;
|
|
}
|
|
|
|
bool equal;
|
|
if (NS_SUCCEEDED(mDoc->NodePrincipal()->Equals(aNewDocument->NodePrincipal(),
|
|
&equal)) &&
|
|
equal) {
|
|
// The origin is the same.
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetInitialPrincipalToSubject()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
// First, grab the subject principal.
|
|
nsCOMPtr<nsIPrincipal> newWindowPrincipal = nsContentUtils::SubjectPrincipalOrSystemIfNativeCaller();
|
|
|
|
// We should never create windows with an expanded principal.
|
|
// If we have a system principal, make sure we're not using it for a content
|
|
// docshell.
|
|
// NOTE: Please keep this logic in sync with nsWebShellWindow::Initialize().
|
|
if (nsContentUtils::IsExpandedPrincipal(newWindowPrincipal) ||
|
|
(nsContentUtils::IsSystemPrincipal(newWindowPrincipal) &&
|
|
GetDocShell()->ItemType() != nsIDocShellTreeItem::typeChrome)) {
|
|
newWindowPrincipal = nullptr;
|
|
}
|
|
|
|
// If there's an existing document, bail if it either:
|
|
if (mDoc) {
|
|
// (a) is not an initial about:blank document, or
|
|
if (!mDoc->IsInitialDocument())
|
|
return;
|
|
// (b) already has the correct principal.
|
|
if (mDoc->NodePrincipal() == newWindowPrincipal)
|
|
return;
|
|
|
|
#ifdef DEBUG
|
|
// If we have a document loaded at this point, it had better be about:blank.
|
|
// Otherwise, something is really weird. An about:blank page has a
|
|
// NullPrincipal.
|
|
bool isNullPrincipal;
|
|
MOZ_ASSERT(NS_SUCCEEDED(mDoc->NodePrincipal()->GetIsNullPrincipal(&isNullPrincipal)) &&
|
|
isNullPrincipal);
|
|
#endif
|
|
}
|
|
|
|
GetDocShell()->CreateAboutBlankContentViewer(newWindowPrincipal);
|
|
|
|
if (mDoc) {
|
|
mDoc->SetIsInitialDocument(true);
|
|
}
|
|
|
|
nsCOMPtr<nsIPresShell> shell = GetDocShell()->GetPresShell();
|
|
|
|
if (shell && !shell->DidInitialize()) {
|
|
// Ensure that if someone plays with this document they will get
|
|
// layout happening.
|
|
nsRect r = shell->GetPresContext()->GetVisibleArea();
|
|
shell->Initialize(r.Width(), r.Height());
|
|
}
|
|
}
|
|
|
|
PopupControlState
|
|
PushPopupControlState(PopupControlState aState, bool aForce)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
PopupControlState oldState = gPopupControlState;
|
|
|
|
if (aState < gPopupControlState || aForce) {
|
|
gPopupControlState = aState;
|
|
}
|
|
|
|
return oldState;
|
|
}
|
|
|
|
void
|
|
PopPopupControlState(PopupControlState aState)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
gPopupControlState = aState;
|
|
}
|
|
|
|
PopupControlState
|
|
nsGlobalWindow::PushPopupControlState(PopupControlState aState,
|
|
bool aForce) const
|
|
{
|
|
return ::PushPopupControlState(aState, aForce);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::PopPopupControlState(PopupControlState aState) const
|
|
{
|
|
::PopPopupControlState(aState);
|
|
}
|
|
|
|
PopupControlState
|
|
nsGlobalWindow::GetPopupControlState() const
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
return gPopupControlState;
|
|
}
|
|
|
|
#define WINDOWSTATEHOLDER_IID \
|
|
{0x0b917c3e, 0xbd50, 0x4683, {0xaf, 0xc9, 0xc7, 0x81, 0x07, 0xae, 0x33, 0x26}}
|
|
|
|
class WindowStateHolder final : public nsISupports
|
|
{
|
|
public:
|
|
NS_DECLARE_STATIC_IID_ACCESSOR(WINDOWSTATEHOLDER_IID)
|
|
NS_DECL_ISUPPORTS
|
|
|
|
explicit WindowStateHolder(nsGlobalWindow *aWindow);
|
|
|
|
nsGlobalWindow* GetInnerWindow() { return mInnerWindow; }
|
|
|
|
void DidRestoreWindow()
|
|
{
|
|
mInnerWindow = nullptr;
|
|
mInnerWindowReflector = nullptr;
|
|
}
|
|
|
|
protected:
|
|
~WindowStateHolder();
|
|
|
|
nsGlobalWindow *mInnerWindow;
|
|
// We hold onto this to make sure the inner window doesn't go away. The outer
|
|
// window ends up recalculating it anyway.
|
|
JS::PersistentRooted<JSObject*> mInnerWindowReflector;
|
|
};
|
|
|
|
NS_DEFINE_STATIC_IID_ACCESSOR(WindowStateHolder, WINDOWSTATEHOLDER_IID)
|
|
|
|
WindowStateHolder::WindowStateHolder(nsGlobalWindow* aWindow)
|
|
: mInnerWindow(aWindow),
|
|
mInnerWindowReflector(RootingCx(), aWindow->GetWrapper())
|
|
{
|
|
NS_PRECONDITION(aWindow, "null window");
|
|
NS_PRECONDITION(aWindow->IsInnerWindow(), "Saving an outer window");
|
|
|
|
aWindow->Suspend();
|
|
|
|
// When a global goes into the bfcache, we disable script.
|
|
xpc::Scriptability::Get(mInnerWindowReflector).SetDocShellAllowsScript(false);
|
|
}
|
|
|
|
WindowStateHolder::~WindowStateHolder()
|
|
{
|
|
if (mInnerWindow) {
|
|
// This window was left in the bfcache and is now going away. We need to
|
|
// free it up.
|
|
// Note that FreeInnerObjects may already have been called on the
|
|
// inner window if its outer has already had SetDocShell(null)
|
|
// called.
|
|
mInnerWindow->FreeInnerObjects();
|
|
}
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS(WindowStateHolder, WindowStateHolder)
|
|
|
|
// We need certain special behavior for remote XUL whitelisted domains, but we
|
|
// don't want that behavior to take effect in automation, because we whitelist
|
|
// all the mochitest domains. So we need to check a pref here.
|
|
static bool
|
|
TreatAsRemoteXUL(nsIPrincipal* aPrincipal)
|
|
{
|
|
MOZ_ASSERT(!nsContentUtils::IsSystemPrincipal(aPrincipal));
|
|
return nsContentUtils::AllowXULXBLForPrincipal(aPrincipal) &&
|
|
!Preferences::GetBool("dom.use_xbl_scopes_for_remote_xul", false);
|
|
}
|
|
|
|
static bool
|
|
EnablePrivilege(JSContext* cx, unsigned argc, JS::Value* vp)
|
|
{
|
|
Telemetry::Accumulate(Telemetry::ENABLE_PRIVILEGE_EVER_CALLED, true);
|
|
return xpc::EnableUniversalXPConnect(cx);
|
|
}
|
|
|
|
static const JSFunctionSpec EnablePrivilegeSpec[] = {
|
|
JS_FN("enablePrivilege", EnablePrivilege, 1, 0),
|
|
JS_FS_END
|
|
};
|
|
|
|
static bool
|
|
InitializeLegacyNetscapeObject(JSContext* aCx, JS::Handle<JSObject*> aGlobal)
|
|
{
|
|
JSAutoCompartment ac(aCx, aGlobal);
|
|
|
|
// Note: MathJax depends on window.netscape being exposed. See bug 791526.
|
|
JS::Rooted<JSObject*> obj(aCx);
|
|
obj = JS_DefineObject(aCx, aGlobal, "netscape", nullptr);
|
|
NS_ENSURE_TRUE(obj, false);
|
|
|
|
obj = JS_DefineObject(aCx, obj, "security", nullptr);
|
|
NS_ENSURE_TRUE(obj, false);
|
|
|
|
// We hide enablePrivilege behind a pref because it has been altered in a
|
|
// way that makes it fundamentally insecure to use in production. Mozilla
|
|
// uses this pref during automated testing to support legacy test code that
|
|
// uses enablePrivilege. If you're not doing test automation, you _must_ not
|
|
// flip this pref, or you will be exposing all your users to security
|
|
// vulnerabilities.
|
|
if (!xpc::IsInAutomation()) {
|
|
return true;
|
|
}
|
|
|
|
/* Define PrivilegeManager object with the necessary "static" methods. */
|
|
obj = JS_DefineObject(aCx, obj, "PrivilegeManager", nullptr);
|
|
NS_ENSURE_TRUE(obj, false);
|
|
|
|
return JS_DefineFunctions(aCx, obj, EnablePrivilegeSpec);
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::ComputeIsSecureContext(nsIDocument* aDocument, SecureContextFlags aFlags)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
nsCOMPtr<nsIPrincipal> principal = aDocument->NodePrincipal();
|
|
if (nsContentUtils::IsSystemPrincipal(principal)) {
|
|
return true;
|
|
}
|
|
|
|
// Implement https://w3c.github.io/webappsec-secure-contexts/#settings-object
|
|
// With some modifications to allow for aFlags.
|
|
|
|
bool hadNonSecureContextCreator = false;
|
|
|
|
nsPIDOMWindowOuter* parentOuterWin = GetScriptableParent();
|
|
MOZ_ASSERT(parentOuterWin, "How can we get here? No docShell somehow?");
|
|
if (nsGlobalWindow::Cast(parentOuterWin) != this) {
|
|
// There may be a small chance that parentOuterWin has navigated in
|
|
// the time that it took us to start loading this sub-document. If that
|
|
// were the case then parentOuterWin->GetCurrentInnerWindow() wouldn't
|
|
// return the window for the document that is embedding us. For this
|
|
// reason we only use the GetScriptableParent call above to check that we
|
|
// have a same-type parent, but actually get the inner window via the
|
|
// document that we know is embedding us.
|
|
nsIDocument* creatorDoc = aDocument->GetParentDocument();
|
|
if (!creatorDoc) {
|
|
return false; // we must be tearing down
|
|
}
|
|
nsGlobalWindow* parentWin =
|
|
nsGlobalWindow::Cast(creatorDoc->GetInnerWindow());
|
|
if (!parentWin) {
|
|
return false; // we must be tearing down
|
|
}
|
|
MOZ_ASSERT(parentWin ==
|
|
nsGlobalWindow::Cast(parentOuterWin->GetCurrentInnerWindow()),
|
|
"Creator window mismatch while setting Secure Context state");
|
|
if (aFlags != SecureContextFlags::eIgnoreOpener) {
|
|
hadNonSecureContextCreator = !parentWin->IsSecureContext();
|
|
} else {
|
|
hadNonSecureContextCreator = !parentWin->IsSecureContextIfOpenerIgnored();
|
|
}
|
|
} else if (mHadOriginalOpener) {
|
|
if (aFlags != SecureContextFlags::eIgnoreOpener) {
|
|
hadNonSecureContextCreator = !mOriginalOpenerWasSecureContext;
|
|
}
|
|
}
|
|
|
|
if (hadNonSecureContextCreator) {
|
|
return false;
|
|
}
|
|
|
|
if (nsContentUtils::HttpsStateIsModern(aDocument)) {
|
|
return true;
|
|
}
|
|
|
|
if (principal->GetIsNullPrincipal()) {
|
|
nsCOMPtr<nsIURI> uri = aDocument->GetOriginalURI();
|
|
// IsOriginPotentiallyTrustworthy doesn't care about origin attributes so
|
|
// it doesn't actually matter what we use here, but reusing the document
|
|
// principal's attributes is convenient.
|
|
const OriginAttributes& attrs = principal->OriginAttributesRef();
|
|
// CreateCodebasePrincipal correctly gets a useful principal for blob: and
|
|
// other URI_INHERITS_SECURITY_CONTEXT URIs.
|
|
principal = BasePrincipal::CreateCodebasePrincipal(uri, attrs);
|
|
if (NS_WARN_IF(!principal)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
nsCOMPtr<nsIContentSecurityManager> csm =
|
|
do_GetService(NS_CONTENTSECURITYMANAGER_CONTRACTID);
|
|
NS_WARNING_ASSERTION(csm, "csm is null");
|
|
if (csm) {
|
|
bool isTrustworthyOrigin = false;
|
|
csm->IsOriginPotentiallyTrustworthy(principal, &isTrustworthyOrigin);
|
|
if (isTrustworthyOrigin) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static JS::CompartmentCreationOptions&
|
|
SelectZoneGroup(nsGlobalWindow* aNewInner,
|
|
JS::CompartmentCreationOptions& aOptions)
|
|
{
|
|
JS::CompartmentCreationOptions options;
|
|
|
|
if (aNewInner->GetOuterWindow()) {
|
|
nsGlobalWindow *top = aNewInner->GetTopInternal();
|
|
|
|
// If we have a top-level window, use its zone (and zone group).
|
|
if (top && top->GetGlobalJSObject()) {
|
|
return aOptions.setExistingZone(top->GetGlobalJSObject());
|
|
}
|
|
}
|
|
|
|
// If we're in the parent process, don't bother with zone groups.
|
|
if (XRE_IsParentProcess()) {
|
|
return aOptions.setNewZoneInSystemZoneGroup();
|
|
}
|
|
|
|
// Otherwise, find a zone group from the TabGroup. Typically we only have to
|
|
// go through one iteration of this loop.
|
|
RefPtr<TabGroup> tabGroup = aNewInner->TabGroup();
|
|
for (nsPIDOMWindowOuter* outer : tabGroup->GetWindows()) {
|
|
nsGlobalWindow* window = nsGlobalWindow::Cast(outer);
|
|
if (JSObject* global = window->GetGlobalJSObject()) {
|
|
return aOptions.setNewZoneInExistingZoneGroup(global);
|
|
}
|
|
}
|
|
|
|
return aOptions.setNewZoneInNewZoneGroup();
|
|
}
|
|
|
|
/**
|
|
* Create a new global object that will be used for an inner window.
|
|
* Return the native global and an nsISupports 'holder' that can be used
|
|
* to manage the lifetime of it.
|
|
*/
|
|
static nsresult
|
|
CreateNativeGlobalForInner(JSContext* aCx,
|
|
nsGlobalWindow* aNewInner,
|
|
nsIURI* aURI,
|
|
nsIPrincipal* aPrincipal,
|
|
JS::MutableHandle<JSObject*> aGlobal,
|
|
bool aIsSecureContext)
|
|
{
|
|
MOZ_ASSERT(aCx);
|
|
MOZ_ASSERT(aNewInner);
|
|
MOZ_ASSERT(aNewInner->IsInnerWindow());
|
|
MOZ_ASSERT(aPrincipal);
|
|
|
|
// DOMWindow with nsEP is not supported, we have to make sure
|
|
// no one creates one accidentally.
|
|
nsCOMPtr<nsIExpandedPrincipal> nsEP = do_QueryInterface(aPrincipal);
|
|
MOZ_RELEASE_ASSERT(!nsEP, "DOMWindow with nsEP is not supported");
|
|
|
|
JS::CompartmentOptions options;
|
|
|
|
SelectZoneGroup(aNewInner, options.creationOptions());
|
|
|
|
// Sometimes add-ons load their own XUL windows, either as separate top-level
|
|
// windows or inside a browser element. In such cases we want to tag the
|
|
// window's compartment with the add-on ID. See bug 1092156.
|
|
if (nsContentUtils::IsSystemPrincipal(aPrincipal)) {
|
|
options.creationOptions().setAddonId(MapURIToAddonID(aURI));
|
|
}
|
|
|
|
options.creationOptions().setSecureContext(aIsSecureContext);
|
|
|
|
xpc::InitGlobalObjectOptions(options, aPrincipal);
|
|
|
|
// Determine if we need the Components object.
|
|
bool needComponents = nsContentUtils::IsSystemPrincipal(aPrincipal) ||
|
|
TreatAsRemoteXUL(aPrincipal);
|
|
uint32_t flags = needComponents ? 0 : xpc::OMIT_COMPONENTS_OBJECT;
|
|
flags |= xpc::DONT_FIRE_ONNEWGLOBALHOOK;
|
|
|
|
if (!WindowBinding::Wrap(aCx, aNewInner, aNewInner, options,
|
|
nsJSPrincipals::get(aPrincipal), false, aGlobal) ||
|
|
!xpc::InitGlobalObject(aCx, aGlobal, flags)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
MOZ_ASSERT(aNewInner->GetWrapperPreserveColor() == aGlobal);
|
|
|
|
// Set the location information for the new global, so that tools like
|
|
// about:memory may use that information
|
|
xpc::SetLocationForGlobal(aGlobal, aURI);
|
|
|
|
if (!InitializeLegacyNetscapeObject(aCx, aGlobal)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::SetNewDocument(nsIDocument* aDocument,
|
|
nsISupports* aState,
|
|
bool aForceReuseInnerWindow)
|
|
{
|
|
NS_PRECONDITION(mDocumentPrincipal == nullptr,
|
|
"mDocumentPrincipal prematurely set!");
|
|
MOZ_ASSERT(aDocument);
|
|
|
|
if (IsInnerWindow()) {
|
|
if (!mOuterWindow) {
|
|
return NS_ERROR_NOT_INITIALIZED;
|
|
}
|
|
|
|
// Refuse to set a new document if the call came from an inner
|
|
// window that's not the current inner window.
|
|
if (mOuterWindow->GetCurrentInnerWindow() != AsInner()) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
return GetOuterWindowInternal()->SetNewDocument(aDocument, aState,
|
|
aForceReuseInnerWindow);
|
|
}
|
|
|
|
NS_PRECONDITION(IsOuterWindow(), "Must only be called on outer windows");
|
|
|
|
// Bail out early if we're in process of closing down the window.
|
|
NS_ENSURE_STATE(!mCleanedUp);
|
|
|
|
NS_ASSERTION(!AsOuter()->GetCurrentInnerWindow() ||
|
|
AsOuter()->GetCurrentInnerWindow()->GetExtantDoc() == mDoc,
|
|
"Uh, mDoc doesn't match the current inner window "
|
|
"document!");
|
|
|
|
bool wouldReuseInnerWindow = WouldReuseInnerWindow(aDocument);
|
|
if (aForceReuseInnerWindow &&
|
|
!wouldReuseInnerWindow &&
|
|
mDoc &&
|
|
mDoc->NodePrincipal() != aDocument->NodePrincipal()) {
|
|
NS_ERROR("Attempted forced inner window reuse while changing principal");
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
nsCOMPtr<nsIDocument> oldDoc = mDoc;
|
|
|
|
AutoJSAPI jsapi;
|
|
jsapi.Init();
|
|
JSContext *cx = jsapi.cx();
|
|
|
|
// Check if we're anywhere near the stack limit before we reach the
|
|
// transplanting code, since it has no good way to handle errors. This uses
|
|
// the untrusted script limit, which is not strictly necessary since no
|
|
// actual script should run.
|
|
if (!js::CheckRecursionLimitConservativeDontReport(cx)) {
|
|
NS_WARNING("Overrecursion in SetNewDocument");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (!mDoc) {
|
|
// First document load.
|
|
|
|
// Get our private root. If it is equal to us, then we need to
|
|
// attach our global key bindings that handles browser scrolling
|
|
// and other browser commands.
|
|
nsPIDOMWindowOuter* privateRoot = nsGlobalWindow::GetPrivateRoot();
|
|
|
|
if (privateRoot == AsOuter()) {
|
|
nsXBLService::AttachGlobalKeyHandler(mChromeEventHandler);
|
|
}
|
|
}
|
|
|
|
/* No mDocShell means we're already been partially closed down. When that
|
|
happens, setting status isn't a big requirement, so don't. (Doesn't happen
|
|
under normal circumstances, but bug 49615 describes a case.) */
|
|
|
|
nsContentUtils::AddScriptRunner(NewRunnableMethod(
|
|
"nsGlobalWindow::ClearStatus", this, &nsGlobalWindow::ClearStatus));
|
|
|
|
// Sometimes, WouldReuseInnerWindow() returns true even if there's no inner
|
|
// window (see bug 776497). Be safe.
|
|
bool reUseInnerWindow = (aForceReuseInnerWindow || wouldReuseInnerWindow) &&
|
|
GetCurrentInnerWindowInternal();
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
// We set mDoc even though this is an outer window to avoid
|
|
// having to *always* reach into the inner window to find the
|
|
// document.
|
|
mDoc = aDocument;
|
|
|
|
// Take this opportunity to clear mSuspendedDoc. Our old inner window is now
|
|
// responsible for unsuspending it.
|
|
mSuspendedDoc = nullptr;
|
|
|
|
#ifdef DEBUG
|
|
mLastOpenedURI = aDocument->GetDocumentURI();
|
|
#endif
|
|
|
|
mContext->WillInitializeContext();
|
|
|
|
nsGlobalWindow *currentInner = GetCurrentInnerWindowInternal();
|
|
|
|
if (currentInner && currentInner->mNavigator) {
|
|
currentInner->mNavigator->OnNavigation();
|
|
}
|
|
|
|
RefPtr<nsGlobalWindow> newInnerWindow;
|
|
bool createdInnerWindow = false;
|
|
|
|
bool thisChrome = IsChromeWindow();
|
|
|
|
nsCOMPtr<WindowStateHolder> wsh = do_QueryInterface(aState);
|
|
NS_ASSERTION(!aState || wsh, "What kind of weird state are you giving me here?");
|
|
|
|
JS::Rooted<JSObject*> newInnerGlobal(cx);
|
|
if (reUseInnerWindow) {
|
|
// We're reusing the current inner window.
|
|
NS_ASSERTION(!currentInner->IsFrozen(),
|
|
"We should never be reusing a shared inner window");
|
|
newInnerWindow = currentInner;
|
|
newInnerGlobal = currentInner->GetWrapperPreserveColor();
|
|
|
|
if (aDocument != oldDoc) {
|
|
JS::ExposeObjectToActiveJS(newInnerGlobal);
|
|
}
|
|
|
|
// We're reusing the inner window, but this still counts as a navigation,
|
|
// so all expandos and such defined on the outer window should go away. Force
|
|
// all Xray wrappers to be recomputed.
|
|
JS::Rooted<JSObject*> rootedObject(cx, GetWrapper());
|
|
if (!JS_RefreshCrossCompartmentWrappers(cx, rootedObject)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// Inner windows are only reused for same-origin principals, but the principals
|
|
// don't necessarily match exactly. Update the principal on the compartment to
|
|
// match the new document.
|
|
// NB: We don't just call currentInner->RefreshCompartmentPrincipals() here
|
|
// because we haven't yet set its mDoc to aDocument.
|
|
JSCompartment *compartment = js::GetObjectCompartment(newInnerGlobal);
|
|
#ifdef DEBUG
|
|
bool sameOrigin = false;
|
|
nsIPrincipal *existing =
|
|
nsJSPrincipals::get(JS_GetCompartmentPrincipals(compartment));
|
|
aDocument->NodePrincipal()->Equals(existing, &sameOrigin);
|
|
MOZ_ASSERT(sameOrigin);
|
|
#endif
|
|
MOZ_ASSERT_IF(aDocument == oldDoc,
|
|
xpc::GetCompartmentPrincipal(compartment) ==
|
|
aDocument->NodePrincipal());
|
|
if (aDocument != oldDoc) {
|
|
JS_SetCompartmentPrincipals(compartment,
|
|
nsJSPrincipals::get(aDocument->NodePrincipal()));
|
|
// Make sure we clear out the old content XBL scope, so the new one will
|
|
// get created with a principal that subsumes our new principal.
|
|
xpc::ClearContentXBLScope(newInnerGlobal);
|
|
}
|
|
} else {
|
|
if (aState) {
|
|
newInnerWindow = wsh->GetInnerWindow();
|
|
newInnerGlobal = newInnerWindow->GetWrapperPreserveColor();
|
|
} else {
|
|
if (thisChrome) {
|
|
newInnerWindow = nsGlobalWindow::CreateChrome(this);
|
|
} else {
|
|
newInnerWindow = nsGlobalWindow::Create(this);
|
|
}
|
|
|
|
// The outer window is automatically treated as frozen when we
|
|
// null out the inner window. As a result, initializing classes
|
|
// on the new inner won't end up reaching into the old inner
|
|
// window for classes etc.
|
|
//
|
|
// [This happens with Object.prototype when XPConnect creates
|
|
// a temporary global while initializing classes; the reason
|
|
// being that xpconnect creates the temp global w/o a parent
|
|
// and proto, which makes the JS engine look up classes in
|
|
// cx->globalObject, i.e. this outer window].
|
|
|
|
mInnerWindow = nullptr;
|
|
|
|
mCreatingInnerWindow = true;
|
|
// Every script context we are initialized with must create a
|
|
// new global.
|
|
rv = CreateNativeGlobalForInner(cx, newInnerWindow,
|
|
aDocument->GetDocumentURI(),
|
|
aDocument->NodePrincipal(),
|
|
&newInnerGlobal,
|
|
ComputeIsSecureContext(aDocument));
|
|
NS_ASSERTION(NS_SUCCEEDED(rv) && newInnerGlobal &&
|
|
newInnerWindow->GetWrapperPreserveColor() == newInnerGlobal,
|
|
"Failed to get script global");
|
|
newInnerWindow->mIsSecureContextIfOpenerIgnored =
|
|
ComputeIsSecureContext(aDocument, SecureContextFlags::eIgnoreOpener);
|
|
|
|
mCreatingInnerWindow = false;
|
|
createdInnerWindow = true;
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
if (currentInner && currentInner->GetWrapperPreserveColor()) {
|
|
if (oldDoc == aDocument) {
|
|
// Make a copy of the old window's performance object on document.open.
|
|
// Note that we have to force eager creation of it here, because we need
|
|
// to grab the current document channel and whatnot before that changes.
|
|
currentInner->AsInner()->CreatePerformanceObjectIfNeeded();
|
|
if (currentInner->mPerformance) {
|
|
newInnerWindow->mPerformance =
|
|
Performance::CreateForMainThread(newInnerWindow->AsInner(),
|
|
currentInner->mPerformance->GetDOMTiming(),
|
|
currentInner->mPerformance->GetChannel());
|
|
}
|
|
}
|
|
|
|
// Don't free objects on our current inner window if it's going to be
|
|
// held in the bfcache.
|
|
if (!currentInner->IsFrozen()) {
|
|
currentInner->FreeInnerObjects();
|
|
}
|
|
}
|
|
|
|
mInnerWindow = newInnerWindow->AsInner();
|
|
MOZ_ASSERT(mInnerWindow);
|
|
mInnerWindow->TryToCacheTopInnerWindow();
|
|
|
|
if (!GetWrapperPreserveColor()) {
|
|
JS::Rooted<JSObject*> outer(cx,
|
|
NewOuterWindowProxy(cx, newInnerGlobal, thisChrome));
|
|
NS_ENSURE_TRUE(outer, NS_ERROR_FAILURE);
|
|
|
|
js::SetProxyReservedSlot(outer, 0, js::PrivateValue(ToSupports(this)));
|
|
|
|
// Inform the nsJSContext, which is the canonical holder of the outer.
|
|
mContext->SetWindowProxy(outer);
|
|
mContext->DidInitializeContext();
|
|
|
|
SetWrapper(mContext->GetWindowProxy());
|
|
} else {
|
|
JS::ExposeObjectToActiveJS(newInnerGlobal);
|
|
JS::Rooted<JSObject*> outerObject(cx,
|
|
NewOuterWindowProxy(cx, newInnerGlobal, thisChrome));
|
|
if (!outerObject) {
|
|
NS_ERROR("out of memory");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
JS::Rooted<JSObject*> obj(cx, GetWrapperPreserveColor());
|
|
|
|
js::SetProxyReservedSlot(obj, 0, js::PrivateValue(nullptr));
|
|
js::SetProxyReservedSlot(outerObject, 0, js::PrivateValue(nullptr));
|
|
|
|
outerObject = xpc::TransplantObject(cx, obj, outerObject);
|
|
if (!outerObject) {
|
|
NS_ERROR("unable to transplant wrappers, probably OOM");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
js::SetProxyReservedSlot(outerObject, 0, js::PrivateValue(ToSupports(this)));
|
|
|
|
SetWrapper(outerObject);
|
|
|
|
MOZ_ASSERT(js::GetGlobalForObjectCrossCompartment(outerObject) == newInnerGlobal);
|
|
|
|
// Inform the nsJSContext, which is the canonical holder of the outer.
|
|
mContext->SetWindowProxy(outerObject);
|
|
}
|
|
|
|
// Enter the new global's compartment.
|
|
JSAutoCompartment ac(cx, GetWrapperPreserveColor());
|
|
|
|
{
|
|
JS::Rooted<JSObject*> outer(cx, GetWrapperPreserveColor());
|
|
js::SetWindowProxy(cx, newInnerGlobal, outer);
|
|
}
|
|
|
|
// Set scriptability based on the state of the docshell.
|
|
bool allow = GetDocShell()->GetCanExecuteScripts();
|
|
xpc::Scriptability::Get(GetWrapperPreserveColor()).SetDocShellAllowsScript(allow);
|
|
|
|
if (!aState) {
|
|
// Get the "window" property once so it will be cached on our inner. We
|
|
// have to do this here, not in binding code, because this has to happen
|
|
// after we've created the outer window proxy and stashed it in the outer
|
|
// nsGlobalWindow, so GetWrapperPreserveColor() on that outer
|
|
// nsGlobalWindow doesn't return null and nsGlobalWindow::OuterObject
|
|
// works correctly.
|
|
JS::Rooted<JS::Value> unused(cx);
|
|
if (!JS_GetProperty(cx, newInnerGlobal, "window", &unused)) {
|
|
NS_ERROR("can't create the 'window' property");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// And same thing for the "self" property.
|
|
if (!JS_GetProperty(cx, newInnerGlobal, "self", &unused)) {
|
|
NS_ERROR("can't create the 'self' property");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
}
|
|
}
|
|
|
|
JSAutoCompartment ac(cx, GetWrapperPreserveColor());
|
|
|
|
if (!aState && !reUseInnerWindow) {
|
|
// Loading a new page and creating a new inner window, *not*
|
|
// restoring from session history.
|
|
|
|
// Now that both the the inner and outer windows are initialized
|
|
// let the script context do its magic to hook them together.
|
|
MOZ_ASSERT(mContext->GetWindowProxy() == GetWrapperPreserveColor());
|
|
#ifdef DEBUG
|
|
JS::Rooted<JSObject*> rootedJSObject(cx, GetWrapperPreserveColor());
|
|
JS::Rooted<JSObject*> proto1(cx), proto2(cx);
|
|
JS_GetPrototype(cx, rootedJSObject, &proto1);
|
|
JS_GetPrototype(cx, newInnerGlobal, &proto2);
|
|
NS_ASSERTION(proto1 == proto2,
|
|
"outer and inner globals should have the same prototype");
|
|
#endif
|
|
|
|
mInnerWindow->SyncStateFromParentWindow();
|
|
}
|
|
|
|
// Add an extra ref in case we release mContext during GC.
|
|
nsCOMPtr<nsIScriptContext> kungFuDeathGrip(mContext);
|
|
|
|
aDocument->SetScriptGlobalObject(newInnerWindow);
|
|
MOZ_ASSERT(newInnerWindow->mTabGroup,
|
|
"We must have a TabGroup cached at this point");
|
|
|
|
if (!aState) {
|
|
if (reUseInnerWindow) {
|
|
|
|
if (newInnerWindow->mDoc != aDocument) {
|
|
newInnerWindow->mDoc = aDocument;
|
|
|
|
// The storage objects contain the URL of the window. We have to
|
|
// recreate them when the innerWindow is reused.
|
|
newInnerWindow->mLocalStorage = nullptr;
|
|
newInnerWindow->mSessionStorage = nullptr;
|
|
|
|
newInnerWindow->ClearDocumentDependentSlots(cx);
|
|
}
|
|
} else {
|
|
newInnerWindow->InnerSetNewDocument(cx, aDocument);
|
|
|
|
// Initialize DOM classes etc on the inner window.
|
|
JS::Rooted<JSObject*> obj(cx, newInnerGlobal);
|
|
rv = kungFuDeathGrip->InitClasses(obj);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
// If the document comes from a JAR, check if the channel was determined
|
|
// to be unsafe. If so, permanently disable script on the compartment by
|
|
// calling Block() and throwing away the key.
|
|
nsCOMPtr<nsIJARChannel> jarChannel = do_QueryInterface(aDocument->GetChannel());
|
|
if (jarChannel && jarChannel->GetIsUnsafe()) {
|
|
xpc::Scriptability::Get(newInnerGlobal).Block();
|
|
}
|
|
|
|
if (mArguments) {
|
|
newInnerWindow->DefineArgumentsProperty(mArguments);
|
|
mArguments = nullptr;
|
|
}
|
|
|
|
// Give the new inner window our chrome event handler (since it
|
|
// doesn't have one).
|
|
newInnerWindow->mChromeEventHandler = mChromeEventHandler;
|
|
}
|
|
|
|
// Ask the JS engine to assert that it's valid to access our DocGroup whenever
|
|
// it runs JS code for this compartment. We skip the check if this window is
|
|
// for chrome JS or an add-on.
|
|
nsCOMPtr<nsIPrincipal> principal = mDoc->NodePrincipal();
|
|
if (GetDocGroup() && !nsContentUtils::IsSystemPrincipal(principal) &&
|
|
!BasePrincipal::Cast(principal)->AddonPolicy()) {
|
|
js::SetCompartmentValidAccessPtr(cx, newInnerGlobal,
|
|
newInnerWindow->GetDocGroup()->GetValidAccessPtr());
|
|
}
|
|
|
|
kungFuDeathGrip->DidInitializeContext();
|
|
|
|
// We wait to fire the debugger hook until the window is all set up and hooked
|
|
// up with the outer. See bug 969156.
|
|
if (createdInnerWindow) {
|
|
nsContentUtils::AddScriptRunner(
|
|
NewRunnableMethod("nsGlobalWindow::FireOnNewGlobalObject",
|
|
newInnerWindow,
|
|
&nsGlobalWindow::FireOnNewGlobalObject));
|
|
}
|
|
|
|
if (newInnerWindow && !newInnerWindow->mHasNotifiedGlobalCreated && mDoc) {
|
|
// We should probably notify. However if this is the, arguably bad,
|
|
// situation when we're creating a temporary non-chrome-about-blank
|
|
// document in a chrome docshell, don't notify just yet. Instead wait
|
|
// until we have a real chrome doc.
|
|
if (!mDocShell ||
|
|
mDocShell->ItemType() != nsIDocShellTreeItem::typeChrome ||
|
|
nsContentUtils::IsSystemPrincipal(mDoc->NodePrincipal())) {
|
|
newInnerWindow->mHasNotifiedGlobalCreated = true;
|
|
nsContentUtils::AddScriptRunner(
|
|
NewRunnableMethod("nsGlobalWindow::DispatchDOMWindowCreated",
|
|
this,
|
|
&nsGlobalWindow::DispatchDOMWindowCreated));
|
|
}
|
|
}
|
|
|
|
PreloadLocalStorage();
|
|
|
|
// If we have a recorded interesting Large-Allocation header status, report it
|
|
// to the newly attached document.
|
|
ReportLargeAllocStatus();
|
|
mLargeAllocStatus = LargeAllocStatus::NONE;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::PreloadLocalStorage()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
if (!Preferences::GetBool(kStorageEnabled)) {
|
|
return;
|
|
}
|
|
|
|
if (IsChromeWindow()) {
|
|
return;
|
|
}
|
|
|
|
nsIPrincipal* principal = GetPrincipal();
|
|
if (!principal) {
|
|
return;
|
|
}
|
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIDOMStorageManager> storageManager =
|
|
do_GetService("@mozilla.org/dom/localStorage-manager;1", &rv);
|
|
if (NS_FAILED(rv)) {
|
|
return;
|
|
}
|
|
|
|
// private browsing windows do not persist local storage to disk so we should
|
|
// only try to precache storage when we're not a private browsing window.
|
|
if (principal->GetPrivateBrowsingId() == 0) {
|
|
nsCOMPtr<nsIDOMStorage> storage;
|
|
rv = storageManager->PrecacheStorage(principal, getter_AddRefs(storage));
|
|
if (NS_SUCCEEDED(rv)) {
|
|
mLocalStorage = static_cast<Storage*>(storage.get());
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::DispatchDOMWindowCreated()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDoc) {
|
|
return;
|
|
}
|
|
|
|
// Fire DOMWindowCreated at chrome event listeners
|
|
nsContentUtils::DispatchChromeEvent(mDoc, mDoc, NS_LITERAL_STRING("DOMWindowCreated"),
|
|
true /* bubbles */,
|
|
false /* not cancellable */);
|
|
|
|
nsCOMPtr<nsIObserverService> observerService =
|
|
mozilla::services::GetObserverService();
|
|
|
|
// The event dispatching could possibly cause docshell destory, and
|
|
// consequently cause mDoc to be set to nullptr by DropOuterWindowDocs(),
|
|
// so check it again here.
|
|
if (observerService && mDoc) {
|
|
nsAutoString origin;
|
|
nsIPrincipal* principal = mDoc->NodePrincipal();
|
|
nsContentUtils::GetUTFOrigin(principal, origin);
|
|
observerService->
|
|
NotifyObservers(static_cast<nsIDOMWindow*>(this),
|
|
nsContentUtils::IsSystemPrincipal(principal) ?
|
|
"chrome-document-global-created" :
|
|
"content-document-global-created",
|
|
origin.get());
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ClearStatus()
|
|
{
|
|
SetStatusOuter(EmptyString());
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::InnerSetNewDocument(JSContext* aCx, nsIDocument* aDocument)
|
|
{
|
|
NS_PRECONDITION(IsInnerWindow(), "Must only be called on inner windows");
|
|
MOZ_ASSERT(aDocument);
|
|
|
|
if (MOZ_LOG_TEST(gDOMLeakPRLog, LogLevel::Debug)) {
|
|
nsIURI *uri = aDocument->GetDocumentURI();
|
|
MOZ_LOG(gDOMLeakPRLog, LogLevel::Debug,
|
|
("DOMWINDOW %p SetNewDocument %s",
|
|
this, uri ? uri->GetSpecOrDefault().get() : ""));
|
|
}
|
|
|
|
mDoc = aDocument;
|
|
ClearDocumentDependentSlots(aCx);
|
|
mFocusedNode = nullptr;
|
|
mLocalStorage = nullptr;
|
|
mSessionStorage = nullptr;
|
|
|
|
#ifdef DEBUG
|
|
mLastOpenedURI = aDocument->GetDocumentURI();
|
|
#endif
|
|
|
|
Telemetry::Accumulate(Telemetry::INNERWINDOWS_WITH_MUTATION_LISTENERS,
|
|
mMutationBits ? 1 : 0);
|
|
|
|
// Clear our mutation bitfield.
|
|
mMutationBits = 0;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetDocShell(nsIDocShell* aDocShell)
|
|
{
|
|
NS_ASSERTION(IsOuterWindow(), "Uh, SetDocShell() called on inner window!");
|
|
MOZ_ASSERT(aDocShell);
|
|
|
|
if (aDocShell == mDocShell) {
|
|
return;
|
|
}
|
|
|
|
mDocShell = aDocShell; // Weak Reference
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> parentWindow = GetScriptableParentOrNull();
|
|
MOZ_RELEASE_ASSERT(!parentWindow || !mTabGroup || mTabGroup == Cast(parentWindow)->mTabGroup);
|
|
|
|
mTopLevelOuterContentWindow =
|
|
!mIsChrome && GetScriptableTopInternal() == this;
|
|
|
|
NS_ASSERTION(!mNavigator, "Non-null mNavigator in outer window!");
|
|
|
|
if (mFrames) {
|
|
mFrames->SetDocShell(aDocShell);
|
|
}
|
|
|
|
// Get our enclosing chrome shell and retrieve its global window impl, so
|
|
// that we can do some forwarding to the chrome document.
|
|
nsCOMPtr<nsIDOMEventTarget> chromeEventHandler;
|
|
mDocShell->GetChromeEventHandler(getter_AddRefs(chromeEventHandler));
|
|
mChromeEventHandler = do_QueryInterface(chromeEventHandler);
|
|
if (!mChromeEventHandler) {
|
|
// We have no chrome event handler. If we have a parent,
|
|
// get our chrome event handler from the parent. If
|
|
// we don't have a parent, then we need to make a new
|
|
// window root object that will function as a chrome event
|
|
// handler and receive all events that occur anywhere inside
|
|
// our window.
|
|
nsCOMPtr<nsPIDOMWindowOuter> parentWindow = GetParent();
|
|
if (parentWindow.get() != AsOuter()) {
|
|
mChromeEventHandler = parentWindow->GetChromeEventHandler();
|
|
}
|
|
else {
|
|
mChromeEventHandler = NS_NewWindowRoot(AsOuter());
|
|
mIsRootOuterWindow = true;
|
|
}
|
|
}
|
|
|
|
bool docShellActive;
|
|
mDocShell->GetIsActive(&docShellActive);
|
|
SetIsBackgroundInternal(!docShellActive);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::DetachFromDocShell()
|
|
{
|
|
NS_ASSERTION(IsOuterWindow(), "Uh, DetachFromDocShell() called on inner window!");
|
|
|
|
// DetachFromDocShell means the window is being torn down. Drop our
|
|
// reference to the script context, allowing it to be deleted
|
|
// later. Meanwhile, keep our weak reference to the script object
|
|
// so that it can be retrieved later (until it is finalized by the JS GC).
|
|
|
|
// Call FreeInnerObjects on all inner windows, not just the current
|
|
// one, since some could be held by WindowStateHolder objects that
|
|
// are GC-owned.
|
|
for (RefPtr<nsGlobalWindow> inner = (nsGlobalWindow *)PR_LIST_HEAD(this);
|
|
inner != this;
|
|
inner = (nsGlobalWindow*)PR_NEXT_LINK(inner)) {
|
|
MOZ_ASSERT(!inner->mOuterWindow || inner->mOuterWindow == AsOuter());
|
|
inner->FreeInnerObjects();
|
|
}
|
|
|
|
if (auto* reporter = nsWindowMemoryReporter::Get()) {
|
|
reporter->ObserveDOMWindowDetached(this);
|
|
}
|
|
|
|
NotifyWindowIDDestroyed("outer-window-destroyed");
|
|
|
|
nsGlobalWindow *currentInner = GetCurrentInnerWindowInternal();
|
|
|
|
if (currentInner) {
|
|
NS_ASSERTION(mDoc, "Must have doc!");
|
|
|
|
// Remember the document's principal and URI.
|
|
mDocumentPrincipal = mDoc->NodePrincipal();
|
|
mDocumentURI = mDoc->GetDocumentURI();
|
|
mDocBaseURI = mDoc->GetDocBaseURI();
|
|
|
|
// Release our document reference
|
|
DropOuterWindowDocs();
|
|
mFocusedNode = nullptr;
|
|
}
|
|
|
|
ClearControllers();
|
|
|
|
mChromeEventHandler = nullptr; // force release now
|
|
|
|
if (mContext) {
|
|
// When we're about to destroy a top level content window
|
|
// (for example a tab), we trigger a full GC by passing null as the last
|
|
// param. We also trigger a full GC for chrome windows.
|
|
nsJSContext::PokeGC(JS::gcreason::SET_DOC_SHELL,
|
|
(mTopLevelOuterContentWindow || mIsChrome) ?
|
|
nullptr : GetWrapperPreserveColor());
|
|
mContext = nullptr;
|
|
}
|
|
|
|
mDocShell = nullptr; // Weak Reference
|
|
|
|
NS_ASSERTION(!mNavigator, "Non-null mNavigator in outer window!");
|
|
|
|
if (mFrames) {
|
|
mFrames->SetDocShell(nullptr);
|
|
}
|
|
|
|
MaybeForgiveSpamCount();
|
|
CleanUp();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetOpenerWindow(nsPIDOMWindowOuter* aOpener,
|
|
bool aOriginalOpener)
|
|
{
|
|
FORWARD_TO_OUTER_VOID(SetOpenerWindow, (aOpener, aOriginalOpener));
|
|
|
|
nsWeakPtr opener = do_GetWeakReference(aOpener);
|
|
if (opener == mOpener) {
|
|
return;
|
|
}
|
|
|
|
NS_ASSERTION(!aOriginalOpener || !mSetOpenerWindowCalled,
|
|
"aOriginalOpener is true, but not first call to "
|
|
"SetOpenerWindow!");
|
|
NS_ASSERTION(aOpener || !aOriginalOpener,
|
|
"Shouldn't set mHadOriginalOpener if aOpener is null");
|
|
|
|
mOpener = opener.forget();
|
|
NS_ASSERTION(mOpener || !aOpener, "Opener must support weak references!");
|
|
|
|
// Check that the js visible opener matches! We currently don't depend on this
|
|
// being true outside of nightly, so we disable the assertion in optimized
|
|
// release / beta builds.
|
|
nsPIDOMWindowOuter* contentOpener = GetSanitizedOpener(aOpener);
|
|
|
|
// contentOpener is not used when the DIAGNOSTIC_ASSERT is compiled out.
|
|
mozilla::Unused << contentOpener;
|
|
MOZ_DIAGNOSTIC_ASSERT(!contentOpener || !mTabGroup ||
|
|
mTabGroup == Cast(contentOpener)->mTabGroup);
|
|
|
|
if (aOriginalOpener) {
|
|
MOZ_ASSERT(!mHadOriginalOpener,
|
|
"Probably too late to call ComputeIsSecureContext again");
|
|
mHadOriginalOpener = true;
|
|
mOriginalOpenerWasSecureContext =
|
|
aOpener->GetCurrentInnerWindow()->IsSecureContext();
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
mSetOpenerWindowCalled = true;
|
|
#endif
|
|
}
|
|
|
|
static
|
|
already_AddRefed<EventTarget>
|
|
TryGetTabChildGlobalAsEventTarget(nsISupports *aFrom)
|
|
{
|
|
nsCOMPtr<nsIFrameLoaderOwner> frameLoaderOwner = do_QueryInterface(aFrom);
|
|
if (!frameLoaderOwner) {
|
|
return nullptr;
|
|
}
|
|
|
|
RefPtr<nsFrameLoader> frameLoader = frameLoaderOwner->GetFrameLoader();
|
|
if (!frameLoader) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsCOMPtr<EventTarget> target = frameLoader->GetTabChildGlobalAsEventTarget();
|
|
return target.forget();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::UpdateParentTarget()
|
|
{
|
|
// Try to get our frame element's tab child global (its in-process message
|
|
// manager). If that fails, fall back to the chrome event handler's tab
|
|
// child global, and if it doesn't have one, just use the chrome event
|
|
// handler itself.
|
|
|
|
nsCOMPtr<Element> frameElement = GetOuterWindow()->GetFrameElementInternal();
|
|
nsCOMPtr<EventTarget> eventTarget =
|
|
TryGetTabChildGlobalAsEventTarget(frameElement);
|
|
|
|
if (!eventTarget) {
|
|
nsGlobalWindow* topWin = GetScriptableTopInternal();
|
|
if (topWin) {
|
|
frameElement = topWin->AsOuter()->GetFrameElementInternal();
|
|
eventTarget = TryGetTabChildGlobalAsEventTarget(frameElement);
|
|
}
|
|
}
|
|
|
|
if (!eventTarget) {
|
|
eventTarget = TryGetTabChildGlobalAsEventTarget(mChromeEventHandler);
|
|
}
|
|
|
|
if (!eventTarget) {
|
|
eventTarget = mChromeEventHandler;
|
|
}
|
|
|
|
mParentTarget = eventTarget;
|
|
}
|
|
|
|
EventTarget*
|
|
nsGlobalWindow::GetTargetForDOMEvent()
|
|
{
|
|
return GetOuterWindowInternal();
|
|
}
|
|
|
|
EventTarget*
|
|
nsGlobalWindow::GetTargetForEventTargetChain()
|
|
{
|
|
return IsInnerWindow() ? this : GetCurrentInnerWindowInternal();
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::WillHandleEvent(EventChainPostVisitor& aVisitor)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::GetEventTargetParent(EventChainPreVisitor& aVisitor)
|
|
{
|
|
NS_PRECONDITION(IsInnerWindow(),
|
|
"GetEventTargetParent is used on outer window!?");
|
|
EventMessage msg = aVisitor.mEvent->mMessage;
|
|
|
|
aVisitor.mCanHandle = true;
|
|
aVisitor.mForceContentDispatch = true; //FIXME! Bug 329119
|
|
if (msg == eResize && aVisitor.mEvent->IsTrusted()) {
|
|
// QIing to window so that we can keep the old behavior also in case
|
|
// a child window is handling resize.
|
|
nsCOMPtr<nsPIDOMWindowInner> window =
|
|
do_QueryInterface(aVisitor.mEvent->mOriginalTarget);
|
|
if (window) {
|
|
mIsHandlingResizeEvent = true;
|
|
}
|
|
} else if (msg == eMouseDown && aVisitor.mEvent->IsTrusted()) {
|
|
gMouseDown = true;
|
|
} else if ((msg == eMouseUp || msg == eDragEnd) &&
|
|
aVisitor.mEvent->IsTrusted()) {
|
|
gMouseDown = false;
|
|
if (gDragServiceDisabled) {
|
|
nsCOMPtr<nsIDragService> ds =
|
|
do_GetService("@mozilla.org/widget/dragservice;1");
|
|
if (ds) {
|
|
gDragServiceDisabled = false;
|
|
ds->Unsuppress();
|
|
}
|
|
}
|
|
}
|
|
|
|
aVisitor.mParentTarget = GetParentTarget();
|
|
|
|
// Handle 'active' event.
|
|
if (!mIdleObservers.IsEmpty() &&
|
|
aVisitor.mEvent->IsTrusted() &&
|
|
(aVisitor.mEvent->HasMouseEventMessage() ||
|
|
aVisitor.mEvent->HasDragEventMessage())) {
|
|
mAddActiveEventFuzzTime = false;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::ShouldPromptToBlockDialogs()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
nsGlobalWindow *topWindow = GetScriptableTopInternal();
|
|
if (!topWindow) {
|
|
NS_ASSERTION(!mDocShell, "ShouldPromptToBlockDialogs() called without a top window?");
|
|
return true;
|
|
}
|
|
|
|
topWindow = topWindow->GetCurrentInnerWindowInternal();
|
|
if (!topWindow) {
|
|
return true;
|
|
}
|
|
|
|
return topWindow->DialogsAreBeingAbused();
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::AreDialogsEnabled()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
nsGlobalWindow *topWindow = GetScriptableTopInternal();
|
|
if (!topWindow) {
|
|
NS_ERROR("AreDialogsEnabled() called without a top window?");
|
|
return false;
|
|
}
|
|
|
|
// TODO: Warn if no top window?
|
|
topWindow = topWindow->GetCurrentInnerWindowInternal();
|
|
if (!topWindow) {
|
|
return false;
|
|
}
|
|
|
|
// Dialogs are blocked if the content viewer is hidden
|
|
if (mDocShell) {
|
|
nsCOMPtr<nsIContentViewer> cv;
|
|
mDocShell->GetContentViewer(getter_AddRefs(cv));
|
|
|
|
bool isHidden;
|
|
cv->GetIsHidden(&isHidden);
|
|
if (isHidden) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Dialogs are also blocked if the document is sandboxed with SANDBOXED_MODALS
|
|
// (or if we have no document, of course). Which document? Who knows; the
|
|
// spec is daft. See <https://github.com/whatwg/html/issues/1206>. For now
|
|
// just go ahead and check mDoc, since in everything except edge cases in
|
|
// which a frame is allow-same-origin but not allow-scripts and is being poked
|
|
// at by some other window this should be the right thing anyway.
|
|
if (!mDoc || (mDoc->GetSandboxFlags() & SANDBOXED_MODALS)) {
|
|
return false;
|
|
}
|
|
|
|
return topWindow->mAreDialogsEnabled;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::DialogsAreBeingAbused()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
NS_ASSERTION(GetScriptableTopInternal() &&
|
|
GetScriptableTopInternal()->GetCurrentInnerWindowInternal() == this,
|
|
"DialogsAreBeingAbused called with invalid window");
|
|
|
|
if (mLastDialogQuitTime.IsNull() ||
|
|
nsContentUtils::IsCallerChrome()) {
|
|
return false;
|
|
}
|
|
|
|
TimeDuration dialogInterval(TimeStamp::Now() - mLastDialogQuitTime);
|
|
if (dialogInterval.ToSeconds() <
|
|
Preferences::GetInt("dom.successive_dialog_time_limit",
|
|
DEFAULT_SUCCESSIVE_DIALOG_TIME_LIMIT)) {
|
|
mDialogAbuseCount++;
|
|
|
|
return GetPopupControlState() > openAllowed ||
|
|
mDialogAbuseCount > MAX_SUCCESSIVE_DIALOG_COUNT;
|
|
}
|
|
|
|
// Reset the abuse counter
|
|
mDialogAbuseCount = 0;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::ConfirmDialogIfNeeded()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
NS_ENSURE_TRUE(mDocShell, false);
|
|
nsCOMPtr<nsIPromptService> promptSvc =
|
|
do_GetService("@mozilla.org/embedcomp/prompt-service;1");
|
|
|
|
if (!promptSvc) {
|
|
return true;
|
|
}
|
|
|
|
// Reset popup state while opening a modal dialog, and firing events
|
|
// about the dialog, to prevent the current state from being active
|
|
// the whole time a modal dialog is open.
|
|
nsAutoPopupStatePusher popupStatePusher(openAbused, true);
|
|
|
|
bool disableDialog = false;
|
|
nsAutoString label, title;
|
|
nsContentUtils::GetLocalizedString(nsContentUtils::eCOMMON_DIALOG_PROPERTIES,
|
|
"ScriptDialogLabel", label);
|
|
nsContentUtils::GetLocalizedString(nsContentUtils::eCOMMON_DIALOG_PROPERTIES,
|
|
"ScriptDialogPreventTitle", title);
|
|
promptSvc->Confirm(AsOuter(), title.get(), label.get(), &disableDialog);
|
|
if (disableDialog) {
|
|
DisableDialogs();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::DisableDialogs()
|
|
{
|
|
nsGlobalWindow *topWindow = GetScriptableTopInternal();
|
|
if (!topWindow) {
|
|
NS_ERROR("DisableDialogs() called without a top window?");
|
|
return;
|
|
}
|
|
|
|
topWindow = topWindow->GetCurrentInnerWindowInternal();
|
|
// TODO: Warn if no top window?
|
|
if (topWindow) {
|
|
topWindow->mAreDialogsEnabled = false;
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::EnableDialogs()
|
|
{
|
|
nsGlobalWindow *topWindow = GetScriptableTopInternal();
|
|
if (!topWindow) {
|
|
NS_ERROR("EnableDialogs() called without a top window?");
|
|
return;
|
|
}
|
|
|
|
// TODO: Warn if no top window?
|
|
topWindow = topWindow->GetCurrentInnerWindowInternal();
|
|
if (topWindow) {
|
|
topWindow->mAreDialogsEnabled = true;
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::PostHandleEvent(EventChainPostVisitor& aVisitor)
|
|
{
|
|
NS_PRECONDITION(IsInnerWindow(), "PostHandleEvent is used on outer window!?");
|
|
|
|
// Return early if there is nothing to do.
|
|
switch (aVisitor.mEvent->mMessage) {
|
|
case eResize:
|
|
case eUnload:
|
|
case eLoad:
|
|
break;
|
|
default:
|
|
return NS_OK;
|
|
}
|
|
|
|
/* mChromeEventHandler and mContext go dangling in the middle of this
|
|
function under some circumstances (events that destroy the window)
|
|
without this addref. */
|
|
nsCOMPtr<nsIDOMEventTarget> kungFuDeathGrip1(mChromeEventHandler);
|
|
mozilla::Unused << kungFuDeathGrip1; // These aren't referred to through the function
|
|
nsCOMPtr<nsIScriptContext> kungFuDeathGrip2(GetContextInternal());
|
|
mozilla::Unused << kungFuDeathGrip2; // These aren't referred to through the function
|
|
|
|
|
|
if (aVisitor.mEvent->mMessage == eResize) {
|
|
mIsHandlingResizeEvent = false;
|
|
} else if (aVisitor.mEvent->mMessage == eUnload &&
|
|
aVisitor.mEvent->IsTrusted()) {
|
|
|
|
// If any VR display presentation is active at unload, the next page
|
|
// will receive a vrdisplayactive event to indicate that it should
|
|
// immediately begin vr presentation. This should occur when navigating
|
|
// forwards, navigating backwards, and on page reload.
|
|
for (const auto& display : mVRDisplays) {
|
|
if (display->IsPresenting()) {
|
|
// Save this VR display ID to trigger vrdisplayactivate event
|
|
// after the next load event.
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
if (outer) {
|
|
outer->SetAutoActivateVRDisplayID(display->DisplayId());
|
|
}
|
|
|
|
// XXX The WebVR 1.1 spec does not define which of multiple VR
|
|
// presenting VR displays will be chosen during navigation.
|
|
// As the underlying platform VR API's currently only allow a single
|
|
// VR display, it is safe to choose the first VR display for now.
|
|
break;
|
|
}
|
|
}
|
|
// Execute bindingdetached handlers before we tear ourselves
|
|
// down.
|
|
if (mDoc) {
|
|
mDoc->BindingManager()->ExecuteDetachedHandlers();
|
|
}
|
|
mIsDocumentLoaded = false;
|
|
} else if (aVisitor.mEvent->mMessage == eLoad &&
|
|
aVisitor.mEvent->IsTrusted()) {
|
|
// This is page load event since load events don't propagate to |window|.
|
|
// @see nsDocument::GetEventTargetParent.
|
|
mIsDocumentLoaded = true;
|
|
|
|
mTimeoutManager->OnDocumentLoaded();
|
|
|
|
nsCOMPtr<Element> element = GetOuterWindow()->GetFrameElementInternal();
|
|
nsIDocShell* docShell = GetDocShell();
|
|
if (element && GetParentInternal() &&
|
|
docShell && docShell->ItemType() != nsIDocShellTreeItem::typeChrome) {
|
|
// If we're not in chrome, or at a chrome boundary, fire the
|
|
// onload event for the frame element.
|
|
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
WidgetEvent event(aVisitor.mEvent->IsTrusted(), eLoad);
|
|
event.mFlags.mBubbles = false;
|
|
event.mFlags.mCancelable = false;
|
|
|
|
// Most of the time we could get a pres context to pass in here,
|
|
// but not always (i.e. if this window is not shown there won't
|
|
// be a pres context available). Since we're not firing a GUI
|
|
// event we don't need a pres context anyway so we just pass
|
|
// null as the pres context all the time here.
|
|
EventDispatcher::Dispatch(element, nullptr, &event, nullptr, &status);
|
|
}
|
|
|
|
uint32_t autoActivateVRDisplayID = 0;
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
if (outer) {
|
|
autoActivateVRDisplayID = outer->GetAutoActivateVRDisplayID();
|
|
}
|
|
if (autoActivateVRDisplayID) {
|
|
DispatchVRDisplayActivate(autoActivateVRDisplayID,
|
|
VRDisplayEventReason::Navigation);
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::PoisonOuterWindowProxy(JSObject *aObject)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
if (aObject == GetWrapperMaybeDead()) {
|
|
PoisonWrapper();
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::SetArguments(nsIArray *aArguments)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
nsresult rv;
|
|
|
|
// Historically, we've used the same machinery to handle openDialog arguments
|
|
// (exposed via window.arguments) and showModalDialog arguments (exposed via
|
|
// window.dialogArguments), even though the former is XUL-only and uses an XPCOM
|
|
// array while the latter is web-exposed and uses an arbitrary JS value.
|
|
// Moreover, per-spec |dialogArguments| is a property of the browsing context
|
|
// (outer), whereas |arguments| lives on the inner.
|
|
//
|
|
// We've now mostly separated them, but the difference is still opaque to
|
|
// nsWindowWatcher (the caller of SetArguments in this little back-and-forth
|
|
// embedding waltz we do here).
|
|
//
|
|
// So we need to demultiplex the two cases here.
|
|
nsGlobalWindow *currentInner = GetCurrentInnerWindowInternal();
|
|
|
|
mArguments = aArguments;
|
|
rv = currentInner->DefineArgumentsProperty(aArguments);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::DefineArgumentsProperty(nsIArray *aArguments)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
nsIScriptContext *ctx = GetOuterWindowInternal()->mContext;
|
|
NS_ENSURE_TRUE(aArguments && ctx, NS_ERROR_NOT_INITIALIZED);
|
|
|
|
JS::Rooted<JSObject*> obj(RootingCx(), GetWrapperPreserveColor());
|
|
return ctx->SetProperty(obj, "arguments", aArguments);
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// nsGlobalWindow::nsIScriptObjectPrincipal
|
|
//*****************************************************************************
|
|
|
|
nsIPrincipal*
|
|
nsGlobalWindow::GetPrincipal()
|
|
{
|
|
if (mDoc) {
|
|
// If we have a document, get the principal from the document
|
|
return mDoc->NodePrincipal();
|
|
}
|
|
|
|
if (mDocumentPrincipal) {
|
|
return mDocumentPrincipal;
|
|
}
|
|
|
|
// If we don't have a principal and we don't have a document we
|
|
// ask the parent window for the principal. This can happen when
|
|
// loading a frameset that has a <frame src="javascript:xxx">, in
|
|
// that case the global window is used in JS before we've loaded
|
|
// a document into the window.
|
|
|
|
nsCOMPtr<nsIScriptObjectPrincipal> objPrincipal =
|
|
do_QueryInterface(GetParentInternal());
|
|
|
|
if (objPrincipal) {
|
|
return objPrincipal->GetPrincipal();
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// nsGlobalWindow::nsIDOMWindow
|
|
//*****************************************************************************
|
|
|
|
template <class T>
|
|
nsIURI*
|
|
nsPIDOMWindow<T>::GetDocumentURI() const
|
|
{
|
|
return mDoc ? mDoc->GetDocumentURI() : mDocumentURI.get();
|
|
}
|
|
|
|
template <class T>
|
|
nsIURI*
|
|
nsPIDOMWindow<T>::GetDocBaseURI() const
|
|
{
|
|
return mDoc ? mDoc->GetDocBaseURI() : mDocBaseURI.get();
|
|
}
|
|
|
|
template <class T>
|
|
void
|
|
nsPIDOMWindow<T>::MaybeCreateDoc()
|
|
{
|
|
MOZ_ASSERT(!mDoc);
|
|
if (nsIDocShell* docShell = GetDocShell()) {
|
|
// Note that |document| here is the same thing as our mDoc, but we
|
|
// don't have to explicitly set the member variable because the docshell
|
|
// has already called SetNewDocument().
|
|
nsCOMPtr<nsIDocument> document = docShell->GetDocument();
|
|
Unused << document;
|
|
}
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowOuter::SetInitialKeyboardIndicators(
|
|
UIStateChangeType aShowAccelerators, UIStateChangeType aShowFocusRings)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
MOZ_ASSERT(!GetCurrentInnerWindow());
|
|
|
|
nsPIDOMWindowOuter* piWin = GetPrivateRoot();
|
|
if (!piWin) {
|
|
return;
|
|
}
|
|
|
|
MOZ_ASSERT(piWin == AsOuter());
|
|
|
|
// only change the flags that have been modified
|
|
nsCOMPtr<nsPIWindowRoot> windowRoot = do_QueryInterface(mChromeEventHandler);
|
|
if (!windowRoot) {
|
|
return;
|
|
}
|
|
|
|
if (aShowAccelerators != UIStateChangeType_NoChange) {
|
|
windowRoot->SetShowAccelerators(aShowAccelerators == UIStateChangeType_Set);
|
|
}
|
|
if (aShowFocusRings != UIStateChangeType_NoChange) {
|
|
windowRoot->SetShowFocusRings(aShowFocusRings == UIStateChangeType_Set);
|
|
}
|
|
|
|
nsContentUtils::SetKeyboardIndicatorsOnRemoteChildren(GetOuterWindow(),
|
|
aShowAccelerators,
|
|
aShowFocusRings);
|
|
}
|
|
|
|
Element*
|
|
nsPIDOMWindowOuter::GetFrameElementInternal() const
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
return mFrameElement;
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowOuter::SetFrameElementInternal(Element* aFrameElement)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
mFrameElement = aFrameElement;
|
|
}
|
|
|
|
bool
|
|
nsPIDOMWindowInner::AddAudioContext(AudioContext* aAudioContext)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
mAudioContexts.AppendElement(aAudioContext);
|
|
|
|
// Return true if the context should be muted and false if not.
|
|
nsIDocShell* docShell = GetDocShell();
|
|
return docShell && !docShell->GetAllowMedia() && !aAudioContext->IsOffline();
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowInner::RemoveAudioContext(AudioContext* aAudioContext)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
mAudioContexts.RemoveElement(aAudioContext);
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowInner::MuteAudioContexts()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
for (uint32_t i = 0; i < mAudioContexts.Length(); ++i) {
|
|
if (!mAudioContexts[i]->IsOffline()) {
|
|
mAudioContexts[i]->Mute();
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowInner::UnmuteAudioContexts()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
for (uint32_t i = 0; i < mAudioContexts.Length(); ++i) {
|
|
if (!mAudioContexts[i]->IsOffline()) {
|
|
mAudioContexts[i]->Unmute();
|
|
}
|
|
}
|
|
}
|
|
|
|
nsGlobalWindow*
|
|
nsGlobalWindow::Window()
|
|
{
|
|
return this;
|
|
}
|
|
|
|
nsGlobalWindow*
|
|
nsGlobalWindow::Self()
|
|
{
|
|
return this;
|
|
}
|
|
|
|
Navigator*
|
|
nsGlobalWindow::Navigator()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mNavigator) {
|
|
mNavigator = new mozilla::dom::Navigator(AsInner());
|
|
}
|
|
|
|
return mNavigator;
|
|
}
|
|
|
|
nsIDOMNavigator*
|
|
nsGlobalWindow::GetNavigator()
|
|
{
|
|
FORWARD_TO_INNER(GetNavigator, (), nullptr);
|
|
|
|
return Navigator();
|
|
}
|
|
|
|
nsScreen*
|
|
nsGlobalWindow::GetScreen(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mScreen) {
|
|
mScreen = nsScreen::Create(AsInner());
|
|
if (!mScreen) {
|
|
aError.Throw(NS_ERROR_UNEXPECTED);
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
return mScreen;
|
|
}
|
|
|
|
nsIDOMScreen*
|
|
nsGlobalWindow::GetScreen()
|
|
{
|
|
FORWARD_TO_INNER(GetScreen, (), nullptr);
|
|
|
|
ErrorResult dummy;
|
|
nsIDOMScreen* screen = GetScreen(dummy);
|
|
dummy.SuppressException();
|
|
return screen;
|
|
}
|
|
|
|
nsHistory*
|
|
nsGlobalWindow::GetHistory(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mHistory) {
|
|
mHistory = new nsHistory(AsInner());
|
|
}
|
|
|
|
return mHistory;
|
|
}
|
|
|
|
CustomElementRegistry*
|
|
nsGlobalWindow::CustomElements()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mCustomElements) {
|
|
mCustomElements = new CustomElementRegistry(AsInner());
|
|
}
|
|
|
|
return mCustomElements;
|
|
}
|
|
|
|
Performance*
|
|
nsPIDOMWindowInner::GetPerformance()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
CreatePerformanceObjectIfNeeded();
|
|
return mPerformance;
|
|
}
|
|
|
|
Performance*
|
|
nsGlobalWindow::GetPerformance()
|
|
{
|
|
return AsInner()->GetPerformance();
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowInner::CreatePerformanceObjectIfNeeded()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
if (mPerformance || !mDoc) {
|
|
return;
|
|
}
|
|
RefPtr<nsDOMNavigationTiming> timing = mDoc->GetNavigationTiming();
|
|
nsCOMPtr<nsITimedChannel> timedChannel(do_QueryInterface(mDoc->GetChannel()));
|
|
bool timingEnabled = false;
|
|
if (!timedChannel ||
|
|
!NS_SUCCEEDED(timedChannel->GetTimingEnabled(&timingEnabled)) ||
|
|
!timingEnabled) {
|
|
timedChannel = nullptr;
|
|
}
|
|
if (timing) {
|
|
mPerformance = Performance::CreateForMainThread(this, timing, timedChannel);
|
|
}
|
|
}
|
|
|
|
bool
|
|
nsPIDOMWindowInner::IsSecureContext() const
|
|
{
|
|
return nsGlobalWindow::Cast(this)->IsSecureContext();
|
|
}
|
|
|
|
bool
|
|
nsPIDOMWindowInner::IsSecureContextIfOpenerIgnored() const
|
|
{
|
|
return nsGlobalWindow::Cast(this)->IsSecureContextIfOpenerIgnored();
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowInner::Suspend()
|
|
{
|
|
nsGlobalWindow::Cast(this)->Suspend();
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowInner::Resume()
|
|
{
|
|
nsGlobalWindow::Cast(this)->Resume();
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowInner::Freeze()
|
|
{
|
|
nsGlobalWindow::Cast(this)->Freeze();
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowInner::Thaw()
|
|
{
|
|
nsGlobalWindow::Cast(this)->Thaw();
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowInner::SyncStateFromParentWindow()
|
|
{
|
|
nsGlobalWindow::Cast(this)->SyncStateFromParentWindow();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::UpdateTopInnerWindow()
|
|
{
|
|
if (!IsInnerWindow() || AsInner()->IsTopInnerWindow() || !mTopInnerWindow) {
|
|
return;
|
|
}
|
|
|
|
mTopInnerWindow->UpdateWebSocketCount(-(int32_t)mNumOfOpenWebSockets);
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowInner::AddPeerConnection()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
mTopInnerWindow ? mTopInnerWindow->mActivePeerConnections++
|
|
: mActivePeerConnections++;
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowInner::RemovePeerConnection()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
MOZ_ASSERT(mTopInnerWindow ? mTopInnerWindow->mActivePeerConnections
|
|
: mActivePeerConnections);
|
|
|
|
mTopInnerWindow ? mTopInnerWindow->mActivePeerConnections--
|
|
: mActivePeerConnections--;
|
|
}
|
|
|
|
bool
|
|
nsPIDOMWindowInner::HasActivePeerConnections()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
return mTopInnerWindow ? mTopInnerWindow->mActivePeerConnections
|
|
: mActivePeerConnections;
|
|
}
|
|
|
|
bool
|
|
nsPIDOMWindowInner::IsPlayingAudio()
|
|
{
|
|
for (uint32_t i = 0; i < mAudioContexts.Length(); i++) {
|
|
if (mAudioContexts[i]->IsRunning()) {
|
|
return true;
|
|
}
|
|
}
|
|
RefPtr<AudioChannelService> acs = AudioChannelService::Get();
|
|
if (!acs) {
|
|
return false;
|
|
}
|
|
auto outer = GetOuterWindow();
|
|
if (!outer) {
|
|
// We've been unlinked and are about to die. Not a good time to pretend to
|
|
// be playing audio.
|
|
return false;
|
|
}
|
|
return acs->IsWindowActive(outer);
|
|
}
|
|
|
|
bool
|
|
nsPIDOMWindowInner::IsDocumentLoaded() const
|
|
{
|
|
return mIsDocumentLoaded;
|
|
}
|
|
|
|
mozilla::dom::TimeoutManager&
|
|
nsPIDOMWindowInner::TimeoutManager()
|
|
{
|
|
return *mTimeoutManager;
|
|
}
|
|
|
|
bool
|
|
nsPIDOMWindowInner::IsRunningTimeout()
|
|
{
|
|
return TimeoutManager().IsRunningTimeout();
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowInner::TryToCacheTopInnerWindow()
|
|
{
|
|
if (mHasTriedToCacheTopInnerWindow) {
|
|
return;
|
|
}
|
|
|
|
MOZ_ASSERT(!mInnerObjectsFreed);
|
|
|
|
mHasTriedToCacheTopInnerWindow = true;
|
|
|
|
nsGlobalWindow* window = nsGlobalWindow::Cast(AsInner());
|
|
|
|
MOZ_ASSERT(window);
|
|
|
|
if (nsCOMPtr<nsPIDOMWindowOuter> topOutter = window->GetScriptableTop()) {
|
|
mTopInnerWindow = topOutter->GetCurrentInnerWindow();
|
|
}
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowInner::UpdateActiveIndexedDBTransactionCount(int32_t aDelta)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (aDelta == 0) {
|
|
return;
|
|
}
|
|
|
|
TabGroup()->IndexedDBTransactionCounter() += aDelta;
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowInner::UpdateActiveIndexedDBDatabaseCount(int32_t aDelta)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (aDelta == 0) {
|
|
return;
|
|
}
|
|
|
|
// We count databases but not transactions because only active databases
|
|
// could block throttling.
|
|
uint32_t& counter = mTopInnerWindow ?
|
|
mTopInnerWindow->mNumOfIndexedDBDatabases : mNumOfIndexedDBDatabases;
|
|
|
|
counter+= aDelta;
|
|
|
|
TabGroup()->IndexedDBDatabaseCounter() += aDelta;
|
|
}
|
|
|
|
bool
|
|
nsPIDOMWindowInner::HasActiveIndexedDBDatabases()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
return mTopInnerWindow ?
|
|
mTopInnerWindow->mNumOfIndexedDBDatabases > 0 :
|
|
mNumOfIndexedDBDatabases > 0;
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowInner::UpdateWebSocketCount(int32_t aDelta)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (aDelta == 0) {
|
|
return;
|
|
}
|
|
|
|
if (mTopInnerWindow && !IsTopInnerWindow()) {
|
|
mTopInnerWindow->UpdateWebSocketCount(aDelta);
|
|
}
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(
|
|
aDelta > 0 || ((aDelta + mNumOfOpenWebSockets) < mNumOfOpenWebSockets));
|
|
|
|
mNumOfOpenWebSockets += aDelta;
|
|
}
|
|
|
|
bool
|
|
nsPIDOMWindowInner::HasOpenWebSockets() const
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
return mNumOfOpenWebSockets ||
|
|
(mTopInnerWindow && mTopInnerWindow->mNumOfOpenWebSockets);
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowOuter::MaybeActiveMediaComponents()
|
|
{
|
|
if (IsInnerWindow()) {
|
|
return mOuterWindow->MaybeActiveMediaComponents();
|
|
}
|
|
|
|
if (mMediaSuspend != nsISuspendedTypes::SUSPENDED_BLOCK) {
|
|
return;
|
|
}
|
|
|
|
MOZ_LOG(AudioChannelService::GetAudioChannelLog(), LogLevel::Debug,
|
|
("nsPIDOMWindowOuter, MaybeActiveMediaComponents, "
|
|
"resume the window from blocked, this = %p\n", this));
|
|
|
|
SetMediaSuspend(nsISuspendedTypes::NONE_SUSPENDED);
|
|
}
|
|
|
|
SuspendTypes
|
|
nsPIDOMWindowOuter::GetMediaSuspend() const
|
|
{
|
|
if (IsInnerWindow()) {
|
|
return mOuterWindow->GetMediaSuspend();
|
|
}
|
|
|
|
return mMediaSuspend;
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowOuter::SetMediaSuspend(SuspendTypes aSuspend)
|
|
{
|
|
if (IsInnerWindow()) {
|
|
mOuterWindow->SetMediaSuspend(aSuspend);
|
|
return;
|
|
}
|
|
|
|
if (!IsDisposableSuspend(aSuspend)) {
|
|
MaybeNotifyMediaResumedFromBlock(aSuspend);
|
|
mMediaSuspend = aSuspend;
|
|
}
|
|
|
|
RefreshMediaElementsSuspend(aSuspend);
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowOuter::MaybeNotifyMediaResumedFromBlock(SuspendTypes aSuspend)
|
|
{
|
|
if (mMediaSuspend == nsISuspendedTypes::SUSPENDED_BLOCK &&
|
|
aSuspend == nsISuspendedTypes::NONE_SUSPENDED) {
|
|
RefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
|
|
if (service) {
|
|
service->NotifyMediaResumedFromBlock(GetOuterWindow());
|
|
}
|
|
}
|
|
}
|
|
|
|
bool
|
|
nsPIDOMWindowOuter::GetAudioMuted() const
|
|
{
|
|
if (IsInnerWindow()) {
|
|
return mOuterWindow->GetAudioMuted();
|
|
}
|
|
|
|
return mAudioMuted;
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowOuter::SetAudioMuted(bool aMuted)
|
|
{
|
|
if (IsInnerWindow()) {
|
|
mOuterWindow->SetAudioMuted(aMuted);
|
|
return;
|
|
}
|
|
|
|
if (mAudioMuted == aMuted) {
|
|
return;
|
|
}
|
|
|
|
mAudioMuted = aMuted;
|
|
RefreshMediaElementsVolume();
|
|
}
|
|
|
|
float
|
|
nsPIDOMWindowOuter::GetAudioVolume() const
|
|
{
|
|
if (IsInnerWindow()) {
|
|
return mOuterWindow->GetAudioVolume();
|
|
}
|
|
|
|
return mAudioVolume;
|
|
}
|
|
|
|
nsresult
|
|
nsPIDOMWindowOuter::SetAudioVolume(float aVolume)
|
|
{
|
|
if (IsInnerWindow()) {
|
|
return mOuterWindow->SetAudioVolume(aVolume);
|
|
}
|
|
|
|
if (aVolume < 0.0) {
|
|
return NS_ERROR_DOM_INDEX_SIZE_ERR;
|
|
}
|
|
|
|
if (mAudioVolume == aVolume) {
|
|
return NS_OK;
|
|
}
|
|
|
|
mAudioVolume = aVolume;
|
|
RefreshMediaElementsVolume();
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowOuter::RefreshMediaElementsVolume()
|
|
{
|
|
RefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
|
|
if (service) {
|
|
service->RefreshAgentsVolume(GetOuterWindow());
|
|
}
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowOuter::RefreshMediaElementsSuspend(SuspendTypes aSuspend)
|
|
{
|
|
RefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
|
|
if (service) {
|
|
service->RefreshAgentsSuspend(GetOuterWindow(), aSuspend);
|
|
}
|
|
}
|
|
|
|
bool
|
|
nsPIDOMWindowOuter::IsDisposableSuspend(SuspendTypes aSuspend) const
|
|
{
|
|
return (aSuspend == nsISuspendedTypes::SUSPENDED_PAUSE_DISPOSABLE ||
|
|
aSuspend == nsISuspendedTypes::SUSPENDED_STOP_DISPOSABLE);
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowOuter::SetServiceWorkersTestingEnabled(bool aEnabled)
|
|
{
|
|
// Devtools should only be setting this on the top level window. Its
|
|
// ok if devtools clears the flag on clean up of nested windows, though.
|
|
// It will have no affect.
|
|
#ifdef DEBUG
|
|
nsCOMPtr<nsPIDOMWindowOuter> topWindow = GetScriptableTop();
|
|
MOZ_ASSERT_IF(aEnabled, this == topWindow);
|
|
#endif
|
|
mServiceWorkersTestingEnabled = aEnabled;
|
|
}
|
|
|
|
bool
|
|
nsPIDOMWindowOuter::GetServiceWorkersTestingEnabled()
|
|
{
|
|
// Automatically get this setting from the top level window so that nested
|
|
// iframes get the correct devtools setting.
|
|
nsCOMPtr<nsPIDOMWindowOuter> topWindow = GetScriptableTop();
|
|
if (!topWindow) {
|
|
return false;
|
|
}
|
|
return topWindow->mServiceWorkersTestingEnabled;
|
|
}
|
|
|
|
bool
|
|
nsPIDOMWindowInner::GetAudioCaptured() const
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
return mAudioCaptured;
|
|
}
|
|
|
|
nsresult
|
|
nsPIDOMWindowInner::SetAudioCapture(bool aCapture)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
mAudioCaptured = aCapture;
|
|
|
|
RefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
|
|
if (service) {
|
|
service->SetWindowAudioCaptured(GetOuterWindow(), mWindowID, aCapture);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// nsISpeechSynthesisGetter
|
|
|
|
#ifdef MOZ_WEBSPEECH
|
|
SpeechSynthesis*
|
|
nsGlobalWindow::GetSpeechSynthesis(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mSpeechSynthesis) {
|
|
mSpeechSynthesis = new SpeechSynthesis(AsInner());
|
|
}
|
|
|
|
return mSpeechSynthesis;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::HasActiveSpeechSynthesis()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
if (mSpeechSynthesis) {
|
|
return !mSpeechSynthesis->HasEmptyQueue();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#endif
|
|
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsGlobalWindow::GetParentOuter()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDocShell) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> parent;
|
|
if (mDocShell->GetIsMozBrowser()) {
|
|
parent = AsOuter();
|
|
} else {
|
|
parent = GetParent();
|
|
}
|
|
|
|
return parent.forget();
|
|
}
|
|
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsGlobalWindow::GetParent(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetParentOuter, (), aError, nullptr);
|
|
}
|
|
|
|
/**
|
|
* GetScriptableParent is called when script reads window.parent.
|
|
*
|
|
* In contrast to GetRealParent, GetScriptableParent respects <iframe
|
|
* mozbrowser> boundaries, so if |this| is contained by an <iframe
|
|
* mozbrowser>, we will return |this| as its own parent.
|
|
*/
|
|
nsPIDOMWindowOuter*
|
|
nsGlobalWindow::GetScriptableParent()
|
|
{
|
|
FORWARD_TO_OUTER(GetScriptableParent, (), nullptr);
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> parent = GetParentOuter();
|
|
return parent.get();
|
|
}
|
|
|
|
/**
|
|
* Behavies identically to GetScriptableParent extept that it returns null
|
|
* if GetScriptableParent would return this window.
|
|
*/
|
|
nsPIDOMWindowOuter*
|
|
nsGlobalWindow::GetScriptableParentOrNull()
|
|
{
|
|
FORWARD_TO_OUTER(GetScriptableParentOrNull, (), nullptr);
|
|
|
|
nsPIDOMWindowOuter* parent = GetScriptableParent();
|
|
return (Cast(parent) == this) ? nullptr : parent;
|
|
}
|
|
|
|
/**
|
|
* nsPIDOMWindow::GetParent (when called from C++) is just a wrapper around
|
|
* GetRealParent.
|
|
*/
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsGlobalWindow::GetParent()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDocShell) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsCOMPtr<nsIDocShell> parent;
|
|
mDocShell->GetSameTypeParentIgnoreBrowserBoundaries(getter_AddRefs(parent));
|
|
|
|
if (parent) {
|
|
nsCOMPtr<nsPIDOMWindowOuter> win = parent->GetWindow();
|
|
return win.forget();
|
|
}
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> win(AsOuter());
|
|
return win.forget();
|
|
}
|
|
|
|
static nsresult
|
|
GetTopImpl(nsGlobalWindow* aWin, nsPIDOMWindowOuter** aTop, bool aScriptable)
|
|
{
|
|
*aTop = nullptr;
|
|
|
|
// Walk up the parent chain.
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> prevParent = aWin->AsOuter();
|
|
nsCOMPtr<nsPIDOMWindowOuter> parent = aWin->AsOuter();
|
|
do {
|
|
if (!parent) {
|
|
break;
|
|
}
|
|
|
|
prevParent = parent;
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> newParent;
|
|
if (aScriptable) {
|
|
newParent = parent->GetScriptableParent();
|
|
}
|
|
else {
|
|
newParent = parent->GetParent();
|
|
}
|
|
|
|
parent = newParent;
|
|
|
|
} while (parent != prevParent);
|
|
|
|
if (parent) {
|
|
parent.swap(*aTop);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/**
|
|
* GetScriptableTop is called when script reads window.top.
|
|
*
|
|
* In contrast to GetRealTop, GetScriptableTop respects <iframe mozbrowser>
|
|
* boundaries. If we encounter a window owned by an <iframe mozbrowser> while
|
|
* walking up the window hierarchy, we'll stop and return that window.
|
|
*/
|
|
nsPIDOMWindowOuter*
|
|
nsGlobalWindow::GetScriptableTop()
|
|
{
|
|
FORWARD_TO_OUTER(GetScriptableTop, (), nullptr);
|
|
nsCOMPtr<nsPIDOMWindowOuter> window;
|
|
GetTopImpl(this, getter_AddRefs(window), /* aScriptable = */ true);
|
|
return window.get();
|
|
}
|
|
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsGlobalWindow::GetTop()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
nsCOMPtr<nsPIDOMWindowOuter> window;
|
|
GetTopImpl(this, getter_AddRefs(window), /* aScriptable = */ false);
|
|
return window.forget();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetContentOuter(JSContext* aCx,
|
|
JS::MutableHandle<JSObject*> aRetval,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> content =
|
|
GetContentInternal(aError, aCallerType);
|
|
if (aError.Failed()) {
|
|
return;
|
|
}
|
|
|
|
if (content) {
|
|
JS::Rooted<JS::Value> val(aCx);
|
|
aError = nsContentUtils::WrapNative(aCx, content, &val);
|
|
if (aError.Failed()) {
|
|
return;
|
|
}
|
|
|
|
aRetval.set(&val.toObject());
|
|
return;
|
|
}
|
|
|
|
aRetval.set(nullptr);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetContent(JSContext* aCx,
|
|
JS::MutableHandle<JSObject*> aRetval,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetContentOuter,
|
|
(aCx, aRetval, aCallerType, aError), aError, );
|
|
}
|
|
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsGlobalWindow::GetContentInternal(ErrorResult& aError, CallerType aCallerType)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
// First check for a named frame named "content"
|
|
nsCOMPtr<nsPIDOMWindowOuter> domWindow =
|
|
GetChildWindow(NS_LITERAL_STRING("content"));
|
|
if (domWindow) {
|
|
return domWindow.forget();
|
|
}
|
|
|
|
// If we're contained in <iframe mozbrowser>, then GetContent is the same as
|
|
// window.top.
|
|
if (mDocShell && mDocShell->GetIsInMozBrowser()) {
|
|
return GetTopOuter();
|
|
}
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> primaryContent;
|
|
if (aCallerType != CallerType::System) {
|
|
if (mDoc) {
|
|
mDoc->WarnOnceAbout(nsIDocument::eWindowContentUntrusted);
|
|
}
|
|
// If we're called by non-chrome code, make sure we don't return
|
|
// the primary content window if the calling tab is hidden. In
|
|
// such a case we return the same-type root in the hidden tab,
|
|
// which is "good enough", for now.
|
|
nsCOMPtr<nsIBaseWindow> baseWin(do_QueryInterface(mDocShell));
|
|
|
|
if (baseWin) {
|
|
bool visible = false;
|
|
baseWin->GetVisibility(&visible);
|
|
|
|
if (!visible) {
|
|
mDocShell->GetSameTypeRootTreeItem(getter_AddRefs(primaryContent));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!primaryContent) {
|
|
nsCOMPtr<nsIDocShellTreeOwner> treeOwner = GetTreeOwner();
|
|
if (!treeOwner) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return nullptr;
|
|
}
|
|
|
|
treeOwner->GetPrimaryContentShell(getter_AddRefs(primaryContent));
|
|
}
|
|
|
|
if (!primaryContent) {
|
|
return nullptr;
|
|
}
|
|
|
|
domWindow = primaryContent->GetWindow();
|
|
return domWindow.forget();
|
|
}
|
|
|
|
MozSelfSupport*
|
|
nsGlobalWindow::GetMozSelfSupport(ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
if (mMozSelfSupport) {
|
|
return mMozSelfSupport;
|
|
}
|
|
|
|
// We're called from JS and want to use out existing JSContext (and,
|
|
// importantly, its compartment!) here.
|
|
AutoJSContext cx;
|
|
GlobalObject global(cx, FastGetGlobalJSObject());
|
|
mMozSelfSupport = MozSelfSupport::Constructor(global, cx, aError);
|
|
return mMozSelfSupport;
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::GetPrompter(nsIPrompt** aPrompt)
|
|
{
|
|
if (IsInnerWindow()) {
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
if (!outer) {
|
|
NS_WARNING("No outer window available!");
|
|
return NS_ERROR_NOT_INITIALIZED;
|
|
}
|
|
return outer->GetPrompter(aPrompt);
|
|
}
|
|
|
|
if (!mDocShell)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
nsCOMPtr<nsIPrompt> prompter(do_GetInterface(mDocShell));
|
|
NS_ENSURE_TRUE(prompter, NS_ERROR_NO_INTERFACE);
|
|
|
|
prompter.forget(aPrompt);
|
|
return NS_OK;
|
|
}
|
|
|
|
BarProp*
|
|
nsGlobalWindow::GetMenubar(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mMenubar) {
|
|
mMenubar = new MenubarProp(this);
|
|
}
|
|
|
|
return mMenubar;
|
|
}
|
|
|
|
BarProp*
|
|
nsGlobalWindow::GetToolbar(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mToolbar) {
|
|
mToolbar = new ToolbarProp(this);
|
|
}
|
|
|
|
return mToolbar;
|
|
}
|
|
|
|
BarProp*
|
|
nsGlobalWindow::GetLocationbar(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mLocationbar) {
|
|
mLocationbar = new LocationbarProp(this);
|
|
}
|
|
return mLocationbar;
|
|
}
|
|
|
|
BarProp*
|
|
nsGlobalWindow::GetPersonalbar(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mPersonalbar) {
|
|
mPersonalbar = new PersonalbarProp(this);
|
|
}
|
|
return mPersonalbar;
|
|
}
|
|
|
|
BarProp*
|
|
nsGlobalWindow::GetStatusbar(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mStatusbar) {
|
|
mStatusbar = new StatusbarProp(this);
|
|
}
|
|
return mStatusbar;
|
|
}
|
|
|
|
BarProp*
|
|
nsGlobalWindow::GetScrollbars(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mScrollbars) {
|
|
mScrollbars = new ScrollbarsProp(this);
|
|
}
|
|
|
|
return mScrollbars;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::GetClosedOuter()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
// If someone called close(), or if we don't have a docshell, we're closed.
|
|
return mIsClosed || !mDocShell;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::GetClosed(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetClosedOuter, (), aError, false);
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::Closed()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
return GetClosedOuter();
|
|
}
|
|
|
|
nsDOMWindowList*
|
|
nsGlobalWindow::GetWindowList()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
if (!mFrames && mDocShell) {
|
|
mFrames = new nsDOMWindowList(mDocShell);
|
|
}
|
|
|
|
return mFrames;
|
|
}
|
|
|
|
already_AddRefed<nsIDOMWindowCollection>
|
|
nsGlobalWindow::GetFrames()
|
|
{
|
|
FORWARD_TO_OUTER(GetFrames, (), nullptr);
|
|
|
|
nsCOMPtr<nsIDOMWindowCollection> frames = GetWindowList();
|
|
return frames.forget();
|
|
}
|
|
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsGlobalWindow::IndexedGetterOuter(uint32_t aIndex)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
nsDOMWindowList* windows = GetWindowList();
|
|
NS_ENSURE_TRUE(windows, nullptr);
|
|
|
|
return windows->IndexedGetter(aIndex);
|
|
}
|
|
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsGlobalWindow::IndexedGetter(uint32_t aIndex)
|
|
{
|
|
FORWARD_TO_OUTER(IndexedGetterOuter, (aIndex), nullptr);
|
|
MOZ_CRASH();
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::DoResolve(JSContext* aCx, JS::Handle<JSObject*> aObj,
|
|
JS::Handle<jsid> aId,
|
|
JS::MutableHandle<JS::PropertyDescriptor> aDesc)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
// Note: Keep this in sync with MayResolve.
|
|
|
|
// Note: The infallibleInit call in GlobalResolve depends on this check.
|
|
if (!JSID_IS_STRING(aId)) {
|
|
return true;
|
|
}
|
|
|
|
bool found;
|
|
if (!WebIDLGlobalNameHash::DefineIfEnabled(aCx, aObj, aId, aDesc, &found)) {
|
|
return false;
|
|
}
|
|
|
|
if (found) {
|
|
return true;
|
|
}
|
|
|
|
nsresult rv = nsWindowSH::GlobalResolve(this, aCx, aObj, aId, aDesc);
|
|
if (NS_FAILED(rv)) {
|
|
return Throw(aCx, rv);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/* static */
|
|
bool
|
|
nsGlobalWindow::MayResolve(jsid aId)
|
|
{
|
|
// Note: This function does not fail and may not have any side-effects.
|
|
// Note: Keep this in sync with DoResolve.
|
|
if (!JSID_IS_STRING(aId)) {
|
|
return false;
|
|
}
|
|
|
|
if (aId == XPCJSRuntime::Get()->GetStringID(XPCJSContext::IDX_COMPONENTS)) {
|
|
return true;
|
|
}
|
|
|
|
if (aId == XPCJSRuntime::Get()->GetStringID(XPCJSContext::IDX_CONTROLLERS) ||
|
|
aId == XPCJSRuntime::Get()->GetStringID(XPCJSContext::IDX_CONTROLLERS_CLASS)) {
|
|
// We only resolve .controllers/.Controllers in release builds and on non-chrome
|
|
// windows, but let's not worry about any of that stuff.
|
|
return true;
|
|
}
|
|
|
|
if (WebIDLGlobalNameHash::MayResolve(aId)) {
|
|
return true;
|
|
}
|
|
|
|
nsScriptNameSpaceManager *nameSpaceManager = PeekNameSpaceManager();
|
|
if (!nameSpaceManager) {
|
|
// Really shouldn't happen. Fail safe.
|
|
return true;
|
|
}
|
|
|
|
nsAutoString name;
|
|
AssignJSFlatString(name, JSID_TO_FLAT_STRING(aId));
|
|
|
|
return nameSpaceManager->LookupName(name);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetOwnPropertyNames(JSContext* aCx, JS::AutoIdVector& aNames,
|
|
bool aEnumerableOnly, ErrorResult& aRv)
|
|
{
|
|
if (aEnumerableOnly) {
|
|
// The names we would return from here get defined on the window via one of
|
|
// two codepaths. The ones coming from the WebIDLGlobalNameHash will end up
|
|
// in the DefineConstructor function in BindingUtils, which always defines
|
|
// things as non-enumerable. The ones coming from the script namespace
|
|
// manager get defined by nsDOMClassInfo::PostCreatePrototype calling
|
|
// ResolvePrototype and using the resulting descriptot to define the
|
|
// property. ResolvePrototype always passes 0 to the FillPropertyDescriptor
|
|
// for the property attributes, so all those are non-enumerable as well.
|
|
//
|
|
// So in the aEnumerableOnly case we have nothing to do.
|
|
return;
|
|
}
|
|
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
// "Components" is marked as enumerable but only resolved on demand :-/.
|
|
//aNames.AppendElement(NS_LITERAL_STRING("Components"));
|
|
|
|
nsScriptNameSpaceManager* nameSpaceManager = GetNameSpaceManager();
|
|
if (nameSpaceManager) {
|
|
JS::Rooted<JSObject*> wrapper(aCx, GetWrapper());
|
|
|
|
// There are actually two ways we can get called here: For normal
|
|
// enumeration or for Xray enumeration. In the latter case, we want to
|
|
// return all possible WebIDL names, because we don't really support
|
|
// deleting these names off our Xray; trying to resolve them will just make
|
|
// them come back. In the former case, we want to avoid returning deleted
|
|
// names. But the JS engine already knows about the non-deleted
|
|
// already-resolved names, so we can just return the so-far-unresolved ones.
|
|
//
|
|
// We can tell which case we're in by whether aCx is in our wrapper's
|
|
// compartment. If not, we're in the Xray case.
|
|
WebIDLGlobalNameHash::NameType nameType =
|
|
js::IsObjectInContextCompartment(wrapper, aCx) ?
|
|
WebIDLGlobalNameHash::UnresolvedNamesOnly :
|
|
WebIDLGlobalNameHash::AllNames;
|
|
if (!WebIDLGlobalNameHash::GetNames(aCx, wrapper, nameType, aNames)) {
|
|
aRv.NoteJSContextException(aCx);
|
|
}
|
|
|
|
for (auto i = nameSpaceManager->GlobalNameIter(); !i.Done(); i.Next()) {
|
|
const GlobalNameMapEntry* entry = i.Get();
|
|
if (nsWindowSH::NameStructEnabled(aCx, this, entry->mKey,
|
|
entry->mGlobalName)) {
|
|
// Just append all of these; even if they get deleted our resolve hook
|
|
// just goes ahead and recreates them.
|
|
JSString* str = JS_AtomizeUCStringN(aCx,
|
|
entry->mKey.BeginReading(),
|
|
entry->mKey.Length());
|
|
if (!str || !aNames.append(NON_INTEGER_ATOM_TO_JSID(str))) {
|
|
aRv.NoteJSContextException(aCx);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* static */ bool
|
|
nsGlobalWindow::IsPrivilegedChromeWindow(JSContext* aCx, JSObject* aObj)
|
|
{
|
|
// For now, have to deal with XPConnect objects here.
|
|
return xpc::WindowOrNull(aObj)->IsChromeWindow() &&
|
|
nsContentUtils::ObjectPrincipal(aObj) == nsContentUtils::GetSystemPrincipal();
|
|
}
|
|
|
|
/* static */ bool
|
|
nsGlobalWindow::IsRequestIdleCallbackEnabled(JSContext* aCx, JSObject* aObj)
|
|
{
|
|
// The requestIdleCallback should always be enabled for system code.
|
|
return nsContentUtils::RequestIdleCallbackEnabled() ||
|
|
nsContentUtils::IsSystemCaller(aCx);
|
|
}
|
|
|
|
nsIDOMOfflineResourceList*
|
|
nsGlobalWindow::GetApplicationCache(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mApplicationCache) {
|
|
nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(GetDocShell()));
|
|
if (!webNav || !mDoc) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return nullptr;
|
|
}
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
aError = webNav->GetCurrentURI(getter_AddRefs(uri));
|
|
if (aError.Failed()) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsCOMPtr<nsIURI> manifestURI;
|
|
nsContentUtils::GetOfflineAppManifest(mDoc, getter_AddRefs(manifestURI));
|
|
|
|
RefPtr<nsDOMOfflineResourceList> applicationCache =
|
|
new nsDOMOfflineResourceList(manifestURI, uri, mDoc->NodePrincipal(),
|
|
AsInner());
|
|
|
|
applicationCache->Init();
|
|
|
|
mApplicationCache = applicationCache;
|
|
}
|
|
|
|
return mApplicationCache;
|
|
}
|
|
|
|
already_AddRefed<nsIDOMOfflineResourceList>
|
|
nsGlobalWindow::GetApplicationCache()
|
|
{
|
|
FORWARD_TO_INNER(GetApplicationCache, (), nullptr);
|
|
|
|
ErrorResult dummy;
|
|
nsCOMPtr<nsIDOMOfflineResourceList> applicationCache =
|
|
GetApplicationCache(dummy);
|
|
dummy.SuppressException();
|
|
return applicationCache.forget();
|
|
}
|
|
|
|
Crypto*
|
|
nsGlobalWindow::GetCrypto(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mCrypto) {
|
|
mCrypto = new Crypto();
|
|
mCrypto->Init(this);
|
|
}
|
|
return mCrypto;
|
|
}
|
|
|
|
mozilla::dom::U2F*
|
|
nsGlobalWindow::GetU2f(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mU2F) {
|
|
RefPtr<U2F> u2f = new U2F(AsInner());
|
|
u2f->Init(aError);
|
|
if (NS_WARN_IF(aError.Failed())) {
|
|
return nullptr;
|
|
}
|
|
|
|
mU2F = u2f;
|
|
}
|
|
return mU2F;
|
|
}
|
|
|
|
nsIControllers*
|
|
nsGlobalWindow::GetControllersOuter(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
if (!mControllers) {
|
|
nsresult rv;
|
|
mControllers = do_CreateInstance(kXULControllersCID, &rv);
|
|
if (NS_FAILED(rv)) {
|
|
aError.Throw(rv);
|
|
return nullptr;
|
|
}
|
|
|
|
// Add in the default controller
|
|
nsCOMPtr<nsIController> controller = do_CreateInstance(
|
|
NS_WINDOWCONTROLLER_CONTRACTID, &rv);
|
|
if (NS_FAILED(rv)) {
|
|
aError.Throw(rv);
|
|
return nullptr;
|
|
}
|
|
|
|
mControllers->InsertControllerAt(0, controller);
|
|
nsCOMPtr<nsIControllerContext> controllerContext = do_QueryInterface(controller);
|
|
if (!controllerContext) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return nullptr;
|
|
}
|
|
|
|
controllerContext->SetCommandContext(static_cast<nsIDOMWindow*>(this));
|
|
}
|
|
|
|
return mControllers;
|
|
}
|
|
|
|
nsIControllers*
|
|
nsGlobalWindow::GetControllers(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetControllersOuter, (aError), aError, nullptr);
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::GetControllers(nsIControllers** aResult)
|
|
{
|
|
FORWARD_TO_INNER(GetControllers, (aResult), NS_ERROR_UNEXPECTED);
|
|
|
|
ErrorResult rv;
|
|
nsCOMPtr<nsIControllers> controllers = GetControllers(rv);
|
|
controllers.forget(aResult);
|
|
|
|
return rv.StealNSResult();
|
|
}
|
|
|
|
nsPIDOMWindowOuter*
|
|
nsGlobalWindow::GetSanitizedOpener(nsPIDOMWindowOuter* aOpener)
|
|
{
|
|
if (!aOpener) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsGlobalWindow* win = nsGlobalWindow::Cast(aOpener);
|
|
|
|
// First, ensure that we're not handing back a chrome window to content:
|
|
if (win->IsChromeWindow()) {
|
|
return nullptr;
|
|
}
|
|
|
|
// We don't want to reveal the opener if the opener is a mail window,
|
|
// because opener can be used to spoof the contents of a message (bug 105050).
|
|
// So, we look in the opener's root docshell to see if it's a mail window.
|
|
nsCOMPtr<nsIDocShell> openerDocShell = aOpener->GetDocShell();
|
|
|
|
if (openerDocShell) {
|
|
nsCOMPtr<nsIDocShellTreeItem> openerRootItem;
|
|
openerDocShell->GetRootTreeItem(getter_AddRefs(openerRootItem));
|
|
nsCOMPtr<nsIDocShell> openerRootDocShell(do_QueryInterface(openerRootItem));
|
|
if (openerRootDocShell) {
|
|
uint32_t appType;
|
|
nsresult rv = openerRootDocShell->GetAppType(&appType);
|
|
if (NS_SUCCEEDED(rv) && appType != nsIDocShell::APP_TYPE_MAIL) {
|
|
return aOpener;
|
|
}
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
nsPIDOMWindowOuter*
|
|
nsGlobalWindow::GetOpenerWindowOuter()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> opener = do_QueryReferent(mOpener);
|
|
|
|
if (!opener) {
|
|
return nullptr;
|
|
}
|
|
|
|
// First, check if we were called from a privileged chrome script
|
|
if (nsContentUtils::LegacyIsCallerChromeOrNativeCode()) {
|
|
// Catch the case where we're chrome but the opener is not...
|
|
if (GetPrincipal() == nsContentUtils::GetSystemPrincipal() &&
|
|
nsGlobalWindow::Cast(opener)->GetPrincipal() != nsContentUtils::GetSystemPrincipal()) {
|
|
return nullptr;
|
|
}
|
|
return opener;
|
|
}
|
|
|
|
return GetSanitizedOpener(opener);
|
|
}
|
|
|
|
nsPIDOMWindowOuter*
|
|
nsGlobalWindow::GetOpenerWindow(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetOpenerWindowOuter, (), aError, nullptr);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetOpener(JSContext* aCx, JS::MutableHandle<JS::Value> aRetval,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> opener = GetOpenerWindow(aError);
|
|
if (aError.Failed() || !opener) {
|
|
aRetval.setNull();
|
|
return;
|
|
}
|
|
|
|
aError = nsContentUtils::WrapNative(aCx, opener, aRetval);
|
|
}
|
|
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsGlobalWindow::GetOpener()
|
|
{
|
|
FORWARD_TO_OUTER(GetOpener, (), nullptr);
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> opener = GetOpenerWindowOuter();
|
|
return opener.forget();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetOpener(JSContext* aCx, JS::Handle<JS::Value> aOpener,
|
|
ErrorResult& aError)
|
|
{
|
|
// Check if we were called from a privileged chrome script. If not, and if
|
|
// aOpener is not null, just define aOpener on our inner window's JS object,
|
|
// wrapped into the current compartment so that for Xrays we define on the
|
|
// Xray expando object, but don't set it on the outer window, so that it'll
|
|
// get reset on navigation. This is just like replaceable properties, but
|
|
// we're not quite readonly.
|
|
if (!aOpener.isNull() && !nsContentUtils::IsCallerChrome()) {
|
|
RedefineProperty(aCx, "opener", aOpener, aError);
|
|
return;
|
|
}
|
|
|
|
if (!aOpener.isObjectOrNull()) {
|
|
// Chrome code trying to set some random value as opener
|
|
aError.Throw(NS_ERROR_INVALID_ARG);
|
|
return;
|
|
}
|
|
|
|
nsPIDOMWindowInner* win = nullptr;
|
|
if (aOpener.isObject()) {
|
|
JSObject* unwrapped = js::CheckedUnwrap(&aOpener.toObject(),
|
|
/* stopAtWindowProxy = */ false);
|
|
if (!unwrapped) {
|
|
aError.Throw(NS_ERROR_DOM_SECURITY_ERR);
|
|
return;
|
|
}
|
|
|
|
auto* globalWindow = xpc::WindowOrNull(unwrapped);
|
|
if (!globalWindow) {
|
|
// Wasn't a window
|
|
aError.Throw(NS_ERROR_INVALID_ARG);
|
|
return;
|
|
}
|
|
|
|
win = globalWindow->AsInner();
|
|
}
|
|
|
|
nsPIDOMWindowOuter* outer = nullptr;
|
|
if (win) {
|
|
if (!win->IsCurrentInnerWindow()) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
outer = win->GetOuterWindow();
|
|
}
|
|
|
|
SetOpenerWindow(outer, false);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetStatusOuter(nsAString& aStatus)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
aStatus = mStatus;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetStatus(nsAString& aStatus, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetStatusOuter, (aStatus), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetStatusOuter(const nsAString& aStatus)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
mStatus = aStatus;
|
|
|
|
/*
|
|
* If caller is not chrome and dom.disable_window_status_change is true,
|
|
* prevent propagating window.status to the UI by exiting early
|
|
*/
|
|
|
|
if (!CanSetProperty("dom.disable_window_status_change")) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIWebBrowserChrome> browserChrome = GetWebBrowserChrome();
|
|
if (browserChrome) {
|
|
browserChrome->SetStatus(nsIWebBrowserChrome::STATUS_SCRIPT,
|
|
PromiseFlatString(aStatus).get());
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetStatus(const nsAString& aStatus, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(SetStatusOuter, (aStatus), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetNameOuter(nsAString& aName)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
if (mDocShell) {
|
|
mDocShell->GetName(aName);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetName(nsAString& aName, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetNameOuter, (aName), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetNameOuter(const nsAString& aName, mozilla::ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
if (mDocShell) {
|
|
aError = mDocShell->SetName(aName);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetName(const nsAString& aName, mozilla::ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(SetNameOuter, (aName, aError), aError, );
|
|
}
|
|
|
|
// Helper functions used by many methods below.
|
|
int32_t
|
|
nsGlobalWindow::DevToCSSIntPixels(int32_t px)
|
|
{
|
|
if (!mDocShell)
|
|
return px; // assume 1:1
|
|
|
|
RefPtr<nsPresContext> presContext;
|
|
mDocShell->GetPresContext(getter_AddRefs(presContext));
|
|
if (!presContext)
|
|
return px;
|
|
|
|
return presContext->DevPixelsToIntCSSPixels(px);
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::CSSToDevIntPixels(int32_t px)
|
|
{
|
|
if (!mDocShell)
|
|
return px; // assume 1:1
|
|
|
|
RefPtr<nsPresContext> presContext;
|
|
mDocShell->GetPresContext(getter_AddRefs(presContext));
|
|
if (!presContext)
|
|
return px;
|
|
|
|
return presContext->CSSPixelsToDevPixels(px);
|
|
}
|
|
|
|
nsIntSize
|
|
nsGlobalWindow::DevToCSSIntPixels(nsIntSize px)
|
|
{
|
|
if (!mDocShell)
|
|
return px; // assume 1:1
|
|
|
|
RefPtr<nsPresContext> presContext;
|
|
mDocShell->GetPresContext(getter_AddRefs(presContext));
|
|
if (!presContext)
|
|
return px;
|
|
|
|
return nsIntSize(
|
|
presContext->DevPixelsToIntCSSPixels(px.width),
|
|
presContext->DevPixelsToIntCSSPixels(px.height));
|
|
}
|
|
|
|
nsIntSize
|
|
nsGlobalWindow::CSSToDevIntPixels(nsIntSize px)
|
|
{
|
|
if (!mDocShell)
|
|
return px; // assume 1:1
|
|
|
|
RefPtr<nsPresContext> presContext;
|
|
mDocShell->GetPresContext(getter_AddRefs(presContext));
|
|
if (!presContext)
|
|
return px;
|
|
|
|
return nsIntSize(
|
|
presContext->CSSPixelsToDevPixels(px.width),
|
|
presContext->CSSPixelsToDevPixels(px.height));
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::GetInnerSize(CSSIntSize& aSize)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
EnsureSizeAndPositionUpToDate();
|
|
|
|
NS_ENSURE_STATE(mDocShell);
|
|
|
|
RefPtr<nsPresContext> presContext;
|
|
mDocShell->GetPresContext(getter_AddRefs(presContext));
|
|
RefPtr<nsIPresShell> presShell = mDocShell->GetPresShell();
|
|
|
|
if (!presContext || !presShell) {
|
|
aSize = CSSIntSize(0, 0);
|
|
return NS_OK;
|
|
}
|
|
|
|
/*
|
|
* On platforms with resolution-based zooming, the CSS viewport
|
|
* and visual viewport may not be the same. The inner size should
|
|
* be the visual viewport, but we fall back to the CSS viewport
|
|
* if it is not set.
|
|
*/
|
|
if (presShell->IsScrollPositionClampingScrollPortSizeSet()) {
|
|
aSize = CSSIntRect::FromAppUnitsRounded(
|
|
presShell->GetScrollPositionClampingScrollPortSize());
|
|
} else {
|
|
RefPtr<nsViewManager> viewManager = presShell->GetViewManager();
|
|
if (viewManager) {
|
|
viewManager->FlushDelayedResize(false);
|
|
}
|
|
|
|
aSize = CSSIntRect::FromAppUnitsRounded(
|
|
presContext->GetVisibleArea().Size());
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetInnerWidthOuter(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
CSSIntSize size;
|
|
aError = GetInnerSize(size);
|
|
return size.width;
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetInnerWidth(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
// We ignore aCallerType; we only have that argument because some other things
|
|
// called by GetReplaceableWindowCoord need it. If this ever changes, fix
|
|
// nsresult nsGlobalWindow::GetInnerWidth(int32_t* aInnerWidth)
|
|
// to actually take a useful CallerType and pass it in here.
|
|
FORWARD_TO_OUTER_OR_THROW(GetInnerWidthOuter, (aError), aError, 0);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetInnerWidth(JSContext* aCx,
|
|
JS::MutableHandle<JS::Value> aValue,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
GetReplaceableWindowCoord(aCx, &nsGlobalWindow::GetInnerWidth, aValue,
|
|
aCallerType, aError);
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::GetInnerWidth(int32_t* aInnerWidth)
|
|
{
|
|
FORWARD_TO_INNER(GetInnerWidth, (aInnerWidth), NS_ERROR_UNEXPECTED);
|
|
|
|
ErrorResult rv;
|
|
// Callee doesn't care about the caller type, but play it safe.
|
|
*aInnerWidth = GetInnerWidth(CallerType::NonSystem, rv);
|
|
|
|
return rv.StealNSResult();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetInnerWidthOuter(int32_t aInnerWidth,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDocShell) {
|
|
aError.Throw(NS_ERROR_UNEXPECTED);
|
|
return;
|
|
}
|
|
|
|
CheckSecurityWidthAndHeight(&aInnerWidth, nullptr, aCallerType);
|
|
|
|
RefPtr<nsIPresShell> presShell = mDocShell->GetPresShell();
|
|
|
|
if (presShell && presShell->GetIsViewportOverridden())
|
|
{
|
|
nscoord height = 0;
|
|
|
|
RefPtr<nsPresContext> presContext;
|
|
presContext = presShell->GetPresContext();
|
|
|
|
nsRect shellArea = presContext->GetVisibleArea();
|
|
height = shellArea.Height();
|
|
SetCSSViewportWidthAndHeight(nsPresContext::CSSPixelsToAppUnits(aInnerWidth),
|
|
height);
|
|
return;
|
|
}
|
|
|
|
int32_t height = 0;
|
|
int32_t unused = 0;
|
|
|
|
nsCOMPtr<nsIBaseWindow> docShellAsWin(do_QueryInterface(mDocShell));
|
|
docShellAsWin->GetSize(&unused, &height);
|
|
aError = SetDocShellWidthAndHeight(CSSToDevIntPixels(aInnerWidth), height);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetInnerWidth(int32_t aInnerWidth, CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(SetInnerWidthOuter,
|
|
(aInnerWidth, aCallerType, aError), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetInnerWidth(JSContext* aCx, JS::Handle<JS::Value> aValue,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
SetReplaceableWindowCoord(aCx, &nsGlobalWindow::SetInnerWidth,
|
|
aValue, "innerWidth", aCallerType, aError);
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetInnerHeightOuter(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
CSSIntSize size;
|
|
aError = GetInnerSize(size);
|
|
return size.height;
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetInnerHeight(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
// We ignore aCallerType; we only have that argument because some other things
|
|
// called by GetReplaceableWindowCoord need it. If this ever changes, fix
|
|
// nsresult nsGlobalWindow::GetInnerHeight(int32_t* aInnerWidth)
|
|
// to actually take a useful CallerType and pass it in here.
|
|
FORWARD_TO_OUTER_OR_THROW(GetInnerHeightOuter, (aError), aError, 0);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetInnerHeight(JSContext* aCx,
|
|
JS::MutableHandle<JS::Value> aValue,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
GetReplaceableWindowCoord(aCx, &nsGlobalWindow::GetInnerHeight, aValue,
|
|
aCallerType, aError);
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::GetInnerHeight(int32_t* aInnerHeight)
|
|
{
|
|
FORWARD_TO_INNER(GetInnerHeight, (aInnerHeight), NS_ERROR_UNEXPECTED);
|
|
|
|
ErrorResult rv;
|
|
// Callee doesn't care about the caller type, but play it safe.
|
|
*aInnerHeight = GetInnerHeight(CallerType::NonSystem, rv);
|
|
|
|
return rv.StealNSResult();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetInnerHeightOuter(int32_t aInnerHeight,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDocShell) {
|
|
aError.Throw(NS_ERROR_UNEXPECTED);
|
|
return;
|
|
}
|
|
|
|
RefPtr<nsIPresShell> presShell = mDocShell->GetPresShell();
|
|
|
|
if (presShell && presShell->GetIsViewportOverridden())
|
|
{
|
|
RefPtr<nsPresContext> presContext;
|
|
presContext = presShell->GetPresContext();
|
|
|
|
nsRect shellArea = presContext->GetVisibleArea();
|
|
nscoord height = aInnerHeight;
|
|
nscoord width = shellArea.Width();
|
|
CheckSecurityWidthAndHeight(nullptr, &height, aCallerType);
|
|
SetCSSViewportWidthAndHeight(width,
|
|
nsPresContext::CSSPixelsToAppUnits(height));
|
|
return;
|
|
}
|
|
|
|
int32_t height = 0;
|
|
int32_t width = 0;
|
|
|
|
nsCOMPtr<nsIBaseWindow> docShellAsWin(do_QueryInterface(mDocShell));
|
|
docShellAsWin->GetSize(&width, &height);
|
|
CheckSecurityWidthAndHeight(nullptr, &aInnerHeight, aCallerType);
|
|
aError = SetDocShellWidthAndHeight(width, CSSToDevIntPixels(aInnerHeight));
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetInnerHeight(int32_t aInnerHeight,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(SetInnerHeightOuter,
|
|
(aInnerHeight, aCallerType, aError), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetInnerHeight(JSContext* aCx, JS::Handle<JS::Value> aValue,
|
|
CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
SetReplaceableWindowCoord(aCx, &nsGlobalWindow::SetInnerHeight,
|
|
aValue, "innerHeight", aCallerType, aError);
|
|
}
|
|
|
|
nsIntSize
|
|
nsGlobalWindow::GetOuterSize(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
if (nsContentUtils::ResistFingerprinting(aCallerType)) {
|
|
CSSIntSize size;
|
|
aError = GetInnerSize(size);
|
|
return nsIntSize(size.width, size.height);
|
|
}
|
|
|
|
nsCOMPtr<nsIBaseWindow> treeOwnerAsWin = GetTreeOwnerWindow();
|
|
if (!treeOwnerAsWin) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return nsIntSize(0, 0);
|
|
}
|
|
|
|
nsIntSize sizeDevPixels;
|
|
aError = treeOwnerAsWin->GetSize(&sizeDevPixels.width, &sizeDevPixels.height);
|
|
if (aError.Failed()) {
|
|
return nsIntSize();
|
|
}
|
|
|
|
return DevToCSSIntPixels(sizeDevPixels);
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetOuterWidthOuter(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
return GetOuterSize(aCallerType, aError).width;
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetOuterWidth(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetOuterWidthOuter, (aCallerType, aError),
|
|
aError, 0);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetOuterWidth(JSContext* aCx,
|
|
JS::MutableHandle<JS::Value> aValue,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
GetReplaceableWindowCoord(aCx, &nsGlobalWindow::GetOuterWidth, aValue,
|
|
aCallerType, aError);
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetOuterHeightOuter(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
return GetOuterSize(aCallerType, aError).height;
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetOuterHeight(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetOuterHeightOuter, (aCallerType, aError),
|
|
aError, 0);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetOuterHeight(JSContext* aCx,
|
|
JS::MutableHandle<JS::Value> aValue,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
GetReplaceableWindowCoord(aCx, &nsGlobalWindow::GetOuterHeight, aValue,
|
|
aCallerType, aError);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetOuterSize(int32_t aLengthCSSPixels, bool aIsWidth,
|
|
CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
nsCOMPtr<nsIBaseWindow> treeOwnerAsWin = GetTreeOwnerWindow();
|
|
if (!treeOwnerAsWin) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
CheckSecurityWidthAndHeight(aIsWidth ? &aLengthCSSPixels : nullptr,
|
|
aIsWidth ? nullptr : &aLengthCSSPixels,
|
|
aCallerType);
|
|
|
|
int32_t width, height;
|
|
aError = treeOwnerAsWin->GetSize(&width, &height);
|
|
if (aError.Failed()) {
|
|
return;
|
|
}
|
|
|
|
int32_t lengthDevPixels = CSSToDevIntPixels(aLengthCSSPixels);
|
|
if (aIsWidth) {
|
|
width = lengthDevPixels;
|
|
} else {
|
|
height = lengthDevPixels;
|
|
}
|
|
aError = treeOwnerAsWin->SetSize(width, height, true);
|
|
|
|
CheckForDPIChange();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetOuterWidthOuter(int32_t aOuterWidth,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
SetOuterSize(aOuterWidth, true, aCallerType, aError);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetOuterWidth(int32_t aOuterWidth,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(SetOuterWidthOuter,
|
|
(aOuterWidth, aCallerType, aError), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetOuterWidth(JSContext* aCx, JS::Handle<JS::Value> aValue,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
SetReplaceableWindowCoord(aCx, &nsGlobalWindow::SetOuterWidth,
|
|
aValue, "outerWidth", aCallerType, aError);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetOuterHeightOuter(int32_t aOuterHeight,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
SetOuterSize(aOuterHeight, false, aCallerType, aError);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetOuterHeight(int32_t aOuterHeight,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(SetOuterHeightOuter,
|
|
(aOuterHeight, aCallerType, aError), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetOuterHeight(JSContext* aCx, JS::Handle<JS::Value> aValue,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
SetReplaceableWindowCoord(aCx, &nsGlobalWindow::SetOuterHeight,
|
|
aValue, "outerHeight", aCallerType, aError);
|
|
}
|
|
|
|
CSSIntPoint
|
|
nsGlobalWindow::GetScreenXY(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
// When resisting fingerprinting, always return (0,0)
|
|
if (nsContentUtils::ResistFingerprinting(aCallerType)) {
|
|
return CSSIntPoint(0, 0);
|
|
}
|
|
|
|
nsCOMPtr<nsIBaseWindow> treeOwnerAsWin = GetTreeOwnerWindow();
|
|
if (!treeOwnerAsWin) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return CSSIntPoint(0, 0);
|
|
}
|
|
|
|
int32_t x = 0, y = 0;
|
|
aError = treeOwnerAsWin->GetPosition(&x, &y); // LayoutDevice px values
|
|
|
|
RefPtr<nsPresContext> presContext;
|
|
mDocShell->GetPresContext(getter_AddRefs(presContext));
|
|
if (!presContext) {
|
|
return CSSIntPoint(x, y);
|
|
}
|
|
|
|
// Find the global desktop coordinate of the top-left of the screen.
|
|
// We'll use this as a "fake origin" when converting to CSS px units,
|
|
// to avoid overlapping coordinates in cases such as a hi-dpi screen
|
|
// placed to the right of a lo-dpi screen on Windows. (Instead, there
|
|
// may be "gaps" in the resulting CSS px coordinates in some cases.)
|
|
nsDeviceContext *dc = presContext->DeviceContext();
|
|
nsRect screenRect;
|
|
dc->GetRect(screenRect);
|
|
LayoutDeviceRect screenRectDev =
|
|
LayoutDevicePixel::FromAppUnits(screenRect, dc->AppUnitsPerDevPixel());
|
|
|
|
DesktopToLayoutDeviceScale scale = dc->GetDesktopToDeviceScale();
|
|
DesktopRect screenRectDesk = screenRectDev / scale;
|
|
|
|
CSSPoint cssPt =
|
|
LayoutDevicePoint(x - screenRectDev.x, y - screenRectDev.y) /
|
|
presContext->CSSToDevPixelScale();
|
|
cssPt.x += screenRectDesk.x;
|
|
cssPt.y += screenRectDesk.y;
|
|
|
|
return CSSIntPoint(NSToIntRound(cssPt.x), NSToIntRound(cssPt.y));
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetScreenXOuter(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
return GetScreenXY(aCallerType, aError).x;
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetScreenX(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetScreenXOuter, (aCallerType, aError), aError, 0);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetScreenX(JSContext* aCx,
|
|
JS::MutableHandle<JS::Value> aValue,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
GetReplaceableWindowCoord(aCx, &nsGlobalWindow::GetScreenX, aValue,
|
|
aCallerType, aError);
|
|
}
|
|
|
|
nsRect
|
|
nsGlobalWindow::GetInnerScreenRect()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDocShell) {
|
|
return nsRect();
|
|
}
|
|
|
|
EnsureSizeAndPositionUpToDate();
|
|
|
|
if (!mDocShell) {
|
|
return nsRect();
|
|
}
|
|
|
|
nsCOMPtr<nsIPresShell> presShell = mDocShell->GetPresShell();
|
|
if (!presShell) {
|
|
return nsRect();
|
|
}
|
|
nsIFrame* rootFrame = presShell->GetRootFrame();
|
|
if (!rootFrame) {
|
|
return nsRect();
|
|
}
|
|
|
|
return rootFrame->GetScreenRectInAppUnits();
|
|
}
|
|
|
|
float
|
|
nsGlobalWindow::GetMozInnerScreenXOuter(CallerType aCallerType)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
// When resisting fingerprinting, always return 0.
|
|
if (nsContentUtils::ResistFingerprinting(aCallerType)) {
|
|
return 0.0;
|
|
}
|
|
|
|
nsRect r = GetInnerScreenRect();
|
|
return nsPresContext::AppUnitsToFloatCSSPixels(r.x);
|
|
}
|
|
|
|
float
|
|
nsGlobalWindow::GetMozInnerScreenX(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetMozInnerScreenXOuter, (aCallerType), aError, 0);
|
|
}
|
|
|
|
float
|
|
nsGlobalWindow::GetMozInnerScreenYOuter(CallerType aCallerType)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
// Return 0 to prevent fingerprinting.
|
|
if (nsContentUtils::ResistFingerprinting(aCallerType)) {
|
|
return 0.0;
|
|
}
|
|
|
|
nsRect r = GetInnerScreenRect();
|
|
return nsPresContext::AppUnitsToFloatCSSPixels(r.y);
|
|
}
|
|
|
|
float
|
|
nsGlobalWindow::GetMozInnerScreenY(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetMozInnerScreenYOuter, (aCallerType), aError, 0);
|
|
}
|
|
|
|
double
|
|
nsGlobalWindow::GetDevicePixelRatioOuter(CallerType aCallerType)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDocShell) {
|
|
return 1.0;
|
|
}
|
|
|
|
RefPtr<nsPresContext> presContext;
|
|
mDocShell->GetPresContext(getter_AddRefs(presContext));
|
|
if (!presContext) {
|
|
return 1.0;
|
|
}
|
|
|
|
if (nsContentUtils::ResistFingerprinting(aCallerType)) {
|
|
return 1.0;
|
|
}
|
|
|
|
float overrideDPPX = presContext->GetOverrideDPPX();
|
|
|
|
if (overrideDPPX > 0) {
|
|
return overrideDPPX;
|
|
}
|
|
|
|
return double(nsPresContext::AppUnitsPerCSSPixel()) /
|
|
double(presContext->AppUnitsPerDevPixel());
|
|
}
|
|
|
|
double
|
|
nsGlobalWindow::GetDevicePixelRatio(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetDevicePixelRatioOuter, (aCallerType), aError, 0.0);
|
|
}
|
|
|
|
float
|
|
nsPIDOMWindowOuter::GetDevicePixelRatio(CallerType aCallerType)
|
|
{
|
|
return nsGlobalWindow::Cast(this)->GetDevicePixelRatioOuter(aCallerType);
|
|
}
|
|
|
|
uint64_t
|
|
nsGlobalWindow::GetMozPaintCountOuter()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDocShell) {
|
|
return 0;
|
|
}
|
|
|
|
nsCOMPtr<nsIPresShell> presShell = mDocShell->GetPresShell();
|
|
return presShell ? presShell->GetPaintCount() : 0;
|
|
}
|
|
|
|
uint64_t
|
|
nsGlobalWindow::GetMozPaintCount(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetMozPaintCountOuter, (), aError, 0);
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::RequestAnimationFrame(FrameRequestCallback& aCallback,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mDoc) {
|
|
return 0;
|
|
}
|
|
|
|
if (GetWrapperPreserveColor()) {
|
|
js::NotifyAnimationActivity(GetWrapperPreserveColor());
|
|
}
|
|
|
|
int32_t handle;
|
|
aError = mDoc->ScheduleFrameRequestCallback(aCallback, &handle);
|
|
return handle;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::CancelAnimationFrame(int32_t aHandle, ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mDoc) {
|
|
return;
|
|
}
|
|
|
|
mDoc->CancelFrameRequestCallback(aHandle);
|
|
}
|
|
|
|
already_AddRefed<MediaQueryList>
|
|
nsGlobalWindow::MatchMediaOuter(const nsAString& aMediaQueryList)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDoc) {
|
|
return nullptr;
|
|
}
|
|
|
|
return mDoc->MatchMedia(aMediaQueryList);
|
|
}
|
|
|
|
already_AddRefed<MediaQueryList>
|
|
nsGlobalWindow::MatchMedia(const nsAString& aMediaQueryList,
|
|
ErrorResult& aError)
|
|
{
|
|
// FIXME: This whole forward-to-outer and then get a pres
|
|
// shell/context off the docshell dance is sort of silly; it'd make
|
|
// more sense to forward to the inner, but it's what everyone else
|
|
// (GetSelection, GetScrollXY, etc.) does around here.
|
|
FORWARD_TO_OUTER_OR_THROW(MatchMediaOuter, (aMediaQueryList), aError, nullptr);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetScreenXOuter(int32_t aScreenX,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
nsCOMPtr<nsIBaseWindow> treeOwnerAsWin = GetTreeOwnerWindow();
|
|
if (!treeOwnerAsWin) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
int32_t x, y;
|
|
aError = treeOwnerAsWin->GetPosition(&x, &y);
|
|
if (aError.Failed()) {
|
|
return;
|
|
}
|
|
|
|
CheckSecurityLeftAndTop(&aScreenX, nullptr, aCallerType);
|
|
x = CSSToDevIntPixels(aScreenX);
|
|
|
|
aError = treeOwnerAsWin->SetPosition(x, y);
|
|
|
|
CheckForDPIChange();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetScreenX(int32_t aScreenX,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(SetScreenXOuter,
|
|
(aScreenX, aCallerType, aError), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetScreenX(JSContext* aCx, JS::Handle<JS::Value> aValue,
|
|
CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
SetReplaceableWindowCoord(aCx, &nsGlobalWindow::SetScreenX,
|
|
aValue, "screenX", aCallerType, aError);
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetScreenYOuter(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
return GetScreenXY(aCallerType, aError).y;
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetScreenY(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetScreenYOuter, (aCallerType, aError), aError, 0);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetScreenY(JSContext* aCx,
|
|
JS::MutableHandle<JS::Value> aValue,
|
|
CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
GetReplaceableWindowCoord(aCx, &nsGlobalWindow::GetScreenY, aValue,
|
|
aCallerType, aError);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetScreenYOuter(int32_t aScreenY,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
nsCOMPtr<nsIBaseWindow> treeOwnerAsWin = GetTreeOwnerWindow();
|
|
if (!treeOwnerAsWin) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
int32_t x, y;
|
|
aError = treeOwnerAsWin->GetPosition(&x, &y);
|
|
if (aError.Failed()) {
|
|
return;
|
|
}
|
|
|
|
CheckSecurityLeftAndTop(nullptr, &aScreenY, aCallerType);
|
|
y = CSSToDevIntPixels(aScreenY);
|
|
|
|
aError = treeOwnerAsWin->SetPosition(x, y);
|
|
|
|
CheckForDPIChange();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetScreenY(int32_t aScreenY,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(SetScreenYOuter,
|
|
(aScreenY, aCallerType, aError), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetScreenY(JSContext* aCx, JS::Handle<JS::Value> aValue,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
SetReplaceableWindowCoord(aCx, &nsGlobalWindow::SetScreenY,
|
|
aValue, "screenY", aCallerType, aError);
|
|
}
|
|
|
|
// NOTE: Arguments to this function should have values scaled to
|
|
// CSS pixels, not device pixels.
|
|
void
|
|
nsGlobalWindow::CheckSecurityWidthAndHeight(int32_t* aWidth, int32_t* aHeight,
|
|
CallerType aCallerType)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
#ifdef MOZ_XUL
|
|
if (aCallerType != CallerType::System) {
|
|
// if attempting to resize the window, hide any open popups
|
|
nsContentUtils::HidePopupsInDocument(mDoc);
|
|
}
|
|
#endif
|
|
|
|
// This one is easy. Just ensure the variable is greater than 100;
|
|
if ((aWidth && *aWidth < 100) || (aHeight && *aHeight < 100)) {
|
|
// Check security state for use in determing window dimensions
|
|
|
|
if (aCallerType != CallerType::System) {
|
|
//sec check failed
|
|
if (aWidth && *aWidth < 100) {
|
|
*aWidth = 100;
|
|
}
|
|
if (aHeight && *aHeight < 100) {
|
|
*aHeight = 100;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// NOTE: Arguments to this function should have values in device pixels
|
|
nsresult
|
|
nsGlobalWindow::SetDocShellWidthAndHeight(int32_t aInnerWidth, int32_t aInnerHeight)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
NS_ENSURE_TRUE(mDocShell, NS_ERROR_FAILURE);
|
|
|
|
nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
|
|
mDocShell->GetTreeOwner(getter_AddRefs(treeOwner));
|
|
NS_ENSURE_TRUE(treeOwner, NS_ERROR_FAILURE);
|
|
|
|
NS_ENSURE_SUCCESS(treeOwner->SizeShellTo(mDocShell, aInnerWidth, aInnerHeight),
|
|
NS_ERROR_FAILURE);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// NOTE: Arguments to this function should have values in app units
|
|
void
|
|
nsGlobalWindow::SetCSSViewportWidthAndHeight(nscoord aInnerWidth, nscoord aInnerHeight)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
RefPtr<nsPresContext> presContext;
|
|
mDocShell->GetPresContext(getter_AddRefs(presContext));
|
|
|
|
nsRect shellArea = presContext->GetVisibleArea();
|
|
shellArea.SetHeight(aInnerHeight);
|
|
shellArea.SetWidth(aInnerWidth);
|
|
|
|
presContext->SetVisibleArea(shellArea);
|
|
}
|
|
|
|
// NOTE: Arguments to this function should have values scaled to
|
|
// CSS pixels, not device pixels.
|
|
void
|
|
nsGlobalWindow::CheckSecurityLeftAndTop(int32_t* aLeft, int32_t* aTop,
|
|
CallerType aCallerType)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
// This one is harder. We have to get the screen size and window dimensions.
|
|
|
|
// Check security state for use in determing window dimensions
|
|
|
|
if (aCallerType != CallerType::System) {
|
|
#ifdef MOZ_XUL
|
|
// if attempting to move the window, hide any open popups
|
|
nsContentUtils::HidePopupsInDocument(mDoc);
|
|
#endif
|
|
|
|
if (nsGlobalWindow* rootWindow = nsGlobalWindow::Cast(GetPrivateRoot())) {
|
|
rootWindow->FlushPendingNotifications(FlushType::Layout);
|
|
}
|
|
|
|
nsCOMPtr<nsIBaseWindow> treeOwner = GetTreeOwnerWindow();
|
|
|
|
nsCOMPtr<nsIDOMScreen> screen = GetScreen();
|
|
|
|
if (treeOwner && screen) {
|
|
int32_t screenLeft, screenTop, screenWidth, screenHeight;
|
|
int32_t winLeft, winTop, winWidth, winHeight;
|
|
|
|
// Get the window size
|
|
treeOwner->GetPositionAndSize(&winLeft, &winTop, &winWidth, &winHeight);
|
|
|
|
// convert those values to CSS pixels
|
|
// XXX four separate retrievals of the prescontext
|
|
winLeft = DevToCSSIntPixels(winLeft);
|
|
winTop = DevToCSSIntPixels(winTop);
|
|
winWidth = DevToCSSIntPixels(winWidth);
|
|
winHeight = DevToCSSIntPixels(winHeight);
|
|
|
|
// Get the screen dimensions
|
|
// XXX This should use nsIScreenManager once it's fully fleshed out.
|
|
screen->GetAvailLeft(&screenLeft);
|
|
screen->GetAvailWidth(&screenWidth);
|
|
screen->GetAvailHeight(&screenHeight);
|
|
#if defined(XP_MACOSX)
|
|
/* The mac's coordinate system is different from the assumed Windows'
|
|
system. It offsets by the height of the menubar so that a window
|
|
placed at (0,0) will be entirely visible. Unfortunately that
|
|
correction is made elsewhere (in Widget) and the meaning of
|
|
the Avail... coordinates is overloaded. Here we allow a window
|
|
to be placed at (0,0) because it does make sense to do so.
|
|
*/
|
|
screen->GetTop(&screenTop);
|
|
#else
|
|
screen->GetAvailTop(&screenTop);
|
|
#endif
|
|
|
|
if (aLeft) {
|
|
if (screenLeft+screenWidth < *aLeft+winWidth)
|
|
*aLeft = screenLeft+screenWidth - winWidth;
|
|
if (screenLeft > *aLeft)
|
|
*aLeft = screenLeft;
|
|
}
|
|
if (aTop) {
|
|
if (screenTop+screenHeight < *aTop+winHeight)
|
|
*aTop = screenTop+screenHeight - winHeight;
|
|
if (screenTop > *aTop)
|
|
*aTop = screenTop;
|
|
}
|
|
} else {
|
|
if (aLeft)
|
|
*aLeft = 0;
|
|
if (aTop)
|
|
*aTop = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetScrollBoundaryOuter(Side aSide)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
FlushPendingNotifications(FlushType::Layout);
|
|
if (nsIScrollableFrame *sf = GetScrollFrame()) {
|
|
return nsPresContext::
|
|
AppUnitsToIntCSSPixels(sf->GetScrollRange().Edge(aSide));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetScrollMinX(ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
FORWARD_TO_OUTER_OR_THROW(GetScrollBoundaryOuter, (eSideLeft), aError, 0);
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetScrollMinY(ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
FORWARD_TO_OUTER_OR_THROW(GetScrollBoundaryOuter, (eSideTop), aError, 0);
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetScrollMaxX(ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
FORWARD_TO_OUTER_OR_THROW(GetScrollBoundaryOuter, (eSideRight), aError, 0);
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::GetScrollMaxY(ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
FORWARD_TO_OUTER_OR_THROW(GetScrollBoundaryOuter, (eSideBottom), aError, 0);
|
|
}
|
|
|
|
CSSPoint
|
|
nsGlobalWindow::GetScrollXY(bool aDoFlush)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
if (aDoFlush) {
|
|
FlushPendingNotifications(FlushType::Layout);
|
|
} else {
|
|
EnsureSizeAndPositionUpToDate();
|
|
}
|
|
|
|
nsIScrollableFrame *sf = GetScrollFrame();
|
|
if (!sf) {
|
|
return CSSIntPoint(0, 0);
|
|
}
|
|
|
|
nsPoint scrollPos = sf->GetScrollPosition();
|
|
if (scrollPos != nsPoint(0,0) && !aDoFlush) {
|
|
// Oh, well. This is the expensive case -- the window is scrolled and we
|
|
// didn't actually flush yet. Repeat, but with a flush, since the content
|
|
// may get shorter and hence our scroll position may decrease.
|
|
return GetScrollXY(true);
|
|
}
|
|
|
|
return CSSPoint::FromAppUnits(scrollPos);
|
|
}
|
|
|
|
double
|
|
nsGlobalWindow::GetScrollXOuter()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
return GetScrollXY(false).x;
|
|
}
|
|
|
|
double
|
|
nsGlobalWindow::GetScrollX(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetScrollXOuter, (), aError, 0);
|
|
}
|
|
|
|
double
|
|
nsGlobalWindow::GetScrollYOuter()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
return GetScrollXY(false).y;
|
|
}
|
|
|
|
double
|
|
nsGlobalWindow::GetScrollY(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetScrollYOuter, (), aError, 0);
|
|
}
|
|
|
|
uint32_t
|
|
nsGlobalWindow::Length()
|
|
{
|
|
FORWARD_TO_OUTER(Length, (), 0);
|
|
|
|
nsDOMWindowList* windows = GetWindowList();
|
|
|
|
return windows ? windows->GetLength() : 0;
|
|
}
|
|
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsGlobalWindow::GetTopOuter()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> top = GetScriptableTop();
|
|
return top.forget();
|
|
}
|
|
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsGlobalWindow::GetTop(mozilla::ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetTopOuter, (), aError, nullptr);
|
|
}
|
|
|
|
nsPIDOMWindowOuter*
|
|
nsGlobalWindow::GetChildWindow(const nsAString& aName)
|
|
{
|
|
nsCOMPtr<nsIDocShell> docShell(GetDocShell());
|
|
NS_ENSURE_TRUE(docShell, nullptr);
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> child;
|
|
docShell->FindChildWithName(aName, false, true, nullptr, nullptr,
|
|
getter_AddRefs(child));
|
|
|
|
return child ? child->GetWindow() : nullptr;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::DispatchCustomEvent(const nsAString& aEventName)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
bool defaultActionEnabled = true;
|
|
nsContentUtils::DispatchTrustedEvent(mDoc, ToSupports(this), aEventName,
|
|
true, true, &defaultActionEnabled);
|
|
|
|
return defaultActionEnabled;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::DispatchResizeEvent(const CSSIntSize& aSize)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
ErrorResult res;
|
|
RefPtr<Event> domEvent =
|
|
mDoc->CreateEvent(NS_LITERAL_STRING("CustomEvent"), CallerType::System,
|
|
res);
|
|
if (res.Failed()) {
|
|
return false;
|
|
}
|
|
|
|
// We don't init the AutoJSAPI with ourselves because we don't want it
|
|
// reporting errors to our onerror handlers.
|
|
AutoJSAPI jsapi;
|
|
jsapi.Init();
|
|
JSContext* cx = jsapi.cx();
|
|
JSAutoCompartment ac(cx, GetWrapperPreserveColor());
|
|
|
|
DOMWindowResizeEventDetail detail;
|
|
detail.mWidth = aSize.width;
|
|
detail.mHeight = aSize.height;
|
|
JS::Rooted<JS::Value> detailValue(cx);
|
|
if (!ToJSValue(cx, detail, &detailValue)) {
|
|
return false;
|
|
}
|
|
|
|
CustomEvent* customEvent = static_cast<CustomEvent*>(domEvent.get());
|
|
customEvent->InitCustomEvent(cx,
|
|
NS_LITERAL_STRING("DOMWindowResize"),
|
|
/* aCanBubble = */ true,
|
|
/* aCancelable = */ true,
|
|
detailValue,
|
|
res);
|
|
if (res.Failed()) {
|
|
return false;
|
|
}
|
|
|
|
domEvent->SetTrusted(true);
|
|
domEvent->WidgetEventPtr()->mFlags.mOnlyChromeDispatch = true;
|
|
|
|
nsCOMPtr<EventTarget> target = do_QueryInterface(GetOuterWindow());
|
|
domEvent->SetTarget(target);
|
|
|
|
bool defaultActionEnabled = true;
|
|
target->DispatchEvent(domEvent, &defaultActionEnabled);
|
|
|
|
return defaultActionEnabled;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::RefreshCompartmentPrincipal()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
JS_SetCompartmentPrincipals(js::GetObjectCompartment(GetWrapperPreserveColor()),
|
|
nsJSPrincipals::get(mDoc->NodePrincipal()));
|
|
}
|
|
|
|
static already_AddRefed<nsIDocShellTreeItem>
|
|
GetCallerDocShellTreeItem()
|
|
{
|
|
nsCOMPtr<nsIWebNavigation> callerWebNav = do_GetInterface(GetEntryGlobal());
|
|
nsCOMPtr<nsIDocShellTreeItem> callerItem = do_QueryInterface(callerWebNav);
|
|
|
|
return callerItem.forget();
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::WindowExists(const nsAString& aName,
|
|
bool aForceNoOpener,
|
|
bool aLookForCallerOnJSStack)
|
|
{
|
|
NS_PRECONDITION(IsOuterWindow(), "Must be outer window");
|
|
NS_PRECONDITION(mDocShell, "Must have docshell");
|
|
|
|
if (aForceNoOpener) {
|
|
return aName.LowerCaseEqualsLiteral("_self") ||
|
|
aName.LowerCaseEqualsLiteral("_top") ||
|
|
aName.LowerCaseEqualsLiteral("_parent");
|
|
}
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> caller;
|
|
if (aLookForCallerOnJSStack) {
|
|
caller = GetCallerDocShellTreeItem();
|
|
}
|
|
|
|
if (!caller) {
|
|
caller = mDocShell;
|
|
}
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> namedItem;
|
|
mDocShell->FindItemWithName(aName, nullptr, caller,
|
|
/* aSkipTabGroup = */ false,
|
|
getter_AddRefs(namedItem));
|
|
return namedItem != nullptr;
|
|
}
|
|
|
|
already_AddRefed<nsIWidget>
|
|
nsGlobalWindow::GetMainWidget()
|
|
{
|
|
FORWARD_TO_OUTER(GetMainWidget, (), nullptr);
|
|
|
|
nsCOMPtr<nsIBaseWindow> treeOwnerAsWin = GetTreeOwnerWindow();
|
|
|
|
nsCOMPtr<nsIWidget> widget;
|
|
|
|
if (treeOwnerAsWin) {
|
|
treeOwnerAsWin->GetMainWidget(getter_AddRefs(widget));
|
|
}
|
|
|
|
return widget.forget();
|
|
}
|
|
|
|
nsIWidget*
|
|
nsGlobalWindow::GetNearestWidget() const
|
|
{
|
|
nsIDocShell* docShell = GetDocShell();
|
|
NS_ENSURE_TRUE(docShell, nullptr);
|
|
nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
|
|
NS_ENSURE_TRUE(presShell, nullptr);
|
|
nsIFrame* rootFrame = presShell->GetRootFrame();
|
|
NS_ENSURE_TRUE(rootFrame, nullptr);
|
|
return rootFrame->GetView()->GetNearestWidget(nullptr);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetFullScreenOuter(bool aFullScreen, mozilla::ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
aError = SetFullscreenInternal(FullscreenReason::ForFullscreenMode, aFullScreen);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetFullScreen(bool aFullScreen, mozilla::ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(SetFullScreenOuter, (aFullScreen, aError), aError, /* void */);
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::SetFullScreen(bool aFullScreen)
|
|
{
|
|
FORWARD_TO_OUTER(SetFullScreen, (aFullScreen), NS_ERROR_NOT_INITIALIZED);
|
|
|
|
return SetFullscreenInternal(FullscreenReason::ForFullscreenMode, aFullScreen);
|
|
}
|
|
|
|
static void
|
|
FinishDOMFullscreenChange(nsIDocument* aDoc, bool aInDOMFullscreen)
|
|
{
|
|
if (aInDOMFullscreen) {
|
|
// Ask the document to handle any pending DOM fullscreen change.
|
|
if (!nsIDocument::HandlePendingFullscreenRequests(aDoc)) {
|
|
// If we don't end up having anything in fullscreen,
|
|
// async request exiting fullscreen.
|
|
nsIDocument::AsyncExitFullscreen(aDoc);
|
|
}
|
|
} else {
|
|
// If the window is leaving fullscreen state, also ask the document
|
|
// to exit from DOM Fullscreen.
|
|
nsIDocument::ExitFullscreenInDocTree(aDoc);
|
|
}
|
|
}
|
|
|
|
struct FullscreenTransitionDuration
|
|
{
|
|
// The unit of the durations is millisecond
|
|
uint16_t mFadeIn = 0;
|
|
uint16_t mFadeOut = 0;
|
|
bool IsSuppressed() const
|
|
{
|
|
return mFadeIn == 0 && mFadeOut == 0;
|
|
}
|
|
};
|
|
|
|
static void
|
|
GetFullscreenTransitionDuration(bool aEnterFullscreen,
|
|
FullscreenTransitionDuration* aDuration)
|
|
{
|
|
const char* pref = aEnterFullscreen ?
|
|
"full-screen-api.transition-duration.enter" :
|
|
"full-screen-api.transition-duration.leave";
|
|
nsAutoCString prefValue;
|
|
Preferences::GetCString(pref, prefValue);
|
|
if (!prefValue.IsEmpty()) {
|
|
sscanf(prefValue.get(), "%hu%hu",
|
|
&aDuration->mFadeIn, &aDuration->mFadeOut);
|
|
}
|
|
}
|
|
|
|
class FullscreenTransitionTask : public Runnable
|
|
{
|
|
public:
|
|
FullscreenTransitionTask(const FullscreenTransitionDuration& aDuration,
|
|
nsGlobalWindow* aWindow,
|
|
bool aFullscreen,
|
|
nsIWidget* aWidget,
|
|
nsIScreen* aScreen,
|
|
nsISupports* aTransitionData)
|
|
: mozilla::Runnable("FullscreenTransitionTask")
|
|
, mWindow(aWindow)
|
|
, mWidget(aWidget)
|
|
, mScreen(aScreen)
|
|
, mTransitionData(aTransitionData)
|
|
, mDuration(aDuration)
|
|
, mStage(eBeforeToggle)
|
|
, mFullscreen(aFullscreen)
|
|
{
|
|
}
|
|
|
|
NS_IMETHOD Run() override;
|
|
|
|
private:
|
|
~FullscreenTransitionTask() override
|
|
{
|
|
}
|
|
|
|
/**
|
|
* The flow of fullscreen transition:
|
|
*
|
|
* parent process | child process
|
|
* ----------------------------------------------------------------
|
|
*
|
|
* | request/exit fullscreen
|
|
* <-----|
|
|
* BeforeToggle stage |
|
|
* |
|
|
* ToggleFullscreen stage *1 |----->
|
|
* | HandleFullscreenRequests
|
|
* |
|
|
* <-----| MozAfterPaint event
|
|
* AfterToggle stage *2 |
|
|
* |
|
|
* End stage |
|
|
*
|
|
* Note we also start a timer at *1 so that if we don't get MozAfterPaint
|
|
* from the child process in time, we continue going to *2.
|
|
*/
|
|
enum Stage {
|
|
// BeforeToggle stage happens before we enter or leave fullscreen
|
|
// state. In this stage, the task triggers the pre-toggle fullscreen
|
|
// transition on the widget.
|
|
eBeforeToggle,
|
|
// ToggleFullscreen stage actually executes the fullscreen toggle,
|
|
// and wait for the next paint on the content to continue.
|
|
eToggleFullscreen,
|
|
// AfterToggle stage happens after we toggle the fullscreen state.
|
|
// In this stage, the task triggers the post-toggle fullscreen
|
|
// transition on the widget.
|
|
eAfterToggle,
|
|
// End stage is triggered after the final transition finishes.
|
|
eEnd
|
|
};
|
|
|
|
class Observer final : public nsIObserver
|
|
{
|
|
public:
|
|
NS_DECL_ISUPPORTS
|
|
NS_DECL_NSIOBSERVER
|
|
|
|
explicit Observer(FullscreenTransitionTask* aTask)
|
|
: mTask(aTask) { }
|
|
|
|
private:
|
|
~Observer() = default;
|
|
|
|
RefPtr<FullscreenTransitionTask> mTask;
|
|
};
|
|
|
|
static const char* const kPaintedTopic;
|
|
|
|
RefPtr<nsGlobalWindow> mWindow;
|
|
nsCOMPtr<nsIWidget> mWidget;
|
|
nsCOMPtr<nsIScreen> mScreen;
|
|
nsCOMPtr<nsITimer> mTimer;
|
|
nsCOMPtr<nsISupports> mTransitionData;
|
|
|
|
TimeStamp mFullscreenChangeStartTime;
|
|
FullscreenTransitionDuration mDuration;
|
|
Stage mStage;
|
|
bool mFullscreen;
|
|
};
|
|
|
|
const char* const
|
|
FullscreenTransitionTask::kPaintedTopic = "fullscreen-painted";
|
|
|
|
NS_IMETHODIMP
|
|
FullscreenTransitionTask::Run()
|
|
{
|
|
Stage stage = mStage;
|
|
mStage = Stage(mStage + 1);
|
|
if (MOZ_UNLIKELY(mWidget->Destroyed())) {
|
|
// If the widget has been destroyed before we get here, don't try to
|
|
// do anything more. Just let it go and release ourselves.
|
|
NS_WARNING("The widget to fullscreen has been destroyed");
|
|
return NS_OK;
|
|
}
|
|
if (stage == eBeforeToggle) {
|
|
PROFILER_ADD_MARKER("Fullscreen transition start");
|
|
mWidget->PerformFullscreenTransition(nsIWidget::eBeforeFullscreenToggle,
|
|
mDuration.mFadeIn, mTransitionData,
|
|
this);
|
|
} else if (stage == eToggleFullscreen) {
|
|
PROFILER_ADD_MARKER("Fullscreen toggle start");
|
|
mFullscreenChangeStartTime = TimeStamp::Now();
|
|
if (MOZ_UNLIKELY(mWindow->mFullScreen != mFullscreen)) {
|
|
// This could happen in theory if several fullscreen requests in
|
|
// different direction happen continuously in a short time. We
|
|
// need to ensure the fullscreen state matches our target here,
|
|
// otherwise the widget would change the window state as if we
|
|
// toggle for Fullscreen Mode instead of Fullscreen API.
|
|
NS_WARNING("The fullscreen state of the window does not match");
|
|
mWindow->mFullScreen = mFullscreen;
|
|
}
|
|
// Toggle the fullscreen state on the widget
|
|
if (!mWindow->SetWidgetFullscreen(FullscreenReason::ForFullscreenAPI,
|
|
mFullscreen, mWidget, mScreen)) {
|
|
// Fail to setup the widget, call FinishFullscreenChange to
|
|
// complete fullscreen change directly.
|
|
mWindow->FinishFullscreenChange(mFullscreen);
|
|
}
|
|
// Set observer for the next content paint.
|
|
nsCOMPtr<nsIObserver> observer = new Observer(this);
|
|
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
|
|
obs->AddObserver(observer, kPaintedTopic, false);
|
|
// There are several edge cases where we may never get the paint
|
|
// notification, including:
|
|
// 1. the window/tab is closed before the next paint;
|
|
// 2. the user has switched to another tab before we get here.
|
|
// Completely fixing those cases seems to be tricky, and since they
|
|
// should rarely happen, it probably isn't worth to fix. Hence we
|
|
// simply add a timeout here to ensure we never hang forever.
|
|
// In addition, if the page is complicated or the machine is less
|
|
// powerful, layout could take a long time, in which case, staying
|
|
// in black screen for that long could hurt user experience even
|
|
// more than exposing an intermediate state.
|
|
mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
|
|
uint32_t timeout =
|
|
Preferences::GetUint("full-screen-api.transition.timeout", 1000);
|
|
mTimer->Init(observer, timeout, nsITimer::TYPE_ONE_SHOT);
|
|
} else if (stage == eAfterToggle) {
|
|
Telemetry::AccumulateTimeDelta(Telemetry::FULLSCREEN_TRANSITION_BLACK_MS,
|
|
mFullscreenChangeStartTime);
|
|
mWidget->PerformFullscreenTransition(nsIWidget::eAfterFullscreenToggle,
|
|
mDuration.mFadeOut, mTransitionData,
|
|
this);
|
|
} else if (stage == eEnd) {
|
|
PROFILER_ADD_MARKER("Fullscreen transition end");
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS(FullscreenTransitionTask::Observer, nsIObserver)
|
|
|
|
NS_IMETHODIMP
|
|
FullscreenTransitionTask::Observer::Observe(nsISupports* aSubject,
|
|
const char* aTopic,
|
|
const char16_t* aData)
|
|
{
|
|
bool shouldContinue = false;
|
|
if (strcmp(aTopic, FullscreenTransitionTask::kPaintedTopic) == 0) {
|
|
nsCOMPtr<nsPIDOMWindowInner> win(do_QueryInterface(aSubject));
|
|
nsCOMPtr<nsIWidget> widget = win ?
|
|
nsGlobalWindow::Cast(win)->GetMainWidget() : nullptr;
|
|
if (widget == mTask->mWidget) {
|
|
// The paint notification arrives first. Cancel the timer.
|
|
mTask->mTimer->Cancel();
|
|
shouldContinue = true;
|
|
PROFILER_ADD_MARKER("Fullscreen toggle end");
|
|
}
|
|
} else {
|
|
#ifdef DEBUG
|
|
MOZ_ASSERT(strcmp(aTopic, NS_TIMER_CALLBACK_TOPIC) == 0,
|
|
"Should only get fullscreen-painted or timer-callback");
|
|
nsCOMPtr<nsITimer> timer(do_QueryInterface(aSubject));
|
|
MOZ_ASSERT(timer && timer == mTask->mTimer,
|
|
"Should only trigger this with the timer the task created");
|
|
#endif
|
|
shouldContinue = true;
|
|
PROFILER_ADD_MARKER("Fullscreen toggle timeout");
|
|
}
|
|
if (shouldContinue) {
|
|
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
|
|
obs->RemoveObserver(this, kPaintedTopic);
|
|
mTask->mTimer = nullptr;
|
|
mTask->Run();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
static bool
|
|
MakeWidgetFullscreen(nsGlobalWindow* aWindow, FullscreenReason aReason,
|
|
bool aFullscreen)
|
|
{
|
|
nsCOMPtr<nsIWidget> widget = aWindow->GetMainWidget();
|
|
if (!widget) {
|
|
return false;
|
|
}
|
|
|
|
FullscreenTransitionDuration duration;
|
|
bool performTransition = false;
|
|
nsCOMPtr<nsISupports> transitionData;
|
|
if (aReason == FullscreenReason::ForFullscreenAPI) {
|
|
GetFullscreenTransitionDuration(aFullscreen, &duration);
|
|
if (!duration.IsSuppressed()) {
|
|
performTransition = widget->
|
|
PrepareForFullscreenTransition(getter_AddRefs(transitionData));
|
|
}
|
|
}
|
|
// We pass nullptr as the screen to SetWidgetFullscreen
|
|
// and FullscreenTransitionTask, as we do not wish to override
|
|
// the default screen selection behavior. The screen containing
|
|
// most of the widget will be selected.
|
|
if (!performTransition) {
|
|
return aWindow->SetWidgetFullscreen(aReason, aFullscreen, widget, nullptr);
|
|
}
|
|
nsCOMPtr<nsIRunnable> task =
|
|
new FullscreenTransitionTask(duration, aWindow, aFullscreen,
|
|
widget, nullptr, transitionData);
|
|
task->Run();
|
|
return true;
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::SetFullscreenInternal(FullscreenReason aReason,
|
|
bool aFullScreen)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
MOZ_ASSERT(nsContentUtils::IsSafeToRunScript(),
|
|
"Requires safe to run script as it "
|
|
"may call FinishDOMFullscreenChange");
|
|
|
|
NS_ENSURE_TRUE(mDocShell, NS_ERROR_FAILURE);
|
|
|
|
MOZ_ASSERT(aReason != FullscreenReason::ForForceExitFullscreen || !aFullScreen,
|
|
"FullscreenReason::ForForceExitFullscreen can "
|
|
"only be used with exiting fullscreen");
|
|
|
|
// Only chrome can change our fullscreen mode. Otherwise, the state
|
|
// can only be changed for DOM fullscreen.
|
|
if (aReason == FullscreenReason::ForFullscreenMode &&
|
|
!nsContentUtils::LegacyIsCallerChromeOrNativeCode()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// SetFullScreen needs to be called on the root window, so get that
|
|
// via the DocShell tree, and if we are not already the root,
|
|
// call SetFullScreen on that window instead.
|
|
nsCOMPtr<nsIDocShellTreeItem> rootItem;
|
|
mDocShell->GetRootTreeItem(getter_AddRefs(rootItem));
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = rootItem ? rootItem->GetWindow() : nullptr;
|
|
if (!window)
|
|
return NS_ERROR_FAILURE;
|
|
if (rootItem != mDocShell)
|
|
return window->SetFullscreenInternal(aReason, aFullScreen);
|
|
|
|
// make sure we don't try to set full screen on a non-chrome window,
|
|
// which might happen in embedding world
|
|
if (mDocShell->ItemType() != nsIDocShellTreeItem::typeChrome)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
// If we are already in full screen mode, just return.
|
|
if (mFullScreen == aFullScreen)
|
|
return NS_OK;
|
|
|
|
// Note that although entering DOM fullscreen could also cause
|
|
// consequential calls to this method, those calls will be skipped
|
|
// at the condition above.
|
|
if (aReason == FullscreenReason::ForFullscreenMode) {
|
|
if (!aFullScreen && !mFullscreenMode) {
|
|
// If we are exiting fullscreen mode, but we actually didn't
|
|
// entered fullscreen mode, the fullscreen state was only for
|
|
// the Fullscreen API. Change the reason here so that we can
|
|
// perform transition for it.
|
|
aReason = FullscreenReason::ForFullscreenAPI;
|
|
} else {
|
|
mFullscreenMode = aFullScreen;
|
|
}
|
|
} else {
|
|
// If we are exiting from DOM fullscreen while we initially make
|
|
// the window fullscreen because of fullscreen mode, don't restore
|
|
// the window. But we still need to exit the DOM fullscreen state.
|
|
if (!aFullScreen && mFullscreenMode) {
|
|
FinishDOMFullscreenChange(mDoc, false);
|
|
return NS_OK;
|
|
}
|
|
}
|
|
|
|
// Prevent chrome documents which are still loading from resizing
|
|
// the window after we set fullscreen mode.
|
|
nsCOMPtr<nsIBaseWindow> treeOwnerAsWin = GetTreeOwnerWindow();
|
|
nsCOMPtr<nsIXULWindow> xulWin(do_GetInterface(treeOwnerAsWin));
|
|
if (aFullScreen && xulWin) {
|
|
xulWin->SetIntrinsicallySized(false);
|
|
}
|
|
|
|
// Set this before so if widget sends an event indicating its
|
|
// gone full screen, the state trap above works.
|
|
mFullScreen = aFullScreen;
|
|
|
|
// Sometimes we don't want the top-level widget to actually go fullscreen,
|
|
// for example in the B2G desktop client, we don't want the emulated screen
|
|
// dimensions to appear to increase when entering fullscreen mode; we just
|
|
// want the content to fill the entire client area of the emulator window.
|
|
if (!Preferences::GetBool("full-screen-api.ignore-widgets", false)) {
|
|
if (MakeWidgetFullscreen(this, aReason, aFullScreen)) {
|
|
// The rest of code for switching fullscreen is in nsGlobalWindow::
|
|
// FinishFullscreenChange() which will be called after sizemodechange
|
|
// event is dispatched.
|
|
return NS_OK;
|
|
}
|
|
}
|
|
|
|
FinishFullscreenChange(aFullScreen);
|
|
return NS_OK;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::SetWidgetFullscreen(FullscreenReason aReason, bool aIsFullscreen,
|
|
nsIWidget* aWidget, nsIScreen* aScreen)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
MOZ_ASSERT(this == GetTopInternal(), "Only topmost window should call this");
|
|
MOZ_ASSERT(!AsOuter()->GetFrameElementInternal(), "Content window should not call this");
|
|
MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
|
|
|
|
if (!NS_WARN_IF(!IsChromeWindow())) {
|
|
if (!NS_WARN_IF(mChromeFields.mFullscreenPresShell)) {
|
|
if (nsIPresShell* shell = mDocShell->GetPresShell()) {
|
|
if (nsRefreshDriver* rd = shell->GetRefreshDriver()) {
|
|
mChromeFields.mFullscreenPresShell = do_GetWeakReference(shell);
|
|
MOZ_ASSERT(mChromeFields.mFullscreenPresShell);
|
|
rd->SetIsResizeSuppressed();
|
|
rd->Freeze();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
nsresult rv = aReason == FullscreenReason::ForFullscreenMode ?
|
|
// If we enter fullscreen for fullscreen mode, we want
|
|
// the native system behavior.
|
|
aWidget->MakeFullScreenWithNativeTransition(aIsFullscreen, aScreen) :
|
|
aWidget->MakeFullScreen(aIsFullscreen, aScreen);
|
|
return NS_SUCCEEDED(rv);
|
|
}
|
|
|
|
/* virtual */ void
|
|
nsGlobalWindow::FinishFullscreenChange(bool aIsFullscreen)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
if (aIsFullscreen != mFullScreen) {
|
|
NS_WARNING("Failed to toggle fullscreen state of the widget");
|
|
// We failed to make the widget enter fullscreen.
|
|
// Stop further changes and restore the state.
|
|
if (!aIsFullscreen) {
|
|
mFullScreen = false;
|
|
mFullscreenMode = false;
|
|
} else {
|
|
MOZ_ASSERT_UNREACHABLE("Failed to exit fullscreen?");
|
|
mFullScreen = true;
|
|
// We don't know how code can reach here. Not sure
|
|
// what value should be set for fullscreen mode.
|
|
mFullscreenMode = false;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Note that we must call this to toggle the DOM fullscreen state
|
|
// of the document before dispatching the "fullscreen" event, so
|
|
// that the chrome can distinguish between browser fullscreen mode
|
|
// and DOM fullscreen.
|
|
FinishDOMFullscreenChange(mDoc, mFullScreen);
|
|
|
|
// dispatch a "fullscreen" DOM event so that XUL apps can
|
|
// respond visually if we are kicked into full screen mode
|
|
DispatchCustomEvent(NS_LITERAL_STRING("fullscreen"));
|
|
|
|
if (!NS_WARN_IF(!IsChromeWindow())) {
|
|
if (nsCOMPtr<nsIPresShell> shell =
|
|
do_QueryReferent(mChromeFields.mFullscreenPresShell)) {
|
|
if (nsRefreshDriver* rd = shell->GetRefreshDriver()) {
|
|
rd->Thaw();
|
|
}
|
|
mChromeFields.mFullscreenPresShell = nullptr;
|
|
}
|
|
}
|
|
|
|
if (!mWakeLock && mFullScreen) {
|
|
RefPtr<power::PowerManagerService> pmService =
|
|
power::PowerManagerService::GetInstance();
|
|
if (!pmService) {
|
|
return;
|
|
}
|
|
|
|
// XXXkhuey using the inner here, do we need to do something if it changes?
|
|
ErrorResult rv;
|
|
mWakeLock = pmService->NewWakeLock(NS_LITERAL_STRING("DOM_Fullscreen"),
|
|
AsOuter()->GetCurrentInnerWindow(), rv);
|
|
NS_WARNING_ASSERTION(!rv.Failed(), "Failed to lock the wakelock");
|
|
rv.SuppressException();
|
|
} else if (mWakeLock && !mFullScreen) {
|
|
ErrorResult rv;
|
|
mWakeLock->Unlock(rv);
|
|
mWakeLock = nullptr;
|
|
rv.SuppressException();
|
|
}
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::FullScreen() const
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
NS_ENSURE_TRUE(mDocShell, mFullScreen);
|
|
|
|
// Get the fullscreen value of the root window, to always have the value
|
|
// accurate, even when called from content.
|
|
nsCOMPtr<nsIDocShellTreeItem> rootItem;
|
|
mDocShell->GetRootTreeItem(getter_AddRefs(rootItem));
|
|
if (rootItem == mDocShell) {
|
|
if (!XRE_IsContentProcess()) {
|
|
// We are the root window. Return our internal value.
|
|
return mFullScreen;
|
|
}
|
|
if (nsCOMPtr<nsIWidget> widget = GetNearestWidget()) {
|
|
// We are in content process, figure out the value from
|
|
// the sizemode of the puppet widget.
|
|
return widget->SizeMode() == nsSizeMode_Fullscreen;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = rootItem->GetWindow();
|
|
NS_ENSURE_TRUE(window, mFullScreen);
|
|
|
|
return nsGlobalWindow::Cast(window)->FullScreen();
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::GetFullScreenOuter()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
return FullScreen();
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::GetFullScreen(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetFullScreenOuter, (), aError, false);
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::GetFullScreen()
|
|
{
|
|
FORWARD_TO_INNER(GetFullScreen, (), false);
|
|
|
|
ErrorResult dummy;
|
|
bool fullscreen = GetFullScreen(dummy);
|
|
dummy.SuppressException();
|
|
return fullscreen;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Dump(const nsAString& aStr)
|
|
{
|
|
if (!nsContentUtils::DOMWindowDumpEnabled()) {
|
|
return;
|
|
}
|
|
|
|
char *cstr = ToNewUTF8String(aStr);
|
|
|
|
#if defined(XP_MACOSX)
|
|
// have to convert \r to \n so that printing to the console works
|
|
char *c = cstr, *cEnd = cstr + strlen(cstr);
|
|
while (c < cEnd) {
|
|
if (*c == '\r')
|
|
*c = '\n';
|
|
c++;
|
|
}
|
|
#endif
|
|
|
|
if (cstr) {
|
|
MOZ_LOG(nsContentUtils::DOMDumpLog(), LogLevel::Debug, ("[Window.Dump] %s", cstr));
|
|
#ifdef XP_WIN
|
|
PrintToDebugger(cstr);
|
|
#endif
|
|
#ifdef ANDROID
|
|
__android_log_write(ANDROID_LOG_INFO, "GeckoDump", cstr);
|
|
#endif
|
|
FILE *fp = gDumpFile ? gDumpFile : stdout;
|
|
fputs(cstr, fp);
|
|
fflush(fp);
|
|
free(cstr);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::EnsureReflowFlushAndPaint()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
NS_ASSERTION(mDocShell, "EnsureReflowFlushAndPaint() called with no "
|
|
"docshell!");
|
|
|
|
if (!mDocShell)
|
|
return;
|
|
|
|
nsCOMPtr<nsIPresShell> presShell = mDocShell->GetPresShell();
|
|
|
|
if (!presShell)
|
|
return;
|
|
|
|
// Flush pending reflows.
|
|
if (mDoc) {
|
|
mDoc->FlushPendingNotifications(FlushType::Layout);
|
|
}
|
|
|
|
// Unsuppress painting.
|
|
presShell->UnsuppressPainting();
|
|
}
|
|
|
|
// static
|
|
void
|
|
nsGlobalWindow::MakeScriptDialogTitle(nsAString& aOutTitle,
|
|
nsIPrincipal* aSubjectPrincipal)
|
|
{
|
|
MOZ_ASSERT(aSubjectPrincipal);
|
|
|
|
aOutTitle.Truncate();
|
|
|
|
// Try to get a host from the running principal -- this will do the
|
|
// right thing for javascript: and data: documents.
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
nsresult rv = aSubjectPrincipal->GetURI(getter_AddRefs(uri));
|
|
// Note - The check for the current JSContext here isn't necessarily sensical.
|
|
// It's just designed to preserve existing behavior during a mass-conversion
|
|
// patch.
|
|
if (NS_SUCCEEDED(rv) && uri && nsContentUtils::GetCurrentJSContext()) {
|
|
// remove user:pass for privacy and spoof prevention
|
|
|
|
nsCOMPtr<nsIURIFixup> fixup(do_GetService(NS_URIFIXUP_CONTRACTID));
|
|
if (fixup) {
|
|
nsCOMPtr<nsIURI> fixedURI;
|
|
rv = fixup->CreateExposableURI(uri, getter_AddRefs(fixedURI));
|
|
if (NS_SUCCEEDED(rv) && fixedURI) {
|
|
nsAutoCString host;
|
|
fixedURI->GetHost(host);
|
|
|
|
if (!host.IsEmpty()) {
|
|
// if this URI has a host we'll show it. For other
|
|
// schemes (e.g. file:) we fall back to the localized
|
|
// generic string
|
|
|
|
nsAutoCString prepath;
|
|
fixedURI->GetDisplayPrePath(prepath);
|
|
|
|
NS_ConvertUTF8toUTF16 ucsPrePath(prepath);
|
|
const char16_t *formatStrings[] = { ucsPrePath.get() };
|
|
nsContentUtils::FormatLocalizedString(nsContentUtils::eCOMMON_DIALOG_PROPERTIES,
|
|
"ScriptDlgHeading",
|
|
formatStrings,
|
|
aOutTitle);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (aOutTitle.IsEmpty()) {
|
|
// We didn't find a host so use the generic heading
|
|
nsContentUtils::GetLocalizedString(nsContentUtils::eCOMMON_DIALOG_PROPERTIES,
|
|
"ScriptDlgGenericHeading",
|
|
aOutTitle);
|
|
}
|
|
|
|
// Just in case
|
|
if (aOutTitle.IsEmpty()) {
|
|
NS_WARNING("could not get ScriptDlgGenericHeading string from string bundle");
|
|
aOutTitle.AssignLiteral("[Script]");
|
|
}
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::CanMoveResizeWindows(CallerType aCallerType)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
// When called from chrome, we can avoid the following checks.
|
|
if (aCallerType != CallerType::System) {
|
|
// Don't allow scripts to move or resize windows that were not opened by a
|
|
// script.
|
|
if (!mHadOriginalOpener) {
|
|
return false;
|
|
}
|
|
|
|
if (!CanSetProperty("dom.disable_window_move_resize")) {
|
|
return false;
|
|
}
|
|
|
|
// Ignore the request if we have more than one tab in the window.
|
|
uint32_t itemCount = 0;
|
|
if (XRE_IsContentProcess()) {
|
|
nsCOMPtr<nsIDocShell> docShell = GetDocShell();
|
|
if (docShell) {
|
|
nsCOMPtr<nsITabChild> child = docShell->GetTabChild();
|
|
if (child) {
|
|
child->SendGetTabCount(&itemCount);
|
|
}
|
|
}
|
|
} else {
|
|
nsCOMPtr<nsIDocShellTreeOwner> treeOwner = GetTreeOwner();
|
|
if (!treeOwner || NS_FAILED(treeOwner->GetTabCount(&itemCount))) {
|
|
itemCount = 0;
|
|
}
|
|
}
|
|
if (itemCount > 1) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (mDocShell) {
|
|
bool allow;
|
|
nsresult rv = mDocShell->GetAllowWindowControl(&allow);
|
|
if (NS_SUCCEEDED(rv) && !allow)
|
|
return false;
|
|
}
|
|
|
|
if (gMouseDown && !gDragServiceDisabled) {
|
|
nsCOMPtr<nsIDragService> ds =
|
|
do_GetService("@mozilla.org/widget/dragservice;1");
|
|
if (ds) {
|
|
gDragServiceDisabled = true;
|
|
ds->Suppress();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::AlertOrConfirm(bool aAlert,
|
|
const nsAString& aMessage,
|
|
nsIPrincipal& aSubjectPrincipal,
|
|
ErrorResult& aError)
|
|
{
|
|
// XXX This method is very similar to nsGlobalWindow::Prompt, make
|
|
// sure any modifications here don't need to happen over there!
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
if (!AreDialogsEnabled()) {
|
|
// Just silently return. In the case of alert(), the return value is
|
|
// ignored. In the case of confirm(), returning false is the same thing as
|
|
// would happen if the user cancels.
|
|
return false;
|
|
}
|
|
|
|
// Reset popup state while opening a modal dialog, and firing events
|
|
// about the dialog, to prevent the current state from being active
|
|
// the whole time a modal dialog is open.
|
|
nsAutoPopupStatePusher popupStatePusher(openAbused, true);
|
|
|
|
// Before bringing up the window, unsuppress painting and flush
|
|
// pending reflows.
|
|
EnsureReflowFlushAndPaint();
|
|
|
|
nsAutoString title;
|
|
MakeScriptDialogTitle(title, &aSubjectPrincipal);
|
|
|
|
// Remove non-terminating null characters from the
|
|
// string. See bug #310037.
|
|
nsAutoString final;
|
|
nsContentUtils::StripNullChars(aMessage, final);
|
|
|
|
nsresult rv;
|
|
nsCOMPtr<nsIPromptFactory> promptFac =
|
|
do_GetService("@mozilla.org/prompter;1", &rv);
|
|
if (NS_FAILED(rv)) {
|
|
aError.Throw(rv);
|
|
return false;
|
|
}
|
|
|
|
nsCOMPtr<nsIPrompt> prompt;
|
|
aError = promptFac->GetPrompt(AsOuter(), NS_GET_IID(nsIPrompt),
|
|
getter_AddRefs(prompt));
|
|
if (aError.Failed()) {
|
|
return false;
|
|
}
|
|
|
|
// Always allow tab modal prompts for alert and confirm.
|
|
if (nsCOMPtr<nsIWritablePropertyBag2> promptBag = do_QueryInterface(prompt)) {
|
|
promptBag->SetPropertyAsBool(NS_LITERAL_STRING("allowTabModal"), true);
|
|
}
|
|
|
|
bool result = false;
|
|
nsAutoSyncOperation sync(mDoc);
|
|
if (ShouldPromptToBlockDialogs()) {
|
|
bool disallowDialog = false;
|
|
nsAutoString label;
|
|
nsContentUtils::GetLocalizedString(nsContentUtils::eCOMMON_DIALOG_PROPERTIES,
|
|
"ScriptDialogLabel", label);
|
|
|
|
aError = aAlert ?
|
|
prompt->AlertCheck(title.get(), final.get(), label.get(),
|
|
&disallowDialog) :
|
|
prompt->ConfirmCheck(title.get(), final.get(), label.get(),
|
|
&disallowDialog, &result);
|
|
|
|
if (disallowDialog)
|
|
DisableDialogs();
|
|
} else {
|
|
aError = aAlert ?
|
|
prompt->Alert(title.get(), final.get()) :
|
|
prompt->Confirm(title.get(), final.get(), &result);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Alert(nsIPrincipal& aSubjectPrincipal,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
Alert(EmptyString(), aSubjectPrincipal, aError);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::AlertOuter(const nsAString& aMessage,
|
|
nsIPrincipal& aSubjectPrincipal,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
AlertOrConfirm(/* aAlert = */ true, aMessage, aSubjectPrincipal, aError);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Alert(const nsAString& aMessage,
|
|
nsIPrincipal& aSubjectPrincipal,
|
|
ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(AlertOuter, (aMessage, aSubjectPrincipal, aError),
|
|
aError, );
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::ConfirmOuter(const nsAString& aMessage,
|
|
nsIPrincipal& aSubjectPrincipal,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
return AlertOrConfirm(/* aAlert = */ false, aMessage, aSubjectPrincipal,
|
|
aError);
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::Confirm(const nsAString& aMessage,
|
|
nsIPrincipal& aSubjectPrincipal,
|
|
ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(ConfirmOuter, (aMessage, aSubjectPrincipal, aError),
|
|
aError, false);
|
|
}
|
|
|
|
already_AddRefed<Promise>
|
|
nsGlobalWindow::Fetch(const RequestOrUSVString& aInput,
|
|
const RequestInit& aInit,
|
|
CallerType aCallerType, ErrorResult& aRv)
|
|
{
|
|
return FetchRequest(this, aInput, aInit, aCallerType, aRv);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::PromptOuter(const nsAString& aMessage,
|
|
const nsAString& aInitial,
|
|
nsAString& aReturn,
|
|
nsIPrincipal& aSubjectPrincipal,
|
|
ErrorResult& aError)
|
|
{
|
|
// XXX This method is very similar to nsGlobalWindow::AlertOrConfirm, make
|
|
// sure any modifications here don't need to happen over there!
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
SetDOMStringToNull(aReturn);
|
|
|
|
if (!AreDialogsEnabled()) {
|
|
// Return null, as if the user just canceled the prompt.
|
|
return;
|
|
}
|
|
|
|
// Reset popup state while opening a modal dialog, and firing events
|
|
// about the dialog, to prevent the current state from being active
|
|
// the whole time a modal dialog is open.
|
|
nsAutoPopupStatePusher popupStatePusher(openAbused, true);
|
|
|
|
// Before bringing up the window, unsuppress painting and flush
|
|
// pending reflows.
|
|
EnsureReflowFlushAndPaint();
|
|
|
|
nsAutoString title;
|
|
MakeScriptDialogTitle(title, &aSubjectPrincipal);
|
|
|
|
// Remove non-terminating null characters from the
|
|
// string. See bug #310037.
|
|
nsAutoString fixedMessage, fixedInitial;
|
|
nsContentUtils::StripNullChars(aMessage, fixedMessage);
|
|
nsContentUtils::StripNullChars(aInitial, fixedInitial);
|
|
|
|
nsresult rv;
|
|
nsCOMPtr<nsIPromptFactory> promptFac =
|
|
do_GetService("@mozilla.org/prompter;1", &rv);
|
|
if (NS_FAILED(rv)) {
|
|
aError.Throw(rv);
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIPrompt> prompt;
|
|
aError = promptFac->GetPrompt(AsOuter(), NS_GET_IID(nsIPrompt),
|
|
getter_AddRefs(prompt));
|
|
if (aError.Failed()) {
|
|
return;
|
|
}
|
|
|
|
// Always allow tab modal prompts for prompt.
|
|
if (nsCOMPtr<nsIWritablePropertyBag2> promptBag = do_QueryInterface(prompt)) {
|
|
promptBag->SetPropertyAsBool(NS_LITERAL_STRING("allowTabModal"), true);
|
|
}
|
|
|
|
// Pass in the default value, if any.
|
|
char16_t *inoutValue = ToNewUnicode(fixedInitial);
|
|
bool disallowDialog = false;
|
|
|
|
nsAutoString label;
|
|
label.SetIsVoid(true);
|
|
if (ShouldPromptToBlockDialogs()) {
|
|
nsContentUtils::GetLocalizedString(nsContentUtils::eCOMMON_DIALOG_PROPERTIES,
|
|
"ScriptDialogLabel", label);
|
|
}
|
|
|
|
nsAutoSyncOperation sync(mDoc);
|
|
bool ok;
|
|
aError = prompt->Prompt(title.get(), fixedMessage.get(), &inoutValue,
|
|
label.IsVoid() ? nullptr : label.get(),
|
|
&disallowDialog, &ok);
|
|
|
|
if (disallowDialog) {
|
|
DisableDialogs();
|
|
}
|
|
|
|
if (aError.Failed()) {
|
|
return;
|
|
}
|
|
|
|
nsString outValue;
|
|
outValue.Adopt(inoutValue);
|
|
|
|
if (ok && inoutValue) {
|
|
aReturn.Assign(outValue);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Prompt(const nsAString& aMessage, const nsAString& aInitial,
|
|
nsAString& aReturn,
|
|
nsIPrincipal& aSubjectPrincipal,
|
|
ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(PromptOuter,
|
|
(aMessage, aInitial, aReturn, aSubjectPrincipal,
|
|
aError),
|
|
aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::FocusOuter(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
nsIFocusManager* fm = nsFocusManager::GetFocusManager();
|
|
if (!fm) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIBaseWindow> baseWin = do_QueryInterface(mDocShell);
|
|
|
|
bool isVisible = false;
|
|
if (baseWin) {
|
|
baseWin->GetVisibility(&isVisible);
|
|
}
|
|
|
|
if (!isVisible) {
|
|
// A hidden tab is being focused, ignore this call.
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsPIDOMWindowInner> caller = do_QueryInterface(GetEntryGlobal());
|
|
nsPIDOMWindowOuter* callerOuter = caller ? caller->GetOuterWindow() : nullptr;
|
|
nsCOMPtr<nsPIDOMWindowOuter> opener = GetOpener();
|
|
|
|
// Enforce dom.disable_window_flip (for non-chrome), but still allow the
|
|
// window which opened us to raise us at times when popups are allowed
|
|
// (bugs 355482 and 369306).
|
|
bool canFocus = CanSetProperty("dom.disable_window_flip") ||
|
|
(opener == callerOuter &&
|
|
RevisePopupAbuseLevel(gPopupControlState) < openBlocked);
|
|
|
|
nsCOMPtr<mozIDOMWindowProxy> activeDOMWindow;
|
|
fm->GetActiveWindow(getter_AddRefs(activeDOMWindow));
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> rootItem;
|
|
mDocShell->GetRootTreeItem(getter_AddRefs(rootItem));
|
|
nsCOMPtr<nsPIDOMWindowOuter> rootWin = rootItem ? rootItem->GetWindow() : nullptr;
|
|
auto* activeWindow = nsPIDOMWindowOuter::From(activeDOMWindow);
|
|
bool isActive = (rootWin == activeWindow);
|
|
|
|
nsCOMPtr<nsIBaseWindow> treeOwnerAsWin = GetTreeOwnerWindow();
|
|
if (treeOwnerAsWin && (canFocus || isActive)) {
|
|
bool isEnabled = true;
|
|
if (NS_SUCCEEDED(treeOwnerAsWin->GetEnabled(&isEnabled)) && !isEnabled) {
|
|
NS_WARNING( "Should not try to set the focus on a disabled window" );
|
|
return;
|
|
}
|
|
|
|
// XXXndeakin not sure what this is for or if it should go somewhere else
|
|
nsCOMPtr<nsIEmbeddingSiteWindow> embeddingWin(do_GetInterface(treeOwnerAsWin));
|
|
if (embeddingWin)
|
|
embeddingWin->SetFocus();
|
|
}
|
|
|
|
if (!mDocShell) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
// Don't look for a presshell if we're a root chrome window that's got
|
|
// about:blank loaded. We don't want to focus our widget in that case.
|
|
// XXXbz should we really be checking for IsInitialDocument() instead?
|
|
bool lookForPresShell = true;
|
|
if (mDocShell->ItemType() == nsIDocShellTreeItem::typeChrome &&
|
|
GetPrivateRoot() == AsOuter() && mDoc) {
|
|
nsIURI* ourURI = mDoc->GetDocumentURI();
|
|
if (ourURI) {
|
|
lookForPresShell = !NS_IsAboutBlank(ourURI);
|
|
}
|
|
}
|
|
|
|
if (lookForPresShell) {
|
|
mDocShell->GetEldestPresShell(getter_AddRefs(presShell));
|
|
}
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> parentDsti;
|
|
mDocShell->GetParent(getter_AddRefs(parentDsti));
|
|
|
|
// set the parent's current focus to the frame containing this window.
|
|
nsCOMPtr<nsPIDOMWindowOuter> parent =
|
|
parentDsti ? parentDsti->GetWindow() : nullptr;
|
|
if (parent) {
|
|
nsCOMPtr<nsIDocument> parentdoc = parent->GetDoc();
|
|
if (!parentdoc) {
|
|
return;
|
|
}
|
|
|
|
nsIContent* frame = parentdoc->FindContentForSubDocument(mDoc);
|
|
nsCOMPtr<nsIDOMElement> frameElement = do_QueryInterface(frame);
|
|
if (frameElement) {
|
|
uint32_t flags = nsIFocusManager::FLAG_NOSCROLL;
|
|
if (canFocus)
|
|
flags |= nsIFocusManager::FLAG_RAISE;
|
|
aError = fm->SetFocus(frameElement, flags);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (canFocus) {
|
|
// if there is no parent, this must be a toplevel window, so raise the
|
|
// window if canFocus is true. If this is a child process, the raise
|
|
// window request will get forwarded to the parent by the puppet widget.
|
|
aError = fm->SetActiveWindow(AsOuter());
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Focus(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(FocusOuter, (aError), aError, );
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::Focus()
|
|
{
|
|
FORWARD_TO_INNER(Focus, (), NS_ERROR_UNEXPECTED);
|
|
|
|
ErrorResult rv;
|
|
Focus(rv);
|
|
|
|
return rv.StealNSResult();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::BlurOuter()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
// If dom.disable_window_flip == true, then content should not be allowed
|
|
// to call this function (this would allow popunders, bug 369306)
|
|
if (!CanSetProperty("dom.disable_window_flip")) {
|
|
return;
|
|
}
|
|
|
|
// If embedding apps don't implement nsIEmbeddingSiteWindow, we
|
|
// shouldn't throw exceptions to web content.
|
|
|
|
nsCOMPtr<nsIDocShellTreeOwner> treeOwner = GetTreeOwner();
|
|
nsCOMPtr<nsIEmbeddingSiteWindow> siteWindow(do_GetInterface(treeOwner));
|
|
if (siteWindow) {
|
|
// This method call may cause mDocShell to become nullptr.
|
|
siteWindow->Blur();
|
|
|
|
// if the root is focused, clear the focus
|
|
nsIFocusManager* fm = nsFocusManager::GetFocusManager();
|
|
if (fm && mDoc) {
|
|
nsCOMPtr<nsIDOMElement> element;
|
|
fm->GetFocusedElementForWindow(AsOuter(), false, nullptr, getter_AddRefs(element));
|
|
nsCOMPtr<nsIContent> content = do_QueryInterface(element);
|
|
if (content == mDoc->GetRootElement()) {
|
|
fm->ClearFocus(AsOuter());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Blur(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(BlurOuter, (), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::BackOuter(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(mDocShell));
|
|
if (!webNav) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
aError = webNav->GoBack();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Back(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(BackOuter, (aError), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ForwardOuter(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(mDocShell));
|
|
if (!webNav) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
aError = webNav->GoForward();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Forward(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(ForwardOuter, (aError), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::HomeOuter(nsIPrincipal& aSubjectPrincipal, ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDocShell) {
|
|
return;
|
|
}
|
|
|
|
nsAutoString homeURL;
|
|
Preferences::GetLocalizedString(PREF_BROWSER_STARTUP_HOMEPAGE, homeURL);
|
|
|
|
if (homeURL.IsEmpty()) {
|
|
// if all else fails, use this
|
|
#ifdef DEBUG_seth
|
|
printf("all else failed. using %s as the home page\n", DEFAULT_HOME_PAGE);
|
|
#endif
|
|
CopyASCIItoUTF16(DEFAULT_HOME_PAGE, homeURL);
|
|
}
|
|
|
|
#ifdef MOZ_PHOENIX
|
|
{
|
|
// Firefox lets the user specify multiple home pages to open in
|
|
// individual tabs by separating them with '|'. Since we don't
|
|
// have the machinery in place to easily open new tabs from here,
|
|
// simply truncate the homeURL at the first '|' character to
|
|
// prevent any possibilities of leaking the users list of home
|
|
// pages to the first home page.
|
|
//
|
|
// Once bug https://bugzilla.mozilla.org/show_bug.cgi?id=221445 is
|
|
// fixed we can revisit this.
|
|
int32_t firstPipe = homeURL.FindChar('|');
|
|
|
|
if (firstPipe > 0) {
|
|
homeURL.Truncate(firstPipe);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(mDocShell));
|
|
if (!webNav) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
aError = webNav->LoadURI(homeURL.get(),
|
|
nsIWebNavigation::LOAD_FLAGS_NONE,
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
&aSubjectPrincipal);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Home(nsIPrincipal& aSubjectPrincipal, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(HomeOuter, (aSubjectPrincipal, aError), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::StopOuter(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(mDocShell));
|
|
if (webNav) {
|
|
aError = webNav->Stop(nsIWebNavigation::STOP_ALL);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Stop(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(StopOuter, (aError), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::PrintOuter(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
#ifdef NS_PRINTING
|
|
if (Preferences::GetBool("dom.disable_window_print", false)) {
|
|
aError.Throw(NS_ERROR_NOT_AVAILABLE);
|
|
return;
|
|
}
|
|
|
|
if (!AreDialogsEnabled()) {
|
|
// We probably want to keep throwing here; silently doing nothing is a bit
|
|
// weird given the typical use cases of print().
|
|
aError.Throw(NS_ERROR_NOT_AVAILABLE);
|
|
return;
|
|
}
|
|
|
|
if (ShouldPromptToBlockDialogs() && !ConfirmDialogIfNeeded()) {
|
|
aError.Throw(NS_ERROR_NOT_AVAILABLE);
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIWebBrowserPrint> webBrowserPrint;
|
|
if (NS_SUCCEEDED(GetInterface(NS_GET_IID(nsIWebBrowserPrint),
|
|
getter_AddRefs(webBrowserPrint)))) {
|
|
nsAutoSyncOperation sync(GetCurrentInnerWindowInternal() ?
|
|
GetCurrentInnerWindowInternal()->mDoc.get() :
|
|
nullptr);
|
|
|
|
nsCOMPtr<nsIPrintSettingsService> printSettingsService =
|
|
do_GetService("@mozilla.org/gfx/printsettings-service;1");
|
|
|
|
nsCOMPtr<nsIPrintSettings> printSettings;
|
|
if (printSettingsService) {
|
|
bool printSettingsAreGlobal =
|
|
Preferences::GetBool("print.use_global_printsettings", false);
|
|
|
|
if (printSettingsAreGlobal) {
|
|
printSettingsService->GetGlobalPrintSettings(getter_AddRefs(printSettings));
|
|
|
|
nsAutoString printerName;
|
|
printSettings->GetPrinterName(printerName);
|
|
|
|
bool shouldGetDefaultPrinterName = printerName.IsEmpty();
|
|
#ifdef MOZ_X11
|
|
// In Linux, GTK backend does not support per printer settings.
|
|
// Calling GetDefaultPrinterName causes a sandbox violation (see Bug 1329216).
|
|
// The printer name is not needed anywhere else on Linux before it gets to the parent.
|
|
// In the parent, we will then query the default printer name if no name is set.
|
|
// Unless we are in the parent, we will skip this part.
|
|
if (!XRE_IsParentProcess()) {
|
|
shouldGetDefaultPrinterName = false;
|
|
}
|
|
#endif
|
|
if (shouldGetDefaultPrinterName) {
|
|
printSettingsService->GetDefaultPrinterName(printerName);
|
|
printSettings->SetPrinterName(printerName);
|
|
}
|
|
printSettingsService->InitPrintSettingsFromPrinter(printerName,
|
|
printSettings);
|
|
printSettingsService->InitPrintSettingsFromPrefs(printSettings,
|
|
true,
|
|
nsIPrintSettings::kInitSaveAll);
|
|
} else {
|
|
printSettingsService->GetNewPrintSettings(getter_AddRefs(printSettings));
|
|
}
|
|
|
|
EnterModalState();
|
|
webBrowserPrint->Print(printSettings, nullptr);
|
|
LeaveModalState();
|
|
|
|
bool savePrintSettings =
|
|
Preferences::GetBool("print.save_print_settings", false);
|
|
if (printSettingsAreGlobal && savePrintSettings) {
|
|
printSettingsService->
|
|
SavePrintSettingsToPrefs(printSettings,
|
|
true,
|
|
nsIPrintSettings::kInitSaveAll);
|
|
printSettingsService->
|
|
SavePrintSettingsToPrefs(printSettings,
|
|
false,
|
|
nsIPrintSettings::kInitSavePrinterName);
|
|
}
|
|
} else {
|
|
webBrowserPrint->GetGlobalPrintSettings(getter_AddRefs(printSettings));
|
|
webBrowserPrint->Print(printSettings, nullptr);
|
|
}
|
|
}
|
|
#endif //NS_PRINTING
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Print(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(PrintOuter, (aError), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::MoveToOuter(int32_t aXPos, int32_t aYPos,
|
|
CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
/*
|
|
* If caller is not chrome and the user has not explicitly exempted the site,
|
|
* prevent window.moveTo() by exiting early
|
|
*/
|
|
|
|
if (!CanMoveResizeWindows(aCallerType) || IsFrame()) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIBaseWindow> treeOwnerAsWin = GetTreeOwnerWindow();
|
|
if (!treeOwnerAsWin) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIScreenManager> screenMgr =
|
|
do_GetService("@mozilla.org/gfx/screenmanager;1");
|
|
nsCOMPtr<nsIScreen> screen;
|
|
if (screenMgr) {
|
|
CSSIntSize size;
|
|
GetInnerSize(size);
|
|
screenMgr->ScreenForRect(aXPos, aYPos, size.width, size.height,
|
|
getter_AddRefs(screen));
|
|
}
|
|
|
|
if (screen) {
|
|
// On secondary displays, the "CSS px" coordinates are offset so that they
|
|
// share their origin with global desktop pixels, to avoid ambiguities in
|
|
// the coordinate space when there are displays with different DPIs.
|
|
// (See the corresponding code in GetScreenXY() above.)
|
|
int32_t screenLeftDeskPx, screenTopDeskPx, w, h;
|
|
screen->GetRectDisplayPix(&screenLeftDeskPx, &screenTopDeskPx, &w, &h);
|
|
CSSIntPoint cssPos(aXPos - screenLeftDeskPx, aYPos - screenTopDeskPx);
|
|
CheckSecurityLeftAndTop(&cssPos.x, &cssPos.y, aCallerType);
|
|
|
|
double scale;
|
|
screen->GetDefaultCSSScaleFactor(&scale);
|
|
LayoutDevicePoint devPos = cssPos * CSSToLayoutDeviceScale(scale);
|
|
|
|
screen->GetContentsScaleFactor(&scale);
|
|
DesktopPoint deskPos = devPos / DesktopToLayoutDeviceScale(scale);
|
|
aError = treeOwnerAsWin->SetPositionDesktopPix(screenLeftDeskPx + deskPos.x,
|
|
screenTopDeskPx + deskPos.y);
|
|
} else {
|
|
// We couldn't find a screen? Just assume a 1:1 mapping.
|
|
CSSIntPoint cssPos(aXPos, aXPos);
|
|
CheckSecurityLeftAndTop(&cssPos.x, &cssPos.y, aCallerType);
|
|
LayoutDevicePoint devPos = cssPos * CSSToLayoutDeviceScale(1.0);
|
|
aError = treeOwnerAsWin->SetPosition(devPos.x, devPos.y);
|
|
}
|
|
|
|
CheckForDPIChange();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::MoveTo(int32_t aXPos, int32_t aYPos,
|
|
CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(MoveToOuter,
|
|
(aXPos, aYPos, aCallerType, aError), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::MoveByOuter(int32_t aXDif, int32_t aYDif,
|
|
CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
/*
|
|
* If caller is not chrome and the user has not explicitly exempted the site,
|
|
* prevent window.moveBy() by exiting early
|
|
*/
|
|
|
|
if (!CanMoveResizeWindows(aCallerType) || IsFrame()) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIBaseWindow> treeOwnerAsWin = GetTreeOwnerWindow();
|
|
if (!treeOwnerAsWin) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
// To do this correctly we have to convert what we get from GetPosition
|
|
// into CSS pixels, add the arguments, do the security check, and
|
|
// then convert back to device pixels for the call to SetPosition.
|
|
|
|
int32_t x, y;
|
|
aError = treeOwnerAsWin->GetPosition(&x, &y);
|
|
if (aError.Failed()) {
|
|
return;
|
|
}
|
|
|
|
// mild abuse of a "size" object so we don't need more helper functions
|
|
nsIntSize cssPos(DevToCSSIntPixels(nsIntSize(x, y)));
|
|
|
|
cssPos.width += aXDif;
|
|
cssPos.height += aYDif;
|
|
|
|
CheckSecurityLeftAndTop(&cssPos.width, &cssPos.height, aCallerType);
|
|
|
|
nsIntSize newDevPos(CSSToDevIntPixels(cssPos));
|
|
|
|
aError = treeOwnerAsWin->SetPosition(newDevPos.width, newDevPos.height);
|
|
|
|
CheckForDPIChange();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::MoveBy(int32_t aXDif, int32_t aYDif,
|
|
CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(MoveByOuter,
|
|
(aXDif, aYDif, aCallerType, aError), aError, );
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::MoveBy(int32_t aXDif, int32_t aYDif)
|
|
{
|
|
FORWARD_TO_OUTER(MoveBy, (aXDif, aYDif), NS_ERROR_UNEXPECTED);
|
|
|
|
ErrorResult rv;
|
|
MoveByOuter(aXDif, aYDif, CallerType::System, rv);
|
|
|
|
return rv.StealNSResult();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ResizeToOuter(int32_t aWidth, int32_t aHeight,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
/*
|
|
* If caller is a browser-element then dispatch a resize event to
|
|
* the embedder.
|
|
*/
|
|
if (mDocShell && mDocShell->GetIsMozBrowser()) {
|
|
CSSIntSize size(aWidth, aHeight);
|
|
if (!DispatchResizeEvent(size)) {
|
|
// The embedder chose to prevent the default action for this
|
|
// event, so let's not resize this window after all...
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If caller is not chrome and the user has not explicitly exempted the site,
|
|
* prevent window.resizeTo() by exiting early
|
|
*/
|
|
|
|
if (!CanMoveResizeWindows(aCallerType) || IsFrame()) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIBaseWindow> treeOwnerAsWin = GetTreeOwnerWindow();
|
|
if (!treeOwnerAsWin) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
nsIntSize cssSize(aWidth, aHeight);
|
|
CheckSecurityWidthAndHeight(&cssSize.width, &cssSize.height, aCallerType);
|
|
|
|
nsIntSize devSz(CSSToDevIntPixels(cssSize));
|
|
|
|
aError = treeOwnerAsWin->SetSize(devSz.width, devSz.height, true);
|
|
|
|
CheckForDPIChange();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ResizeTo(int32_t aWidth, int32_t aHeight,
|
|
CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(ResizeToOuter,
|
|
(aWidth, aHeight, aCallerType, aError), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ResizeByOuter(int32_t aWidthDif, int32_t aHeightDif,
|
|
CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
/*
|
|
* If caller is a browser-element then dispatch a resize event to
|
|
* parent.
|
|
*/
|
|
if (mDocShell && mDocShell->GetIsMozBrowser()) {
|
|
CSSIntSize size;
|
|
if (NS_FAILED(GetInnerSize(size))) {
|
|
return;
|
|
}
|
|
|
|
size.width += aWidthDif;
|
|
size.height += aHeightDif;
|
|
|
|
if (!DispatchResizeEvent(size)) {
|
|
// The embedder chose to prevent the default action for this
|
|
// event, so let's not resize this window after all...
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If caller is not chrome and the user has not explicitly exempted the site,
|
|
* prevent window.resizeBy() by exiting early
|
|
*/
|
|
|
|
if (!CanMoveResizeWindows(aCallerType) || IsFrame()) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIBaseWindow> treeOwnerAsWin = GetTreeOwnerWindow();
|
|
if (!treeOwnerAsWin) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
int32_t width, height;
|
|
aError = treeOwnerAsWin->GetSize(&width, &height);
|
|
if (aError.Failed()) {
|
|
return;
|
|
}
|
|
|
|
// To do this correctly we have to convert what we got from GetSize
|
|
// into CSS pixels, add the arguments, do the security check, and
|
|
// then convert back to device pixels for the call to SetSize.
|
|
|
|
nsIntSize cssSize(DevToCSSIntPixels(nsIntSize(width, height)));
|
|
|
|
cssSize.width += aWidthDif;
|
|
cssSize.height += aHeightDif;
|
|
|
|
CheckSecurityWidthAndHeight(&cssSize.width, &cssSize.height, aCallerType);
|
|
|
|
nsIntSize newDevSize(CSSToDevIntPixels(cssSize));
|
|
|
|
aError = treeOwnerAsWin->SetSize(newDevSize.width, newDevSize.height, true);
|
|
|
|
CheckForDPIChange();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ResizeBy(int32_t aWidthDif, int32_t aHeightDif,
|
|
CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(ResizeByOuter,
|
|
(aWidthDif, aHeightDif, aCallerType, aError),
|
|
aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SizeToContentOuter(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDocShell) {
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* If caller is not chrome and the user has not explicitly exempted the site,
|
|
* prevent window.sizeToContent() by exiting early
|
|
*/
|
|
|
|
if (!CanMoveResizeWindows(aCallerType) || IsFrame()) {
|
|
return;
|
|
}
|
|
|
|
// The content viewer does a check to make sure that it's a content
|
|
// viewer for a toplevel docshell.
|
|
nsCOMPtr<nsIContentViewer> cv;
|
|
mDocShell->GetContentViewer(getter_AddRefs(cv));
|
|
if (!cv) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
int32_t width, height;
|
|
aError = cv->GetContentSize(&width, &height);
|
|
if (aError.Failed()) {
|
|
return;
|
|
}
|
|
|
|
// Make sure the new size is following the CheckSecurityWidthAndHeight
|
|
// rules.
|
|
nsCOMPtr<nsIDocShellTreeOwner> treeOwner = GetTreeOwner();
|
|
if (!treeOwner) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
nsIntSize cssSize(DevToCSSIntPixels(nsIntSize(width, height)));
|
|
CheckSecurityWidthAndHeight(&cssSize.width, &cssSize.height, aCallerType);
|
|
|
|
nsIntSize newDevSize(CSSToDevIntPixels(cssSize));
|
|
|
|
aError = treeOwner->SizeShellTo(mDocShell, newDevSize.width,
|
|
newDevSize.height);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SizeToContent(CallerType aCallerType, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(SizeToContentOuter, (aCallerType, aError),
|
|
aError, );
|
|
}
|
|
|
|
already_AddRefed<nsPIWindowRoot>
|
|
nsGlobalWindow::GetTopWindowRoot()
|
|
{
|
|
nsPIDOMWindowOuter* piWin = GetPrivateRoot();
|
|
if (!piWin) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsCOMPtr<nsPIWindowRoot> window = do_QueryInterface(piWin->GetChromeEventHandler());
|
|
return window.forget();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Scroll(double aXScroll, double aYScroll)
|
|
{
|
|
// Convert -Inf, Inf, and NaN to 0; otherwise, convert by C-style cast.
|
|
auto scrollPos = CSSIntPoint::Truncate(mozilla::ToZeroIfNonfinite(aXScroll),
|
|
mozilla::ToZeroIfNonfinite(aYScroll));
|
|
ScrollTo(scrollPos, ScrollOptions());
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ScrollTo(double aXScroll, double aYScroll)
|
|
{
|
|
// Convert -Inf, Inf, and NaN to 0; otherwise, convert by C-style cast.
|
|
auto scrollPos = CSSIntPoint::Truncate(mozilla::ToZeroIfNonfinite(aXScroll),
|
|
mozilla::ToZeroIfNonfinite(aYScroll));
|
|
ScrollTo(scrollPos, ScrollOptions());
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ScrollTo(const ScrollToOptions& aOptions)
|
|
{
|
|
// When scrolling to a non-zero offset, we need to determine whether that
|
|
// position is within our scrollable range, so we need updated layout
|
|
// information which requires a layout flush, otherwise all we need is to
|
|
// flush frames to be able to access our scrollable frame here.
|
|
FlushType flushType = ((aOptions.mLeft.WasPassed() &&
|
|
aOptions.mLeft.Value() > 0) ||
|
|
(aOptions.mTop.WasPassed() &&
|
|
aOptions.mTop.Value() > 0)) ?
|
|
FlushType::Layout :
|
|
FlushType::Frames;
|
|
FlushPendingNotifications(flushType);
|
|
nsIScrollableFrame *sf = GetScrollFrame();
|
|
|
|
if (sf) {
|
|
CSSIntPoint scrollPos = sf->GetScrollPositionCSSPixels();
|
|
if (aOptions.mLeft.WasPassed()) {
|
|
scrollPos.x = mozilla::ToZeroIfNonfinite(aOptions.mLeft.Value());
|
|
}
|
|
if (aOptions.mTop.WasPassed()) {
|
|
scrollPos.y = mozilla::ToZeroIfNonfinite(aOptions.mTop.Value());
|
|
}
|
|
|
|
ScrollTo(scrollPos, aOptions);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Scroll(const ScrollToOptions& aOptions)
|
|
{
|
|
ScrollTo(aOptions);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ScrollTo(const CSSIntPoint& aScroll,
|
|
const ScrollOptions& aOptions)
|
|
{
|
|
// When scrolling to a non-zero offset, we need to determine whether that
|
|
// position is within our scrollable range, so we need updated layout
|
|
// information which requires a layout flush, otherwise all we need is to
|
|
// flush frames to be able to access our scrollable frame here.
|
|
FlushType flushType = (aScroll.x || aScroll.y) ?
|
|
FlushType::Layout :
|
|
FlushType::Frames;
|
|
FlushPendingNotifications(flushType);
|
|
nsIScrollableFrame *sf = GetScrollFrame();
|
|
|
|
if (sf) {
|
|
// Here we calculate what the max pixel value is that we can
|
|
// scroll to, we do this by dividing maxint with the pixel to
|
|
// twips conversion factor, and subtracting 4, the 4 comes from
|
|
// experimenting with this value, anything less makes the view
|
|
// code not scroll correctly, I have no idea why. -- jst
|
|
const int32_t maxpx = nsPresContext::AppUnitsToIntCSSPixels(0x7fffffff) - 4;
|
|
|
|
CSSIntPoint scroll(aScroll);
|
|
if (scroll.x > maxpx) {
|
|
scroll.x = maxpx;
|
|
}
|
|
|
|
if (scroll.y > maxpx) {
|
|
scroll.y = maxpx;
|
|
}
|
|
|
|
bool smoothScroll = sf->GetScrollbarStyles().IsSmoothScroll(aOptions.mBehavior);
|
|
|
|
sf->ScrollToCSSPixels(scroll, smoothScroll
|
|
? nsIScrollableFrame::SMOOTH_MSD
|
|
: nsIScrollableFrame::INSTANT);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ScrollBy(double aXScrollDif, double aYScrollDif)
|
|
{
|
|
FlushPendingNotifications(FlushType::Layout);
|
|
nsIScrollableFrame *sf = GetScrollFrame();
|
|
|
|
if (sf) {
|
|
// Convert -Inf, Inf, and NaN to 0; otherwise, convert by C-style cast.
|
|
auto scrollDif = CSSIntPoint::Truncate(mozilla::ToZeroIfNonfinite(aXScrollDif),
|
|
mozilla::ToZeroIfNonfinite(aYScrollDif));
|
|
// It seems like it would make more sense for ScrollBy to use
|
|
// SMOOTH mode, but tests seem to depend on the synchronous behaviour.
|
|
// Perhaps Web content does too.
|
|
ScrollTo(sf->GetScrollPositionCSSPixels() + scrollDif, ScrollOptions());
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ScrollBy(const ScrollToOptions& aOptions)
|
|
{
|
|
FlushPendingNotifications(FlushType::Layout);
|
|
nsIScrollableFrame *sf = GetScrollFrame();
|
|
|
|
if (sf) {
|
|
CSSIntPoint scrollPos = sf->GetScrollPositionCSSPixels();
|
|
if (aOptions.mLeft.WasPassed()) {
|
|
scrollPos.x += mozilla::ToZeroIfNonfinite(aOptions.mLeft.Value());
|
|
}
|
|
if (aOptions.mTop.WasPassed()) {
|
|
scrollPos.y += mozilla::ToZeroIfNonfinite(aOptions.mTop.Value());
|
|
}
|
|
|
|
ScrollTo(scrollPos, aOptions);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ScrollByLines(int32_t numLines,
|
|
const ScrollOptions& aOptions)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
FlushPendingNotifications(FlushType::Layout);
|
|
nsIScrollableFrame *sf = GetScrollFrame();
|
|
if (sf) {
|
|
// It seems like it would make more sense for ScrollByLines to use
|
|
// SMOOTH mode, but tests seem to depend on the synchronous behaviour.
|
|
// Perhaps Web content does too.
|
|
bool smoothScroll = sf->GetScrollbarStyles().IsSmoothScroll(aOptions.mBehavior);
|
|
|
|
sf->ScrollBy(nsIntPoint(0, numLines), nsIScrollableFrame::LINES,
|
|
smoothScroll
|
|
? nsIScrollableFrame::SMOOTH_MSD
|
|
: nsIScrollableFrame::INSTANT);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ScrollByPages(int32_t numPages,
|
|
const ScrollOptions& aOptions)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
FlushPendingNotifications(FlushType::Layout);
|
|
nsIScrollableFrame *sf = GetScrollFrame();
|
|
if (sf) {
|
|
// It seems like it would make more sense for ScrollByPages to use
|
|
// SMOOTH mode, but tests seem to depend on the synchronous behaviour.
|
|
// Perhaps Web content does too.
|
|
bool smoothScroll = sf->GetScrollbarStyles().IsSmoothScroll(aOptions.mBehavior);
|
|
|
|
sf->ScrollBy(nsIntPoint(0, numPages), nsIScrollableFrame::PAGES,
|
|
smoothScroll
|
|
? nsIScrollableFrame::SMOOTH_MSD
|
|
: nsIScrollableFrame::INSTANT);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::MozScrollSnap()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
FlushPendingNotifications(FlushType::Layout);
|
|
nsIScrollableFrame *sf = GetScrollFrame();
|
|
if (sf) {
|
|
sf->ScrollSnap();
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ClearTimeout(int32_t aHandle)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (aHandle > 0) {
|
|
mTimeoutManager->ClearTimeout(aHandle, Timeout::Reason::eTimeoutOrInterval);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ClearInterval(int32_t aHandle)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (aHandle > 0) {
|
|
mTimeoutManager->ClearTimeout(aHandle, Timeout::Reason::eTimeoutOrInterval);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetResizable(bool aResizable) const
|
|
{
|
|
// nop
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::CaptureEvents()
|
|
{
|
|
if (mDoc) {
|
|
mDoc->WarnOnceAbout(nsIDocument::eUseOfCaptureEvents);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ReleaseEvents()
|
|
{
|
|
if (mDoc) {
|
|
mDoc->WarnOnceAbout(nsIDocument::eUseOfReleaseEvents);
|
|
}
|
|
}
|
|
|
|
static
|
|
bool IsPopupBlocked(nsIDocument* aDoc)
|
|
{
|
|
nsCOMPtr<nsIPopupWindowManager> pm =
|
|
do_GetService(NS_POPUPWINDOWMANAGER_CONTRACTID);
|
|
|
|
if (!pm) {
|
|
return false;
|
|
}
|
|
|
|
if (!aDoc) {
|
|
return true;
|
|
}
|
|
|
|
uint32_t permission = nsIPopupWindowManager::ALLOW_POPUP;
|
|
pm->TestPermission(aDoc->NodePrincipal(), &permission);
|
|
return permission == nsIPopupWindowManager::DENY_POPUP;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::FirePopupBlockedEvent(nsIDocument* aDoc,
|
|
nsIURI* aPopupURI,
|
|
const nsAString& aPopupWindowName,
|
|
const nsAString& aPopupWindowFeatures)
|
|
{
|
|
MOZ_ASSERT(aDoc);
|
|
|
|
// Fire a "DOMPopupBlocked" event so that the UI can hear about
|
|
// blocked popups.
|
|
PopupBlockedEventInit init;
|
|
init.mBubbles = true;
|
|
init.mCancelable = true;
|
|
init.mRequestingWindow = this;
|
|
init.mPopupWindowURI = aPopupURI;
|
|
init.mPopupWindowName = aPopupWindowName;
|
|
init.mPopupWindowFeatures = aPopupWindowFeatures;
|
|
|
|
RefPtr<PopupBlockedEvent> event =
|
|
PopupBlockedEvent::Constructor(aDoc,
|
|
NS_LITERAL_STRING("DOMPopupBlocked"),
|
|
init);
|
|
|
|
event->SetTrusted(true);
|
|
|
|
bool defaultActionEnabled;
|
|
aDoc->DispatchEvent(event, &defaultActionEnabled);
|
|
}
|
|
|
|
// static
|
|
bool
|
|
nsGlobalWindow::CanSetProperty(const char *aPrefName)
|
|
{
|
|
// Chrome can set any property.
|
|
if (nsContentUtils::LegacyIsCallerChromeOrNativeCode()) {
|
|
return true;
|
|
}
|
|
|
|
// If the pref is set to true, we can not set the property
|
|
// and vice versa.
|
|
return !Preferences::GetBool(aPrefName, true);
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::PopupWhitelisted()
|
|
{
|
|
if (!IsPopupBlocked(mDoc))
|
|
return true;
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> parent = GetParent();
|
|
if (parent == AsOuter())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return nsGlobalWindow::Cast(parent)->PopupWhitelisted();
|
|
}
|
|
|
|
/*
|
|
* Examine the current document state to see if we're in a way that is
|
|
* typically abused by web designers. The window.open code uses this
|
|
* routine to determine whether to allow the new window.
|
|
* Returns a value from the PopupControlState enum.
|
|
*/
|
|
PopupControlState
|
|
nsGlobalWindow::RevisePopupAbuseLevel(PopupControlState aControl)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
NS_ASSERTION(mDocShell, "Must have docshell");
|
|
|
|
if (mDocShell->ItemType() != nsIDocShellTreeItem::typeContent) {
|
|
return openAllowed;
|
|
}
|
|
|
|
PopupControlState abuse = aControl;
|
|
switch (abuse) {
|
|
case openControlled:
|
|
case openBlocked:
|
|
case openOverridden:
|
|
if (PopupWhitelisted())
|
|
abuse = PopupControlState(abuse - 1);
|
|
break;
|
|
case openAbused:
|
|
if (PopupWhitelisted())
|
|
//Skip openBlocked
|
|
abuse = openControlled;
|
|
break;
|
|
case openAllowed: break;
|
|
default:
|
|
NS_WARNING("Strange PopupControlState!");
|
|
}
|
|
|
|
// limit the number of simultaneously open popups
|
|
if (abuse == openAbused ||
|
|
abuse == openBlocked ||
|
|
abuse == openControlled) {
|
|
int32_t popupMax = Preferences::GetInt("dom.popup_maximum", -1);
|
|
if (popupMax >= 0 && gOpenPopupSpamCount >= popupMax)
|
|
abuse = openOverridden;
|
|
}
|
|
|
|
return abuse;
|
|
}
|
|
|
|
/* If a window open is blocked, fire the appropriate DOM events. */
|
|
void
|
|
nsGlobalWindow::FireAbuseEvents(const nsAString &aPopupURL,
|
|
const nsAString &aPopupWindowName,
|
|
const nsAString &aPopupWindowFeatures)
|
|
{
|
|
// fetch the URI of the window requesting the opened window
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> window = GetTop();
|
|
if (!window) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIDocument> topDoc = window->GetDoc();
|
|
nsCOMPtr<nsIURI> popupURI;
|
|
|
|
// build the URI of the would-have-been popup window
|
|
// (see nsWindowWatcher::URIfromURL)
|
|
|
|
// first, fetch the opener's base URI
|
|
|
|
nsIURI *baseURL = nullptr;
|
|
|
|
nsCOMPtr<nsIDocument> doc = GetEntryDocument();
|
|
if (doc)
|
|
baseURL = doc->GetDocBaseURI();
|
|
|
|
// use the base URI to build what would have been the popup's URI
|
|
nsCOMPtr<nsIIOService> ios(do_GetService(NS_IOSERVICE_CONTRACTID));
|
|
if (ios)
|
|
ios->NewURI(NS_ConvertUTF16toUTF8(aPopupURL), nullptr, baseURL,
|
|
getter_AddRefs(popupURI));
|
|
|
|
// fire an event chock full of informative URIs
|
|
FirePopupBlockedEvent(topDoc, popupURI, aPopupWindowName,
|
|
aPopupWindowFeatures);
|
|
}
|
|
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsGlobalWindow::OpenOuter(const nsAString& aUrl, const nsAString& aName,
|
|
const nsAString& aOptions, ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
nsCOMPtr<nsPIDOMWindowOuter> window;
|
|
aError = OpenJS(aUrl, aName, aOptions, getter_AddRefs(window));
|
|
return window.forget();
|
|
}
|
|
|
|
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsGlobalWindow::Open(const nsAString& aUrl, const nsAString& aName,
|
|
const nsAString& aOptions, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(OpenOuter, (aUrl, aName, aOptions, aError), aError,
|
|
nullptr);
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::Open(const nsAString& aUrl, const nsAString& aName,
|
|
const nsAString& aOptions, nsIDocShellLoadInfo* aLoadInfo,
|
|
bool aForceNoOpener, nsPIDOMWindowOuter **_retval)
|
|
{
|
|
FORWARD_TO_OUTER(Open, (aUrl, aName, aOptions, aLoadInfo, aForceNoOpener,
|
|
_retval),
|
|
NS_ERROR_NOT_INITIALIZED);
|
|
return OpenInternal(aUrl, aName, aOptions,
|
|
false, // aDialog
|
|
false, // aContentModal
|
|
true, // aCalledNoScript
|
|
false, // aDoJSFixups
|
|
true, // aNavigate
|
|
nullptr, nullptr, // No args
|
|
aLoadInfo,
|
|
aForceNoOpener,
|
|
_retval);
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::OpenJS(const nsAString& aUrl, const nsAString& aName,
|
|
const nsAString& aOptions, nsPIDOMWindowOuter **_retval)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
return OpenInternal(aUrl, aName, aOptions,
|
|
false, // aDialog
|
|
false, // aContentModal
|
|
false, // aCalledNoScript
|
|
true, // aDoJSFixups
|
|
true, // aNavigate
|
|
nullptr, nullptr, // No args
|
|
nullptr, // aLoadInfo
|
|
false, // aForceNoOpener
|
|
_retval);
|
|
}
|
|
|
|
// like Open, but attaches to the new window any extra parameters past
|
|
// [features] as a JS property named "arguments"
|
|
nsresult
|
|
nsGlobalWindow::OpenDialog(const nsAString& aUrl, const nsAString& aName,
|
|
const nsAString& aOptions,
|
|
nsISupports* aExtraArgument,
|
|
nsPIDOMWindowOuter** _retval)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
return OpenInternal(aUrl, aName, aOptions,
|
|
true, // aDialog
|
|
false, // aContentModal
|
|
true, // aCalledNoScript
|
|
false, // aDoJSFixups
|
|
true, // aNavigate
|
|
nullptr, aExtraArgument, // Arguments
|
|
nullptr, // aLoadInfo
|
|
false, // aForceNoOpener
|
|
_retval);
|
|
}
|
|
|
|
// Like Open, but passes aNavigate=false.
|
|
/* virtual */ nsresult
|
|
nsGlobalWindow::OpenNoNavigate(const nsAString& aUrl,
|
|
const nsAString& aName,
|
|
const nsAString& aOptions,
|
|
nsPIDOMWindowOuter **_retval)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
return OpenInternal(aUrl, aName, aOptions,
|
|
false, // aDialog
|
|
false, // aContentModal
|
|
true, // aCalledNoScript
|
|
false, // aDoJSFixups
|
|
false, // aNavigate
|
|
nullptr, nullptr, // No args
|
|
nullptr, // aLoadInfo
|
|
false, // aForceNoOpener
|
|
_retval);
|
|
|
|
}
|
|
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsGlobalWindow::OpenDialogOuter(JSContext* aCx, const nsAString& aUrl,
|
|
const nsAString& aName, const nsAString& aOptions,
|
|
const Sequence<JS::Value>& aExtraArgument,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
nsCOMPtr<nsIJSArgArray> argvArray;
|
|
aError = NS_CreateJSArgv(aCx, aExtraArgument.Length(),
|
|
aExtraArgument.Elements(),
|
|
getter_AddRefs(argvArray));
|
|
if (aError.Failed()) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> dialog;
|
|
aError = OpenInternal(aUrl, aName, aOptions,
|
|
true, // aDialog
|
|
false, // aContentModal
|
|
false, // aCalledNoScript
|
|
false, // aDoJSFixups
|
|
true, // aNavigate
|
|
argvArray, nullptr, // Arguments
|
|
nullptr, // aLoadInfo
|
|
false, // aForceNoOpener
|
|
getter_AddRefs(dialog));
|
|
return dialog.forget();
|
|
}
|
|
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsGlobalWindow::OpenDialog(JSContext* aCx, const nsAString& aUrl,
|
|
const nsAString& aName, const nsAString& aOptions,
|
|
const Sequence<JS::Value>& aExtraArgument,
|
|
ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(OpenDialogOuter,
|
|
(aCx, aUrl, aName, aOptions, aExtraArgument, aError),
|
|
aError, nullptr);
|
|
}
|
|
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsGlobalWindow::GetFramesOuter()
|
|
{
|
|
RefPtr<nsPIDOMWindowOuter> frames(AsOuter());
|
|
FlushPendingNotifications(FlushType::ContentAndNotify);
|
|
return frames.forget();
|
|
}
|
|
|
|
already_AddRefed<nsPIDOMWindowOuter>
|
|
nsGlobalWindow::GetFrames(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetFramesOuter, (), aError, nullptr);
|
|
}
|
|
|
|
nsGlobalWindow*
|
|
nsGlobalWindow::CallerInnerWindow()
|
|
{
|
|
JSContext *cx = nsContentUtils::GetCurrentJSContext();
|
|
NS_ENSURE_TRUE(cx, nullptr);
|
|
nsIGlobalObject* global = GetIncumbentGlobal();
|
|
NS_ENSURE_TRUE(global, nullptr);
|
|
JS::Rooted<JSObject*> scope(cx, global->GetGlobalJSObject());
|
|
NS_ENSURE_TRUE(scope, nullptr);
|
|
|
|
// When Jetpack runs content scripts inside a sandbox, it uses
|
|
// sandboxPrototype to make them appear as though they're running in the
|
|
// scope of the page. So when a content script invokes postMessage, it expects
|
|
// the |source| of the received message to be the window set as the
|
|
// sandboxPrototype. This used to work incidentally for unrelated reasons, but
|
|
// now we need to do some special handling to support it.
|
|
if (xpc::IsSandbox(scope)) {
|
|
JSAutoCompartment ac(cx, scope);
|
|
JS::Rooted<JSObject*> scopeProto(cx);
|
|
bool ok = JS_GetPrototype(cx, scope, &scopeProto);
|
|
NS_ENSURE_TRUE(ok, nullptr);
|
|
if (scopeProto && xpc::IsSandboxPrototypeProxy(scopeProto) &&
|
|
(scopeProto = js::CheckedUnwrap(scopeProto, /* stopAtWindowProxy = */ false)))
|
|
{
|
|
global = xpc::NativeGlobal(scopeProto);
|
|
NS_ENSURE_TRUE(global, nullptr);
|
|
}
|
|
}
|
|
|
|
// The calling window must be holding a reference, so we can return a weak
|
|
// pointer.
|
|
nsCOMPtr<nsPIDOMWindowInner> win = do_QueryInterface(global);
|
|
return nsGlobalWindow::Cast(win);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::PostMessageMozOuter(JSContext* aCx, JS::Handle<JS::Value> aMessage,
|
|
const nsAString& aTargetOrigin,
|
|
JS::Handle<JS::Value> aTransfer,
|
|
nsIPrincipal& aSubjectPrincipal,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
//
|
|
// Window.postMessage is an intentional subversion of the same-origin policy.
|
|
// As such, this code must be particularly careful in the information it
|
|
// exposes to calling code.
|
|
//
|
|
// http://www.whatwg.org/specs/web-apps/current-work/multipage/section-crossDocumentMessages.html
|
|
//
|
|
|
|
// First, get the caller's window
|
|
RefPtr<nsGlobalWindow> callerInnerWin = CallerInnerWindow();
|
|
nsIPrincipal* callerPrin;
|
|
if (callerInnerWin) {
|
|
MOZ_ASSERT(callerInnerWin->IsInnerWindow(),
|
|
"should have gotten an inner window here");
|
|
|
|
// Compute the caller's origin either from its principal or, in the case the
|
|
// principal doesn't carry a URI (e.g. the system principal), the caller's
|
|
// document. We must get this now instead of when the event is created and
|
|
// dispatched, because ultimately it is the identity of the calling window
|
|
// *now* that determines who sent the message (and not an identity which might
|
|
// have changed due to intervening navigations).
|
|
callerPrin = callerInnerWin->GetPrincipal();
|
|
}
|
|
else {
|
|
// In case the global is not a window, it can be a sandbox, and the sandbox's
|
|
// principal can be used for the security check.
|
|
nsIGlobalObject* global = GetIncumbentGlobal();
|
|
NS_ASSERTION(global, "Why is there no global object?");
|
|
callerPrin = global->PrincipalOrNull();
|
|
}
|
|
if (!callerPrin) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIURI> callerOuterURI;
|
|
if (NS_FAILED(callerPrin->GetURI(getter_AddRefs(callerOuterURI)))) {
|
|
return;
|
|
}
|
|
|
|
nsAutoString origin;
|
|
if (callerOuterURI) {
|
|
// if the principal has a URI, use that to generate the origin
|
|
nsContentUtils::GetUTFOrigin(callerPrin, origin);
|
|
}
|
|
else if (callerInnerWin) {
|
|
// otherwise use the URI of the document to generate origin
|
|
nsCOMPtr<nsIDocument> doc = callerInnerWin->GetExtantDoc();
|
|
if (!doc) {
|
|
return;
|
|
}
|
|
callerOuterURI = doc->GetDocumentURI();
|
|
// if the principal has a URI, use that to generate the origin
|
|
nsContentUtils::GetUTFOrigin(callerOuterURI, origin);
|
|
}
|
|
else {
|
|
// in case of a sandbox with a system principal origin can be empty
|
|
if (!nsContentUtils::IsSystemPrincipal(callerPrin)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Convert the provided origin string into a URI for comparison purposes.
|
|
nsCOMPtr<nsIPrincipal> providedPrincipal;
|
|
|
|
if (aTargetOrigin.EqualsASCII("/")) {
|
|
providedPrincipal = callerPrin;
|
|
}
|
|
// "*" indicates no specific origin is required.
|
|
else if (!aTargetOrigin.EqualsASCII("*")) {
|
|
nsCOMPtr<nsIURI> originURI;
|
|
if (NS_FAILED(NS_NewURI(getter_AddRefs(originURI), aTargetOrigin))) {
|
|
aError.Throw(NS_ERROR_DOM_SYNTAX_ERR);
|
|
return;
|
|
}
|
|
|
|
if (NS_FAILED(originURI->SetUserPass(EmptyCString())) ||
|
|
NS_FAILED(originURI->SetPathQueryRef(EmptyCString()))) {
|
|
return;
|
|
}
|
|
|
|
OriginAttributes attrs = aSubjectPrincipal.OriginAttributesRef();
|
|
if (aSubjectPrincipal.GetIsSystemPrincipal()) {
|
|
auto principal = BasePrincipal::Cast(GetPrincipal());
|
|
|
|
if (attrs != principal->OriginAttributesRef()) {
|
|
nsCOMPtr<nsIURI> targetURI;
|
|
nsAutoCString targetURL;
|
|
nsAutoCString sourceOrigin;
|
|
nsAutoCString targetOrigin;
|
|
|
|
if (NS_FAILED(principal->GetURI(getter_AddRefs(targetURI))) ||
|
|
NS_FAILED(targetURI->GetAsciiSpec(targetURL)) ||
|
|
NS_FAILED(principal->GetOrigin(targetOrigin)) ||
|
|
NS_FAILED(aSubjectPrincipal.GetOrigin(sourceOrigin))) {
|
|
NS_WARNING("Failed to get source and target origins");
|
|
return;
|
|
}
|
|
|
|
nsContentUtils::LogSimpleConsoleError(
|
|
NS_ConvertUTF8toUTF16(nsPrintfCString(
|
|
R"(Attempting to post a message to window with url "%s" and )"
|
|
R"(origin "%s" from a system principal scope with mismatched )"
|
|
R"(origin "%s".)",
|
|
targetURL.get(), targetOrigin.get(), sourceOrigin.get())),
|
|
"DOM");
|
|
|
|
attrs = principal->OriginAttributesRef();
|
|
}
|
|
}
|
|
|
|
// Create a nsIPrincipal inheriting the app/browser attributes from the
|
|
// caller.
|
|
providedPrincipal = BasePrincipal::CreateCodebasePrincipal(originURI, attrs);
|
|
if (NS_WARN_IF(!providedPrincipal)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Create and asynchronously dispatch a runnable which will handle actual DOM
|
|
// event creation and dispatch.
|
|
RefPtr<PostMessageEvent> event =
|
|
new PostMessageEvent(nsContentUtils::IsCallerChrome() || !callerInnerWin
|
|
? nullptr
|
|
: callerInnerWin->GetOuterWindowInternal(),
|
|
origin,
|
|
this,
|
|
providedPrincipal,
|
|
callerInnerWin
|
|
? callerInnerWin->GetDoc()
|
|
: nullptr,
|
|
nsContentUtils::IsCallerChrome());
|
|
|
|
JS::Rooted<JS::Value> message(aCx, aMessage);
|
|
JS::Rooted<JS::Value> transfer(aCx, aTransfer);
|
|
|
|
event->Write(aCx, message, transfer, JS::CloneDataPolicy(), aError);
|
|
if (NS_WARN_IF(aError.Failed())) {
|
|
return;
|
|
}
|
|
|
|
aError = Dispatch(TaskCategory::Other, event.forget());
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::PostMessageMoz(JSContext* aCx, JS::Handle<JS::Value> aMessage,
|
|
const nsAString& aTargetOrigin,
|
|
JS::Handle<JS::Value> aTransfer,
|
|
nsIPrincipal& aSubjectPrincipal,
|
|
ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(PostMessageMozOuter,
|
|
(aCx, aMessage, aTargetOrigin, aTransfer,
|
|
aSubjectPrincipal, aError),
|
|
aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::PostMessageMoz(JSContext* aCx, JS::Handle<JS::Value> aMessage,
|
|
const nsAString& aTargetOrigin,
|
|
const Sequence<JSObject*>& aTransfer,
|
|
nsIPrincipal& aSubjectPrincipal,
|
|
ErrorResult& aRv)
|
|
{
|
|
JS::Rooted<JS::Value> transferArray(aCx, JS::UndefinedValue());
|
|
|
|
aRv = nsContentUtils::CreateJSValueFromSequenceOfObject(aCx, aTransfer,
|
|
&transferArray);
|
|
if (NS_WARN_IF(aRv.Failed())) {
|
|
return;
|
|
}
|
|
|
|
PostMessageMoz(aCx, aMessage, aTargetOrigin, transferArray,
|
|
aSubjectPrincipal, aRv);
|
|
}
|
|
|
|
class nsCloseEvent : public Runnable {
|
|
|
|
RefPtr<nsGlobalWindow> mWindow;
|
|
bool mIndirect;
|
|
|
|
nsCloseEvent(nsGlobalWindow* aWindow, bool aIndirect)
|
|
: mozilla::Runnable("nsCloseEvent")
|
|
, mWindow(aWindow)
|
|
, mIndirect(aIndirect)
|
|
{}
|
|
|
|
public:
|
|
|
|
static nsresult
|
|
PostCloseEvent(nsGlobalWindow* aWindow, bool aIndirect) {
|
|
nsCOMPtr<nsIRunnable> ev = new nsCloseEvent(aWindow, aIndirect);
|
|
nsresult rv =
|
|
aWindow->Dispatch(TaskCategory::Other, ev.forget());
|
|
if (NS_SUCCEEDED(rv))
|
|
aWindow->MaybeForgiveSpamCount();
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHOD Run() override {
|
|
if (mWindow) {
|
|
if (mIndirect) {
|
|
return PostCloseEvent(mWindow, false);
|
|
}
|
|
mWindow->ReallyCloseWindow();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
};
|
|
|
|
bool
|
|
nsGlobalWindow::CanClose()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
if (mIsChrome) {
|
|
nsCOMPtr<nsIBrowserDOMWindow> bwin;
|
|
GetBrowserDOMWindow(getter_AddRefs(bwin));
|
|
|
|
bool canClose = true;
|
|
if (bwin && NS_SUCCEEDED(bwin->CanClose(&canClose))) {
|
|
return canClose;
|
|
}
|
|
}
|
|
|
|
if (!mDocShell) {
|
|
return true;
|
|
}
|
|
|
|
// Ask the content viewer whether the toplevel window can close.
|
|
// If the content viewer returns false, it is responsible for calling
|
|
// Close() as soon as it is possible for the window to close.
|
|
// This allows us to not close the window while printing is happening.
|
|
|
|
nsCOMPtr<nsIContentViewer> cv;
|
|
mDocShell->GetContentViewer(getter_AddRefs(cv));
|
|
if (cv) {
|
|
bool canClose;
|
|
nsresult rv = cv->PermitUnload(&canClose);
|
|
if (NS_SUCCEEDED(rv) && !canClose)
|
|
return false;
|
|
|
|
rv = cv->RequestWindowClose(&canClose);
|
|
if (NS_SUCCEEDED(rv) && !canClose)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::CloseOuter(bool aTrustedCaller)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDocShell || IsInModalState() ||
|
|
(IsFrame() && !mDocShell->GetIsMozBrowser())) {
|
|
// window.close() is called on a frame in a frameset, on a window
|
|
// that's already closed, or on a window for which there's
|
|
// currently a modal dialog open. Ignore such calls.
|
|
return;
|
|
}
|
|
|
|
if (mHavePendingClose) {
|
|
// We're going to be closed anyway; do nothing since we don't want
|
|
// to double-close
|
|
return;
|
|
}
|
|
|
|
if (mBlockScriptedClosingFlag)
|
|
{
|
|
// A script's popup has been blocked and we don't want
|
|
// the window to be closed directly after this event,
|
|
// so the user can see that there was a blocked popup.
|
|
return;
|
|
}
|
|
|
|
// Don't allow scripts from content to close non-neterror windows that
|
|
// were not opened by script.
|
|
nsAutoString url;
|
|
nsresult rv = mDoc->GetURL(url);
|
|
NS_ENSURE_SUCCESS_VOID(rv);
|
|
|
|
if (!StringBeginsWith(url, NS_LITERAL_STRING("about:neterror")) &&
|
|
!mHadOriginalOpener && !aTrustedCaller) {
|
|
bool allowClose = mAllowScriptsToClose ||
|
|
Preferences::GetBool("dom.allow_scripts_to_close_windows", true);
|
|
if (!allowClose) {
|
|
// We're blocking the close operation
|
|
// report localized error msg in JS console
|
|
nsContentUtils::ReportToConsole(
|
|
nsIScriptError::warningFlag,
|
|
NS_LITERAL_CSTRING("DOM Window"), mDoc, // Better name for the category?
|
|
nsContentUtils::eDOM_PROPERTIES,
|
|
"WindowCloseBlockedWarning");
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!mInClose && !mIsClosed && !CanClose()) {
|
|
return;
|
|
}
|
|
|
|
// Fire a DOM event notifying listeners that this window is about to
|
|
// be closed. The tab UI code may choose to cancel the default
|
|
// action for this event, if so, we won't actually close the window
|
|
// (since the tab UI code will close the tab in stead). Sure, this
|
|
// could be abused by content code, but do we care? I don't think
|
|
// so...
|
|
|
|
bool wasInClose = mInClose;
|
|
mInClose = true;
|
|
|
|
if (!DispatchCustomEvent(NS_LITERAL_STRING("DOMWindowClose"))) {
|
|
// Someone chose to prevent the default action for this event, if
|
|
// so, let's not close this window after all...
|
|
|
|
mInClose = wasInClose;
|
|
return;
|
|
}
|
|
|
|
FinalClose();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Close(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(CloseOuter, (nsContentUtils::IsCallerChrome()), aError, );
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::Close()
|
|
{
|
|
FORWARD_TO_OUTER(Close, (), NS_ERROR_UNEXPECTED);
|
|
CloseOuter(/* aTrustedCaller = */ true);
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ForceClose()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
|
|
|
|
if (IsFrame() || !mDocShell) {
|
|
// This may be a frame in a frameset, or a window that's already closed.
|
|
// Ignore such calls.
|
|
return;
|
|
}
|
|
|
|
if (mHavePendingClose) {
|
|
// We're going to be closed anyway; do nothing since we don't want
|
|
// to double-close
|
|
return;
|
|
}
|
|
|
|
mInClose = true;
|
|
|
|
DispatchCustomEvent(NS_LITERAL_STRING("DOMWindowClose"));
|
|
|
|
FinalClose();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::FinalClose()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
// Flag that we were closed.
|
|
mIsClosed = true;
|
|
|
|
// If we get here from CloseOuter then it means that the parent process is
|
|
// going to close our window for us. It's just important to set mIsClosed.
|
|
if (XRE_GetProcessType() == GeckoProcessType_Content) {
|
|
return;
|
|
}
|
|
|
|
// This stuff is non-sensical but incredibly fragile. The reasons for the
|
|
// behavior here don't make sense today and may not have ever made sense,
|
|
// but various bits of frontend code break when you change them. If you need
|
|
// to fix up this behavior, feel free to. It's a righteous task, but involves
|
|
// wrestling with various download manager tests, frontend code, and possible
|
|
// broken addons. The chrome tests in toolkit/mozapps/downloads are a good
|
|
// testing ground.
|
|
//
|
|
// In particular, if some inner of |win| is the entry global, we must
|
|
// complete _two_ round-trips to the event loop before the call to
|
|
// ReallyCloseWindow. This allows setTimeout handlers that are set after
|
|
// FinalClose() is called to run before the window is torn down.
|
|
nsCOMPtr<nsPIDOMWindowInner> entryWindow =
|
|
do_QueryInterface(GetEntryGlobal());
|
|
bool indirect =
|
|
entryWindow && entryWindow->GetOuterWindow() == this->AsOuter();
|
|
if (NS_FAILED(nsCloseEvent::PostCloseEvent(this, indirect))) {
|
|
ReallyCloseWindow();
|
|
} else {
|
|
mHavePendingClose = true;
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
nsGlobalWindow::ReallyCloseWindow()
|
|
{
|
|
FORWARD_TO_OUTER_VOID(ReallyCloseWindow, ());
|
|
|
|
// Make sure we never reenter this method.
|
|
mHavePendingClose = true;
|
|
|
|
nsCOMPtr<nsIBaseWindow> treeOwnerAsWin = GetTreeOwnerWindow();
|
|
|
|
// If there's no treeOwnerAsWin, this window must already be closed.
|
|
|
|
if (treeOwnerAsWin) {
|
|
|
|
// but if we're a browser window we could be in some nasty
|
|
// self-destroying cascade that we should mostly ignore
|
|
|
|
if (mDocShell) {
|
|
nsCOMPtr<nsIBrowserDOMWindow> bwin;
|
|
nsCOMPtr<nsIDocShellTreeItem> rootItem;
|
|
mDocShell->GetRootTreeItem(getter_AddRefs(rootItem));
|
|
nsCOMPtr<nsPIDOMWindowOuter> rootWin =
|
|
rootItem ? rootItem->GetWindow() : nullptr;
|
|
nsCOMPtr<nsIDOMChromeWindow> chromeWin(do_QueryInterface(rootWin));
|
|
if (chromeWin)
|
|
chromeWin->GetBrowserDOMWindow(getter_AddRefs(bwin));
|
|
|
|
if (rootWin) {
|
|
/* Normally we destroy the entire window, but not if
|
|
this DOM window belongs to a tabbed browser and doesn't
|
|
correspond to a tab. This allows a well-behaved tab
|
|
to destroy the container as it should but is a final measure
|
|
to prevent an errant tab from doing so when it shouldn't.
|
|
This works because we reach this code when we shouldn't only
|
|
in the particular circumstance that we belong to a tab
|
|
that has just been closed (and is therefore already missing
|
|
from the list of browsers) (and has an unload handler
|
|
that closes the window). */
|
|
// XXXbz now that we have mHavePendingClose, is this needed?
|
|
bool isTab;
|
|
if (rootWin == AsOuter() ||
|
|
!bwin ||
|
|
(NS_SUCCEEDED(bwin->IsTabContentWindow(GetOuterWindowInternal(),
|
|
&isTab)) && isTab)) {
|
|
treeOwnerAsWin->Destroy();
|
|
}
|
|
}
|
|
}
|
|
|
|
CleanUp();
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::EnterModalState()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow(), "Modal state is maintained on outer windows");
|
|
|
|
// GetScriptableTop, not GetTop, so that EnterModalState works properly with
|
|
// <iframe mozbrowser>.
|
|
nsGlobalWindow* topWin = GetScriptableTopInternal();
|
|
|
|
if (!topWin) {
|
|
NS_ERROR("Uh, EnterModalState() called w/o a reachable top window?");
|
|
return;
|
|
}
|
|
|
|
// If there is an active ESM in this window, clear it. Otherwise, this can
|
|
// cause a problem if a modal state is entered during a mouseup event.
|
|
EventStateManager* activeESM =
|
|
static_cast<EventStateManager*>(
|
|
EventStateManager::GetActiveEventStateManager());
|
|
if (activeESM && activeESM->GetPresContext()) {
|
|
nsIPresShell* activeShell = activeESM->GetPresContext()->GetPresShell();
|
|
if (activeShell && (
|
|
nsContentUtils::ContentIsCrossDocDescendantOf(activeShell->GetDocument(), mDoc) ||
|
|
nsContentUtils::ContentIsCrossDocDescendantOf(mDoc, activeShell->GetDocument()))) {
|
|
EventStateManager::ClearGlobalActiveContent(activeESM);
|
|
|
|
activeShell->SetCapturingContent(nullptr, 0);
|
|
|
|
if (activeShell) {
|
|
RefPtr<nsFrameSelection> frameSelection = activeShell->FrameSelection();
|
|
frameSelection->SetDragState(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
// If there are any drag and drop operations in flight, try to end them.
|
|
nsCOMPtr<nsIDragService> ds =
|
|
do_GetService("@mozilla.org/widget/dragservice;1");
|
|
if (ds) {
|
|
ds->EndDragSession(true, 0);
|
|
}
|
|
|
|
// Clear the capturing content if it is under topDoc.
|
|
// Usually the activeESM check above does that, but there are cases when
|
|
// we don't have activeESM, or it is for different document.
|
|
nsIDocument* topDoc = topWin->GetExtantDoc();
|
|
nsIContent* capturingContent = nsIPresShell::GetCapturingContent();
|
|
if (capturingContent && topDoc &&
|
|
nsContentUtils::ContentIsCrossDocDescendantOf(capturingContent, topDoc)) {
|
|
nsIPresShell::SetCapturingContent(nullptr, 0);
|
|
}
|
|
|
|
if (topWin->mModalStateDepth == 0) {
|
|
NS_ASSERTION(!topWin->mSuspendedDoc, "Shouldn't have mSuspendedDoc here!");
|
|
|
|
topWin->mSuspendedDoc = topDoc;
|
|
if (topDoc) {
|
|
topDoc->SuppressEventHandling();
|
|
}
|
|
|
|
nsGlobalWindow* inner = topWin->GetCurrentInnerWindowInternal();
|
|
if (inner) {
|
|
topWin->GetCurrentInnerWindowInternal()->Suspend();
|
|
}
|
|
}
|
|
topWin->mModalStateDepth++;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::LeaveModalState()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow(), "Modal state is maintained on outer windows");
|
|
|
|
nsGlobalWindow* topWin = GetScriptableTopInternal();
|
|
|
|
if (!topWin) {
|
|
NS_ERROR("Uh, LeaveModalState() called w/o a reachable top window?");
|
|
return;
|
|
}
|
|
|
|
MOZ_ASSERT(topWin->mModalStateDepth != 0);
|
|
MOZ_ASSERT(IsSuspended());
|
|
MOZ_ASSERT(topWin->IsSuspended());
|
|
topWin->mModalStateDepth--;
|
|
|
|
nsGlobalWindow* inner = topWin->GetCurrentInnerWindowInternal();
|
|
|
|
if (topWin->mModalStateDepth == 0) {
|
|
if (inner) {
|
|
inner->Resume();
|
|
}
|
|
|
|
if (topWin->mSuspendedDoc) {
|
|
nsCOMPtr<nsIDocument> currentDoc = topWin->GetExtantDoc();
|
|
topWin->mSuspendedDoc->UnsuppressEventHandlingAndFireEvents(currentDoc == topWin->mSuspendedDoc);
|
|
topWin->mSuspendedDoc = nullptr;
|
|
}
|
|
}
|
|
|
|
// Remember the time of the last dialog quit.
|
|
if (inner) {
|
|
inner->mLastDialogQuitTime = TimeStamp::Now();
|
|
}
|
|
|
|
if (topWin->mModalStateDepth == 0) {
|
|
RefPtr<Event> event = NS_NewDOMEvent(inner, nullptr, nullptr);
|
|
event->InitEvent(NS_LITERAL_STRING("endmodalstate"), true, false);
|
|
event->SetTrusted(true);
|
|
event->WidgetEventPtr()->mFlags.mOnlyChromeDispatch = true;
|
|
bool dummy;
|
|
topWin->DispatchEvent(event, &dummy);
|
|
}
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::IsInModalState()
|
|
{
|
|
nsGlobalWindow *topWin = GetScriptableTopInternal();
|
|
|
|
if (!topWin) {
|
|
// IsInModalState() getting called w/o a reachable top window is a bit
|
|
// iffy, but valid enough not to make noise about it. See bug 404828
|
|
return false;
|
|
}
|
|
|
|
return topWin->mModalStateDepth != 0;
|
|
}
|
|
|
|
// static
|
|
void
|
|
nsGlobalWindow::NotifyDOMWindowDestroyed(nsGlobalWindow* aWindow) {
|
|
nsCOMPtr<nsIObserverService> observerService =
|
|
services::GetObserverService();
|
|
if (observerService) {
|
|
observerService->
|
|
NotifyObservers(ToSupports(aWindow),
|
|
DOM_WINDOW_DESTROYED_TOPIC, nullptr);
|
|
}
|
|
}
|
|
|
|
// Try to match compartments that are not web content by matching compartments
|
|
// with principals that are either the system principal or an expanded principal.
|
|
// This may not return true for all non-web-content compartments.
|
|
struct BrowserCompartmentMatcher : public js::CompartmentFilter {
|
|
bool match(JSCompartment* aC) const override
|
|
{
|
|
nsCOMPtr<nsIPrincipal> pc = nsJSPrincipals::get(JS_GetCompartmentPrincipals(aC));
|
|
return nsContentUtils::IsSystemOrExpandedPrincipal(pc);
|
|
}
|
|
};
|
|
|
|
|
|
class WindowDestroyedEvent final : public Runnable
|
|
{
|
|
public:
|
|
WindowDestroyedEvent(nsIDOMWindow* aWindow, uint64_t aID, const char* aTopic)
|
|
: mozilla::Runnable("WindowDestroyedEvent")
|
|
, mID(aID)
|
|
, mPhase(Phase::Destroying)
|
|
, mTopic(aTopic)
|
|
{
|
|
mWindow = do_GetWeakReference(aWindow);
|
|
}
|
|
|
|
enum class Phase
|
|
{
|
|
Destroying,
|
|
Nuking
|
|
};
|
|
|
|
NS_IMETHOD Run() override
|
|
{
|
|
AUTO_PROFILER_LABEL("WindowDestroyedEvent::Run", OTHER);
|
|
|
|
nsCOMPtr<nsIObserverService> observerService =
|
|
services::GetObserverService();
|
|
if (!observerService) {
|
|
return NS_OK;
|
|
}
|
|
|
|
nsCOMPtr<nsISupportsPRUint64> wrapper =
|
|
do_CreateInstance(NS_SUPPORTS_PRUINT64_CONTRACTID);
|
|
if (wrapper) {
|
|
wrapper->SetData(mID);
|
|
observerService->NotifyObservers(wrapper, mTopic.get(), nullptr);
|
|
}
|
|
|
|
switch (mPhase) {
|
|
case Phase::Destroying:
|
|
{
|
|
bool skipNukeCrossCompartment = false;
|
|
#ifndef DEBUG
|
|
nsCOMPtr<nsIAppStartup> appStartup =
|
|
do_GetService(NS_APPSTARTUP_CONTRACTID);
|
|
|
|
if (appStartup) {
|
|
appStartup->GetShuttingDown(&skipNukeCrossCompartment);
|
|
}
|
|
#endif
|
|
|
|
if (!skipNukeCrossCompartment) {
|
|
// The compartment nuking phase might be too expensive, so do that
|
|
// part off of idle dispatch.
|
|
|
|
// For the compartment nuking phase, we dispatch either an
|
|
// inner-window-nuked or an outer-window-nuked notification.
|
|
// This will allow tests to wait for compartment nuking to happen.
|
|
if (mTopic.EqualsLiteral("inner-window-destroyed")) {
|
|
mTopic.AssignLiteral("inner-window-nuked");
|
|
} else if (mTopic.EqualsLiteral("outer-window-destroyed")) {
|
|
mTopic.AssignLiteral("outer-window-nuked");
|
|
}
|
|
mPhase = Phase::Nuking;
|
|
|
|
nsCOMPtr<nsIRunnable> copy(this);
|
|
NS_IdleDispatchToCurrentThread(copy.forget(), 1000);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case Phase::Nuking:
|
|
{
|
|
nsCOMPtr<nsISupports> window = do_QueryReferent(mWindow);
|
|
if (window) {
|
|
nsGlobalWindow* win = nsGlobalWindow::FromSupports(window);
|
|
nsGlobalWindow* currentInner = win->IsInnerWindow() ? win : win->GetCurrentInnerWindowInternal();
|
|
NS_ENSURE_TRUE(currentInner, NS_OK);
|
|
|
|
AutoSafeJSContext cx;
|
|
JS::Rooted<JSObject*> obj(cx, currentInner->FastGetGlobalJSObject());
|
|
if (obj && !js::IsSystemCompartment(js::GetObjectCompartment(obj))) {
|
|
JSCompartment* cpt = js::GetObjectCompartment(obj);
|
|
nsCOMPtr<nsIPrincipal> pc = nsJSPrincipals::get(JS_GetCompartmentPrincipals(cpt));
|
|
|
|
if (BasePrincipal::Cast(pc)->AddonPolicy()) {
|
|
// We want to nuke all references to the add-on compartment.
|
|
xpc::NukeAllWrappersForCompartment(cx, cpt,
|
|
win->IsInnerWindow() ? js::DontNukeWindowReferences
|
|
: js::NukeWindowReferences);
|
|
} else {
|
|
// We only want to nuke wrappers for the chrome->content case
|
|
js::NukeCrossCompartmentWrappers(cx, BrowserCompartmentMatcher(), cpt,
|
|
win->IsInnerWindow() ? js::DontNukeWindowReferences
|
|
: js::NukeWindowReferences,
|
|
js::NukeIncomingReferences);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
private:
|
|
uint64_t mID;
|
|
Phase mPhase;
|
|
nsCString mTopic;
|
|
nsWeakPtr mWindow;
|
|
};
|
|
|
|
void
|
|
nsGlobalWindow::NotifyWindowIDDestroyed(const char* aTopic)
|
|
{
|
|
nsCOMPtr<nsIRunnable> runnable = new WindowDestroyedEvent(this, mWindowID, aTopic);
|
|
nsresult rv = Dispatch(TaskCategory::Other, runnable.forget());
|
|
if (NS_SUCCEEDED(rv)) {
|
|
mNotifiedIDDestroyed = true;
|
|
}
|
|
}
|
|
|
|
// static
|
|
void
|
|
nsGlobalWindow::NotifyDOMWindowFrozen(nsGlobalWindow* aWindow) {
|
|
if (aWindow && aWindow->IsInnerWindow()) {
|
|
nsCOMPtr<nsIObserverService> observerService =
|
|
services::GetObserverService();
|
|
if (observerService) {
|
|
observerService->
|
|
NotifyObservers(ToSupports(aWindow),
|
|
DOM_WINDOW_FROZEN_TOPIC, nullptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
// static
|
|
void
|
|
nsGlobalWindow::NotifyDOMWindowThawed(nsGlobalWindow* aWindow) {
|
|
if (aWindow && aWindow->IsInnerWindow()) {
|
|
nsCOMPtr<nsIObserverService> observerService =
|
|
services::GetObserverService();
|
|
if (observerService) {
|
|
observerService->
|
|
NotifyObservers(ToSupports(aWindow),
|
|
DOM_WINDOW_THAWED_TOPIC, nullptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
JSObject*
|
|
nsGlobalWindow::GetCachedXBLPrototypeHandler(nsXBLPrototypeHandler* aKey)
|
|
{
|
|
JS::Rooted<JSObject*> handler(RootingCx());
|
|
if (mCachedXBLPrototypeHandlers) {
|
|
mCachedXBLPrototypeHandlers->Get(aKey, handler.address());
|
|
}
|
|
return handler;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::CacheXBLPrototypeHandler(nsXBLPrototypeHandler* aKey,
|
|
JS::Handle<JSObject*> aHandler)
|
|
{
|
|
if (!mCachedXBLPrototypeHandlers) {
|
|
mCachedXBLPrototypeHandlers = MakeUnique<XBLPrototypeHandlerTable>();
|
|
PreserveWrapper(ToSupports(this));
|
|
}
|
|
|
|
mCachedXBLPrototypeHandlers->Put(aKey, aHandler);
|
|
}
|
|
|
|
Element*
|
|
nsGlobalWindow::GetFrameElementOuter(nsIPrincipal& aSubjectPrincipal)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDocShell || mDocShell->GetIsMozBrowser()) {
|
|
return nullptr;
|
|
}
|
|
|
|
// Per HTML5, the frameElement getter returns null in cross-origin situations.
|
|
Element* element = GetRealFrameElementOuter();
|
|
if (!element) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (!aSubjectPrincipal.SubsumesConsideringDomain(element->NodePrincipal())) {
|
|
return nullptr;
|
|
}
|
|
|
|
return element;
|
|
}
|
|
|
|
Element*
|
|
nsGlobalWindow::GetFrameElement(nsIPrincipal& aSubjectPrincipal,
|
|
ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetFrameElementOuter, (aSubjectPrincipal), aError,
|
|
nullptr);
|
|
}
|
|
|
|
Element*
|
|
nsGlobalWindow::GetRealFrameElementOuter()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDocShell) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsCOMPtr<nsIDocShell> parent;
|
|
mDocShell->GetSameTypeParentIgnoreBrowserBoundaries(getter_AddRefs(parent));
|
|
|
|
if (!parent || parent == mDocShell) {
|
|
// We're at a chrome boundary, don't expose the chrome iframe
|
|
// element to content code.
|
|
return nullptr;
|
|
}
|
|
|
|
return mFrameElement;
|
|
}
|
|
|
|
Element*
|
|
nsGlobalWindow::GetRealFrameElement(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetRealFrameElementOuter, (), aError, nullptr);
|
|
}
|
|
|
|
/**
|
|
* nsIGlobalWindow::GetFrameElement (when called from C++) is just a wrapper
|
|
* around GetRealFrameElement.
|
|
*/
|
|
already_AddRefed<nsIDOMElement>
|
|
nsGlobalWindow::GetFrameElement()
|
|
{
|
|
FORWARD_TO_INNER(GetFrameElement, (), nullptr);
|
|
|
|
ErrorResult dummy;
|
|
nsCOMPtr<nsIDOMElement> frameElement =
|
|
do_QueryInterface(GetRealFrameElement(dummy));
|
|
dummy.SuppressException();
|
|
return frameElement.forget();
|
|
}
|
|
|
|
/* static */ bool
|
|
nsGlobalWindow::TokenizeDialogOptions(nsAString& aToken,
|
|
nsAString::const_iterator& aIter,
|
|
nsAString::const_iterator aEnd)
|
|
{
|
|
while (aIter != aEnd && nsCRT::IsAsciiSpace(*aIter)) {
|
|
++aIter;
|
|
}
|
|
|
|
if (aIter == aEnd) {
|
|
return false;
|
|
}
|
|
|
|
if (*aIter == ';' || *aIter == ':' || *aIter == '=') {
|
|
aToken.Assign(*aIter);
|
|
++aIter;
|
|
return true;
|
|
}
|
|
|
|
nsAString::const_iterator start = aIter;
|
|
|
|
// Skip characters until we find whitespace, ';', ':', or '='
|
|
while (aIter != aEnd && !nsCRT::IsAsciiSpace(*aIter) &&
|
|
*aIter != ';' &&
|
|
*aIter != ':' &&
|
|
*aIter != '=') {
|
|
++aIter;
|
|
}
|
|
|
|
aToken.Assign(Substring(start, aIter));
|
|
return true;
|
|
}
|
|
|
|
// Helper for converting window.showModalDialog() options (list of ';'
|
|
// separated name (:|=) value pairs) to a format that's parsable by
|
|
// our normal window opening code.
|
|
|
|
/* static */
|
|
void
|
|
nsGlobalWindow::ConvertDialogOptions(const nsAString& aOptions,
|
|
nsAString& aResult)
|
|
{
|
|
nsAString::const_iterator end;
|
|
aOptions.EndReading(end);
|
|
|
|
nsAString::const_iterator iter;
|
|
aOptions.BeginReading(iter);
|
|
|
|
nsAutoString token;
|
|
nsAutoString name;
|
|
nsAutoString value;
|
|
|
|
while (true) {
|
|
if (!TokenizeDialogOptions(name, iter, end)) {
|
|
break;
|
|
}
|
|
|
|
// Invalid name.
|
|
if (name.EqualsLiteral("=") ||
|
|
name.EqualsLiteral(":") ||
|
|
name.EqualsLiteral(";")) {
|
|
break;
|
|
}
|
|
|
|
if (!TokenizeDialogOptions(token, iter, end)) {
|
|
break;
|
|
}
|
|
|
|
if (!token.EqualsLiteral(":") && !token.EqualsLiteral("=")) {
|
|
continue;
|
|
}
|
|
|
|
// We found name followed by ':' or '='. Look for a value.
|
|
if (!TokenizeDialogOptions(value, iter, end)) {
|
|
break;
|
|
}
|
|
|
|
if (name.LowerCaseEqualsLiteral("center")) {
|
|
if (value.LowerCaseEqualsLiteral("on") ||
|
|
value.LowerCaseEqualsLiteral("yes") ||
|
|
value.LowerCaseEqualsLiteral("1")) {
|
|
aResult.AppendLiteral(",centerscreen=1");
|
|
}
|
|
} else if (name.LowerCaseEqualsLiteral("dialogwidth")) {
|
|
if (!value.IsEmpty()) {
|
|
aResult.AppendLiteral(",width=");
|
|
aResult.Append(value);
|
|
}
|
|
} else if (name.LowerCaseEqualsLiteral("dialogheight")) {
|
|
if (!value.IsEmpty()) {
|
|
aResult.AppendLiteral(",height=");
|
|
aResult.Append(value);
|
|
}
|
|
} else if (name.LowerCaseEqualsLiteral("dialogtop")) {
|
|
if (!value.IsEmpty()) {
|
|
aResult.AppendLiteral(",top=");
|
|
aResult.Append(value);
|
|
}
|
|
} else if (name.LowerCaseEqualsLiteral("dialogleft")) {
|
|
if (!value.IsEmpty()) {
|
|
aResult.AppendLiteral(",left=");
|
|
aResult.Append(value);
|
|
}
|
|
} else if (name.LowerCaseEqualsLiteral("resizable")) {
|
|
if (value.LowerCaseEqualsLiteral("on") ||
|
|
value.LowerCaseEqualsLiteral("yes") ||
|
|
value.LowerCaseEqualsLiteral("1")) {
|
|
aResult.AppendLiteral(",resizable=1");
|
|
}
|
|
} else if (name.LowerCaseEqualsLiteral("scroll")) {
|
|
if (value.LowerCaseEqualsLiteral("off") ||
|
|
value.LowerCaseEqualsLiteral("no") ||
|
|
value.LowerCaseEqualsLiteral("0")) {
|
|
aResult.AppendLiteral(",scrollbars=0");
|
|
}
|
|
}
|
|
|
|
if (iter == end ||
|
|
!TokenizeDialogOptions(token, iter, end) ||
|
|
!token.EqualsLiteral(";")) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
class ChildCommandDispatcher : public Runnable
|
|
{
|
|
public:
|
|
ChildCommandDispatcher(nsGlobalWindow* aWindow,
|
|
nsITabChild* aTabChild,
|
|
const nsAString& aAction)
|
|
: mozilla::Runnable("ChildCommandDispatcher")
|
|
, mWindow(aWindow)
|
|
, mTabChild(aTabChild)
|
|
, mAction(aAction)
|
|
{
|
|
}
|
|
|
|
NS_IMETHOD Run() override
|
|
{
|
|
nsCOMPtr<nsPIWindowRoot> root = mWindow->GetTopWindowRoot();
|
|
if (!root) {
|
|
return NS_OK;
|
|
}
|
|
|
|
nsTArray<nsCString> enabledCommands, disabledCommands;
|
|
root->GetEnabledDisabledCommands(enabledCommands, disabledCommands);
|
|
if (enabledCommands.Length() || disabledCommands.Length()) {
|
|
mTabChild->EnableDisableCommands(mAction, enabledCommands, disabledCommands);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
private:
|
|
RefPtr<nsGlobalWindow> mWindow;
|
|
nsCOMPtr<nsITabChild> mTabChild;
|
|
nsString mAction;
|
|
};
|
|
|
|
class CommandDispatcher : public Runnable
|
|
{
|
|
public:
|
|
CommandDispatcher(nsIDOMXULCommandDispatcher* aDispatcher,
|
|
const nsAString& aAction)
|
|
: mozilla::Runnable("CommandDispatcher")
|
|
, mDispatcher(aDispatcher)
|
|
, mAction(aAction)
|
|
{
|
|
}
|
|
|
|
NS_IMETHOD Run() override
|
|
{
|
|
return mDispatcher->UpdateCommands(mAction);
|
|
}
|
|
|
|
nsCOMPtr<nsIDOMXULCommandDispatcher> mDispatcher;
|
|
nsString mAction;
|
|
};
|
|
|
|
nsresult
|
|
nsGlobalWindow::UpdateCommands(const nsAString& anAction, nsISelection* aSel, int16_t aReason)
|
|
{
|
|
// If this is a child process, redirect to the parent process.
|
|
if (nsIDocShell* docShell = GetDocShell()) {
|
|
if (nsCOMPtr<nsITabChild> child = docShell->GetTabChild()) {
|
|
nsContentUtils::AddScriptRunner(new ChildCommandDispatcher(this, child,
|
|
anAction));
|
|
return NS_OK;
|
|
}
|
|
}
|
|
|
|
nsPIDOMWindowOuter *rootWindow = nsGlobalWindow::GetPrivateRoot();
|
|
if (!rootWindow)
|
|
return NS_OK;
|
|
|
|
nsCOMPtr<nsIDOMXULDocument> xulDoc =
|
|
do_QueryInterface(rootWindow->GetExtantDoc());
|
|
// See if we contain a XUL document.
|
|
// selectionchange action is only used for mozbrowser, not for XUL. So we bypass
|
|
// XUL command dispatch if anAction is "selectionchange".
|
|
if (xulDoc && !anAction.EqualsLiteral("selectionchange")) {
|
|
// Retrieve the command dispatcher and call updateCommands on it.
|
|
nsCOMPtr<nsIDOMXULCommandDispatcher> xulCommandDispatcher;
|
|
xulDoc->GetCommandDispatcher(getter_AddRefs(xulCommandDispatcher));
|
|
if (xulCommandDispatcher) {
|
|
nsContentUtils::AddScriptRunner(new CommandDispatcher(xulCommandDispatcher,
|
|
anAction));
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
Selection*
|
|
nsGlobalWindow::GetSelectionOuter()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDocShell) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsCOMPtr<nsIPresShell> presShell = mDocShell->GetPresShell();
|
|
if (!presShell) {
|
|
return nullptr;
|
|
}
|
|
nsISelection* domSelection =
|
|
presShell->GetCurrentSelection(SelectionType::eNormal);
|
|
return domSelection ? domSelection->AsSelection() : nullptr;
|
|
}
|
|
|
|
Selection*
|
|
nsGlobalWindow::GetSelection(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetSelectionOuter, (), aError, nullptr);
|
|
}
|
|
|
|
already_AddRefed<nsISelection>
|
|
nsGlobalWindow::GetSelection()
|
|
{
|
|
nsCOMPtr<nsISelection> selection = GetSelectionOuter();
|
|
return selection.forget();
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::FindOuter(const nsAString& aString, bool aCaseSensitive,
|
|
bool aBackwards, bool aWrapAround, bool aWholeWord,
|
|
bool aSearchInFrames, bool aShowDialog,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
Unused << aShowDialog;
|
|
|
|
if (Preferences::GetBool("dom.disable_window_find", false)) {
|
|
aError.Throw(NS_ERROR_NOT_AVAILABLE);
|
|
return false;
|
|
}
|
|
|
|
nsCOMPtr<nsIWebBrowserFind> finder(do_GetInterface(mDocShell));
|
|
if (!finder) {
|
|
aError.Throw(NS_ERROR_NOT_AVAILABLE);
|
|
return false;
|
|
}
|
|
|
|
// Set the options of the search
|
|
aError = finder->SetSearchString(PromiseFlatString(aString).get());
|
|
if (aError.Failed()) {
|
|
return false;
|
|
}
|
|
finder->SetMatchCase(aCaseSensitive);
|
|
finder->SetFindBackwards(aBackwards);
|
|
finder->SetWrapFind(aWrapAround);
|
|
finder->SetEntireWord(aWholeWord);
|
|
finder->SetSearchFrames(aSearchInFrames);
|
|
|
|
// the nsIWebBrowserFind is initialized to use this window
|
|
// as the search root, but uses focus to set the current search
|
|
// frame. If we're being called from JS (as here), this window
|
|
// should be the current search frame.
|
|
nsCOMPtr<nsIWebBrowserFindInFrames> framesFinder(do_QueryInterface(finder));
|
|
if (framesFinder) {
|
|
framesFinder->SetRootSearchFrame(AsOuter()); // paranoia
|
|
framesFinder->SetCurrentSearchFrame(AsOuter());
|
|
}
|
|
|
|
if (aString.IsEmpty()) {
|
|
return false;
|
|
}
|
|
|
|
// Launch the search with the passed in search string
|
|
bool didFind = false;
|
|
aError = finder->FindNext(&didFind);
|
|
return didFind;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::Find(const nsAString& aString, bool aCaseSensitive,
|
|
bool aBackwards, bool aWrapAround, bool aWholeWord,
|
|
bool aSearchInFrames, bool aShowDialog,
|
|
ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(FindOuter,
|
|
(aString, aCaseSensitive, aBackwards, aWrapAround,
|
|
aWholeWord, aSearchInFrames, aShowDialog, aError),
|
|
aError, false);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetOrigin(nsAString& aOrigin)
|
|
{
|
|
MOZ_DIAGNOSTIC_ASSERT(IsInnerWindow());
|
|
nsContentUtils::GetUTFOrigin(GetPrincipal(), aOrigin);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Atob(const nsAString& aAsciiBase64String,
|
|
nsAString& aBinaryData, ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
aError = nsContentUtils::Atob(aAsciiBase64String, aBinaryData);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Btoa(const nsAString& aBinaryData,
|
|
nsAString& aAsciiBase64String, ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
aError = nsContentUtils::Btoa(aBinaryData, aAsciiBase64String);
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// nsGlobalWindow::nsIDOMEventTarget
|
|
//*****************************************************************************
|
|
|
|
nsPIDOMWindowOuter*
|
|
nsGlobalWindow::GetOwnerGlobalForBindings()
|
|
{
|
|
if (IsOuterWindow()) {
|
|
return AsOuter();
|
|
}
|
|
|
|
return nsPIDOMWindowOuter::GetFromCurrentInner(AsInner());
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsGlobalWindow::RemoveEventListener(const nsAString& aType,
|
|
nsIDOMEventListener* aListener,
|
|
bool aUseCapture)
|
|
{
|
|
if (RefPtr<EventListenerManager> elm = GetExistingListenerManager()) {
|
|
elm->RemoveEventListener(aType, aListener, aUseCapture);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMPL_REMOVE_SYSTEM_EVENT_LISTENER(nsGlobalWindow)
|
|
|
|
NS_IMETHODIMP
|
|
nsGlobalWindow::DispatchEvent(nsIDOMEvent* aEvent, bool* aRetVal)
|
|
{
|
|
FORWARD_TO_INNER(DispatchEvent, (aEvent, aRetVal), NS_OK);
|
|
|
|
if (!AsInner()->IsCurrentInnerWindow()) {
|
|
NS_WARNING("DispatchEvent called on non-current inner window, dropping. "
|
|
"Please check the window in the caller instead.");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (!mDoc) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// Obtain a presentation shell
|
|
nsIPresShell *shell = mDoc->GetShell();
|
|
RefPtr<nsPresContext> presContext;
|
|
if (shell) {
|
|
// Retrieve the context
|
|
presContext = shell->GetPresContext();
|
|
}
|
|
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
nsresult rv = EventDispatcher::DispatchDOMEvent(AsInner(), nullptr, aEvent,
|
|
presContext, &status);
|
|
|
|
*aRetVal = (status != nsEventStatus_eConsumeNoDefault);
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsGlobalWindow::AddEventListener(const nsAString& aType,
|
|
nsIDOMEventListener *aListener,
|
|
bool aUseCapture, bool aWantsUntrusted,
|
|
uint8_t aOptionalArgc)
|
|
{
|
|
NS_ASSERTION(!aWantsUntrusted || aOptionalArgc > 1,
|
|
"Won't check if this is chrome, you want to set "
|
|
"aWantsUntrusted to false or make the aWantsUntrusted "
|
|
"explicit by making optional_argc non-zero.");
|
|
|
|
if (!aWantsUntrusted &&
|
|
(aOptionalArgc < 2 && !nsContentUtils::IsChromeDoc(mDoc))) {
|
|
aWantsUntrusted = true;
|
|
}
|
|
|
|
EventListenerManager* manager = GetOrCreateListenerManager();
|
|
NS_ENSURE_STATE(manager);
|
|
manager->AddEventListener(aType, aListener, aUseCapture, aWantsUntrusted);
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::AddEventListener(const nsAString& aType,
|
|
EventListener* aListener,
|
|
const AddEventListenerOptionsOrBoolean& aOptions,
|
|
const Nullable<bool>& aWantsUntrusted,
|
|
ErrorResult& aRv)
|
|
{
|
|
if (IsOuterWindow() && mInnerWindow &&
|
|
!nsContentUtils::CanCallerAccess(mInnerWindow)) {
|
|
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
|
|
return;
|
|
}
|
|
|
|
bool wantsUntrusted;
|
|
if (aWantsUntrusted.IsNull()) {
|
|
wantsUntrusted = !nsContentUtils::IsChromeDoc(mDoc);
|
|
} else {
|
|
wantsUntrusted = aWantsUntrusted.Value();
|
|
}
|
|
|
|
EventListenerManager* manager = GetOrCreateListenerManager();
|
|
if (!manager) {
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return;
|
|
}
|
|
|
|
manager->AddEventListener(aType, aListener, aOptions, wantsUntrusted);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsGlobalWindow::AddSystemEventListener(const nsAString& aType,
|
|
nsIDOMEventListener *aListener,
|
|
bool aUseCapture,
|
|
bool aWantsUntrusted,
|
|
uint8_t aOptionalArgc)
|
|
{
|
|
NS_ASSERTION(!aWantsUntrusted || aOptionalArgc > 1,
|
|
"Won't check if this is chrome, you want to set "
|
|
"aWantsUntrusted to false or make the aWantsUntrusted "
|
|
"explicit by making optional_argc non-zero.");
|
|
|
|
if (IsOuterWindow() && mInnerWindow &&
|
|
!nsContentUtils::LegacyIsCallerNativeCode() &&
|
|
!nsContentUtils::CanCallerAccess(mInnerWindow)) {
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
}
|
|
|
|
if (!aWantsUntrusted &&
|
|
(aOptionalArgc < 2 && !nsContentUtils::IsChromeDoc(mDoc))) {
|
|
aWantsUntrusted = true;
|
|
}
|
|
|
|
return NS_AddSystemEventListener(this, aType, aListener, aUseCapture,
|
|
aWantsUntrusted);
|
|
}
|
|
|
|
EventListenerManager*
|
|
nsGlobalWindow::GetOrCreateListenerManager()
|
|
{
|
|
FORWARD_TO_INNER_CREATE(GetOrCreateListenerManager, (), nullptr);
|
|
|
|
if (!mListenerManager) {
|
|
mListenerManager =
|
|
new EventListenerManager(static_cast<EventTarget*>(this));
|
|
}
|
|
|
|
return mListenerManager;
|
|
}
|
|
|
|
EventListenerManager*
|
|
nsGlobalWindow::GetExistingListenerManager() const
|
|
{
|
|
FORWARD_TO_INNER(GetExistingListenerManager, (), nullptr);
|
|
|
|
return mListenerManager;
|
|
}
|
|
|
|
nsIScriptContext*
|
|
nsGlobalWindow::GetContextForEventHandlers(nsresult* aRv)
|
|
{
|
|
*aRv = NS_ERROR_UNEXPECTED;
|
|
NS_ENSURE_TRUE(!IsInnerWindow() || AsInner()->IsCurrentInnerWindow(), nullptr);
|
|
|
|
nsIScriptContext* scx;
|
|
if ((scx = GetContext())) {
|
|
*aRv = NS_OK;
|
|
return scx;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// nsGlobalWindow::nsPIDOMWindow
|
|
//*****************************************************************************
|
|
|
|
nsPIDOMWindowOuter*
|
|
nsGlobalWindow::GetPrivateParent()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> parent = GetParent();
|
|
|
|
if (AsOuter() == parent) {
|
|
nsCOMPtr<nsIContent> chromeElement(do_QueryInterface(mChromeEventHandler));
|
|
if (!chromeElement)
|
|
return nullptr; // This is ok, just means a null parent.
|
|
|
|
nsIDocument* doc = chromeElement->GetComposedDoc();
|
|
if (!doc)
|
|
return nullptr; // This is ok, just means a null parent.
|
|
|
|
return doc->GetWindow();
|
|
}
|
|
|
|
return parent;
|
|
}
|
|
|
|
nsPIDOMWindowOuter*
|
|
nsGlobalWindow::GetPrivateRoot()
|
|
{
|
|
if (IsInnerWindow()) {
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
if (!outer) {
|
|
NS_WARNING("No outer window available!");
|
|
return nullptr;
|
|
}
|
|
return outer->GetPrivateRoot();
|
|
}
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> top = GetTop();
|
|
|
|
nsCOMPtr<nsIContent> chromeElement(do_QueryInterface(mChromeEventHandler));
|
|
if (chromeElement) {
|
|
nsIDocument* doc = chromeElement->GetComposedDoc();
|
|
if (doc) {
|
|
nsCOMPtr<nsPIDOMWindowOuter> parent = doc->GetWindow();
|
|
if (parent) {
|
|
top = parent->GetTop();
|
|
}
|
|
}
|
|
}
|
|
|
|
return top;
|
|
}
|
|
|
|
Location*
|
|
nsGlobalWindow::GetLocation()
|
|
{
|
|
// This method can be called on the outer window as well.
|
|
FORWARD_TO_INNER(GetLocation, (), nullptr);
|
|
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mLocation) {
|
|
mLocation = new dom::Location(AsInner(), GetDocShell());
|
|
}
|
|
|
|
return mLocation;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ActivateOrDeactivate(bool aActivate)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDoc) {
|
|
return;
|
|
}
|
|
|
|
// Set / unset mIsActive on the top level window, which is used for the
|
|
// :-moz-window-inactive pseudoclass, and its sheet (if any).
|
|
nsCOMPtr<nsIWidget> mainWidget = GetMainWidget();
|
|
nsCOMPtr<nsIWidget> topLevelWidget;
|
|
if (mainWidget) {
|
|
// Get the top level widget (if the main widget is a sheet, this will
|
|
// be the sheet's top (non-sheet) parent).
|
|
topLevelWidget = mainWidget->GetSheetWindowParent();
|
|
if (!topLevelWidget) {
|
|
topLevelWidget = mainWidget;
|
|
}
|
|
}
|
|
|
|
SetActive(aActivate);
|
|
|
|
if (mainWidget != topLevelWidget) {
|
|
// This is a workaround for the following problem:
|
|
// When a window with an open sheet gains or loses focus, only the sheet
|
|
// window receives the NS_ACTIVATE/NS_DEACTIVATE event. However the
|
|
// styling of the containing top level window also needs to change. We
|
|
// get around this by calling nsPIDOMWindow::SetActive() on both windows.
|
|
|
|
// Get the top level widget's nsGlobalWindow
|
|
nsCOMPtr<nsPIDOMWindowOuter> topLevelWindow;
|
|
|
|
// widgetListener should be a nsXULWindow
|
|
nsIWidgetListener* listener = topLevelWidget->GetWidgetListener();
|
|
if (listener) {
|
|
nsCOMPtr<nsIXULWindow> window = listener->GetXULWindow();
|
|
nsCOMPtr<nsIInterfaceRequestor> req(do_QueryInterface(window));
|
|
topLevelWindow = do_GetInterface(req);
|
|
}
|
|
|
|
if (topLevelWindow) {
|
|
topLevelWindow->SetActive(aActivate);
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool
|
|
NotifyDocumentTree(nsIDocument* aDocument, void* aData)
|
|
{
|
|
aDocument->EnumerateSubDocuments(NotifyDocumentTree, nullptr);
|
|
aDocument->DocumentStatesChanged(NS_DOCUMENT_STATE_WINDOW_INACTIVE);
|
|
return true;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetActive(bool aActive)
|
|
{
|
|
nsPIDOMWindow::SetActive(aActive);
|
|
if (mDoc) {
|
|
NotifyDocumentTree(mDoc, nullptr);
|
|
}
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::IsTopLevelWindowActive()
|
|
{
|
|
nsCOMPtr<nsIDocShellTreeItem> treeItem(GetDocShell());
|
|
if (!treeItem) {
|
|
return false;
|
|
}
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> rootItem;
|
|
treeItem->GetRootTreeItem(getter_AddRefs(rootItem));
|
|
if (!rootItem) {
|
|
return false;
|
|
}
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> domWindow = rootItem->GetWindow();
|
|
return domWindow && domWindow->IsActive();
|
|
}
|
|
|
|
void nsGlobalWindow::SetIsBackground(bool aIsBackground)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
bool changed = aIsBackground != AsOuter()->IsBackground();
|
|
SetIsBackgroundInternal(aIsBackground);
|
|
|
|
nsGlobalWindow* inner = GetCurrentInnerWindowInternal();
|
|
|
|
if (inner && changed) {
|
|
inner->mTimeoutManager->UpdateBackgroundState();
|
|
}
|
|
|
|
if (aIsBackground) {
|
|
// Notify gamepadManager we are at the background window,
|
|
// we need to stop vibrate.
|
|
if (inner) {
|
|
inner->StopGamepadHaptics();
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (inner) {
|
|
inner->SyncGamepadState();
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetIsBackgroundInternal(bool aIsBackground)
|
|
{
|
|
if (mIsBackground != aIsBackground) {
|
|
TabGroup()->WindowChangedBackgroundStatus(aIsBackground);
|
|
}
|
|
mIsBackground = aIsBackground;
|
|
}
|
|
|
|
void nsGlobalWindow::MaybeUpdateTouchState()
|
|
{
|
|
FORWARD_TO_INNER_VOID(MaybeUpdateTouchState, ());
|
|
|
|
if (mMayHaveTouchEventListener) {
|
|
nsCOMPtr<nsIObserverService> observerService =
|
|
services::GetObserverService();
|
|
|
|
if (observerService) {
|
|
observerService->NotifyObservers(static_cast<nsIDOMWindow*>(this),
|
|
DOM_TOUCH_LISTENER_ADDED,
|
|
nullptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::EnableGamepadUpdates()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
if (mHasGamepad) {
|
|
RefPtr<GamepadManager> gamepadManager(GamepadManager::GetService());
|
|
if (gamepadManager) {
|
|
gamepadManager->AddListener(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::DisableGamepadUpdates()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
if (mHasGamepad) {
|
|
RefPtr<GamepadManager> gamepadManager(GamepadManager::GetService());
|
|
if (gamepadManager) {
|
|
gamepadManager->RemoveListener(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::EnableVRUpdates()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
if (mHasVREvents && !mVREventObserver) {
|
|
mVREventObserver = new VREventObserver(this);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::DisableVRUpdates()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
if (mVREventObserver) {
|
|
mVREventObserver->DisconnectFromOwner();
|
|
mVREventObserver = nullptr;
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetChromeEventHandler(EventTarget* aChromeEventHandler)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
SetChromeEventHandlerInternal(aChromeEventHandler);
|
|
// update the chrome event handler on all our inner windows
|
|
for (nsGlobalWindow *inner = (nsGlobalWindow *)PR_LIST_HEAD(this);
|
|
inner != this;
|
|
inner = (nsGlobalWindow*)PR_NEXT_LINK(inner)) {
|
|
NS_ASSERTION(!inner->mOuterWindow || inner->mOuterWindow == AsOuter(),
|
|
"bad outer window pointer");
|
|
inner->SetChromeEventHandlerInternal(aChromeEventHandler);
|
|
}
|
|
}
|
|
|
|
static bool IsLink(nsIContent* aContent)
|
|
{
|
|
return aContent && (aContent->IsHTMLElement(nsGkAtoms::a) ||
|
|
aContent->AttrValueIs(kNameSpaceID_XLink, nsGkAtoms::type,
|
|
nsGkAtoms::simple, eCaseMatters));
|
|
}
|
|
|
|
static bool ShouldShowFocusRingIfFocusedByMouse(nsIContent* aNode)
|
|
{
|
|
if (!aNode) {
|
|
return true;
|
|
}
|
|
return !IsLink(aNode) &&
|
|
!aNode->IsAnyOfHTMLElements(nsGkAtoms::video, nsGkAtoms::audio);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetFocusedNode(nsIContent* aNode,
|
|
uint32_t aFocusMethod,
|
|
bool aNeedsFocus)
|
|
{
|
|
FORWARD_TO_INNER_VOID(SetFocusedNode, (aNode, aFocusMethod, aNeedsFocus));
|
|
|
|
if (aNode && aNode->GetComposedDoc() != mDoc) {
|
|
NS_WARNING("Trying to set focus to a node from a wrong document");
|
|
return;
|
|
}
|
|
|
|
if (mCleanedUp) {
|
|
NS_ASSERTION(!aNode, "Trying to focus cleaned up window!");
|
|
aNode = nullptr;
|
|
aNeedsFocus = false;
|
|
}
|
|
if (mFocusedNode != aNode) {
|
|
UpdateCanvasFocus(false, aNode);
|
|
mFocusedNode = aNode;
|
|
mFocusMethod = aFocusMethod & FOCUSMETHOD_MASK;
|
|
mShowFocusRingForContent = false;
|
|
}
|
|
|
|
if (mFocusedNode) {
|
|
// if a node was focused by a keypress, turn on focus rings for the
|
|
// window.
|
|
if (mFocusMethod & nsIFocusManager::FLAG_BYKEY) {
|
|
mFocusByKeyOccurred = true;
|
|
} else if (
|
|
// otherwise, we set mShowFocusRingForContent, as we don't want this to
|
|
// be permanent for the window. On Windows, focus rings are only shown
|
|
// when the FLAG_SHOWRING flag is used. On other platforms, focus rings
|
|
// are only visible on some elements.
|
|
#ifndef XP_WIN
|
|
!(mFocusMethod & nsIFocusManager::FLAG_BYMOUSE) ||
|
|
ShouldShowFocusRingIfFocusedByMouse(aNode) ||
|
|
#endif
|
|
aFocusMethod & nsIFocusManager::FLAG_SHOWRING) {
|
|
mShowFocusRingForContent = true;
|
|
}
|
|
}
|
|
|
|
if (aNeedsFocus)
|
|
mNeedsFocus = aNeedsFocus;
|
|
}
|
|
|
|
uint32_t
|
|
nsGlobalWindow::GetFocusMethod()
|
|
{
|
|
FORWARD_TO_INNER(GetFocusMethod, (), 0);
|
|
|
|
return mFocusMethod;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::ShouldShowFocusRing()
|
|
{
|
|
FORWARD_TO_INNER(ShouldShowFocusRing, (), false);
|
|
|
|
if (mShowFocusRingForContent || mFocusByKeyOccurred) {
|
|
return true;
|
|
}
|
|
|
|
nsCOMPtr<nsPIWindowRoot> root = GetTopWindowRoot();
|
|
return root ? root->ShowFocusRings() : false;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetKeyboardIndicators(UIStateChangeType aShowAccelerators,
|
|
UIStateChangeType aShowFocusRings)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
nsPIDOMWindowOuter* piWin = GetPrivateRoot();
|
|
if (!piWin) {
|
|
return;
|
|
}
|
|
|
|
MOZ_ASSERT(piWin == AsOuter());
|
|
|
|
bool oldShouldShowFocusRing = ShouldShowFocusRing();
|
|
|
|
// only change the flags that have been modified
|
|
nsCOMPtr<nsPIWindowRoot> windowRoot = do_QueryInterface(mChromeEventHandler);
|
|
if (!windowRoot) {
|
|
return;
|
|
}
|
|
|
|
if (aShowAccelerators != UIStateChangeType_NoChange) {
|
|
windowRoot->SetShowAccelerators(aShowAccelerators == UIStateChangeType_Set);
|
|
}
|
|
if (aShowFocusRings != UIStateChangeType_NoChange) {
|
|
windowRoot->SetShowFocusRings(aShowFocusRings == UIStateChangeType_Set);
|
|
}
|
|
|
|
nsContentUtils::SetKeyboardIndicatorsOnRemoteChildren(GetOuterWindow(),
|
|
aShowAccelerators,
|
|
aShowFocusRings);
|
|
|
|
bool newShouldShowFocusRing = ShouldShowFocusRing();
|
|
if (mHasFocus && mFocusedNode &&
|
|
oldShouldShowFocusRing != newShouldShowFocusRing &&
|
|
mFocusedNode->IsElement()) {
|
|
// Update mFocusedNode's state.
|
|
if (newShouldShowFocusRing) {
|
|
mFocusedNode->AsElement()->AddStates(NS_EVENT_STATE_FOCUSRING);
|
|
} else {
|
|
mFocusedNode->AsElement()->RemoveStates(NS_EVENT_STATE_FOCUSRING);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::TakeFocus(bool aFocus, uint32_t aFocusMethod)
|
|
{
|
|
FORWARD_TO_INNER(TakeFocus, (aFocus, aFocusMethod), false);
|
|
|
|
if (mCleanedUp) {
|
|
return false;
|
|
}
|
|
|
|
if (aFocus)
|
|
mFocusMethod = aFocusMethod & FOCUSMETHOD_MASK;
|
|
|
|
if (mHasFocus != aFocus) {
|
|
mHasFocus = aFocus;
|
|
UpdateCanvasFocus(true, mFocusedNode);
|
|
}
|
|
|
|
// if mNeedsFocus is true, then the document has not yet received a
|
|
// document-level focus event. If there is a root content node, then return
|
|
// true to tell the calling focus manager that a focus event is expected. If
|
|
// there is no root content node, the document hasn't loaded enough yet, or
|
|
// there isn't one and there is no point in firing a focus event.
|
|
if (aFocus && mNeedsFocus && mDoc && mDoc->GetRootElement() != nullptr) {
|
|
mNeedsFocus = false;
|
|
return true;
|
|
}
|
|
|
|
mNeedsFocus = false;
|
|
return false;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetReadyForFocus()
|
|
{
|
|
FORWARD_TO_INNER_VOID(SetReadyForFocus, ());
|
|
|
|
bool oldNeedsFocus = mNeedsFocus;
|
|
mNeedsFocus = false;
|
|
|
|
nsIFocusManager* fm = nsFocusManager::GetFocusManager();
|
|
if (fm) {
|
|
fm->WindowShown(GetOuterWindow(), oldNeedsFocus);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::PageHidden()
|
|
{
|
|
FORWARD_TO_INNER_VOID(PageHidden, ());
|
|
|
|
// the window is being hidden, so tell the focus manager that the frame is
|
|
// no longer valid. Use the persisted field to determine if the document
|
|
// is being destroyed.
|
|
|
|
nsIFocusManager* fm = nsFocusManager::GetFocusManager();
|
|
if (fm) {
|
|
fm->WindowHidden(GetOuterWindow());
|
|
}
|
|
|
|
mNeedsFocus = true;
|
|
}
|
|
|
|
class HashchangeCallback : public Runnable
|
|
{
|
|
public:
|
|
HashchangeCallback(const nsAString& aOldURL,
|
|
const nsAString& aNewURL,
|
|
nsGlobalWindow* aWindow)
|
|
: mozilla::Runnable("HashchangeCallback")
|
|
, mWindow(aWindow)
|
|
{
|
|
MOZ_ASSERT(mWindow);
|
|
MOZ_ASSERT(mWindow->IsInnerWindow());
|
|
mOldURL.Assign(aOldURL);
|
|
mNewURL.Assign(aNewURL);
|
|
}
|
|
|
|
NS_IMETHOD Run() override
|
|
{
|
|
NS_PRECONDITION(NS_IsMainThread(), "Should be called on the main thread.");
|
|
return mWindow->FireHashchange(mOldURL, mNewURL);
|
|
}
|
|
|
|
private:
|
|
nsString mOldURL;
|
|
nsString mNewURL;
|
|
RefPtr<nsGlobalWindow> mWindow;
|
|
};
|
|
|
|
nsresult
|
|
nsGlobalWindow::DispatchAsyncHashchange(nsIURI *aOldURI, nsIURI *aNewURI)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
// Make sure that aOldURI and aNewURI are identical up to the '#', and that
|
|
// their hashes are different.
|
|
bool equal = false;
|
|
NS_ENSURE_STATE(NS_SUCCEEDED(aOldURI->EqualsExceptRef(aNewURI, &equal)) && equal);
|
|
nsAutoCString oldHash, newHash;
|
|
bool oldHasHash, newHasHash;
|
|
NS_ENSURE_STATE(NS_SUCCEEDED(aOldURI->GetRef(oldHash)) &&
|
|
NS_SUCCEEDED(aNewURI->GetRef(newHash)) &&
|
|
NS_SUCCEEDED(aOldURI->GetHasRef(&oldHasHash)) &&
|
|
NS_SUCCEEDED(aNewURI->GetHasRef(&newHasHash)) &&
|
|
(oldHasHash != newHasHash || !oldHash.Equals(newHash)));
|
|
|
|
nsAutoCString oldSpec, newSpec;
|
|
nsresult rv = aOldURI->GetSpec(oldSpec);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
rv = aNewURI->GetSpec(newSpec);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
NS_ConvertUTF8toUTF16 oldWideSpec(oldSpec);
|
|
NS_ConvertUTF8toUTF16 newWideSpec(newSpec);
|
|
|
|
nsCOMPtr<nsIRunnable> callback =
|
|
new HashchangeCallback(oldWideSpec, newWideSpec, this);
|
|
return Dispatch(TaskCategory::Other, callback.forget());
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::FireHashchange(const nsAString &aOldURL,
|
|
const nsAString &aNewURL)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
// Don't do anything if the window is frozen.
|
|
if (IsFrozen()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// Get a presentation shell for use in creating the hashchange event.
|
|
NS_ENSURE_STATE(AsInner()->IsCurrentInnerWindow());
|
|
|
|
nsIPresShell *shell = mDoc->GetShell();
|
|
RefPtr<nsPresContext> presContext;
|
|
if (shell) {
|
|
presContext = shell->GetPresContext();
|
|
}
|
|
|
|
HashChangeEventInit init;
|
|
init.mBubbles = true;
|
|
init.mCancelable = false;
|
|
init.mNewURL = aNewURL;
|
|
init.mOldURL = aOldURL;
|
|
|
|
RefPtr<HashChangeEvent> event =
|
|
HashChangeEvent::Constructor(this, NS_LITERAL_STRING("hashchange"),
|
|
init);
|
|
|
|
event->SetTrusted(true);
|
|
|
|
bool dummy;
|
|
return DispatchEvent(event, &dummy);
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::DispatchSyncPopState()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
NS_ASSERTION(nsContentUtils::IsSafeToRunScript(),
|
|
"Must be safe to run script here.");
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
// Bail if the window is frozen.
|
|
if (IsFrozen()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// Get the document's pending state object -- it contains the data we're
|
|
// going to send along with the popstate event. The object is serialized
|
|
// using structured clone.
|
|
nsCOMPtr<nsIVariant> stateObj;
|
|
rv = mDoc->GetStateObject(getter_AddRefs(stateObj));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Obtain a presentation shell for use in creating a popstate event.
|
|
nsIPresShell *shell = mDoc->GetShell();
|
|
RefPtr<nsPresContext> presContext;
|
|
if (shell) {
|
|
presContext = shell->GetPresContext();
|
|
}
|
|
|
|
bool result = true;
|
|
AutoJSAPI jsapi;
|
|
result = jsapi.Init(AsInner());
|
|
NS_ENSURE_TRUE(result, NS_ERROR_FAILURE);
|
|
|
|
JSContext* cx = jsapi.cx();
|
|
JS::Rooted<JS::Value> stateJSValue(cx, JS::NullValue());
|
|
result = stateObj ? VariantToJsval(cx, stateObj, &stateJSValue) : true;
|
|
NS_ENSURE_TRUE(result, NS_ERROR_FAILURE);
|
|
|
|
RootedDictionary<PopStateEventInit> init(cx);
|
|
init.mBubbles = true;
|
|
init.mCancelable = false;
|
|
init.mState = stateJSValue;
|
|
|
|
RefPtr<PopStateEvent> event =
|
|
PopStateEvent::Constructor(this, NS_LITERAL_STRING("popstate"),
|
|
init);
|
|
event->SetTrusted(true);
|
|
event->SetTarget(this);
|
|
|
|
bool dummy; // default action
|
|
return DispatchEvent(event, &dummy);
|
|
}
|
|
|
|
// Find an nsICanvasFrame under aFrame. Only search the principal
|
|
// child lists. aFrame must be non-null.
|
|
static nsCanvasFrame* FindCanvasFrame(nsIFrame* aFrame)
|
|
{
|
|
nsCanvasFrame* canvasFrame = do_QueryFrame(aFrame);
|
|
if (canvasFrame) {
|
|
return canvasFrame;
|
|
}
|
|
|
|
for (nsIFrame* kid : aFrame->PrincipalChildList()) {
|
|
canvasFrame = FindCanvasFrame(kid);
|
|
if (canvasFrame) {
|
|
return canvasFrame;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
//-------------------------------------------------------
|
|
// Tells the HTMLFrame/CanvasFrame that is now has focus
|
|
void
|
|
nsGlobalWindow::UpdateCanvasFocus(bool aFocusChanged, nsIContent* aNewContent)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
// this is called from the inner window so use GetDocShell
|
|
nsIDocShell* docShell = GetDocShell();
|
|
if (!docShell)
|
|
return;
|
|
|
|
bool editable;
|
|
docShell->GetEditable(&editable);
|
|
if (editable)
|
|
return;
|
|
|
|
nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
|
|
if (!presShell || !mDoc)
|
|
return;
|
|
|
|
Element *rootElement = mDoc->GetRootElement();
|
|
if (rootElement) {
|
|
if ((mHasFocus || aFocusChanged) &&
|
|
(mFocusedNode == rootElement || aNewContent == rootElement)) {
|
|
nsIFrame* frame = rootElement->GetPrimaryFrame();
|
|
if (frame) {
|
|
frame = frame->GetParent();
|
|
nsCanvasFrame* canvasFrame = do_QueryFrame(frame);
|
|
if (canvasFrame) {
|
|
canvasFrame->SetHasFocus(mHasFocus && rootElement == aNewContent);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Look for the frame the hard way
|
|
nsIFrame* frame = presShell->GetRootFrame();
|
|
if (frame) {
|
|
nsCanvasFrame* canvasFrame = FindCanvasFrame(frame);
|
|
if (canvasFrame) {
|
|
canvasFrame->SetHasFocus(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
already_AddRefed<nsICSSDeclaration>
|
|
nsGlobalWindow::GetComputedStyle(Element& aElt, const nsAString& aPseudoElt,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
return GetComputedStyleHelper(aElt, aPseudoElt, false, aError);
|
|
}
|
|
|
|
already_AddRefed<nsICSSDeclaration>
|
|
nsGlobalWindow::GetDefaultComputedStyle(Element& aElt,
|
|
const nsAString& aPseudoElt,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
return GetComputedStyleHelper(aElt, aPseudoElt, true, aError);
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::GetComputedStyleHelper(nsIDOMElement* aElt,
|
|
const nsAString& aPseudoElt,
|
|
bool aDefaultStylesOnly,
|
|
nsIDOMCSSStyleDeclaration** aReturn)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
NS_ENSURE_ARG_POINTER(aReturn);
|
|
*aReturn = nullptr;
|
|
|
|
nsCOMPtr<dom::Element> element = do_QueryInterface(aElt);
|
|
if (!element) {
|
|
return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
|
|
}
|
|
|
|
ErrorResult rv;
|
|
nsCOMPtr<nsIDOMCSSStyleDeclaration> declaration =
|
|
GetComputedStyleHelper(*element, aPseudoElt, aDefaultStylesOnly, rv);
|
|
declaration.forget(aReturn);
|
|
|
|
return rv.StealNSResult();
|
|
}
|
|
|
|
already_AddRefed<nsICSSDeclaration>
|
|
nsGlobalWindow::GetComputedStyleHelperOuter(Element& aElt,
|
|
const nsAString& aPseudoElt,
|
|
bool aDefaultStylesOnly)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
if (!mDocShell) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsCOMPtr<nsIPresShell> presShell = mDocShell->GetPresShell();
|
|
|
|
if (!presShell) {
|
|
// Try flushing frames on our parent in case there's a pending
|
|
// style change that will create the presshell.
|
|
auto* parent = nsGlobalWindow::Cast(GetPrivateParent());
|
|
if (!parent) {
|
|
return nullptr;
|
|
}
|
|
|
|
parent->FlushPendingNotifications(FlushType::Frames);
|
|
|
|
// Might have killed mDocShell
|
|
if (!mDocShell) {
|
|
return nullptr;
|
|
}
|
|
|
|
presShell = mDocShell->GetPresShell();
|
|
if (!presShell) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
RefPtr<nsComputedDOMStyle> compStyle =
|
|
NS_NewComputedDOMStyle(&aElt, aPseudoElt, presShell,
|
|
aDefaultStylesOnly ? nsComputedDOMStyle::eDefaultOnly :
|
|
nsComputedDOMStyle::eAll);
|
|
|
|
return compStyle.forget();
|
|
}
|
|
|
|
already_AddRefed<nsICSSDeclaration>
|
|
nsGlobalWindow::GetComputedStyleHelper(Element& aElt,
|
|
const nsAString& aPseudoElt,
|
|
bool aDefaultStylesOnly,
|
|
ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetComputedStyleHelperOuter,
|
|
(aElt, aPseudoElt, aDefaultStylesOnly),
|
|
aError, nullptr);
|
|
}
|
|
|
|
Storage*
|
|
nsGlobalWindow::GetSessionStorage(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
nsIPrincipal *principal = GetPrincipal();
|
|
nsIDocShell* docShell = GetDocShell();
|
|
|
|
if (!principal || !docShell || !Preferences::GetBool(kStorageEnabled)) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (mSessionStorage) {
|
|
MOZ_LOG(gDOMLeakPRLog, LogLevel::Debug,
|
|
("nsGlobalWindow %p has %p sessionStorage", this, mSessionStorage.get()));
|
|
bool canAccess = principal->Subsumes(mSessionStorage->Principal());
|
|
NS_ASSERTION(canAccess,
|
|
"This window owned sessionStorage "
|
|
"that could not be accessed!");
|
|
if (!canAccess) {
|
|
mSessionStorage = nullptr;
|
|
}
|
|
}
|
|
|
|
if (!mSessionStorage) {
|
|
nsString documentURI;
|
|
if (mDoc) {
|
|
aError = mDoc->GetDocumentURI(documentURI);
|
|
if (NS_WARN_IF(aError.Failed())) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
// If the document has the sandboxed origin flag set
|
|
// don't allow access to sessionStorage.
|
|
if (!mDoc) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return nullptr;
|
|
}
|
|
|
|
if (mDoc->GetSandboxFlags() & SANDBOXED_ORIGIN) {
|
|
aError.Throw(NS_ERROR_DOM_SECURITY_ERR);
|
|
return nullptr;
|
|
}
|
|
|
|
nsresult rv;
|
|
|
|
nsCOMPtr<nsIDOMStorageManager> storageManager = do_QueryInterface(docShell, &rv);
|
|
if (NS_FAILED(rv)) {
|
|
aError.Throw(rv);
|
|
return nullptr;
|
|
}
|
|
|
|
nsCOMPtr<nsIDOMStorage> storage;
|
|
aError = storageManager->CreateStorage(AsInner(), principal, documentURI,
|
|
IsPrivateBrowsing(),
|
|
getter_AddRefs(storage));
|
|
if (aError.Failed()) {
|
|
return nullptr;
|
|
}
|
|
|
|
mSessionStorage = static_cast<Storage*>(storage.get());
|
|
MOZ_ASSERT(mSessionStorage);
|
|
|
|
MOZ_LOG(gDOMLeakPRLog, LogLevel::Debug,
|
|
("nsGlobalWindow %p tried to get a new sessionStorage %p", this, mSessionStorage.get()));
|
|
|
|
if (!mSessionStorage) {
|
|
aError.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
MOZ_LOG(gDOMLeakPRLog, LogLevel::Debug,
|
|
("nsGlobalWindow %p returns %p sessionStorage", this, mSessionStorage.get()));
|
|
|
|
return mSessionStorage;
|
|
}
|
|
|
|
Storage*
|
|
nsGlobalWindow::GetLocalStorage(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!Preferences::GetBool(kStorageEnabled)) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (!mLocalStorage) {
|
|
if (nsContentUtils::StorageAllowedForWindow(AsInner()) ==
|
|
nsContentUtils::StorageAccess::eDeny) {
|
|
aError.Throw(NS_ERROR_DOM_SECURITY_ERR);
|
|
return nullptr;
|
|
}
|
|
|
|
nsIPrincipal *principal = GetPrincipal();
|
|
if (!principal) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsresult rv;
|
|
nsCOMPtr<nsIDOMStorageManager> storageManager =
|
|
do_GetService("@mozilla.org/dom/localStorage-manager;1", &rv);
|
|
if (NS_FAILED(rv)) {
|
|
aError.Throw(rv);
|
|
return nullptr;
|
|
}
|
|
|
|
nsString documentURI;
|
|
if (mDoc) {
|
|
aError = mDoc->GetDocumentURI(documentURI);
|
|
if (NS_WARN_IF(aError.Failed())) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
nsCOMPtr<nsIDOMStorage> storage;
|
|
aError = storageManager->CreateStorage(AsInner(), principal, documentURI,
|
|
IsPrivateBrowsing(),
|
|
getter_AddRefs(storage));
|
|
if (aError.Failed()) {
|
|
return nullptr;
|
|
}
|
|
|
|
mLocalStorage = static_cast<Storage*>(storage.get());
|
|
MOZ_ASSERT(mLocalStorage);
|
|
}
|
|
|
|
return mLocalStorage;
|
|
}
|
|
|
|
IDBFactory*
|
|
nsGlobalWindow::GetIndexedDB(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
if (!mIndexedDB) {
|
|
// This may keep mIndexedDB null without setting an error.
|
|
aError = IDBFactory::CreateForWindow(AsInner(),
|
|
getter_AddRefs(mIndexedDB));
|
|
}
|
|
|
|
return mIndexedDB;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// nsGlobalWindow::nsIInterfaceRequestor
|
|
//*****************************************************************************
|
|
|
|
NS_IMETHODIMP
|
|
nsGlobalWindow::GetInterface(const nsIID & aIID, void **aSink)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aSink);
|
|
*aSink = nullptr;
|
|
|
|
if (aIID.Equals(NS_GET_IID(nsIDocCharset))) {
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
NS_ENSURE_TRUE(outer, NS_ERROR_NOT_INITIALIZED);
|
|
|
|
NS_WARNING("Using deprecated nsIDocCharset: use nsIDocShell.GetCharset() instead ");
|
|
nsCOMPtr<nsIDocCharset> docCharset(do_QueryInterface(outer->mDocShell));
|
|
docCharset.forget(aSink);
|
|
}
|
|
else if (aIID.Equals(NS_GET_IID(nsIWebNavigation))) {
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
NS_ENSURE_TRUE(outer, NS_ERROR_NOT_INITIALIZED);
|
|
|
|
nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(outer->mDocShell));
|
|
webNav.forget(aSink);
|
|
}
|
|
else if (aIID.Equals(NS_GET_IID(nsIDocShell))) {
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
NS_ENSURE_TRUE(outer, NS_ERROR_NOT_INITIALIZED);
|
|
|
|
nsCOMPtr<nsIDocShell> docShell = outer->mDocShell;
|
|
docShell.forget(aSink);
|
|
}
|
|
#ifdef NS_PRINTING
|
|
else if (aIID.Equals(NS_GET_IID(nsIWebBrowserPrint))) {
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
NS_ENSURE_TRUE(outer, NS_ERROR_NOT_INITIALIZED);
|
|
|
|
if (outer->mDocShell) {
|
|
nsCOMPtr<nsIContentViewer> viewer;
|
|
outer->mDocShell->GetContentViewer(getter_AddRefs(viewer));
|
|
if (viewer) {
|
|
nsCOMPtr<nsIWebBrowserPrint> webBrowserPrint(do_QueryInterface(viewer));
|
|
webBrowserPrint.forget(aSink);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
else if (aIID.Equals(NS_GET_IID(nsIDOMWindowUtils))) {
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
NS_ENSURE_TRUE(outer, NS_ERROR_NOT_INITIALIZED);
|
|
|
|
if (!mWindowUtils) {
|
|
mWindowUtils = new nsDOMWindowUtils(outer);
|
|
}
|
|
|
|
*aSink = mWindowUtils;
|
|
NS_ADDREF(((nsISupports *) *aSink));
|
|
}
|
|
else if (aIID.Equals(NS_GET_IID(nsILoadContext))) {
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
NS_ENSURE_TRUE(outer, NS_ERROR_NOT_INITIALIZED);
|
|
|
|
nsCOMPtr<nsILoadContext> loadContext(do_QueryInterface(outer->mDocShell));
|
|
loadContext.forget(aSink);
|
|
}
|
|
else {
|
|
return QueryInterface(aIID, aSink);
|
|
}
|
|
|
|
return *aSink ? NS_OK : NS_ERROR_NO_INTERFACE;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetInterface(JSContext* aCx, nsIJSID* aIID,
|
|
JS::MutableHandle<JS::Value> aRetval,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
dom::GetInterface(aCx, this, aIID, aRetval, aError);
|
|
}
|
|
|
|
already_AddRefed<CacheStorage>
|
|
nsGlobalWindow::GetCaches(ErrorResult& aRv)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
if (!mCacheStorage) {
|
|
bool forceTrustedOrigin =
|
|
GetOuterWindow()->GetServiceWorkersTestingEnabled();
|
|
|
|
nsContentUtils::StorageAccess access =
|
|
nsContentUtils::StorageAllowedForWindow(AsInner());
|
|
|
|
// We don't block the cache API when being told to only allow storage for the
|
|
// current session.
|
|
bool storageBlocked = access <= nsContentUtils::StorageAccess::ePrivateBrowsing;
|
|
|
|
mCacheStorage = CacheStorage::CreateOnMainThread(cache::DEFAULT_NAMESPACE,
|
|
this, GetPrincipal(),
|
|
storageBlocked,
|
|
forceTrustedOrigin, aRv);
|
|
}
|
|
|
|
RefPtr<CacheStorage> ref = mCacheStorage;
|
|
return ref.forget();
|
|
}
|
|
|
|
already_AddRefed<ServiceWorkerRegistration>
|
|
nsPIDOMWindowInner::GetServiceWorkerRegistration(const nsAString& aScope)
|
|
{
|
|
RefPtr<ServiceWorkerRegistration> registration;
|
|
if (!mServiceWorkerRegistrationTable.Get(aScope,
|
|
getter_AddRefs(registration))) {
|
|
registration =
|
|
ServiceWorkerRegistration::CreateForMainThread(this, aScope);
|
|
mServiceWorkerRegistrationTable.Put(aScope, registration);
|
|
}
|
|
return registration.forget();
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowInner::InvalidateServiceWorkerRegistration(const nsAString& aScope)
|
|
{
|
|
mServiceWorkerRegistrationTable.Remove(aScope);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::FireOfflineStatusEventIfChanged()
|
|
{
|
|
if (!AsInner()->IsCurrentInnerWindow())
|
|
return;
|
|
|
|
// Don't fire an event if the status hasn't changed
|
|
if (mWasOffline == NS_IsOffline()) {
|
|
return;
|
|
}
|
|
|
|
mWasOffline = !mWasOffline;
|
|
|
|
nsAutoString name;
|
|
if (mWasOffline) {
|
|
name.AssignLiteral("offline");
|
|
} else {
|
|
name.AssignLiteral("online");
|
|
}
|
|
// The event is fired at the body element, or if there is no body element,
|
|
// at the document.
|
|
nsCOMPtr<EventTarget> eventTarget = mDoc.get();
|
|
nsHTMLDocument* htmlDoc = mDoc->AsHTMLDocument();
|
|
if (htmlDoc) {
|
|
Element* body = htmlDoc->GetBody();
|
|
if (body) {
|
|
eventTarget = body;
|
|
}
|
|
} else {
|
|
Element* documentElement = mDoc->GetDocumentElement();
|
|
if (documentElement) {
|
|
eventTarget = documentElement;
|
|
}
|
|
}
|
|
nsContentUtils::DispatchTrustedEvent(mDoc, eventTarget, name, true, false);
|
|
}
|
|
|
|
class NotifyIdleObserverRunnable : public Runnable
|
|
{
|
|
public:
|
|
NotifyIdleObserverRunnable(nsIIdleObserver* aIdleObserver,
|
|
uint32_t aTimeInS,
|
|
bool aCallOnidle,
|
|
nsGlobalWindow* aIdleWindow)
|
|
: mozilla::Runnable("NotifyIdleObserverRunnable")
|
|
, mIdleObserver(aIdleObserver)
|
|
, mTimeInS(aTimeInS)
|
|
, mIdleWindow(aIdleWindow)
|
|
, mCallOnidle(aCallOnidle)
|
|
{ }
|
|
|
|
NS_IMETHOD Run() override
|
|
{
|
|
if (mIdleWindow->ContainsIdleObserver(mIdleObserver, mTimeInS)) {
|
|
return mCallOnidle ? mIdleObserver->Onidle() : mIdleObserver->Onactive();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
private:
|
|
nsCOMPtr<nsIIdleObserver> mIdleObserver;
|
|
uint32_t mTimeInS;
|
|
RefPtr<nsGlobalWindow> mIdleWindow;
|
|
|
|
// If false then call on active
|
|
bool mCallOnidle;
|
|
};
|
|
|
|
void
|
|
nsGlobalWindow::NotifyIdleObserver(IdleObserverHolder* aIdleObserverHolder,
|
|
bool aCallOnidle)
|
|
{
|
|
MOZ_ASSERT(aIdleObserverHolder);
|
|
aIdleObserverHolder->mPrevNotificationIdle = aCallOnidle;
|
|
|
|
nsCOMPtr<nsIRunnable> caller =
|
|
new NotifyIdleObserverRunnable(aIdleObserverHolder->mIdleObserver,
|
|
aIdleObserverHolder->mTimeInS,
|
|
aCallOnidle, this);
|
|
if (NS_FAILED(Dispatch(TaskCategory::Other, caller.forget()))) {
|
|
NS_WARNING("Failed to dispatch thread for idle observer notification.");
|
|
}
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::ContainsIdleObserver(nsIIdleObserver* aIdleObserver, uint32_t aTimeInS)
|
|
{
|
|
MOZ_ASSERT(aIdleObserver, "Idle observer not instantiated.");
|
|
bool found = false;
|
|
nsTObserverArray<IdleObserverHolder>::ForwardIterator iter(mIdleObservers);
|
|
while (iter.HasMore()) {
|
|
IdleObserverHolder& idleObserver = iter.GetNext();
|
|
if (idleObserver.mIdleObserver == aIdleObserver &&
|
|
idleObserver.mTimeInS == aTimeInS) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
return found;
|
|
}
|
|
|
|
void
|
|
IdleActiveTimerCallback(nsITimer* aTimer, void* aClosure)
|
|
{
|
|
RefPtr<nsGlobalWindow> idleWindow = static_cast<nsGlobalWindow*>(aClosure);
|
|
MOZ_ASSERT(idleWindow, "Idle window has not been instantiated.");
|
|
idleWindow->HandleIdleActiveEvent();
|
|
}
|
|
|
|
void
|
|
IdleObserverTimerCallback(nsITimer* aTimer, void* aClosure)
|
|
{
|
|
RefPtr<nsGlobalWindow> idleWindow = static_cast<nsGlobalWindow*>(aClosure);
|
|
MOZ_ASSERT(idleWindow, "Idle window has not been instantiated.");
|
|
idleWindow->HandleIdleObserverCallback();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::HandleIdleObserverCallback()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow(), "Must be an inner window!");
|
|
MOZ_ASSERT(static_cast<uint32_t>(mIdleCallbackIndex) < mIdleObservers.Length(),
|
|
"Idle callback index exceeds array bounds!");
|
|
IdleObserverHolder& idleObserver = mIdleObservers.ElementAt(mIdleCallbackIndex);
|
|
NotifyIdleObserver(&idleObserver, true);
|
|
mIdleCallbackIndex++;
|
|
if (NS_FAILED(ScheduleNextIdleObserverCallback())) {
|
|
NS_WARNING("Failed to set next idle observer callback.");
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::ScheduleNextIdleObserverCallback()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow(), "Must be an inner window!");
|
|
MOZ_ASSERT(mIdleService, "No idle service!");
|
|
|
|
if (mIdleCallbackIndex < 0 ||
|
|
static_cast<uint32_t>(mIdleCallbackIndex) >= mIdleObservers.Length()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
IdleObserverHolder& idleObserver =
|
|
mIdleObservers.ElementAt(mIdleCallbackIndex);
|
|
|
|
uint32_t userIdleTimeMS = 0;
|
|
nsresult rv = mIdleService->GetIdleTime(&userIdleTimeMS);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
uint32_t callbackTimeMS = 0;
|
|
if (idleObserver.mTimeInS * 1000 + mIdleFuzzFactor > userIdleTimeMS) {
|
|
callbackTimeMS = idleObserver.mTimeInS * 1000 - userIdleTimeMS + mIdleFuzzFactor;
|
|
}
|
|
|
|
mIdleTimer->Cancel();
|
|
rv = mIdleTimer->InitWithNamedFuncCallback(
|
|
IdleObserverTimerCallback,
|
|
this,
|
|
callbackTimeMS,
|
|
nsITimer::TYPE_ONE_SHOT,
|
|
"nsGlobalWindow::ScheduleNextIdleObserverCallback");
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
uint32_t
|
|
nsGlobalWindow::GetFuzzTimeMS()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow(), "Must be an inner window!");
|
|
|
|
if (sIdleObserversAPIFuzzTimeDisabled) {
|
|
return 0;
|
|
}
|
|
|
|
uint32_t randNum = MAX_IDLE_FUZZ_TIME_MS;
|
|
size_t nbytes = PR_GetRandomNoise(&randNum, sizeof(randNum));
|
|
if (nbytes != sizeof(randNum)) {
|
|
NS_WARNING("PR_GetRandomNoise(...) Not implemented or no available noise!");
|
|
return MAX_IDLE_FUZZ_TIME_MS;
|
|
}
|
|
|
|
if (randNum > MAX_IDLE_FUZZ_TIME_MS) {
|
|
randNum %= MAX_IDLE_FUZZ_TIME_MS;
|
|
}
|
|
|
|
return randNum;
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::ScheduleActiveTimerCallback()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow(), "Must be an inner window!");
|
|
|
|
if (!mAddActiveEventFuzzTime) {
|
|
return HandleIdleActiveEvent();
|
|
}
|
|
|
|
MOZ_ASSERT(mIdleTimer);
|
|
mIdleTimer->Cancel();
|
|
|
|
uint32_t fuzzFactorInMS = GetFuzzTimeMS();
|
|
nsresult rv = mIdleTimer->InitWithNamedFuncCallback(
|
|
IdleActiveTimerCallback,
|
|
this,
|
|
fuzzFactorInMS,
|
|
nsITimer::TYPE_ONE_SHOT,
|
|
"nsGlobalWindow::ScheduleActiveTimerCallback");
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::HandleIdleActiveEvent()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow(), "Must be an inner window!");
|
|
|
|
if (mCurrentlyIdle) {
|
|
mIdleCallbackIndex = 0;
|
|
mIdleFuzzFactor = GetFuzzTimeMS();
|
|
nsresult rv = ScheduleNextIdleObserverCallback();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
return NS_OK;
|
|
}
|
|
|
|
mIdleCallbackIndex = -1;
|
|
MOZ_ASSERT(mIdleTimer);
|
|
mIdleTimer->Cancel();
|
|
nsTObserverArray<IdleObserverHolder>::ForwardIterator iter(mIdleObservers);
|
|
while (iter.HasMore()) {
|
|
IdleObserverHolder& idleObserver = iter.GetNext();
|
|
if (idleObserver.mPrevNotificationIdle) {
|
|
NotifyIdleObserver(&idleObserver, false);
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsGlobalWindow::SlowScriptResponse
|
|
nsGlobalWindow::ShowSlowScriptDialog(const nsString& aAddonId)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
nsresult rv;
|
|
AutoJSContext cx;
|
|
|
|
if (Preferences::GetBool("dom.always_stop_slow_scripts")) {
|
|
return KillSlowScript;
|
|
}
|
|
|
|
// If it isn't safe to run script, then it isn't safe to bring up the prompt
|
|
// (since that spins the event loop). In that (rare) case, we just kill the
|
|
// script and report a warning.
|
|
if (!nsContentUtils::IsSafeToRunScript()) {
|
|
JS_ReportWarningASCII(cx, "A long running script was terminated");
|
|
return KillSlowScript;
|
|
}
|
|
|
|
// If our document is not active, just kill the script: we've been unloaded
|
|
if (!AsInner()->HasActiveDocument()) {
|
|
return KillSlowScript;
|
|
}
|
|
|
|
// Check if we should offer the option to debug
|
|
JS::AutoFilename filename;
|
|
unsigned lineno;
|
|
// Computing the line number can be very expensive (see bug 1330231 for
|
|
// example), and we don't use the line number anywhere except than in the
|
|
// parent process, so we avoid computing it elsewhere. This gives us most of
|
|
// the wins we are interested in, since the source of the slowness here is
|
|
// minified scripts which is more common in Web content that is loaded in the
|
|
// content process.
|
|
unsigned* linenop = XRE_IsParentProcess() ? &lineno : nullptr;
|
|
bool hasFrame = JS::DescribeScriptedCaller(cx, &filename, linenop);
|
|
|
|
// Record the slow script event if we haven't done so already for this inner window
|
|
// (which represents a particular page to the user).
|
|
if (!mHasHadSlowScript) {
|
|
Telemetry::Accumulate(Telemetry::SLOW_SCRIPT_PAGE_COUNT, 1);
|
|
}
|
|
mHasHadSlowScript = true;
|
|
|
|
if (XRE_IsContentProcess() &&
|
|
ProcessHangMonitor::Get()) {
|
|
ProcessHangMonitor::SlowScriptAction action;
|
|
RefPtr<ProcessHangMonitor> monitor = ProcessHangMonitor::Get();
|
|
nsIDocShell* docShell = GetDocShell();
|
|
nsCOMPtr<nsITabChild> child = docShell ? docShell->GetTabChild() : nullptr;
|
|
action = monitor->NotifySlowScript(child,
|
|
filename.get(),
|
|
aAddonId);
|
|
if (action == ProcessHangMonitor::Terminate) {
|
|
return KillSlowScript;
|
|
}
|
|
if (action == ProcessHangMonitor::TerminateGlobal) {
|
|
return KillScriptGlobal;
|
|
}
|
|
|
|
if (action == ProcessHangMonitor::StartDebugger) {
|
|
// Spin a nested event loop so that the debugger in the parent can fetch
|
|
// any information it needs. Once the debugger has started, return to the
|
|
// script.
|
|
RefPtr<nsGlobalWindow> outer = GetOuterWindowInternal();
|
|
outer->EnterModalState();
|
|
SpinEventLoopUntil([&]() { return monitor->IsDebuggerStartupComplete(); });
|
|
outer->LeaveModalState();
|
|
return ContinueSlowScript;
|
|
}
|
|
|
|
return ContinueSlowScriptAndKeepNotifying;
|
|
}
|
|
|
|
// Reached only on non-e10s - once per slow script dialog.
|
|
// On e10s - we probe once at ProcessHangsMonitor.jsm
|
|
Telemetry::Accumulate(Telemetry::SLOW_SCRIPT_NOTICE_COUNT, 1);
|
|
|
|
// Get the nsIPrompt interface from the docshell
|
|
nsCOMPtr<nsIDocShell> ds = GetDocShell();
|
|
NS_ENSURE_TRUE(ds, KillSlowScript);
|
|
nsCOMPtr<nsIPrompt> prompt = do_GetInterface(ds);
|
|
NS_ENSURE_TRUE(prompt, KillSlowScript);
|
|
|
|
// Prioritize the SlowScriptDebug interface over JSD1.
|
|
nsCOMPtr<nsISlowScriptDebugCallback> debugCallback;
|
|
|
|
if (hasFrame) {
|
|
const char *debugCID = "@mozilla.org/dom/slow-script-debug;1";
|
|
nsCOMPtr<nsISlowScriptDebug> debugService = do_GetService(debugCID, &rv);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
debugService->GetActivationHandler(getter_AddRefs(debugCallback));
|
|
}
|
|
}
|
|
|
|
bool failed = false;
|
|
auto getString = [&] (const char* name,
|
|
nsContentUtils::PropertiesFile propFile = nsContentUtils::eDOM_PROPERTIES) {
|
|
nsAutoString result;
|
|
nsresult rv = nsContentUtils::GetLocalizedString(
|
|
propFile, name, result);
|
|
|
|
// GetStringFromName can return NS_OK and still give nullptr string
|
|
failed = failed || NS_FAILED(rv) || result.IsEmpty();
|
|
return Move(result);
|
|
};
|
|
|
|
bool isAddonScript = !aAddonId.IsEmpty();
|
|
bool showDebugButton = debugCallback && !isAddonScript;
|
|
|
|
// Get localizable strings
|
|
|
|
nsAutoString title, checkboxMsg, debugButton, msg;
|
|
if (isAddonScript) {
|
|
title = getString("KillAddonScriptTitle");
|
|
checkboxMsg = getString("KillAddonScriptGlobalMessage");
|
|
|
|
auto appName = getString("brandShortName", nsContentUtils::eBRAND_PROPERTIES);
|
|
|
|
nsCOMPtr<nsIAddonPolicyService> aps = do_GetService("@mozilla.org/addons/policy-service;1");
|
|
nsString addonName;
|
|
if (!aps || NS_FAILED(aps->GetExtensionName(aAddonId, addonName))) {
|
|
addonName = aAddonId;
|
|
}
|
|
|
|
const char16_t* params[] = {addonName.get(), appName.get()};
|
|
rv = nsContentUtils::FormatLocalizedString(
|
|
nsContentUtils::eDOM_PROPERTIES, "KillAddonScriptMessage",
|
|
params, msg);
|
|
|
|
failed = failed || NS_FAILED(rv);
|
|
} else {
|
|
title = getString("KillScriptTitle");
|
|
checkboxMsg = getString("DontAskAgain");
|
|
|
|
if (showDebugButton) {
|
|
debugButton = getString("DebugScriptButton");
|
|
msg = getString("KillScriptWithDebugMessage");
|
|
} else {
|
|
msg = getString("KillScriptMessage");
|
|
}
|
|
}
|
|
|
|
auto stopButton = getString("StopScriptButton");
|
|
auto waitButton = getString("WaitForScriptButton");
|
|
|
|
if (failed) {
|
|
NS_ERROR("Failed to get localized strings.");
|
|
return ContinueSlowScript;
|
|
}
|
|
|
|
// Append file and line number information, if available
|
|
if (filename.get()) {
|
|
nsAutoString scriptLocation;
|
|
// We want to drop the middle part of too-long locations. We'll
|
|
// define "too-long" as longer than 60 UTF-16 code units. Just
|
|
// have to be a bit careful about unpaired surrogates.
|
|
NS_ConvertUTF8toUTF16 filenameUTF16(filename.get());
|
|
if (filenameUTF16.Length() > 60) {
|
|
// XXXbz Do we need to insert any bidi overrides here?
|
|
size_t cutStart = 30;
|
|
size_t cutLength = filenameUTF16.Length() - 60;
|
|
MOZ_ASSERT(cutLength > 0);
|
|
if (NS_IS_LOW_SURROGATE(filenameUTF16[cutStart])) {
|
|
// Don't truncate before the low surrogate, in case it's preceded by a
|
|
// high surrogate and forms a single Unicode character. Instead, just
|
|
// include the low surrogate.
|
|
++cutStart;
|
|
--cutLength;
|
|
}
|
|
if (NS_IS_LOW_SURROGATE(filenameUTF16[cutStart + cutLength])) {
|
|
// Likewise, don't drop a trailing low surrogate here. We want to
|
|
// increase cutLength, since it might be 0 already so we can't very well
|
|
// decrease it.
|
|
++cutLength;
|
|
}
|
|
|
|
// Insert U+2026 HORIZONTAL ELLIPSIS
|
|
filenameUTF16.ReplaceLiteral(cutStart, cutLength, u"\x2026");
|
|
}
|
|
const char16_t *formatParams[] = { filenameUTF16.get() };
|
|
rv = nsContentUtils::FormatLocalizedString(nsContentUtils::eDOM_PROPERTIES,
|
|
"KillScriptLocation",
|
|
formatParams,
|
|
scriptLocation);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
msg.AppendLiteral("\n\n");
|
|
msg.Append(scriptLocation);
|
|
msg.Append(':');
|
|
msg.AppendInt(lineno);
|
|
}
|
|
}
|
|
|
|
uint32_t buttonFlags = nsIPrompt::BUTTON_POS_1_DEFAULT +
|
|
(nsIPrompt::BUTTON_TITLE_IS_STRING *
|
|
(nsIPrompt::BUTTON_POS_0 + nsIPrompt::BUTTON_POS_1));
|
|
|
|
// Add a third button if necessary.
|
|
if (showDebugButton)
|
|
buttonFlags += nsIPrompt::BUTTON_TITLE_IS_STRING * nsIPrompt::BUTTON_POS_2;
|
|
|
|
bool checkboxValue = false;
|
|
int32_t buttonPressed = 0; // In case the user exits dialog by clicking X.
|
|
{
|
|
// Null out the operation callback while we're re-entering JS here.
|
|
AutoDisableJSInterruptCallback disabler(cx);
|
|
|
|
// Open the dialog.
|
|
rv = prompt->ConfirmEx(title.get(), msg.get(), buttonFlags,
|
|
waitButton.get(), stopButton.get(),
|
|
debugButton.get(), checkboxMsg.get(),
|
|
&checkboxValue, &buttonPressed);
|
|
}
|
|
|
|
if (buttonPressed == 0) {
|
|
if (checkboxValue && !isAddonScript && NS_SUCCEEDED(rv))
|
|
return AlwaysContinueSlowScript;
|
|
return ContinueSlowScript;
|
|
}
|
|
|
|
if (buttonPressed == 2) {
|
|
MOZ_RELEASE_ASSERT(debugCallback);
|
|
|
|
rv = debugCallback->HandleSlowScriptDebug(this);
|
|
return NS_SUCCEEDED(rv) ? ContinueSlowScript : KillSlowScript;
|
|
}
|
|
|
|
JS_ClearPendingException(cx);
|
|
|
|
if (checkboxValue && isAddonScript)
|
|
return KillScriptGlobal;
|
|
return KillSlowScript;
|
|
}
|
|
|
|
uint32_t
|
|
nsGlobalWindow::FindInsertionIndex(IdleObserverHolder* aIdleObserver)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
MOZ_ASSERT(aIdleObserver, "Idle observer not instantiated.");
|
|
|
|
uint32_t i = 0;
|
|
nsTObserverArray<IdleObserverHolder>::ForwardIterator iter(mIdleObservers);
|
|
while (iter.HasMore()) {
|
|
IdleObserverHolder& idleObserver = iter.GetNext();
|
|
if (idleObserver.mTimeInS > aIdleObserver->mTimeInS) {
|
|
break;
|
|
}
|
|
i++;
|
|
MOZ_ASSERT(i <= mIdleObservers.Length(), "Array index out of bounds error.");
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::RegisterIdleObserver(nsIIdleObserver* aIdleObserver)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow(), "Must be an inner window!");
|
|
|
|
nsresult rv;
|
|
if (mIdleObservers.IsEmpty()) {
|
|
mIdleService = do_GetService("@mozilla.org/widget/idleservice;1", &rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
rv = mIdleService->AddIdleObserver(mObserver, MIN_IDLE_NOTIFICATION_TIME_S);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (!mIdleTimer) {
|
|
mIdleTimer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
} else {
|
|
mIdleTimer->Cancel();
|
|
}
|
|
}
|
|
|
|
MOZ_ASSERT(mIdleService);
|
|
MOZ_ASSERT(mIdleTimer);
|
|
|
|
IdleObserverHolder tmpIdleObserver;
|
|
tmpIdleObserver.mIdleObserver = aIdleObserver;
|
|
rv = aIdleObserver->GetTime(&tmpIdleObserver.mTimeInS);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
NS_ENSURE_ARG_MAX(tmpIdleObserver.mTimeInS, UINT32_MAX / 1000);
|
|
NS_ENSURE_ARG_MIN(tmpIdleObserver.mTimeInS, MIN_IDLE_NOTIFICATION_TIME_S);
|
|
|
|
uint32_t insertAtIndex = FindInsertionIndex(&tmpIdleObserver);
|
|
if (insertAtIndex == mIdleObservers.Length()) {
|
|
mIdleObservers.AppendElement(tmpIdleObserver);
|
|
}
|
|
else {
|
|
mIdleObservers.InsertElementAt(insertAtIndex, tmpIdleObserver);
|
|
}
|
|
|
|
bool userIsIdle = false;
|
|
rv = nsContentUtils::IsUserIdle(MIN_IDLE_NOTIFICATION_TIME_S, &userIsIdle);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Special case. First idle observer added to empty list while the user is idle.
|
|
// Haven't received 'idle' topic notification from slow idle service yet.
|
|
// Need to wait for the idle notification and then notify idle observers in the list.
|
|
if (userIsIdle && mIdleCallbackIndex == -1) {
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!mCurrentlyIdle) {
|
|
return NS_OK;
|
|
}
|
|
|
|
MOZ_ASSERT(mIdleCallbackIndex >= 0);
|
|
|
|
if (static_cast<int32_t>(insertAtIndex) < mIdleCallbackIndex) {
|
|
IdleObserverHolder& idleObserver = mIdleObservers.ElementAt(insertAtIndex);
|
|
NotifyIdleObserver(&idleObserver, true);
|
|
mIdleCallbackIndex++;
|
|
return NS_OK;
|
|
}
|
|
|
|
if (static_cast<int32_t>(insertAtIndex) == mIdleCallbackIndex) {
|
|
mIdleTimer->Cancel();
|
|
rv = ScheduleNextIdleObserverCallback();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::FindIndexOfElementToRemove(nsIIdleObserver* aIdleObserver,
|
|
int32_t* aRemoveElementIndex)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow(), "Must be an inner window!");
|
|
MOZ_ASSERT(aIdleObserver, "Idle observer not instantiated.");
|
|
|
|
*aRemoveElementIndex = 0;
|
|
if (mIdleObservers.IsEmpty()) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
uint32_t aIdleObserverTimeInS;
|
|
nsresult rv = aIdleObserver->GetTime(&aIdleObserverTimeInS);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
NS_ENSURE_ARG_MIN(aIdleObserverTimeInS, MIN_IDLE_NOTIFICATION_TIME_S);
|
|
|
|
nsTObserverArray<IdleObserverHolder>::ForwardIterator iter(mIdleObservers);
|
|
while (iter.HasMore()) {
|
|
IdleObserverHolder& idleObserver = iter.GetNext();
|
|
if (idleObserver.mTimeInS == aIdleObserverTimeInS &&
|
|
idleObserver.mIdleObserver == aIdleObserver ) {
|
|
break;
|
|
}
|
|
(*aRemoveElementIndex)++;
|
|
}
|
|
return static_cast<uint32_t>(*aRemoveElementIndex) >= mIdleObservers.Length() ?
|
|
NS_ERROR_FAILURE : NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::UnregisterIdleObserver(nsIIdleObserver* aIdleObserver)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow(), "Must be an inner window!");
|
|
|
|
int32_t removeElementIndex;
|
|
nsresult rv = FindIndexOfElementToRemove(aIdleObserver, &removeElementIndex);
|
|
if (NS_FAILED(rv)) {
|
|
NS_WARNING("Idle observer not found in list of idle observers. No idle observer removed.");
|
|
return NS_OK;
|
|
}
|
|
mIdleObservers.RemoveElementAt(removeElementIndex);
|
|
|
|
MOZ_ASSERT(mIdleTimer);
|
|
if (mIdleObservers.IsEmpty() && mIdleService) {
|
|
rv = mIdleService->RemoveIdleObserver(mObserver, MIN_IDLE_NOTIFICATION_TIME_S);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
mIdleService = nullptr;
|
|
|
|
mIdleTimer->Cancel();
|
|
mIdleCallbackIndex = -1;
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!mCurrentlyIdle) {
|
|
return NS_OK;
|
|
}
|
|
|
|
if (removeElementIndex < mIdleCallbackIndex) {
|
|
mIdleCallbackIndex--;
|
|
return NS_OK;
|
|
}
|
|
|
|
if (removeElementIndex != mIdleCallbackIndex) {
|
|
return NS_OK;
|
|
}
|
|
|
|
mIdleTimer->Cancel();
|
|
|
|
// If the last element in the array had been notified then decrement
|
|
// mIdleCallbackIndex because an idle was removed from the list of
|
|
// idle observers.
|
|
// Example: add idle observer with time 1, 2, 3,
|
|
// Idle notifications for idle observers with time 1, 2, 3 are complete
|
|
// Remove idle observer with time 3 while the user is still idle.
|
|
// The user never transitioned to active state.
|
|
// Add an idle observer with idle time 4
|
|
if (static_cast<uint32_t>(mIdleCallbackIndex) == mIdleObservers.Length()) {
|
|
mIdleCallbackIndex--;
|
|
}
|
|
rv = ScheduleNextIdleObserverCallback();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::Observe(nsISupports* aSubject, const char* aTopic,
|
|
const char16_t* aData)
|
|
{
|
|
if (!nsCRT::strcmp(aTopic, NS_IOSERVICE_OFFLINE_STATUS_TOPIC)) {
|
|
if (!IsFrozen()) {
|
|
// Fires an offline status event if the offline status has changed
|
|
FireOfflineStatusEventIfChanged();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!nsCRT::strcmp(aTopic, MEMORY_PRESSURE_OBSERVER_TOPIC)) {
|
|
if (mPerformance) {
|
|
mPerformance->MemoryPressure();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!nsCRT::strcmp(aTopic, OBSERVER_TOPIC_IDLE)) {
|
|
mCurrentlyIdle = true;
|
|
if (IsFrozen()) {
|
|
// need to fire only one idle event while the window is frozen.
|
|
mNotifyIdleObserversIdleOnThaw = true;
|
|
mNotifyIdleObserversActiveOnThaw = false;
|
|
} else if (AsInner()->IsCurrentInnerWindow()) {
|
|
HandleIdleActiveEvent();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!nsCRT::strcmp(aTopic, OBSERVER_TOPIC_ACTIVE)) {
|
|
mCurrentlyIdle = false;
|
|
if (IsFrozen()) {
|
|
mNotifyIdleObserversActiveOnThaw = true;
|
|
mNotifyIdleObserversIdleOnThaw = false;
|
|
} else if (AsInner()->IsCurrentInnerWindow()) {
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
ScheduleActiveTimerCallback();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!nsCRT::strcmp(aTopic, "offline-cache-update-added")) {
|
|
if (mApplicationCache)
|
|
return NS_OK;
|
|
|
|
// Instantiate the application object now. It observes update belonging to
|
|
// this window's document and correctly updates the applicationCache object
|
|
// state.
|
|
nsCOMPtr<nsIDOMOfflineResourceList> applicationCache = GetApplicationCache();
|
|
nsCOMPtr<nsIObserver> observer = do_QueryInterface(applicationCache);
|
|
if (observer)
|
|
observer->Observe(aSubject, aTopic, aData);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!nsCRT::strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) {
|
|
MOZ_ASSERT(!NS_strcmp(aData, u"intl.accept_languages"));
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
// The user preferred languages have changed, we need to fire an event on
|
|
// Window object and invalidate the cache for navigator.languages. It is
|
|
// done for every change which can be a waste of cycles but those should be
|
|
// fairly rare.
|
|
// We MUST invalidate navigator.languages before sending the event in the
|
|
// very likely situation where an event handler will try to read its value.
|
|
|
|
if (mNavigator) {
|
|
NavigatorBinding::ClearCachedLanguageValue(mNavigator);
|
|
NavigatorBinding::ClearCachedLanguagesValue(mNavigator);
|
|
}
|
|
|
|
// The event has to be dispatched only to the current inner window.
|
|
if (!AsInner()->IsCurrentInnerWindow()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
RefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
|
|
event->InitEvent(NS_LITERAL_STRING("languagechange"), false, false);
|
|
event->SetTrusted(true);
|
|
|
|
bool dummy;
|
|
return DispatchEvent(event, &dummy);
|
|
}
|
|
|
|
NS_WARNING("unrecognized topic in nsGlobalWindow::Observe");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ObserveStorageNotification(StorageEvent* aEvent,
|
|
const char16_t* aStorageType,
|
|
bool aPrivateBrowsing)
|
|
{
|
|
MOZ_ASSERT(aEvent);
|
|
|
|
// The private browsing check must be done here again because this window
|
|
// could have changed its state before the notification check and now. This
|
|
// happens in case this window did have a docShell at that time.
|
|
if (aPrivateBrowsing != IsPrivateBrowsing()) {
|
|
return;
|
|
}
|
|
|
|
// LocalStorage can only exist on an inner window, and we don't want to
|
|
// generate events on frozen or otherwise-navigated-away from windows.
|
|
// (Actually, this code used to try and buffer events for frozen windows,
|
|
// but it never worked, so we've removed it. See bug 1285898.)
|
|
if (!IsInnerWindow() || !AsInner()->IsCurrentInnerWindow() || IsFrozen()) {
|
|
return;
|
|
}
|
|
|
|
nsIPrincipal *principal = GetPrincipal();
|
|
if (!principal) {
|
|
return;
|
|
}
|
|
|
|
bool fireMozStorageChanged = false;
|
|
nsAutoString eventType;
|
|
eventType.AssignLiteral("storage");
|
|
|
|
if (!NS_strcmp(aStorageType, u"sessionStorage")) {
|
|
nsCOMPtr<nsIDOMStorage> changingStorage = aEvent->GetStorageArea();
|
|
MOZ_ASSERT(changingStorage);
|
|
|
|
bool check = false;
|
|
|
|
nsCOMPtr<nsIDOMStorageManager> storageManager = do_QueryInterface(GetDocShell());
|
|
if (storageManager) {
|
|
nsresult rv = storageManager->CheckStorage(principal, changingStorage,
|
|
&check);
|
|
if (NS_FAILED(rv)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!check) {
|
|
// This storage event is not coming from our storage or is coming
|
|
// from a different docshell, i.e. it is a clone, ignore this event.
|
|
return;
|
|
}
|
|
|
|
MOZ_LOG(gDOMLeakPRLog, LogLevel::Debug,
|
|
("nsGlobalWindow %p with sessionStorage %p passing event from %p",
|
|
this, mSessionStorage.get(), changingStorage.get()));
|
|
|
|
fireMozStorageChanged = mSessionStorage == changingStorage;
|
|
if (fireMozStorageChanged) {
|
|
eventType.AssignLiteral("MozSessionStorageChanged");
|
|
}
|
|
}
|
|
|
|
else {
|
|
MOZ_ASSERT(!NS_strcmp(aStorageType, u"localStorage"));
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(StorageUtils::PrincipalsEqual(aEvent->GetPrincipal(),
|
|
principal));
|
|
|
|
fireMozStorageChanged = mLocalStorage == aEvent->GetStorageArea();
|
|
|
|
if (fireMozStorageChanged) {
|
|
eventType.AssignLiteral("MozLocalStorageChanged");
|
|
}
|
|
}
|
|
|
|
// Clone the storage event included in the observer notification. We want
|
|
// to dispatch clones rather than the original event.
|
|
IgnoredErrorResult error;
|
|
RefPtr<StorageEvent> clonedEvent =
|
|
CloneStorageEvent(eventType, aEvent, error);
|
|
if (error.Failed()) {
|
|
return;
|
|
}
|
|
|
|
clonedEvent->SetTrusted(true);
|
|
|
|
if (fireMozStorageChanged) {
|
|
WidgetEvent* internalEvent = clonedEvent->WidgetEventPtr();
|
|
internalEvent->mFlags.mOnlyChromeDispatch = true;
|
|
}
|
|
|
|
bool defaultActionEnabled;
|
|
DispatchEvent(clonedEvent, &defaultActionEnabled);
|
|
}
|
|
|
|
already_AddRefed<StorageEvent>
|
|
nsGlobalWindow::CloneStorageEvent(const nsAString& aType,
|
|
const RefPtr<StorageEvent>& aEvent,
|
|
ErrorResult& aRv)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
StorageEventInit dict;
|
|
|
|
dict.mBubbles = aEvent->Bubbles();
|
|
dict.mCancelable = aEvent->Cancelable();
|
|
aEvent->GetKey(dict.mKey);
|
|
aEvent->GetOldValue(dict.mOldValue);
|
|
aEvent->GetNewValue(dict.mNewValue);
|
|
aEvent->GetUrl(dict.mUrl);
|
|
|
|
RefPtr<Storage> storageArea = aEvent->GetStorageArea();
|
|
|
|
RefPtr<Storage> storage;
|
|
|
|
// If null, this is a localStorage event received by IPC.
|
|
if (!storageArea) {
|
|
storage = GetLocalStorage(aRv);
|
|
if (aRv.Failed() || !storage) {
|
|
return nullptr;
|
|
}
|
|
|
|
MOZ_ASSERT(storage->Type() == Storage::eLocalStorage);
|
|
RefPtr<LocalStorage> localStorage =
|
|
static_cast<LocalStorage*>(storage.get());
|
|
|
|
// We must apply the current change to the 'local' localStorage.
|
|
localStorage->ApplyEvent(aEvent);
|
|
} else if (storageArea->Type() == Storage::eSessionStorage) {
|
|
storage = GetSessionStorage(aRv);
|
|
} else {
|
|
MOZ_ASSERT(storageArea->Type() == Storage::eLocalStorage);
|
|
storage = GetLocalStorage(aRv);
|
|
}
|
|
|
|
if (aRv.Failed() || !storage) {
|
|
return nullptr;
|
|
}
|
|
|
|
MOZ_ASSERT(storage);
|
|
MOZ_ASSERT_IF(storageArea, storage->IsForkOf(storageArea));
|
|
|
|
dict.mStorageArea = storage;
|
|
|
|
RefPtr<StorageEvent> event = StorageEvent::Constructor(this, aType, dict);
|
|
return event.forget();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Suspend()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_DIAGNOSTIC_ASSERT(IsInnerWindow());
|
|
|
|
// We can only safely suspend windows that are the current inner window. If
|
|
// its not the current inner, then we are in one of two different cases.
|
|
// Either we are in the bfcache or we are doomed window that is going away.
|
|
// When a window becomes inactive we purposely avoid placing already suspended
|
|
// windows into the bfcache. It only expects windows suspended due to the
|
|
// Freeze() method which occurs while the window is still the current inner.
|
|
// So we must not call Suspend() on bfcache windows at this point or this
|
|
// invariant will be broken. If the window is doomed there is no point in
|
|
// suspending it since it will soon be gone.
|
|
if (!AsInner()->IsCurrentInnerWindow()) {
|
|
return;
|
|
}
|
|
|
|
// All children are also suspended. This ensure mSuspendDepth is
|
|
// set properly and the timers are properly canceled for each child.
|
|
CallOnChildren(&nsGlobalWindow::Suspend);
|
|
|
|
mSuspendDepth += 1;
|
|
if (mSuspendDepth != 1) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIDeviceSensors> ac = do_GetService(NS_DEVICE_SENSORS_CONTRACTID);
|
|
if (ac) {
|
|
for (uint32_t i = 0; i < mEnabledSensors.Length(); i++)
|
|
ac->RemoveWindowListener(mEnabledSensors[i], this);
|
|
}
|
|
DisableGamepadUpdates();
|
|
DisableVRUpdates();
|
|
|
|
mozilla::dom::workers::SuspendWorkersForWindow(AsInner());
|
|
|
|
SuspendIdleRequests();
|
|
|
|
mTimeoutManager->Suspend();
|
|
|
|
// Suspend all of the AudioContexts for this window
|
|
for (uint32_t i = 0; i < mAudioContexts.Length(); ++i) {
|
|
ErrorResult dummy;
|
|
RefPtr<Promise> d = mAudioContexts[i]->Suspend(dummy);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Resume()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_DIAGNOSTIC_ASSERT(IsInnerWindow());
|
|
|
|
// We can only safely resume a window if its the current inner window. If
|
|
// its not the current inner, then we are in one of two different cases.
|
|
// Either we are in the bfcache or we are doomed window that is going away.
|
|
// If a window is suspended when it becomes inactive we purposely do not
|
|
// put it in the bfcache, so Resume should never be needed in that case.
|
|
// If the window is doomed then there is no point in resuming it.
|
|
if (!AsInner()->IsCurrentInnerWindow()) {
|
|
return;
|
|
}
|
|
|
|
// Resume all children. This restores timers recursively canceled
|
|
// in Suspend() and ensures all children have the correct mSuspendDepth.
|
|
CallOnChildren(&nsGlobalWindow::Resume);
|
|
|
|
MOZ_ASSERT(mSuspendDepth != 0);
|
|
mSuspendDepth -= 1;
|
|
if (mSuspendDepth != 0) {
|
|
return;
|
|
}
|
|
|
|
// We should not be able to resume a frozen window. It must be Thaw()'d first.
|
|
MOZ_ASSERT(mFreezeDepth == 0);
|
|
|
|
nsCOMPtr<nsIDeviceSensors> ac = do_GetService(NS_DEVICE_SENSORS_CONTRACTID);
|
|
if (ac) {
|
|
for (uint32_t i = 0; i < mEnabledSensors.Length(); i++)
|
|
ac->AddWindowListener(mEnabledSensors[i], this);
|
|
}
|
|
EnableGamepadUpdates();
|
|
EnableVRUpdates();
|
|
|
|
// Resume all of the AudioContexts for this window
|
|
for (uint32_t i = 0; i < mAudioContexts.Length(); ++i) {
|
|
ErrorResult dummy;
|
|
RefPtr<Promise> d = mAudioContexts[i]->Resume(dummy);
|
|
}
|
|
|
|
mTimeoutManager->Resume();
|
|
|
|
ResumeIdleRequests();
|
|
|
|
// Resume all of the workers for this window. We must do this
|
|
// after timeouts since workers may have queued events that can trigger
|
|
// a setTimeout().
|
|
mozilla::dom::workers::ResumeWorkersForWindow(AsInner());
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::IsSuspended() const
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
// No inner means we are effectively suspended
|
|
if (IsOuterWindow()) {
|
|
if (!mInnerWindow) {
|
|
return true;
|
|
}
|
|
return mInnerWindow->IsSuspended();
|
|
}
|
|
return mSuspendDepth != 0;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Freeze()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
Suspend();
|
|
FreezeInternal();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::FreezeInternal()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_DIAGNOSTIC_ASSERT(IsInnerWindow());
|
|
MOZ_DIAGNOSTIC_ASSERT(AsInner()->IsCurrentInnerWindow());
|
|
MOZ_DIAGNOSTIC_ASSERT(IsSuspended());
|
|
|
|
CallOnChildren(&nsGlobalWindow::FreezeInternal);
|
|
|
|
mFreezeDepth += 1;
|
|
MOZ_ASSERT(mSuspendDepth >= mFreezeDepth);
|
|
if (mFreezeDepth != 1) {
|
|
return;
|
|
}
|
|
|
|
mozilla::dom::workers::FreezeWorkersForWindow(AsInner());
|
|
|
|
mTimeoutManager->Freeze();
|
|
|
|
NotifyDOMWindowFrozen(this);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Thaw()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
ThawInternal();
|
|
Resume();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ThawInternal()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_DIAGNOSTIC_ASSERT(IsInnerWindow());
|
|
MOZ_DIAGNOSTIC_ASSERT(AsInner()->IsCurrentInnerWindow());
|
|
MOZ_DIAGNOSTIC_ASSERT(IsSuspended());
|
|
|
|
CallOnChildren(&nsGlobalWindow::ThawInternal);
|
|
|
|
MOZ_ASSERT(mFreezeDepth != 0);
|
|
mFreezeDepth -= 1;
|
|
MOZ_ASSERT(mSuspendDepth >= mFreezeDepth);
|
|
if (mFreezeDepth != 0) {
|
|
return;
|
|
}
|
|
|
|
mTimeoutManager->Thaw();
|
|
|
|
mozilla::dom::workers::ThawWorkersForWindow(AsInner());
|
|
|
|
NotifyDOMWindowThawed(this);
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::IsFrozen() const
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
// No inner means we are effectively frozen
|
|
if (IsOuterWindow()) {
|
|
if (!mInnerWindow) {
|
|
return true;
|
|
}
|
|
return mInnerWindow->IsFrozen();
|
|
}
|
|
bool frozen = mFreezeDepth != 0;
|
|
MOZ_ASSERT_IF(frozen, IsSuspended());
|
|
return frozen;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SyncStateFromParentWindow()
|
|
{
|
|
// This method should only be called on an inner window that has been
|
|
// assigned to an outer window already.
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
MOZ_ASSERT(AsInner()->IsCurrentInnerWindow());
|
|
nsPIDOMWindowOuter* outer = GetOuterWindow();
|
|
MOZ_ASSERT(outer);
|
|
|
|
// Attempt to find our parent windows.
|
|
nsCOMPtr<Element> frame = outer->GetFrameElementInternal();
|
|
nsPIDOMWindowOuter* parentOuter = frame ? frame->OwnerDoc()->GetWindow()
|
|
: nullptr;
|
|
nsGlobalWindow* parentInner =
|
|
parentOuter ? nsGlobalWindow::Cast(parentOuter->GetCurrentInnerWindow())
|
|
: nullptr;
|
|
|
|
// If our outer is in a modal state, but our parent is not in a modal
|
|
// state, then we must apply the suspend directly. If our parent is
|
|
// in a modal state then we should get the suspend automatically
|
|
// via the parentSuspendDepth application below.
|
|
if ((!parentInner || !parentInner->IsInModalState()) && IsInModalState()) {
|
|
Suspend();
|
|
}
|
|
|
|
uint32_t parentFreezeDepth = parentInner ? parentInner->mFreezeDepth : 0;
|
|
uint32_t parentSuspendDepth = parentInner ? parentInner->mSuspendDepth : 0;
|
|
|
|
// Since every Freeze() calls Suspend(), the suspend count must
|
|
// be equal or greater to the freeze count.
|
|
MOZ_ASSERT(parentFreezeDepth <= parentSuspendDepth);
|
|
|
|
// First apply the Freeze() calls.
|
|
for (uint32_t i = 0; i < parentFreezeDepth; ++i) {
|
|
Freeze();
|
|
}
|
|
|
|
// Now apply only the number of Suspend() calls to reach the target
|
|
// suspend count after applying the Freeze() calls.
|
|
for (uint32_t i = 0; i < (parentSuspendDepth - parentFreezeDepth); ++i) {
|
|
Suspend();
|
|
}
|
|
}
|
|
|
|
template<typename Method>
|
|
void
|
|
nsGlobalWindow::CallOnChildren(Method aMethod)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
MOZ_ASSERT(AsInner()->IsCurrentInnerWindow());
|
|
|
|
nsCOMPtr<nsIDocShell> docShell = GetDocShell();
|
|
if (!docShell) {
|
|
return;
|
|
}
|
|
|
|
int32_t childCount = 0;
|
|
docShell->GetChildCount(&childCount);
|
|
|
|
for (int32_t i = 0; i < childCount; ++i) {
|
|
nsCOMPtr<nsIDocShellTreeItem> childShell;
|
|
docShell->GetChildAt(i, getter_AddRefs(childShell));
|
|
NS_ASSERTION(childShell, "null child shell");
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> pWin = childShell->GetWindow();
|
|
if (!pWin) {
|
|
continue;
|
|
}
|
|
|
|
auto* win = nsGlobalWindow::Cast(pWin);
|
|
nsGlobalWindow* inner = win->GetCurrentInnerWindowInternal();
|
|
|
|
// This is a bit hackish. Only freeze/suspend windows which are truly our
|
|
// subwindows.
|
|
nsCOMPtr<Element> frame = pWin->GetFrameElementInternal();
|
|
if (!mDoc || !frame || mDoc != frame->OwnerDoc() || !inner) {
|
|
continue;
|
|
}
|
|
|
|
(inner->*aMethod)();
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::FireDelayedDOMEvents()
|
|
{
|
|
FORWARD_TO_INNER(FireDelayedDOMEvents, (), NS_ERROR_UNEXPECTED);
|
|
|
|
if (mApplicationCache) {
|
|
static_cast<nsDOMOfflineResourceList*>(mApplicationCache.get())->FirePendingEvents();
|
|
}
|
|
|
|
// Fires an offline status event if the offline status has changed
|
|
FireOfflineStatusEventIfChanged();
|
|
|
|
if (mNotifyIdleObserversIdleOnThaw) {
|
|
mNotifyIdleObserversIdleOnThaw = false;
|
|
HandleIdleActiveEvent();
|
|
}
|
|
|
|
if (mNotifyIdleObserversActiveOnThaw) {
|
|
mNotifyIdleObserversActiveOnThaw = false;
|
|
ScheduleActiveTimerCallback();
|
|
}
|
|
|
|
nsCOMPtr<nsIDocShell> docShell = GetDocShell();
|
|
if (docShell) {
|
|
int32_t childCount = 0;
|
|
docShell->GetChildCount(&childCount);
|
|
|
|
for (int32_t i = 0; i < childCount; ++i) {
|
|
nsCOMPtr<nsIDocShellTreeItem> childShell;
|
|
docShell->GetChildAt(i, getter_AddRefs(childShell));
|
|
NS_ASSERTION(childShell, "null child shell");
|
|
|
|
if (nsCOMPtr<nsPIDOMWindowOuter> pWin = childShell->GetWindow()) {
|
|
auto* win = nsGlobalWindow::Cast(pWin);
|
|
win->FireDelayedDOMEvents();
|
|
}
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// nsGlobalWindow: Window Control Functions
|
|
//*****************************************************************************
|
|
|
|
nsPIDOMWindowOuter*
|
|
nsGlobalWindow::GetParentInternal()
|
|
{
|
|
if (IsInnerWindow()) {
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
if (!outer) {
|
|
// No outer window available!
|
|
return nullptr;
|
|
}
|
|
return outer->GetParentInternal();
|
|
}
|
|
|
|
nsCOMPtr<nsPIDOMWindowOuter> parent = GetParent();
|
|
|
|
if (parent && parent != AsOuter()) {
|
|
return parent;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::UnblockScriptedClosing()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
mBlockScriptedClosingFlag = false;
|
|
}
|
|
|
|
class AutoUnblockScriptClosing
|
|
{
|
|
private:
|
|
RefPtr<nsGlobalWindow> mWin;
|
|
public:
|
|
explicit AutoUnblockScriptClosing(nsGlobalWindow* aWin)
|
|
: mWin(aWin)
|
|
{
|
|
MOZ_ASSERT(mWin);
|
|
MOZ_ASSERT(mWin->IsOuterWindow());
|
|
}
|
|
~AutoUnblockScriptClosing()
|
|
{
|
|
void (nsGlobalWindow::*run)() = &nsGlobalWindow::UnblockScriptedClosing;
|
|
nsCOMPtr<nsIRunnable> caller = NewRunnableMethod(
|
|
"AutoUnblockScriptClosing::~AutoUnblockScriptClosing", mWin, run);
|
|
mWin->Dispatch(TaskCategory::Other, caller.forget());
|
|
}
|
|
};
|
|
|
|
nsresult
|
|
nsGlobalWindow::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)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
#ifdef DEBUG
|
|
uint32_t argc = 0;
|
|
if (argv)
|
|
argv->GetLength(&argc);
|
|
#endif
|
|
NS_PRECONDITION(!aExtraArgument || (!argv && argc == 0),
|
|
"Can't pass in arguments both ways");
|
|
NS_PRECONDITION(!aCalledNoScript || (!argv && argc == 0),
|
|
"Can't pass JS args when called via the noscript methods");
|
|
|
|
mozilla::Maybe<AutoUnblockScriptClosing> closeUnblocker;
|
|
|
|
// Calls to window.open from script should navigate.
|
|
MOZ_ASSERT(aCalledNoScript || aNavigate);
|
|
|
|
*aReturn = nullptr;
|
|
|
|
nsCOMPtr<nsIWebBrowserChrome> chrome = GetWebBrowserChrome();
|
|
if (!chrome) {
|
|
// No chrome means we don't want to go through with this open call
|
|
// -- see nsIWindowWatcher.idl
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
NS_ASSERTION(mDocShell, "Must have docshell here");
|
|
|
|
bool forceNoOpener = aForceNoOpener;
|
|
if (!forceNoOpener) {
|
|
// Unlike other window flags, "noopener" comes from splitting on commas with
|
|
// HTML whitespace trimming...
|
|
nsCharSeparatedTokenizerTemplate<nsContentUtils::IsHTMLWhitespace> tok(
|
|
aOptions, ',');
|
|
while (tok.hasMoreTokens()) {
|
|
if (tok.nextToken().EqualsLiteral("noopener")) {
|
|
forceNoOpener = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// XXXbz When this gets fixed to not use LegacyIsCallerNativeCode()
|
|
// (indirectly) maybe we can nix the AutoJSAPI usage OnLinkClickEvent::Run.
|
|
// But note that if you change this to GetEntryGlobal(), say, then
|
|
// OnLinkClickEvent::Run will need a full-blown AutoEntryScript.
|
|
const bool checkForPopup = !nsContentUtils::LegacyIsCallerChromeOrNativeCode() &&
|
|
!aDialog && !WindowExists(aName, forceNoOpener, !aCalledNoScript);
|
|
|
|
// Note: the Void handling here is very important, because the window watcher
|
|
// expects a null URL string (not an empty string) if there is no URL to load.
|
|
nsCString url;
|
|
url.SetIsVoid(true);
|
|
nsresult rv = NS_OK;
|
|
|
|
// It's important to do this security check before determining whether this
|
|
// window opening should be blocked, to ensure that we don't FireAbuseEvents
|
|
// for a window opening that wouldn't have succeeded in the first place.
|
|
if (!aUrl.IsEmpty()) {
|
|
AppendUTF16toUTF8(aUrl, url);
|
|
|
|
// It's safe to skip the security check below if we're not a dialog
|
|
// because window.openDialog is not callable from content script. See bug
|
|
// 56851.
|
|
//
|
|
// If we're not navigating, we assume that whoever *does* navigate the
|
|
// window will do a security check of their own.
|
|
if (!url.IsVoid() && !aDialog && aNavigate)
|
|
rv = SecurityCheckURL(url.get());
|
|
}
|
|
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
|
|
PopupControlState abuseLevel = gPopupControlState;
|
|
if (checkForPopup) {
|
|
abuseLevel = RevisePopupAbuseLevel(abuseLevel);
|
|
if (abuseLevel >= openBlocked) {
|
|
if (!aCalledNoScript) {
|
|
// If script in some other window is doing a window.open on us and
|
|
// it's being blocked, then it's OK to close us afterwards, probably.
|
|
// But if we're doing a window.open on ourselves and block the popup,
|
|
// prevent this window from closing until after this script terminates
|
|
// so that whatever popup blocker UI the app has will be visible.
|
|
nsCOMPtr<nsPIDOMWindowInner> entryWindow =
|
|
do_QueryInterface(GetEntryGlobal());
|
|
// Note that entryWindow can be null here if some JS component was the
|
|
// place where script was entered for this JS execution.
|
|
if (entryWindow &&
|
|
entryWindow->GetOuterWindow() == this->AsOuter()) {
|
|
mBlockScriptedClosingFlag = true;
|
|
closeUnblocker.emplace(this);
|
|
}
|
|
}
|
|
|
|
FireAbuseEvents(aUrl, aName, aOptions);
|
|
return aDoJSFixups ? NS_OK : NS_ERROR_FAILURE;
|
|
}
|
|
}
|
|
|
|
nsCOMPtr<mozIDOMWindowProxy> domReturn;
|
|
|
|
nsCOMPtr<nsIWindowWatcher> wwatch =
|
|
do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
|
|
NS_ENSURE_TRUE(wwatch, rv);
|
|
|
|
NS_ConvertUTF16toUTF8 options(aOptions);
|
|
NS_ConvertUTF16toUTF8 name(aName);
|
|
|
|
const char *options_ptr = aOptions.IsEmpty() ? nullptr : options.get();
|
|
const char *name_ptr = aName.IsEmpty() ? nullptr : name.get();
|
|
|
|
nsCOMPtr<nsPIWindowWatcher> pwwatch(do_QueryInterface(wwatch));
|
|
NS_ENSURE_STATE(pwwatch);
|
|
|
|
MOZ_ASSERT_IF(checkForPopup, abuseLevel < openBlocked);
|
|
// At this point we should know for a fact that if checkForPopup then
|
|
// abuseLevel < openBlocked, so we could just check for abuseLevel ==
|
|
// openControlled. But let's be defensive just in case and treat anything
|
|
// that fails the above assert as a spam popup too, if it ever happens.
|
|
bool isPopupSpamWindow = checkForPopup && (abuseLevel >= openControlled);
|
|
|
|
{
|
|
// Reset popup state while opening a window to prevent the
|
|
// current state from being active the whole time a modal
|
|
// dialog is open.
|
|
nsAutoPopupStatePusher popupStatePusher(openAbused, true);
|
|
|
|
if (!aCalledNoScript) {
|
|
// We asserted at the top of this function that aNavigate is true for
|
|
// !aCalledNoScript.
|
|
rv = pwwatch->OpenWindow2(AsOuter(), url.IsVoid() ? nullptr : url.get(),
|
|
name_ptr,
|
|
options_ptr, /* aCalledFromScript = */ true,
|
|
aDialog, aNavigate, argv,
|
|
isPopupSpamWindow,
|
|
forceNoOpener,
|
|
aLoadInfo,
|
|
getter_AddRefs(domReturn));
|
|
} else {
|
|
// Force a system caller here so that the window watcher won't screw us
|
|
// up. We do NOT want this case looking at the JS context on the stack
|
|
// when searching. Compare comments on
|
|
// nsIDOMWindow::OpenWindow and nsIWindowWatcher::OpenWindow.
|
|
|
|
// Note: Because nsWindowWatcher is so broken, it's actually important
|
|
// that we don't force a system caller here, because that screws it up
|
|
// when it tries to compute the caller principal to associate with dialog
|
|
// arguments. That whole setup just really needs to be rewritten. :-(
|
|
Maybe<AutoNoJSAPI> nojsapi;
|
|
if (!aContentModal) {
|
|
nojsapi.emplace();
|
|
}
|
|
|
|
rv = pwwatch->OpenWindow2(AsOuter(), url.IsVoid() ? nullptr : url.get(),
|
|
name_ptr,
|
|
options_ptr, /* aCalledFromScript = */ false,
|
|
aDialog, aNavigate, aExtraArgument,
|
|
isPopupSpamWindow,
|
|
forceNoOpener,
|
|
aLoadInfo,
|
|
getter_AddRefs(domReturn));
|
|
|
|
}
|
|
}
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// success!
|
|
|
|
NS_ENSURE_TRUE(domReturn, NS_OK);
|
|
nsCOMPtr<nsPIDOMWindowOuter> outerReturn =
|
|
nsPIDOMWindowOuter::From(domReturn);
|
|
outerReturn.swap(*aReturn);
|
|
|
|
if (aDoJSFixups) {
|
|
nsCOMPtr<nsIDOMChromeWindow> chrome_win(do_QueryInterface(*aReturn));
|
|
if (!chrome_win) {
|
|
// A new non-chrome window was created from a call to
|
|
// window.open() from JavaScript, make sure there's a document in
|
|
// the new window. We do this by simply asking the new window for
|
|
// its document, this will synchronously create an empty document
|
|
// if there is no document in the window.
|
|
// XXXbz should this just use EnsureInnerWindow()?
|
|
|
|
// Force document creation.
|
|
nsCOMPtr<nsIDocument> doc = (*aReturn)->GetDoc();
|
|
Unused << doc;
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// nsGlobalWindow: Timeout Functions
|
|
//*****************************************************************************
|
|
|
|
nsGlobalWindow*
|
|
nsGlobalWindow::InnerForSetTimeoutOrInterval(ErrorResult& aError)
|
|
{
|
|
nsGlobalWindow* currentInner;
|
|
nsGlobalWindow* forwardTo;
|
|
if (IsInnerWindow()) {
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
currentInner = outer ? outer->GetCurrentInnerWindowInternal() : this;
|
|
|
|
forwardTo = this;
|
|
} else {
|
|
currentInner = GetCurrentInnerWindowInternal();
|
|
|
|
// This needs to forward to the inner window, but since the current
|
|
// inner may not be the inner in the calling scope, we need to treat
|
|
// this specially here as we don't want timeouts registered in a
|
|
// dying inner window to get registered and run on the current inner
|
|
// window. To get this right, we need to forward this call to the
|
|
// inner window that's calling window.setTimeout().
|
|
|
|
forwardTo = CallerInnerWindow();
|
|
if (!forwardTo && nsContentUtils::IsCallerChrome()) {
|
|
forwardTo = currentInner;
|
|
}
|
|
if (!forwardTo) {
|
|
aError.Throw(NS_ERROR_NOT_AVAILABLE);
|
|
return nullptr;
|
|
}
|
|
|
|
// If the caller and the callee share the same outer window, forward to the
|
|
// caller inner. Else, we forward to the current inner (e.g. someone is
|
|
// calling setTimeout() on a reference to some other window).
|
|
if (forwardTo->GetOuterWindow() != AsOuter() ||
|
|
!forwardTo->IsInnerWindow()) {
|
|
if (!currentInner) {
|
|
NS_WARNING("No inner window available!");
|
|
aError.Throw(NS_ERROR_NOT_INITIALIZED);
|
|
return nullptr;
|
|
}
|
|
|
|
return currentInner;
|
|
}
|
|
}
|
|
|
|
// If forwardTo is not the window with an active document then we want the
|
|
// call to setTimeout/Interval to be a noop, so return null but don't set an
|
|
// error.
|
|
return forwardTo->AsInner()->HasActiveDocument() ? currentInner : nullptr;
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::SetTimeout(JSContext* aCx, Function& aFunction,
|
|
int32_t aTimeout,
|
|
const Sequence<JS::Value>& aArguments,
|
|
ErrorResult& aError)
|
|
{
|
|
return SetTimeoutOrInterval(aCx, aFunction, aTimeout, aArguments, false,
|
|
aError);
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::SetTimeout(JSContext* aCx, const nsAString& aHandler,
|
|
int32_t aTimeout,
|
|
const Sequence<JS::Value>& /* unused */,
|
|
ErrorResult& aError)
|
|
{
|
|
return SetTimeoutOrInterval(aCx, aHandler, aTimeout, false, aError);
|
|
}
|
|
|
|
static bool
|
|
IsInterval(const Optional<int32_t>& aTimeout, int32_t& aResultTimeout)
|
|
{
|
|
if (aTimeout.WasPassed()) {
|
|
aResultTimeout = aTimeout.Value();
|
|
return true;
|
|
}
|
|
|
|
// If no interval was specified, treat this like a timeout, to avoid setting
|
|
// an interval of 0 milliseconds.
|
|
aResultTimeout = 0;
|
|
return false;
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::SetInterval(JSContext* aCx, Function& aFunction,
|
|
const Optional<int32_t>& aTimeout,
|
|
const Sequence<JS::Value>& aArguments,
|
|
ErrorResult& aError)
|
|
{
|
|
int32_t timeout;
|
|
bool isInterval = IsInterval(aTimeout, timeout);
|
|
return SetTimeoutOrInterval(aCx, aFunction, timeout, aArguments, isInterval,
|
|
aError);
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::SetInterval(JSContext* aCx, const nsAString& aHandler,
|
|
const Optional<int32_t>& aTimeout,
|
|
const Sequence<JS::Value>& /* unused */,
|
|
ErrorResult& aError)
|
|
{
|
|
int32_t timeout;
|
|
bool isInterval = IsInterval(aTimeout, timeout);
|
|
return SetTimeoutOrInterval(aCx, aHandler, timeout, isInterval, aError);
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::SetTimeoutOrInterval(JSContext *aCx, Function& aFunction,
|
|
int32_t aTimeout,
|
|
const Sequence<JS::Value>& aArguments,
|
|
bool aIsInterval, ErrorResult& aError)
|
|
{
|
|
nsGlobalWindow* inner = InnerForSetTimeoutOrInterval(aError);
|
|
if (!inner) {
|
|
return -1;
|
|
}
|
|
|
|
if (inner != this) {
|
|
return inner->SetTimeoutOrInterval(aCx, aFunction, aTimeout, aArguments,
|
|
aIsInterval, aError);
|
|
}
|
|
|
|
nsCOMPtr<nsIScriptTimeoutHandler> handler =
|
|
NS_CreateJSTimeoutHandler(aCx, this, aFunction, aArguments, aError);
|
|
if (!handler) {
|
|
return 0;
|
|
}
|
|
|
|
int32_t result;
|
|
aError = mTimeoutManager->SetTimeout(handler, aTimeout, aIsInterval,
|
|
Timeout::Reason::eTimeoutOrInterval,
|
|
&result);
|
|
return result;
|
|
}
|
|
|
|
int32_t
|
|
nsGlobalWindow::SetTimeoutOrInterval(JSContext* aCx, const nsAString& aHandler,
|
|
int32_t aTimeout, bool aIsInterval,
|
|
ErrorResult& aError)
|
|
{
|
|
nsGlobalWindow* inner = InnerForSetTimeoutOrInterval(aError);
|
|
if (!inner) {
|
|
return -1;
|
|
}
|
|
|
|
if (inner != this) {
|
|
return inner->SetTimeoutOrInterval(aCx, aHandler, aTimeout, aIsInterval,
|
|
aError);
|
|
}
|
|
|
|
nsCOMPtr<nsIScriptTimeoutHandler> handler =
|
|
NS_CreateJSTimeoutHandler(aCx, this, aHandler, aError);
|
|
if (!handler) {
|
|
return 0;
|
|
}
|
|
|
|
int32_t result;
|
|
aError = mTimeoutManager->SetTimeout(handler, aTimeout, aIsInterval,
|
|
Timeout::Reason::eTimeoutOrInterval,
|
|
&result);
|
|
return result;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::RunTimeoutHandler(Timeout* aTimeout,
|
|
nsIScriptContext* aScx)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
// Hold on to the timeout in case mExpr or mFunObj releases its
|
|
// doc.
|
|
RefPtr<Timeout> timeout = aTimeout;
|
|
Timeout* last_running_timeout = mTimeoutManager->BeginRunningTimeout(timeout);
|
|
timeout->mRunning = true;
|
|
|
|
// Push this timeout's popup control state, which should only be
|
|
// eabled the first time a timeout fires that was created while
|
|
// popups were enabled and with a delay less than
|
|
// "dom.disable_open_click_delay".
|
|
nsAutoPopupStatePusher popupStatePusher(timeout->mPopupState);
|
|
|
|
// Clear the timeout's popup state, if any, to prevent interval
|
|
// timeouts from repeatedly opening poups.
|
|
timeout->mPopupState = openAbused;
|
|
|
|
bool trackNestingLevel = !timeout->mIsInterval;
|
|
uint32_t nestingLevel;
|
|
if (trackNestingLevel) {
|
|
nestingLevel = TimeoutManager::GetNestingLevel();
|
|
TimeoutManager::SetNestingLevel(timeout->mNestingLevel);
|
|
}
|
|
|
|
const char *reason;
|
|
if (timeout->mIsInterval) {
|
|
reason = "setInterval handler";
|
|
} else {
|
|
reason = "setTimeout handler";
|
|
}
|
|
|
|
bool abortIntervalHandler = false;
|
|
nsCOMPtr<nsIScriptTimeoutHandler> handler(do_QueryInterface(timeout->mScriptHandler));
|
|
if (handler) {
|
|
RefPtr<Function> callback = handler->GetCallback();
|
|
|
|
if (!callback) {
|
|
// Evaluate the timeout expression.
|
|
const nsAString& script = handler->GetHandlerText();
|
|
|
|
const char* filename = nullptr;
|
|
uint32_t lineNo = 0, dummyColumn = 0;
|
|
handler->GetLocation(&filename, &lineNo, &dummyColumn);
|
|
|
|
// New script entry point required, due to the "Create a script" sub-step of
|
|
// http://www.whatwg.org/specs/web-apps/current-work/#timer-initialisation-steps
|
|
nsAutoMicroTask mt;
|
|
AutoEntryScript aes(this, reason, true);
|
|
JS::CompileOptions options(aes.cx());
|
|
options.setFileAndLine(filename, lineNo).setVersion(JSVERSION_DEFAULT);
|
|
options.setNoScriptRval(true);
|
|
JS::Rooted<JSObject*> global(aes.cx(), FastGetGlobalJSObject());
|
|
nsresult rv = NS_OK;
|
|
{
|
|
nsJSUtils::ExecutionContext exec(aes.cx(), global);
|
|
rv = exec.CompileAndExec(options, script);
|
|
}
|
|
|
|
if (rv == NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW_UNCATCHABLE) {
|
|
abortIntervalHandler = true;
|
|
}
|
|
} else {
|
|
// Hold strong ref to ourselves while we call the callback.
|
|
nsCOMPtr<nsISupports> me(static_cast<nsIDOMWindow*>(this));
|
|
ErrorResult rv;
|
|
JS::Rooted<JS::Value> ignoredVal(RootingCx());
|
|
callback->Call(me, handler->GetArgs(), &ignoredVal, rv, reason);
|
|
if (rv.IsUncatchableException()) {
|
|
abortIntervalHandler = true;
|
|
}
|
|
|
|
rv.SuppressException();
|
|
}
|
|
} else {
|
|
nsCOMPtr<nsITimeoutHandler> basicHandler(timeout->mScriptHandler);
|
|
nsCOMPtr<nsISupports> kungFuDeathGrip(static_cast<nsIDOMWindow*>(this));
|
|
mozilla::Unused << kungFuDeathGrip;
|
|
basicHandler->Call();
|
|
}
|
|
|
|
// If we received an uncatchable exception, do not schedule the timeout again.
|
|
// This allows the slow script dialog to break easy DoS attacks like
|
|
// setInterval(function() { while(1); }, 100);
|
|
if (abortIntervalHandler) {
|
|
// If it wasn't an interval timer to begin with, this does nothing. If it
|
|
// was, we'll treat it as a timeout that we just ran and discard it when
|
|
// we return.
|
|
timeout->mIsInterval = false;
|
|
}
|
|
|
|
// We ignore any failures from calling EvaluateString() on the context or
|
|
// Call() on a Function here since we're in a loop
|
|
// where we're likely to be running timeouts whose OS timers
|
|
// didn't fire in time and we don't want to not fire those timers
|
|
// now just because execution of one timer failed. We can't
|
|
// propagate the error to anyone who cares about it from this
|
|
// point anyway, and the script context should have already reported
|
|
// the script error in the usual way - so we just drop it.
|
|
|
|
// Since we might be processing more timeouts, go ahead and flush the promise
|
|
// queue now before we do that. We need to do that while we're still in our
|
|
// "running JS is safe" state (e.g. mRunningTimeout is set, timeout->mRunning
|
|
// is false).
|
|
Promise::PerformMicroTaskCheckpoint();
|
|
|
|
if (trackNestingLevel) {
|
|
TimeoutManager::SetNestingLevel(nestingLevel);
|
|
}
|
|
|
|
mTimeoutManager->EndRunningTimeout(last_running_timeout);
|
|
timeout->mRunning = false;
|
|
|
|
return timeout->mCleared;
|
|
}
|
|
|
|
//*****************************************************************************
|
|
// nsGlobalWindow: Helper Functions
|
|
//*****************************************************************************
|
|
|
|
already_AddRefed<nsIDocShellTreeOwner>
|
|
nsGlobalWindow::GetTreeOwner()
|
|
{
|
|
FORWARD_TO_OUTER(GetTreeOwner, (), nullptr);
|
|
|
|
// If there's no docShellAsItem, this window must have been closed,
|
|
// in that case there is no tree owner.
|
|
|
|
if (!mDocShell) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
|
|
mDocShell->GetTreeOwner(getter_AddRefs(treeOwner));
|
|
return treeOwner.forget();
|
|
}
|
|
|
|
already_AddRefed<nsIBaseWindow>
|
|
nsGlobalWindow::GetTreeOwnerWindow()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
|
|
|
|
// If there's no mDocShell, this window must have been closed,
|
|
// in that case there is no tree owner.
|
|
|
|
if (mDocShell) {
|
|
mDocShell->GetTreeOwner(getter_AddRefs(treeOwner));
|
|
}
|
|
|
|
nsCOMPtr<nsIBaseWindow> baseWindow = do_QueryInterface(treeOwner);
|
|
return baseWindow.forget();
|
|
}
|
|
|
|
already_AddRefed<nsIWebBrowserChrome>
|
|
nsGlobalWindow::GetWebBrowserChrome()
|
|
{
|
|
nsCOMPtr<nsIDocShellTreeOwner> treeOwner = GetTreeOwner();
|
|
|
|
nsCOMPtr<nsIWebBrowserChrome> browserChrome = do_GetInterface(treeOwner);
|
|
return browserChrome.forget();
|
|
}
|
|
|
|
nsIScrollableFrame *
|
|
nsGlobalWindow::GetScrollFrame()
|
|
{
|
|
FORWARD_TO_OUTER(GetScrollFrame, (), nullptr);
|
|
|
|
if (!mDocShell) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsCOMPtr<nsIPresShell> presShell = mDocShell->GetPresShell();
|
|
if (presShell) {
|
|
return presShell->GetRootScrollFrameAsScrollable();
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::SecurityCheckURL(const char *aURL)
|
|
{
|
|
nsCOMPtr<nsPIDOMWindowInner> sourceWindow = do_QueryInterface(GetEntryGlobal());
|
|
if (!sourceWindow) {
|
|
sourceWindow = AsOuter()->GetCurrentInnerWindow();
|
|
}
|
|
AutoJSContext cx;
|
|
nsGlobalWindow* sourceWin = nsGlobalWindow::Cast(sourceWindow);
|
|
JSAutoCompartment ac(cx, sourceWin->GetGlobalJSObject());
|
|
|
|
// Resolve the baseURI, which could be relative to the calling window.
|
|
//
|
|
// Note the algorithm to get the base URI should match the one
|
|
// used to actually kick off the load in nsWindowWatcher.cpp.
|
|
nsCOMPtr<nsIDocument> doc = sourceWindow->GetDoc();
|
|
nsIURI* baseURI = nullptr;
|
|
auto encoding = UTF_8_ENCODING; // default to utf-8
|
|
if (doc) {
|
|
baseURI = doc->GetDocBaseURI();
|
|
encoding = doc->GetDocumentCharacterSet();
|
|
}
|
|
nsCOMPtr<nsIURI> uri;
|
|
nsresult rv = NS_NewURI(getter_AddRefs(uri), nsDependentCString(aURL),
|
|
encoding, baseURI);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
|
}
|
|
|
|
if (NS_FAILED(nsContentUtils::GetSecurityManager()->
|
|
CheckLoadURIFromScript(cx, uri))) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::IsPrivateBrowsing()
|
|
{
|
|
nsCOMPtr<nsILoadContext> loadContext = do_QueryInterface(GetDocShell());
|
|
return loadContext && loadContext->UsePrivateBrowsing();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::FlushPendingNotifications(FlushType aType)
|
|
{
|
|
if (mDoc) {
|
|
mDoc->FlushPendingNotifications(aType);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::EnsureSizeAndPositionUpToDate()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
|
|
// If we're a subframe, make sure our size is up to date. It's OK that this
|
|
// crosses the content/chrome boundary, since chrome can have pending reflows
|
|
// too.
|
|
nsGlobalWindow *parent = nsGlobalWindow::Cast(GetPrivateParent());
|
|
if (parent) {
|
|
parent->FlushPendingNotifications(FlushType::Layout);
|
|
}
|
|
}
|
|
|
|
already_AddRefed<nsISupports>
|
|
nsGlobalWindow::SaveWindowState()
|
|
{
|
|
NS_PRECONDITION(IsOuterWindow(), "Can't save the inner window's state");
|
|
|
|
if (!mContext || !GetWrapperPreserveColor()) {
|
|
// The window may be getting torn down; don't bother saving state.
|
|
return nullptr;
|
|
}
|
|
|
|
nsGlobalWindow *inner = GetCurrentInnerWindowInternal();
|
|
NS_ASSERTION(inner, "No inner window to save");
|
|
|
|
// Don't do anything else to this inner window! After this point, all
|
|
// calls to SetTimeoutOrInterval will create entries in the timeout
|
|
// list that will only run after this window has come out of the bfcache.
|
|
// Also, while we're frozen, we won't dispatch online/offline events
|
|
// to the page.
|
|
inner->Freeze();
|
|
|
|
nsCOMPtr<nsISupports> state = new WindowStateHolder(inner);
|
|
|
|
#ifdef DEBUG_PAGE_CACHE
|
|
printf("saving window state, state = %p\n", (void*)state);
|
|
#endif
|
|
|
|
return state.forget();
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::RestoreWindowState(nsISupports *aState)
|
|
{
|
|
NS_ASSERTION(IsOuterWindow(), "Cannot restore an inner window");
|
|
|
|
if (!mContext || !GetWrapperPreserveColor()) {
|
|
// The window may be getting torn down; don't bother restoring state.
|
|
return NS_OK;
|
|
}
|
|
|
|
nsCOMPtr<WindowStateHolder> holder = do_QueryInterface(aState);
|
|
NS_ENSURE_TRUE(holder, NS_ERROR_FAILURE);
|
|
|
|
#ifdef DEBUG_PAGE_CACHE
|
|
printf("restoring window state, state = %p\n", (void*)holder);
|
|
#endif
|
|
|
|
// And we're ready to go!
|
|
nsGlobalWindow *inner = GetCurrentInnerWindowInternal();
|
|
|
|
// if a link is focused, refocus with the FLAG_SHOWRING flag set. This makes
|
|
// it easy to tell which link was last clicked when going back a page.
|
|
nsIContent* focusedNode = inner->GetFocusedNode();
|
|
if (IsLink(focusedNode)) {
|
|
nsIFocusManager* fm = nsFocusManager::GetFocusManager();
|
|
if (fm) {
|
|
nsCOMPtr<nsIDOMElement> focusedElement(do_QueryInterface(focusedNode));
|
|
fm->SetFocus(focusedElement, nsIFocusManager::FLAG_NOSCROLL |
|
|
nsIFocusManager::FLAG_SHOWRING);
|
|
}
|
|
}
|
|
|
|
inner->Thaw();
|
|
|
|
holder->DidRestoreWindow();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::EnableDeviceSensor(uint32_t aType)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
bool alreadyEnabled = false;
|
|
for (uint32_t i = 0; i < mEnabledSensors.Length(); i++) {
|
|
if (mEnabledSensors[i] == aType) {
|
|
alreadyEnabled = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
mEnabledSensors.AppendElement(aType);
|
|
|
|
if (alreadyEnabled) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIDeviceSensors> ac = do_GetService(NS_DEVICE_SENSORS_CONTRACTID);
|
|
if (ac) {
|
|
ac->AddWindowListener(aType, this);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::DisableDeviceSensor(uint32_t aType)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
int32_t doomedElement = -1;
|
|
int32_t listenerCount = 0;
|
|
for (uint32_t i = 0; i < mEnabledSensors.Length(); i++) {
|
|
if (mEnabledSensors[i] == aType) {
|
|
doomedElement = i;
|
|
listenerCount++;
|
|
}
|
|
}
|
|
|
|
if (doomedElement == -1) {
|
|
return;
|
|
}
|
|
|
|
mEnabledSensors.RemoveElementAt(doomedElement);
|
|
|
|
if (listenerCount > 1) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIDeviceSensors> ac = do_GetService(NS_DEVICE_SENSORS_CONTRACTID);
|
|
if (ac) {
|
|
ac->RemoveWindowListener(aType, this);
|
|
}
|
|
}
|
|
|
|
#if defined(MOZ_WIDGET_ANDROID)
|
|
void
|
|
nsGlobalWindow::EnableOrientationChangeListener()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
if (!nsContentUtils::ShouldResistFingerprinting(mDocShell) &&
|
|
!mOrientationChangeObserver) {
|
|
mOrientationChangeObserver =
|
|
MakeUnique<WindowOrientationObserver>(this);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::DisableOrientationChangeListener()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
mOrientationChangeObserver = nullptr;
|
|
}
|
|
#endif
|
|
|
|
void
|
|
nsGlobalWindow::SetHasGamepadEventListener(bool aHasGamepad/* = true*/)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
mHasGamepad = aHasGamepad;
|
|
if (aHasGamepad) {
|
|
EnableGamepadUpdates();
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
nsGlobalWindow::EventListenerAdded(nsAtom* aType)
|
|
{
|
|
if (aType == nsGkAtoms::onvrdisplayactivate ||
|
|
aType == nsGkAtoms::onvrdisplayconnect ||
|
|
aType == nsGkAtoms::onvrdisplaydeactivate ||
|
|
aType == nsGkAtoms::onvrdisplaydisconnect ||
|
|
aType == nsGkAtoms::onvrdisplaypresentchange) {
|
|
NotifyVREventListenerAdded();
|
|
}
|
|
|
|
if (aType == nsGkAtoms::onvrdisplayactivate) {
|
|
mHasVRDisplayActivateEvents = true;
|
|
}
|
|
|
|
if (aType == nsGkAtoms::onbeforeunload &&
|
|
mTabChild &&
|
|
(!mDoc || !(mDoc->GetSandboxFlags() & SANDBOXED_MODALS))) {
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
mBeforeUnloadListenerCount++;
|
|
MOZ_ASSERT(mBeforeUnloadListenerCount > 0);
|
|
mTabChild->BeforeUnloadAdded();
|
|
}
|
|
|
|
// We need to initialize localStorage in order to receive notifications.
|
|
if (aType == nsGkAtoms::onstorage) {
|
|
ErrorResult rv;
|
|
GetLocalStorage(rv);
|
|
rv.SuppressException();
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::EventListenerRemoved(nsAtom* aType)
|
|
{
|
|
if (aType == nsGkAtoms::onbeforeunload &&
|
|
mTabChild &&
|
|
(!mDoc || !(mDoc->GetSandboxFlags() & SANDBOXED_MODALS))) {
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
mBeforeUnloadListenerCount--;
|
|
MOZ_ASSERT(mBeforeUnloadListenerCount >= 0);
|
|
mTabChild->BeforeUnloadRemoved();
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::NotifyVREventListenerAdded()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
mHasVREvents = true;
|
|
EnableVRUpdates();
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::HasUsedVR() const
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
// Returns true only if any WebVR API call or related event
|
|
// has been used
|
|
return mHasVREvents;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::IsVRContentDetected() const
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
// Returns true only if the content will respond to
|
|
// the VRDisplayActivate event.
|
|
return mHasVRDisplayActivateEvents;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::IsVRContentPresenting() const
|
|
{
|
|
for (const auto& display : mVRDisplays) {
|
|
if (display->IsAnyPresenting(gfx::kVRGroupAll)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::EnableTimeChangeNotifications()
|
|
{
|
|
mozilla::time::AddWindowListener(AsInner());
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::DisableTimeChangeNotifications()
|
|
{
|
|
mozilla::time::RemoveWindowListener(AsInner());
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::AddSizeOfIncludingThis(nsWindowSizes& aWindowSizes) const
|
|
{
|
|
aWindowSizes.mDOMOtherSize += aWindowSizes.mState.mMallocSizeOf(this);
|
|
|
|
if (IsInnerWindow()) {
|
|
EventListenerManager* elm = GetExistingListenerManager();
|
|
if (elm) {
|
|
aWindowSizes.mDOMOtherSize +=
|
|
elm->SizeOfIncludingThis(aWindowSizes.mState.mMallocSizeOf);
|
|
aWindowSizes.mDOMEventListenersCount += elm->ListenerCount();
|
|
}
|
|
if (mDoc) {
|
|
// Multiple global windows can share a document. So only measure the
|
|
// document if it (a) doesn't have a global window, or (b) it's the
|
|
// primary document for the window.
|
|
if (!mDoc->GetInnerWindow() ||
|
|
mDoc->GetInnerWindow() == AsInner()) {
|
|
mDoc->DocAddSizeOfIncludingThis(aWindowSizes);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mNavigator) {
|
|
aWindowSizes.mDOMOtherSize +=
|
|
mNavigator->SizeOfIncludingThis(aWindowSizes.mState.mMallocSizeOf);
|
|
}
|
|
|
|
aWindowSizes.mDOMEventTargetsSize +=
|
|
mEventTargetObjects.ShallowSizeOfExcludingThis(
|
|
aWindowSizes.mState.mMallocSizeOf);
|
|
|
|
for (auto iter = mEventTargetObjects.ConstIter(); !iter.Done(); iter.Next()) {
|
|
DOMEventTargetHelper* et = iter.Get()->GetKey();
|
|
if (nsCOMPtr<nsISizeOfEventTarget> iSizeOf = do_QueryObject(et)) {
|
|
aWindowSizes.mDOMEventTargetsSize +=
|
|
iSizeOf->SizeOfEventTargetIncludingThis(
|
|
aWindowSizes.mState.mMallocSizeOf);
|
|
}
|
|
if (EventListenerManager* elm = et->GetExistingListenerManager()) {
|
|
aWindowSizes.mDOMEventListenersCount += elm->ListenerCount();
|
|
}
|
|
++aWindowSizes.mDOMEventTargetsCount;
|
|
}
|
|
|
|
if (IsInnerWindow() && mPerformance) {
|
|
aWindowSizes.mDOMPerformanceUserEntries =
|
|
mPerformance->SizeOfUserEntries(aWindowSizes.mState.mMallocSizeOf);
|
|
aWindowSizes.mDOMPerformanceResourceEntries =
|
|
mPerformance->SizeOfResourceEntries(aWindowSizes.mState.mMallocSizeOf);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::AddGamepad(uint32_t aIndex, Gamepad* aGamepad)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
// Create the index we will present to content based on which indices are
|
|
// already taken, as required by the spec.
|
|
// https://w3c.github.io/gamepad/gamepad.html#widl-Gamepad-index
|
|
int index = 0;
|
|
while(mGamepadIndexSet.Contains(index)) {
|
|
++index;
|
|
}
|
|
mGamepadIndexSet.Put(index);
|
|
aGamepad->SetIndex(index);
|
|
mGamepads.Put(aIndex, aGamepad);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::RemoveGamepad(uint32_t aIndex)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
RefPtr<Gamepad> gamepad;
|
|
if (!mGamepads.Get(aIndex, getter_AddRefs(gamepad))) {
|
|
return;
|
|
}
|
|
// Free up the index we were using so it can be reused
|
|
mGamepadIndexSet.Remove(gamepad->Index());
|
|
mGamepads.Remove(aIndex);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetGamepads(nsTArray<RefPtr<Gamepad> >& aGamepads)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
aGamepads.Clear();
|
|
|
|
// navigator.getGamepads() always returns an empty array when
|
|
// privacy.resistFingerprinting is true.
|
|
if (nsContentUtils::ShouldResistFingerprinting()) {
|
|
return;
|
|
}
|
|
|
|
// mGamepads.Count() may not be sufficient, but it's not harmful.
|
|
aGamepads.SetCapacity(mGamepads.Count());
|
|
for (auto iter = mGamepads.Iter(); !iter.Done(); iter.Next()) {
|
|
Gamepad* gamepad = iter.UserData();
|
|
aGamepads.EnsureLengthAtLeast(gamepad->Index() + 1);
|
|
aGamepads[gamepad->Index()] = gamepad;
|
|
}
|
|
}
|
|
|
|
already_AddRefed<Gamepad>
|
|
nsGlobalWindow::GetGamepad(uint32_t aIndex)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
RefPtr<Gamepad> gamepad;
|
|
|
|
if (mGamepads.Get(aIndex, getter_AddRefs(gamepad))) {
|
|
return gamepad.forget();
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetHasSeenGamepadInput(bool aHasSeen)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
mHasSeenGamepadInput = aHasSeen;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::HasSeenGamepadInput()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
return mHasSeenGamepadInput;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SyncGamepadState()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
if (mHasSeenGamepadInput) {
|
|
RefPtr<GamepadManager> gamepadManager(GamepadManager::GetService());
|
|
for (auto iter = mGamepads.Iter(); !iter.Done(); iter.Next()) {
|
|
gamepadManager->SyncGamepadState(iter.Key(), iter.UserData());
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::StopGamepadHaptics()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
if (mHasSeenGamepadInput) {
|
|
RefPtr<GamepadManager> gamepadManager(GamepadManager::GetService());
|
|
gamepadManager->StopHaptics();
|
|
}
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::UpdateVRDisplays(nsTArray<RefPtr<mozilla::dom::VRDisplay>>& aDevices)
|
|
{
|
|
FORWARD_TO_INNER(UpdateVRDisplays, (aDevices), false);
|
|
|
|
VRDisplay::UpdateVRDisplays(mVRDisplays, AsInner());
|
|
aDevices = mVRDisplays;
|
|
return true;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::NotifyActiveVRDisplaysChanged()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
if (mNavigator) {
|
|
mNavigator->NotifyActiveVRDisplaysChanged();
|
|
}
|
|
}
|
|
|
|
uint32_t
|
|
nsGlobalWindow::GetAutoActivateVRDisplayID()
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
uint32_t retVal = mAutoActivateVRDisplayID;
|
|
mAutoActivateVRDisplayID = 0;
|
|
return retVal;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetAutoActivateVRDisplayID(uint32_t aAutoActivateVRDisplayID)
|
|
{
|
|
MOZ_ASSERT(IsOuterWindow());
|
|
mAutoActivateVRDisplayID = aAutoActivateVRDisplayID;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::DispatchVRDisplayActivate(uint32_t aDisplayID,
|
|
mozilla::dom::VRDisplayEventReason aReason)
|
|
{
|
|
// Search for the display identified with aDisplayID and fire the
|
|
// event if found.
|
|
for (const auto& display : mVRDisplays) {
|
|
if (display->DisplayId() == aDisplayID) {
|
|
if (aReason != VRDisplayEventReason::Navigation &&
|
|
display->IsAnyPresenting(gfx::kVRGroupContent)) {
|
|
// We only want to trigger this event if nobody is presenting to the
|
|
// display already or when a page is loaded by navigating away
|
|
// from a page with an active VR Presentation.
|
|
continue;
|
|
}
|
|
|
|
VRDisplayEventInit init;
|
|
init.mBubbles = false;
|
|
init.mCancelable = false;
|
|
init.mDisplay = display;
|
|
init.mReason.Construct(aReason);
|
|
|
|
RefPtr<VRDisplayEvent> event =
|
|
VRDisplayEvent::Constructor(this,
|
|
NS_LITERAL_STRING("vrdisplayactivate"),
|
|
init);
|
|
// vrdisplayactivate is a trusted event, allowing VRDisplay.requestPresent
|
|
// to be used in response to link traversal, user request (chrome UX), and
|
|
// HMD mounting detection sensors.
|
|
event->SetTrusted(true);
|
|
bool defaultActionEnabled;
|
|
// VRDisplay.requestPresent normally requires a user gesture; however, an
|
|
// exception is made to allow it to be called in response to vrdisplayactivate
|
|
// during VR link traversal.
|
|
display->StartHandlingVRNavigationEvent();
|
|
Unused << DispatchEvent(event, &defaultActionEnabled);
|
|
display->StopHandlingVRNavigationEvent();
|
|
// Once we dispatch the event, we must not access any members as an event
|
|
// listener can do anything, including closing windows.
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::DispatchVRDisplayDeactivate(uint32_t aDisplayID,
|
|
mozilla::dom::VRDisplayEventReason aReason)
|
|
{
|
|
// Search for the display identified with aDisplayID and fire the
|
|
// event if found.
|
|
for (const auto& display : mVRDisplays) {
|
|
if (display->DisplayId() == aDisplayID && display->IsPresenting()) {
|
|
// We only want to trigger this event to content that is presenting to
|
|
// the display already.
|
|
|
|
VRDisplayEventInit init;
|
|
init.mBubbles = false;
|
|
init.mCancelable = false;
|
|
init.mDisplay = display;
|
|
init.mReason.Construct(aReason);
|
|
|
|
RefPtr<VRDisplayEvent> event =
|
|
VRDisplayEvent::Constructor(this,
|
|
NS_LITERAL_STRING("vrdisplaydeactivate"),
|
|
init);
|
|
event->SetTrusted(true);
|
|
bool defaultActionEnabled;
|
|
Unused << DispatchEvent(event, &defaultActionEnabled);
|
|
// Once we dispatch the event, we must not access any members as an event
|
|
// listener can do anything, including closing windows.
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::DispatchVRDisplayConnect(uint32_t aDisplayID)
|
|
{
|
|
// Search for the display identified with aDisplayID and fire the
|
|
// event if found.
|
|
for (const auto& display : mVRDisplays) {
|
|
if (display->DisplayId() == aDisplayID) {
|
|
// Fire event even if not presenting to the display.
|
|
VRDisplayEventInit init;
|
|
init.mBubbles = false;
|
|
init.mCancelable = false;
|
|
init.mDisplay = display;
|
|
// VRDisplayEvent.reason is not set for vrdisplayconnect
|
|
|
|
RefPtr<VRDisplayEvent> event =
|
|
VRDisplayEvent::Constructor(this,
|
|
NS_LITERAL_STRING("vrdisplayconnect"),
|
|
init);
|
|
event->SetTrusted(true);
|
|
bool defaultActionEnabled;
|
|
Unused << DispatchEvent(event, &defaultActionEnabled);
|
|
// Once we dispatch the event, we must not access any members as an event
|
|
// listener can do anything, including closing windows.
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::DispatchVRDisplayDisconnect(uint32_t aDisplayID)
|
|
{
|
|
// Search for the display identified with aDisplayID and fire the
|
|
// event if found.
|
|
for (const auto& display : mVRDisplays) {
|
|
if (display->DisplayId() == aDisplayID) {
|
|
// Fire event even if not presenting to the display.
|
|
VRDisplayEventInit init;
|
|
init.mBubbles = false;
|
|
init.mCancelable = false;
|
|
init.mDisplay = display;
|
|
// VRDisplayEvent.reason is not set for vrdisplaydisconnect
|
|
|
|
RefPtr<VRDisplayEvent> event =
|
|
VRDisplayEvent::Constructor(this,
|
|
NS_LITERAL_STRING("vrdisplaydisconnect"),
|
|
init);
|
|
event->SetTrusted(true);
|
|
bool defaultActionEnabled;
|
|
Unused << DispatchEvent(event, &defaultActionEnabled);
|
|
// Once we dispatch the event, we must not access any members as an event
|
|
// listener can do anything, including closing windows.
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::DispatchVRDisplayPresentChange(uint32_t aDisplayID)
|
|
{
|
|
// Search for the display identified with aDisplayID and fire the
|
|
// event if found.
|
|
for (const auto& display : mVRDisplays) {
|
|
if (display->DisplayId() == aDisplayID) {
|
|
// Fire event even if not presenting to the display.
|
|
VRDisplayEventInit init;
|
|
init.mBubbles = false;
|
|
init.mCancelable = false;
|
|
init.mDisplay = display;
|
|
// VRDisplayEvent.reason is not set for vrdisplaypresentchange
|
|
RefPtr<VRDisplayEvent> event =
|
|
VRDisplayEvent::Constructor(this,
|
|
NS_LITERAL_STRING("vrdisplaypresentchange"),
|
|
init);
|
|
event->SetTrusted(true);
|
|
bool defaultActionEnabled;
|
|
Unused << DispatchEvent(event, &defaultActionEnabled);
|
|
// Once we dispatch the event, we must not access any members as an event
|
|
// listener can do anything, including closing windows.
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* static */ already_AddRefed<nsGlobalWindow>
|
|
nsGlobalWindow::CreateChrome(nsGlobalWindow *aOuterWindow)
|
|
{
|
|
RefPtr<nsGlobalWindow> window = new nsGlobalWindow(aOuterWindow);
|
|
window->mIsChrome = true;
|
|
window->mCleanMessageManager = true;
|
|
|
|
window->InitWasOffline();
|
|
return window.forget();
|
|
}
|
|
|
|
enum WindowState {
|
|
// These constants need to match the constants in Window.webidl
|
|
STATE_MAXIMIZED = 1,
|
|
STATE_MINIMIZED = 2,
|
|
STATE_NORMAL = 3,
|
|
STATE_FULLSCREEN = 4
|
|
};
|
|
|
|
uint16_t
|
|
nsGlobalWindow::WindowState()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
nsCOMPtr<nsIWidget> widget = GetMainWidget();
|
|
|
|
int32_t mode = widget ? widget->SizeMode() : 0;
|
|
|
|
switch (mode) {
|
|
case nsSizeMode_Minimized:
|
|
return STATE_MINIMIZED;
|
|
case nsSizeMode_Maximized:
|
|
return STATE_MAXIMIZED;
|
|
case nsSizeMode_Fullscreen:
|
|
return STATE_FULLSCREEN;
|
|
case nsSizeMode_Normal:
|
|
return STATE_NORMAL;
|
|
default:
|
|
NS_WARNING("Illegal window state for this chrome window");
|
|
break;
|
|
}
|
|
|
|
return STATE_NORMAL;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::IsFullyOccluded()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetMainWidget();
|
|
return widget && widget->IsFullyOccluded();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Maximize()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetMainWidget();
|
|
|
|
if (widget) {
|
|
widget->SetSizeMode(nsSizeMode_Maximized);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Minimize()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetMainWidget();
|
|
|
|
if (widget) {
|
|
widget->SetSizeMode(nsSizeMode_Minimized);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::Restore()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetMainWidget();
|
|
|
|
if (widget) {
|
|
widget->SetSizeMode(nsSizeMode_Normal);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetAttention(ErrorResult& aResult)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
return GetAttentionWithCycleCount(-1, aResult);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetAttentionWithCycleCount(int32_t aCycleCount,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
nsCOMPtr<nsIWidget> widget = GetMainWidget();
|
|
|
|
if (widget) {
|
|
aError = widget->GetAttention(aCycleCount);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::BeginWindowMove(Event& aMouseDownEvent, Element* aPanel,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
nsCOMPtr<nsIWidget> widget;
|
|
|
|
// if a panel was supplied, use its widget instead.
|
|
#ifdef MOZ_XUL
|
|
if (aPanel) {
|
|
nsIFrame* frame = aPanel->GetPrimaryFrame();
|
|
if (!frame || !frame->IsMenuPopupFrame()) {
|
|
return;
|
|
}
|
|
|
|
widget = (static_cast<nsMenuPopupFrame*>(frame))->GetWidget();
|
|
}
|
|
else {
|
|
#endif
|
|
widget = GetMainWidget();
|
|
#ifdef MOZ_XUL
|
|
}
|
|
#endif
|
|
|
|
if (!widget) {
|
|
return;
|
|
}
|
|
|
|
WidgetMouseEvent* mouseEvent =
|
|
aMouseDownEvent.WidgetEventPtr()->AsMouseEvent();
|
|
if (!mouseEvent || mouseEvent->mClass != eMouseEventClass) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
aError = widget->BeginMoveDrag(mouseEvent);
|
|
}
|
|
|
|
already_AddRefed<nsWindowRoot>
|
|
nsGlobalWindow::GetWindowRootOuter()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
nsCOMPtr<nsPIWindowRoot> root = GetTopWindowRoot();
|
|
return root.forget().downcast<nsWindowRoot>();
|
|
}
|
|
|
|
already_AddRefed<nsWindowRoot>
|
|
nsGlobalWindow::GetWindowRoot(mozilla::ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetWindowRootOuter, (), aError, nullptr);
|
|
}
|
|
|
|
//Note: This call will lock the cursor, it will not change as it moves.
|
|
//To unlock, the cursor must be set back to CURSOR_AUTO.
|
|
void
|
|
nsGlobalWindow::SetCursorOuter(const nsAString& aCursor, ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
int32_t cursor;
|
|
|
|
if (aCursor.EqualsLiteral("auto"))
|
|
cursor = NS_STYLE_CURSOR_AUTO;
|
|
else {
|
|
nsCSSKeyword keyword = nsCSSKeywords::LookupKeyword(aCursor);
|
|
if (!nsCSSProps::FindKeyword(keyword, nsCSSProps::kCursorKTable, cursor)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
RefPtr<nsPresContext> presContext;
|
|
if (mDocShell) {
|
|
mDocShell->GetPresContext(getter_AddRefs(presContext));
|
|
}
|
|
|
|
if (presContext) {
|
|
// Need root widget.
|
|
nsCOMPtr<nsIPresShell> presShell = mDocShell->GetPresShell();
|
|
if (!presShell) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
nsViewManager* vm = presShell->GetViewManager();
|
|
if (!vm) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
nsView* rootView = vm->GetRootView();
|
|
if (!rootView) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
nsIWidget* widget = rootView->GetNearestWidget(nullptr);
|
|
if (!widget) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
// Call esm and set cursor.
|
|
aError = presContext->EventStateManager()->SetCursor(cursor, nullptr,
|
|
false, 0.0f, 0.0f,
|
|
widget, true);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetCursor(const nsAString& aCursor, ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(SetCursorOuter, (aCursor, aError), aError, );
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsGlobalWindow::GetBrowserDOMWindow(nsIBrowserDOMWindow **aBrowserWindow)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsChromeWindow());
|
|
FORWARD_TO_INNER(GetBrowserDOMWindow, (aBrowserWindow), NS_ERROR_UNEXPECTED);
|
|
|
|
ErrorResult rv;
|
|
NS_IF_ADDREF(*aBrowserWindow = GetBrowserDOMWindow(rv));
|
|
return rv.StealNSResult();
|
|
}
|
|
|
|
nsIBrowserDOMWindow*
|
|
nsGlobalWindow::GetBrowserDOMWindowOuter()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
MOZ_ASSERT(IsChromeWindow());
|
|
return mChromeFields.mBrowserDOMWindow;
|
|
}
|
|
|
|
nsIBrowserDOMWindow*
|
|
nsGlobalWindow::GetBrowserDOMWindow(ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(GetBrowserDOMWindowOuter, (), aError, nullptr);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetBrowserDOMWindowOuter(nsIBrowserDOMWindow* aBrowserWindow)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
MOZ_ASSERT(IsChromeWindow());
|
|
mChromeFields.mBrowserDOMWindow = aBrowserWindow;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetBrowserDOMWindow(nsIBrowserDOMWindow* aBrowserWindow,
|
|
ErrorResult& aError)
|
|
{
|
|
FORWARD_TO_OUTER_OR_THROW(SetBrowserDOMWindowOuter, (aBrowserWindow), aError, );
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::NotifyDefaultButtonLoaded(Element& aDefaultButton,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
#ifdef MOZ_XUL
|
|
// Don't snap to a disabled button.
|
|
nsCOMPtr<nsIDOMXULControlElement> xulControl =
|
|
do_QueryInterface(&aDefaultButton);
|
|
if (!xulControl) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
bool disabled;
|
|
aError = xulControl->GetDisabled(&disabled);
|
|
if (aError.Failed() || disabled) {
|
|
return;
|
|
}
|
|
|
|
// Get the button rect in screen coordinates.
|
|
nsIFrame *frame = aDefaultButton.GetPrimaryFrame();
|
|
if (!frame) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
LayoutDeviceIntRect buttonRect =
|
|
LayoutDeviceIntRect::FromAppUnitsToNearest(
|
|
frame->GetScreenRectInAppUnits(),
|
|
frame->PresContext()->AppUnitsPerDevPixel());
|
|
|
|
// Get the widget rect in screen coordinates.
|
|
nsIWidget *widget = GetNearestWidget();
|
|
if (!widget) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
LayoutDeviceIntRect widgetRect = widget->GetScreenBounds();
|
|
|
|
// Convert the buttonRect coordinates from screen to the widget.
|
|
buttonRect -= widgetRect.TopLeft();
|
|
nsresult rv = widget->OnDefaultButtonLoaded(buttonRect);
|
|
if (NS_FAILED(rv) && rv != NS_ERROR_NOT_IMPLEMENTED) {
|
|
aError.Throw(rv);
|
|
}
|
|
#else
|
|
aError.Throw(NS_ERROR_NOT_IMPLEMENTED);
|
|
#endif
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsGlobalWindow::GetMessageManager(nsIMessageBroadcaster** aManager)
|
|
{
|
|
FORWARD_TO_INNER(GetMessageManager, (aManager), NS_ERROR_UNEXPECTED);
|
|
|
|
ErrorResult rv;
|
|
NS_IF_ADDREF(*aManager = GetMessageManager(rv));
|
|
return rv.StealNSResult();
|
|
}
|
|
|
|
nsIMessageBroadcaster*
|
|
nsGlobalWindow::GetMessageManager(ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsChromeWindow());
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
if (!mChromeFields.mMessageManager) {
|
|
nsCOMPtr<nsIMessageBroadcaster> globalMM =
|
|
do_GetService("@mozilla.org/globalmessagemanager;1");
|
|
mChromeFields.mMessageManager =
|
|
new nsFrameMessageManager(nullptr,
|
|
static_cast<nsFrameMessageManager*>(globalMM.get()),
|
|
MM_CHROME | MM_BROADCASTER);
|
|
}
|
|
return mChromeFields.mMessageManager;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsGlobalWindow::GetGroupMessageManager(const nsAString& aGroup,
|
|
nsIMessageBroadcaster** aManager)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsChromeWindow());
|
|
FORWARD_TO_INNER(GetGroupMessageManager, (aGroup, aManager), NS_ERROR_UNEXPECTED);
|
|
|
|
ErrorResult rv;
|
|
NS_IF_ADDREF(*aManager = GetGroupMessageManager(aGroup, rv));
|
|
return rv.StealNSResult();
|
|
}
|
|
|
|
nsIMessageBroadcaster*
|
|
nsGlobalWindow::GetGroupMessageManager(const nsAString& aGroup,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsChromeWindow());
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
nsCOMPtr<nsIMessageBroadcaster> messageManager =
|
|
mChromeFields.mGroupMessageManagers.LookupForAdd(aGroup).OrInsert(
|
|
[this, &aError] () {
|
|
nsFrameMessageManager* parent =
|
|
static_cast<nsFrameMessageManager*>(GetMessageManager(aError));
|
|
|
|
return new nsFrameMessageManager(nullptr,
|
|
parent,
|
|
MM_CHROME | MM_BROADCASTER);
|
|
});
|
|
return messageManager;
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::SetOpenerForInitialContentBrowser(mozIDOMWindowProxy* aOpenerWindow)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsChromeWindow());
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
MOZ_ASSERT(!mChromeFields.mOpenerForInitialContentBrowser);
|
|
mChromeFields.mOpenerForInitialContentBrowser = aOpenerWindow;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::TakeOpenerForInitialContentBrowser(mozIDOMWindowProxy** aOpenerWindow)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsChromeWindow());
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
// Intentionally forget our own member
|
|
mChromeFields.mOpenerForInitialContentBrowser.forget(aOpenerWindow);
|
|
return NS_OK;
|
|
}
|
|
|
|
/* static */ already_AddRefed<nsGlobalWindow>
|
|
nsGlobalWindow::Create(nsGlobalWindow *aOuterWindow)
|
|
{
|
|
RefPtr<nsGlobalWindow> window = new nsGlobalWindow(aOuterWindow);
|
|
window->InitWasOffline();
|
|
return window.forget();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::InitWasOffline()
|
|
{
|
|
mWasOffline = NS_IsOffline();
|
|
}
|
|
|
|
#if defined(MOZ_WIDGET_ANDROID)
|
|
int16_t
|
|
nsGlobalWindow::Orientation(CallerType aCallerType) const
|
|
{
|
|
return nsContentUtils::ResistFingerprinting(aCallerType) ?
|
|
0 : WindowOrientationObserver::OrientationAngle();
|
|
}
|
|
#endif
|
|
|
|
Console*
|
|
nsGlobalWindow::GetConsole(ErrorResult& aRv)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mConsole) {
|
|
mConsole = Console::Create(AsInner(), aRv);
|
|
if (NS_WARN_IF(aRv.Failed())) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
return mConsole;
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::IsSecureContext() const
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
return JS_GetIsSecureContext(js::GetObjectCompartment(GetWrapperPreserveColor()));
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::IsSecureContextIfOpenerIgnored() const
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
return mIsSecureContextIfOpenerIgnored;
|
|
}
|
|
|
|
already_AddRefed<External>
|
|
nsGlobalWindow::GetExternal(ErrorResult& aRv)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
#ifdef HAVE_SIDEBAR
|
|
if (!mExternal) {
|
|
AutoJSContext cx;
|
|
JS::Rooted<JSObject*> jsImplObj(cx);
|
|
ConstructJSImplementation("@mozilla.org/sidebar;1", this, &jsImplObj, aRv);
|
|
if (aRv.Failed()) {
|
|
return nullptr;
|
|
}
|
|
mExternal = new External(jsImplObj, this);
|
|
}
|
|
|
|
RefPtr<External> external = static_cast<External*>(mExternal.get());
|
|
return external.forget();
|
|
#else
|
|
aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
|
|
return nullptr;
|
|
#endif
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetSidebar(OwningExternalOrWindowProxy& aResult,
|
|
ErrorResult& aRv)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
#ifdef HAVE_SIDEBAR
|
|
// First check for a named frame named "sidebar"
|
|
nsCOMPtr<nsPIDOMWindowOuter> domWindow = GetChildWindow(NS_LITERAL_STRING("sidebar"));
|
|
if (domWindow) {
|
|
aResult.SetAsWindowProxy() = domWindow.forget();
|
|
return;
|
|
}
|
|
|
|
RefPtr<External> external = GetExternal(aRv);
|
|
if (external) {
|
|
aResult.SetAsExternal() = external;
|
|
}
|
|
#else
|
|
aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ClearDocumentDependentSlots(JSContext* aCx)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
// If JSAPI OOMs here, there is basically nothing we can do to recover safely.
|
|
if (!WindowBinding::ClearCachedDocumentValue(aCx, this) ||
|
|
!WindowBinding::ClearCachedPerformanceValue(aCx, this)) {
|
|
MOZ_CRASH("Unhandlable OOM while clearing document dependent slots.");
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
JSObject*
|
|
nsGlobalWindow::CreateNamedPropertiesObject(JSContext *aCx,
|
|
JS::Handle<JSObject*> aProto)
|
|
{
|
|
return WindowNamedPropertiesHandler::Create(aCx, aProto);
|
|
}
|
|
|
|
bool
|
|
nsGlobalWindow::GetIsPrerendered()
|
|
{
|
|
nsIDocShell* docShell = GetDocShell();
|
|
return docShell && docShell->GetIsPrerendered();
|
|
}
|
|
|
|
void
|
|
nsPIDOMWindowOuter::SetLargeAllocStatus(LargeAllocStatus aStatus)
|
|
{
|
|
MOZ_ASSERT(mLargeAllocStatus == LargeAllocStatus::NONE);
|
|
mLargeAllocStatus = aStatus;
|
|
}
|
|
|
|
bool
|
|
nsPIDOMWindowOuter::IsTopLevelWindow()
|
|
{
|
|
return nsGlobalWindow::Cast(this)->IsTopLevelWindow();
|
|
}
|
|
|
|
bool
|
|
nsPIDOMWindowOuter::HadOriginalOpener() const
|
|
{
|
|
return nsGlobalWindow::Cast(this)->HadOriginalOpener();
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::ReportLargeAllocStatus()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
uint32_t errorFlags = nsIScriptError::warningFlag;
|
|
const char* message = nullptr;
|
|
|
|
switch (mLargeAllocStatus) {
|
|
case LargeAllocStatus::SUCCESS:
|
|
// Override the error flags such that the success message isn't reported
|
|
// as a warning.
|
|
errorFlags = nsIScriptError::infoFlag;
|
|
message = "LargeAllocationSuccess";
|
|
break;
|
|
case LargeAllocStatus::NON_WIN32:
|
|
errorFlags = nsIScriptError::infoFlag;
|
|
message = "LargeAllocationNonWin32";
|
|
break;
|
|
case LargeAllocStatus::NON_GET:
|
|
message = "LargeAllocationNonGetRequest";
|
|
break;
|
|
case LargeAllocStatus::NON_E10S:
|
|
message = "LargeAllocationNonE10S";
|
|
break;
|
|
case LargeAllocStatus::NOT_ONLY_TOPLEVEL_IN_TABGROUP:
|
|
message = "LargeAllocationNotOnlyToplevelInTabGroup";
|
|
break;
|
|
default: // LargeAllocStatus::NONE
|
|
return; // Don't report a message to the console
|
|
}
|
|
|
|
nsContentUtils::ReportToConsole(errorFlags,
|
|
NS_LITERAL_CSTRING("DOM"),
|
|
mDoc,
|
|
nsContentUtils::eDOM_PROPERTIES,
|
|
message);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::RedefineProperty(JSContext* aCx, const char* aPropName,
|
|
JS::Handle<JS::Value> aValue,
|
|
ErrorResult& aError)
|
|
{
|
|
JS::Rooted<JSObject*> thisObj(aCx, GetWrapperPreserveColor());
|
|
if (!thisObj) {
|
|
aError.Throw(NS_ERROR_UNEXPECTED);
|
|
return;
|
|
}
|
|
|
|
if (!JS_WrapObject(aCx, &thisObj) ||
|
|
!JS_DefineProperty(aCx, thisObj, aPropName, aValue, JSPROP_ENUMERATE)) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetReplaceableWindowCoord(JSContext* aCx,
|
|
nsGlobalWindow::WindowCoordGetter aGetter,
|
|
JS::MutableHandle<JS::Value> aRetval,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
int32_t coord = (this->*aGetter)(aCallerType, aError);
|
|
if (!aError.Failed() &&
|
|
!ToJSValue(aCx, coord, aRetval)) {
|
|
aError.Throw(NS_ERROR_FAILURE);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::SetReplaceableWindowCoord(JSContext* aCx,
|
|
nsGlobalWindow::WindowCoordSetter aSetter,
|
|
JS::Handle<JS::Value> aValue,
|
|
const char* aPropName,
|
|
CallerType aCallerType,
|
|
ErrorResult& aError)
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
/*
|
|
* If caller is not chrome and the user has not explicitly exempted the site,
|
|
* just treat this the way we would an IDL replaceable property.
|
|
*/
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
if (!outer ||
|
|
!outer->CanMoveResizeWindows(aCallerType) ||
|
|
outer->IsFrame()) {
|
|
RedefineProperty(aCx, aPropName, aValue, aError);
|
|
return;
|
|
}
|
|
|
|
int32_t value;
|
|
if (!ValueToPrimitive<int32_t, eDefault>(aCx, aValue, &value)) {
|
|
aError.Throw(NS_ERROR_UNEXPECTED);
|
|
return;
|
|
}
|
|
|
|
if (nsContentUtils::ShouldResistFingerprinting(GetDocShell())) {
|
|
bool innerWidthSpecified = false;
|
|
bool innerHeightSpecified = false;
|
|
bool outerWidthSpecified = false;
|
|
bool outerHeightSpecified = false;
|
|
|
|
if (strcmp(aPropName, "innerWidth") == 0) {
|
|
innerWidthSpecified = true;
|
|
} else if (strcmp(aPropName, "innerHeight") == 0) {
|
|
innerHeightSpecified = true;
|
|
} else if (strcmp(aPropName, "outerWidth") == 0) {
|
|
outerWidthSpecified = true;
|
|
} else if (strcmp(aPropName, "outerHeight") == 0) {
|
|
outerHeightSpecified = true;
|
|
}
|
|
|
|
if (innerWidthSpecified || innerHeightSpecified ||
|
|
outerWidthSpecified || outerHeightSpecified)
|
|
{
|
|
nsCOMPtr<nsIBaseWindow> treeOwnerAsWin = outer->GetTreeOwnerWindow();
|
|
nsCOMPtr<nsIScreen> screen;
|
|
nsCOMPtr<nsIScreenManager> screenMgr(
|
|
do_GetService("@mozilla.org/gfx/screenmanager;1"));
|
|
int32_t winLeft = 0;
|
|
int32_t winTop = 0;
|
|
int32_t winWidth = 0;
|
|
int32_t winHeight = 0;
|
|
double scale = 1.0;
|
|
|
|
|
|
if (treeOwnerAsWin && screenMgr) {
|
|
// Acquire current window size.
|
|
treeOwnerAsWin->GetUnscaledDevicePixelsPerCSSPixel(&scale);
|
|
treeOwnerAsWin->GetPositionAndSize(&winLeft, &winTop, &winWidth, &winHeight);
|
|
winLeft = NSToIntRound(winHeight / scale);
|
|
winTop = NSToIntRound(winWidth / scale);
|
|
winWidth = NSToIntRound(winWidth / scale);
|
|
winHeight = NSToIntRound(winHeight / scale);
|
|
|
|
// Acquire content window size.
|
|
CSSIntSize contentSize;
|
|
outer->GetInnerSize(contentSize);
|
|
|
|
screenMgr->ScreenForRect(winLeft, winTop, winWidth, winHeight,
|
|
getter_AddRefs(screen));
|
|
|
|
if (screen) {
|
|
int32_t* targetContentWidth = nullptr;
|
|
int32_t* targetContentHeight = nullptr;
|
|
int32_t screenWidth = 0;
|
|
int32_t screenHeight = 0;
|
|
int32_t chromeWidth = 0;
|
|
int32_t chromeHeight = 0;
|
|
int32_t inputWidth = 0;
|
|
int32_t inputHeight = 0;
|
|
int32_t unused = 0;
|
|
|
|
// Get screen dimensions (in device pixels)
|
|
screen->GetAvailRect(&unused, &unused, &screenWidth,
|
|
&screenHeight);
|
|
// Convert them to CSS pixels
|
|
screenWidth = NSToIntRound(screenWidth / scale);
|
|
screenHeight = NSToIntRound(screenHeight / scale);
|
|
|
|
// Calculate the chrome UI size.
|
|
chromeWidth = winWidth - contentSize.width;
|
|
chromeHeight = winHeight - contentSize.height;
|
|
|
|
if (innerWidthSpecified || outerWidthSpecified) {
|
|
inputWidth = value;
|
|
targetContentWidth = &value;
|
|
targetContentHeight = &unused;
|
|
} else if (innerHeightSpecified || outerHeightSpecified) {
|
|
inputHeight = value;
|
|
targetContentWidth = &unused;
|
|
targetContentHeight = &value;
|
|
}
|
|
|
|
nsContentUtils::CalcRoundedWindowSizeForResistingFingerprinting(
|
|
chromeWidth,
|
|
chromeHeight,
|
|
screenWidth,
|
|
screenHeight,
|
|
inputWidth,
|
|
inputHeight,
|
|
outerWidthSpecified,
|
|
outerHeightSpecified,
|
|
targetContentWidth,
|
|
targetContentHeight
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
(this->*aSetter)(value, aCallerType, aError);
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::FireOnNewGlobalObject()
|
|
{
|
|
MOZ_ASSERT(IsInnerWindow());
|
|
|
|
// AutoEntryScript required to invoke debugger hook, which is a
|
|
// Gecko-specific concept at present.
|
|
AutoEntryScript aes(this, "nsGlobalWindow report new global");
|
|
JS::Rooted<JSObject*> global(aes.cx(), GetWrapper());
|
|
JS_FireOnNewGlobalObject(aes.cx(), global);
|
|
}
|
|
|
|
#ifdef _WINDOWS_
|
|
#error "Never include windows.h in this file!"
|
|
#endif
|
|
|
|
already_AddRefed<Promise>
|
|
nsGlobalWindow::CreateImageBitmap(JSContext* aCx,
|
|
const ImageBitmapSource& aImage,
|
|
ErrorResult& aRv)
|
|
{
|
|
if (aImage.IsArrayBuffer() || aImage.IsArrayBufferView()) {
|
|
aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
|
|
return nullptr;
|
|
}
|
|
|
|
return ImageBitmap::Create(this, aImage, Nothing(), aRv);
|
|
}
|
|
|
|
already_AddRefed<Promise>
|
|
nsGlobalWindow::CreateImageBitmap(JSContext* aCx,
|
|
const ImageBitmapSource& aImage,
|
|
int32_t aSx, int32_t aSy, int32_t aSw, int32_t aSh,
|
|
ErrorResult& aRv)
|
|
{
|
|
if (aImage.IsArrayBuffer() || aImage.IsArrayBufferView()) {
|
|
aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
|
|
return nullptr;
|
|
}
|
|
|
|
return ImageBitmap::Create(this, aImage, Some(gfx::IntRect(aSx, aSy, aSw, aSh)), aRv);
|
|
}
|
|
|
|
already_AddRefed<mozilla::dom::Promise>
|
|
nsGlobalWindow::CreateImageBitmap(JSContext* aCx,
|
|
const ImageBitmapSource& aImage,
|
|
int32_t aOffset, int32_t aLength,
|
|
ImageBitmapFormat aFormat,
|
|
const Sequence<ChannelPixelLayout>& aLayout,
|
|
ErrorResult& aRv)
|
|
{
|
|
if (!ImageBitmap::ExtensionsEnabled(aCx)) {
|
|
aRv.Throw(NS_ERROR_TYPE_ERR);
|
|
return nullptr;
|
|
}
|
|
if (aImage.IsArrayBuffer() || aImage.IsArrayBufferView()) {
|
|
return ImageBitmap::Create(this, aImage, aOffset, aLength, aFormat, aLayout,
|
|
aRv);
|
|
}
|
|
aRv.Throw(NS_ERROR_TYPE_ERR);
|
|
return nullptr;
|
|
}
|
|
|
|
// Helper called by methods that move/resize the window,
|
|
// to ensure the presContext (if any) is aware of resolution
|
|
// change that may happen in multi-monitor configuration.
|
|
void
|
|
nsGlobalWindow::CheckForDPIChange()
|
|
{
|
|
if (mDocShell) {
|
|
RefPtr<nsPresContext> presContext;
|
|
mDocShell->GetPresContext(getter_AddRefs(presContext));
|
|
if (presContext) {
|
|
if (presContext->DeviceContext()->CheckDPIChange()) {
|
|
presContext->UIResolutionChanged();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
mozilla::dom::TabGroup*
|
|
nsGlobalWindow::TabGroupOuter()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsOuterWindow());
|
|
|
|
// Outer windows lazily join TabGroups when requested. This is usually done
|
|
// because a document is getting its NodePrincipal, and asking for the
|
|
// TabGroup to determine its DocGroup.
|
|
if (!mTabGroup) {
|
|
// Get mOpener ourselves, instead of relying on GetOpenerWindowOuter,
|
|
// because that way we dodge the LegacyIsCallerChromeOrNativeCode() call
|
|
// which we want to return false.
|
|
nsCOMPtr<nsPIDOMWindowOuter> piOpener = do_QueryReferent(mOpener);
|
|
nsPIDOMWindowOuter* opener = GetSanitizedOpener(piOpener);
|
|
nsPIDOMWindowOuter* parent = GetScriptableParentOrNull();
|
|
MOZ_ASSERT(!parent || !opener, "Only one of parent and opener may be provided");
|
|
|
|
mozilla::dom::TabGroup* toJoin = nullptr;
|
|
if (GetDocShell()->ItemType() == nsIDocShellTreeItem::typeChrome) {
|
|
toJoin = TabGroup::GetChromeTabGroup();
|
|
} else if (opener) {
|
|
toJoin = opener->TabGroup();
|
|
} else if (parent) {
|
|
toJoin = parent->TabGroup();
|
|
} else {
|
|
toJoin = TabGroup::GetFromWindow(AsOuter());
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
// Make sure that, if we have a tab group from the actor, it matches the one
|
|
// we're planning to join.
|
|
mozilla::dom::TabGroup* testGroup = TabGroup::GetFromWindow(AsOuter());
|
|
MOZ_ASSERT_IF(testGroup, testGroup == toJoin);
|
|
#endif
|
|
|
|
mTabGroup = mozilla::dom::TabGroup::Join(AsOuter(), toJoin);
|
|
}
|
|
MOZ_ASSERT(mTabGroup);
|
|
|
|
#ifdef DEBUG
|
|
// Ensure that we don't recurse forever
|
|
if (!mIsValidatingTabGroup) {
|
|
mIsValidatingTabGroup = true;
|
|
// We only need to do this check if we aren't in the chrome tab group
|
|
if (mIsChrome) {
|
|
MOZ_ASSERT(mTabGroup == TabGroup::GetChromeTabGroup());
|
|
} else {
|
|
// Sanity check that our tabgroup matches our opener or parent.
|
|
RefPtr<nsPIDOMWindowOuter> parent = GetScriptableParentOrNull();
|
|
MOZ_ASSERT_IF(parent, parent->TabGroup() == mTabGroup);
|
|
nsCOMPtr<nsPIDOMWindowOuter> piOpener = do_QueryReferent(mOpener);
|
|
nsPIDOMWindowOuter* opener = GetSanitizedOpener(piOpener);
|
|
MOZ_ASSERT_IF(opener && Cast(opener) != this, opener->TabGroup() == mTabGroup);
|
|
}
|
|
mIsValidatingTabGroup = false;
|
|
}
|
|
#endif
|
|
|
|
return mTabGroup;
|
|
}
|
|
|
|
mozilla::dom::TabGroup*
|
|
nsGlobalWindow::TabGroupInner()
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
// If we don't have a TabGroup yet, try to get it from the outer window and
|
|
// cache it.
|
|
if (!mTabGroup) {
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
// This will never be called without either an outer window, or a cached tab group.
|
|
// This is because of the following:
|
|
// * This method is only called on inner windows
|
|
// * This method is called as a document is attached to it's script global
|
|
// by the document
|
|
// * Inner windows are created in nsGlobalWindow::SetNewDocument, which
|
|
// immediately sets a document, which will call this method, causing
|
|
// the TabGroup to be cached.
|
|
MOZ_RELEASE_ASSERT(outer, "Inner window without outer window has no cached tab group!");
|
|
mTabGroup = outer->TabGroup();
|
|
}
|
|
MOZ_ASSERT(mTabGroup);
|
|
|
|
#ifdef DEBUG
|
|
nsGlobalWindow* outer = GetOuterWindowInternal();
|
|
MOZ_ASSERT_IF(outer, outer->TabGroup() == mTabGroup);
|
|
#endif
|
|
|
|
return mTabGroup;
|
|
}
|
|
|
|
template<typename T>
|
|
mozilla::dom::TabGroup*
|
|
nsPIDOMWindow<T>::TabGroup()
|
|
{
|
|
nsGlobalWindow* globalWindow =
|
|
static_cast<nsGlobalWindow*>(
|
|
reinterpret_cast<nsPIDOMWindow<nsISupports>*>(this));
|
|
|
|
if (IsInnerWindow()) {
|
|
return globalWindow->TabGroupInner();
|
|
}
|
|
return globalWindow->TabGroupOuter();
|
|
}
|
|
|
|
template<typename T>
|
|
mozilla::dom::DocGroup*
|
|
nsPIDOMWindow<T>::GetDocGroup() const
|
|
{
|
|
nsIDocument* doc = GetExtantDoc();
|
|
if (doc) {
|
|
return doc->GetDocGroup();
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
nsresult
|
|
nsGlobalWindow::Dispatch(TaskCategory aCategory,
|
|
already_AddRefed<nsIRunnable>&& aRunnable)
|
|
{
|
|
MOZ_RELEASE_ASSERT(NS_IsMainThread());
|
|
if (GetDocGroup()) {
|
|
return GetDocGroup()->Dispatch(aCategory, Move(aRunnable));
|
|
}
|
|
return DispatcherTrait::Dispatch(aCategory, Move(aRunnable));
|
|
}
|
|
|
|
nsISerialEventTarget*
|
|
nsGlobalWindow::EventTargetFor(TaskCategory aCategory) const
|
|
{
|
|
MOZ_RELEASE_ASSERT(NS_IsMainThread());
|
|
if (GetDocGroup()) {
|
|
return GetDocGroup()->EventTargetFor(aCategory);
|
|
}
|
|
return DispatcherTrait::EventTargetFor(aCategory);
|
|
}
|
|
|
|
AbstractThread*
|
|
nsGlobalWindow::AbstractMainThreadFor(TaskCategory aCategory)
|
|
{
|
|
MOZ_RELEASE_ASSERT(NS_IsMainThread());
|
|
if (GetDocGroup()) {
|
|
return GetDocGroup()->AbstractMainThreadFor(aCategory);
|
|
}
|
|
return DispatcherTrait::AbstractMainThreadFor(aCategory);
|
|
}
|
|
|
|
nsGlobalWindow::TemporarilyDisableDialogs::TemporarilyDisableDialogs(
|
|
nsGlobalWindow* aWindow MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL)
|
|
{
|
|
MOZ_GUARD_OBJECT_NOTIFIER_INIT;
|
|
|
|
MOZ_ASSERT(aWindow);
|
|
nsGlobalWindow* topWindow = aWindow->GetScriptableTopInternal();
|
|
if (!topWindow) {
|
|
NS_ERROR("nsGlobalWindow::TemporarilyDisableDialogs used without a top "
|
|
"window?");
|
|
return;
|
|
}
|
|
|
|
// TODO: Warn if no top window?
|
|
topWindow = topWindow->GetCurrentInnerWindowInternal();
|
|
if (topWindow) {
|
|
mTopWindow = topWindow;
|
|
mSavedDialogsEnabled = mTopWindow->mAreDialogsEnabled;
|
|
mTopWindow->mAreDialogsEnabled = false;
|
|
}
|
|
}
|
|
|
|
nsGlobalWindow::TemporarilyDisableDialogs::~TemporarilyDisableDialogs()
|
|
{
|
|
if (mTopWindow) {
|
|
mTopWindow->mAreDialogsEnabled = mSavedDialogsEnabled;
|
|
}
|
|
}
|
|
|
|
Worklet*
|
|
nsGlobalWindow::GetAudioWorklet(ErrorResult& aRv)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mAudioWorklet) {
|
|
nsIPrincipal* principal = GetPrincipal();
|
|
if (!principal) {
|
|
aRv.Throw(NS_ERROR_FAILURE);
|
|
return nullptr;
|
|
}
|
|
|
|
mAudioWorklet = new Worklet(AsInner(), principal, Worklet::eAudioWorklet);
|
|
}
|
|
|
|
return mAudioWorklet;
|
|
}
|
|
|
|
Worklet*
|
|
nsGlobalWindow::GetPaintWorklet(ErrorResult& aRv)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mPaintWorklet) {
|
|
nsIPrincipal* principal = GetPrincipal();
|
|
if (!principal) {
|
|
aRv.Throw(NS_ERROR_FAILURE);
|
|
return nullptr;
|
|
}
|
|
|
|
mPaintWorklet = new Worklet(AsInner(), principal, Worklet::ePaintWorklet);
|
|
}
|
|
|
|
return mPaintWorklet;
|
|
}
|
|
|
|
void
|
|
nsGlobalWindow::GetRegionalPrefsLocales(nsTArray<nsString>& aLocales)
|
|
{
|
|
AutoTArray<nsCString, 10> rpLocales;
|
|
mozilla::intl::LocaleService::GetInstance()->GetRegionalPrefsLocales(rpLocales);
|
|
|
|
for (const auto& loc : rpLocales) {
|
|
aLocales.AppendElement(NS_ConvertUTF8toUTF16(loc));
|
|
}
|
|
}
|
|
|
|
IntlUtils*
|
|
nsGlobalWindow::GetIntlUtils(ErrorResult& aError)
|
|
{
|
|
MOZ_RELEASE_ASSERT(IsInnerWindow());
|
|
|
|
if (!mIntlUtils) {
|
|
mIntlUtils = new IntlUtils(AsInner());
|
|
}
|
|
|
|
return mIntlUtils;
|
|
}
|
|
|
|
template class nsPIDOMWindow<mozIDOMWindowProxy>;
|
|
template class nsPIDOMWindow<mozIDOMWindow>;
|
|
template class nsPIDOMWindow<nsISupports>;
|