/* -*- 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 "base/basictypes.h" #include /* This must occur *after* base/basictypes.h to avoid typedefs conflicts. */ #include "mozilla/Util.h" // Local Includes #include "nsGlobalWindow.h" #include "Navigator.h" #include "nsScreen.h" #include "nsHistory.h" #include "nsPerformance.h" #include "nsDOMNavigationTiming.h" #include "nsBarProps.h" #include "nsDOMStorage.h" #include "nsDOMOfflineResourceList.h" #include "nsError.h" #include "nsIIdleService.h" #include "nsIPowerManagerService.h" #include "nsISizeOfEventTarget.h" #ifdef XP_WIN #ifdef GetClassName #undef GetClassName #endif // GetClassName #endif // XP_WIN // Helper Classes #include "nsXPIDLString.h" #include "nsJSUtils.h" #include "jsapi.h" // for JSAutoRequest #include "jsdbgapi.h" // for JS_ClearWatchPointsForObject #include "jsfriendapi.h" // for JS_GetGlobalForFrame #include "jswrapper.h" #include "nsReadableUtils.h" #include "nsDOMClassInfo.h" #include "nsJSEnvironment.h" #include "nsCharSeparatedTokenizer.h" // for Accept-Language parsing #include "nsUnicharUtils.h" #include "mozilla/Preferences.h" #include "mozilla/Likely.h" // Other Classes #include "nsEventListenerManager.h" #include "nsEscape.h" #include "nsStyleCoord.h" #include "nsMimeTypeArray.h" #include "nsNetUtil.h" #include "nsICachingChannel.h" #include "nsPluginArray.h" #include "nsIPluginHost.h" #include "nsPluginHost.h" #include "nsIPluginInstanceOwner.h" #include "nsGeolocation.h" #include "nsDesktopNotification.h" #include "nsContentCID.h" #include "nsLayoutStatics.h" #include "nsCycleCollector.h" #include "nsCCUncollectableMarker.h" #include "nsAutoJSValHolder.h" #include "nsDOMMediaQueryList.h" #include "mozilla/dom/workers/Workers.h" #include "nsJSPrincipals.h" #include "mozilla/Attributes.h" // Interfaces Needed #include "nsIFrame.h" #include "nsCanvasFrame.h" #include "nsIWidget.h" #include "nsIWidgetListener.h" #include "nsIBaseWindow.h" #include "nsDeviceSensors.h" #include "nsIContent.h" #include "nsIContentViewerEdit.h" #include "nsIDocShell.h" #include "nsIDocShellLoadInfo.h" #include "nsIDocShellTreeItem.h" #include "nsIDocShellTreeNode.h" #include "nsIEditorDocShell.h" #include "nsIDocCharset.h" #include "nsIDocument.h" #include "nsIHTMLDocument.h" #include "nsIDOMHTMLDocument.h" #include "nsIDOMHTMLElement.h" #ifndef MOZ_DISABLE_DOMCRYPTO #include "nsIDOMCrypto.h" #endif #include "nsIDOMDocument.h" #include "nsIDOMElement.h" #include "nsIDOMEvent.h" #include "nsIDOMHTMLAnchorElement.h" #include "nsIDOMKeyEvent.h" #include "nsIDOMMessageEvent.h" #include "nsIDOMPopupBlockedEvent.h" #include "nsIDOMPopStateEvent.h" #include "nsIDOMHashChangeEvent.h" #include "nsIDOMOfflineResourceList.h" #include "nsIDOMGeoGeolocation.h" #include "nsIDOMDesktopNotification.h" #include "nsPIDOMStorage.h" #include "nsDOMString.h" #include "nsIEmbeddingSiteWindow.h" #include "nsThreadUtils.h" #include "nsEventStateManager.h" #include "nsIHttpProtocolHandler.h" #include "nsIJSContextStack.h" #include "nsIJSRuntimeService.h" #include "nsILoadContext.h" #include "nsIMarkupDocumentViewer.h" #include "nsIPresShell.h" #include "nsIProgrammingLanguage.h" #include "nsIServiceManager.h" #include "nsIScriptGlobalObjectOwner.h" #include "nsIScriptSecurityManager.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 "nsIWritablePropertyBag2.h" #include "nsIWebNavigation.h" #include "nsIWebBrowser.h" #include "nsIWebBrowserChrome.h" #include "nsIWebBrowserFind.h" // For window.find() #include "nsIWebContentHandlerRegistrar.h" #include "nsIWindowMediator.h" // For window.find() #include "nsComputedDOMStyle.h" #include "nsIEntropyCollector.h" #include "nsDOMCID.h" #include "nsDOMWindowUtils.h" #include "nsIWindowWatcher.h" #include "nsPIWindowWatcher.h" #include "nsIContentViewer.h" #include "nsIJSNativeInitializer.h" #include "nsIScriptError.h" #include "nsIConsoleService.h" #include "nsIControllers.h" #include "nsIControllerContext.h" #include "nsGlobalWindowCommands.h" #include "nsAutoPtr.h" #include "nsContentUtils.h" #include "nsCSSProps.h" #include "nsIDOMFile.h" #include "nsIDOMFileList.h" #include "nsIURIFixup.h" #include "nsIAppStartup.h" #include "nsToolkitCompsCID.h" #include "nsCDefaultURIFixup.h" #include "nsEventDispatcher.h" #include "nsIObserverService.h" #include "nsIXULAppInfo.h" #include "nsNetUtil.h" #include "nsFocusManager.h" #include "nsIXULWindow.h" #include "nsEventStateManager.h" #include "nsITimedChannel.h" #include "nsICookiePermission.h" #include "nsServiceManagerUtils.h" #ifdef MOZ_XUL #include "nsXULPopupManager.h" #include "nsIDOMXULControlElement.h" #include "nsMenuPopupFrame.h" #endif #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" #include "nsIScriptRuntime.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/Selection.h" #include "nsFrameLoader.h" #include "nsISupportsPrimitives.h" #include "nsXPCOMCID.h" #include "GeneratedEvents.h" #include "mozIThirdPartyUtil.h" #ifdef MOZ_LOGGING // so we can get logging even in release builds #define FORCE_PR_LOG 1 #endif #include "prlog.h" #include "prenv.h" #include "mozilla/dom/indexedDB/IDBFactory.h" #include "mozilla/dom/indexedDB/IndexedDatabaseManager.h" #include "mozilla/dom/StructuredCloneTags.h" #include "nsRefreshDriver.h" #include "mozAutoDocUpdate.h" #include "mozilla/Telemetry.h" #include "nsLocation.h" #include "nsWrapperCacheInlines.h" #include "nsDOMEventTargetHelper.h" #include "nsIAppsService.h" #include "prrng.h" #include "nsSandboxFlags.h" #include "TimeChangeObserver.h" #include "nsPISocketTransportService.h" #include "mozilla/dom/AudioContext.h" // Apple system headers seem to have a check() macro. #ifdef check #undef check #endif // check #include "AccessCheck.h" #ifdef ANDROID #include #endif #ifdef PR_LOGGING static PRLogModuleInfo* gDOMLeakPRLog; #endif static const char kStorageEnabled[] = "dom.storage.enabled"; using namespace mozilla; using namespace mozilla::dom; using namespace mozilla::dom::ipc; using mozilla::TimeStamp; using mozilla::TimeDuration; nsGlobalWindow::WindowByIdTable *nsGlobalWindow::sWindowsById = nullptr; bool nsGlobalWindow::sWarnedAboutWindowInternal = false; bool nsGlobalWindow::sIdleObserversAPIFuzzTimeDisabled = false; static nsIEntropyCollector *gEntropyCollector = nullptr; static int32_t gRefCnt = 0; static int32_t gOpenPopupSpamCount = 0; static PopupControlState gPopupControlState = openAbused; static int32_t gRunningTimeoutDepth = 0; static bool gMouseDown = false; static bool gDragServiceDisabled = false; static FILE *gDumpFile = nullptr; static uint64_t gNextWindowID = 0; static uint32_t gSerialCounter = 0; static uint32_t gTimeoutsRecentlySet = 0; static TimeStamp gLastRecordedRecentTimeouts; #define STATISTICS_INTERVAL (30 * PR_MSEC_PER_SEC) #ifdef DEBUG_jst int32_t gTimeoutCnt = 0; #endif #if !(defined(DEBUG) || defined(MOZ_ENABLE_JS_DUMP)) static bool gDOMWindowDumpEnabled = false; #endif #if defined(DEBUG_bryner) || defined(DEBUG_chb) #define DEBUG_PAGE_CACHE #endif #define DOM_TOUCH_LISTENER_ADDED "dom-touch-listener-added" // The default shortest interval/timeout we permit #define DEFAULT_MIN_TIMEOUT_VALUE 4 // 4ms #define DEFAULT_MIN_BACKGROUND_TIMEOUT_VALUE 1000 // 1000ms static int32_t gMinTimeoutValue; static int32_t gMinBackgroundTimeoutValue; inline int32_t nsGlobalWindow::DOMMinTimeoutValue() const { bool isBackground = !mOuterWindow || mOuterWindow->IsBackground(); return std::max(isBackground ? gMinBackgroundTimeoutValue : gMinTimeoutValue, 0); } // The number of nested timeouts before we start clamping. HTML5 says 1, WebKit // uses 5. #define DOM_CLAMP_TIMEOUT_NESTING_LEVEL 5 // The longest interval (as PRIntervalTime) we permit, or that our // timer code can handle, really. See DELAY_INTERVAL_LIMIT in // nsTimerImpl.h for details. #define DOM_MAX_TIMEOUT_VALUE DELAY_INTERVAL_LIMIT #define FORWARD_TO_OUTER(method, args, err_rval) \ PR_BEGIN_MACRO \ if (IsInnerWindow()) { \ nsGlobalWindow *outer = GetOuterWindowInternal(); \ if (!outer) { \ NS_WARNING("No outer window available!"); \ return err_rval; \ } \ return outer->method args; \ } \ PR_END_MACRO #define FORWARD_TO_OUTER_VOID(method, args) \ PR_BEGIN_MACRO \ if (IsInnerWindow()) { \ nsGlobalWindow *outer = GetOuterWindowInternal(); \ if (!outer) { \ NS_WARNING("No outer window available!"); \ return; \ } \ outer->method args; \ return; \ } \ PR_END_MACRO #define FORWARD_TO_OUTER_CHROME(method, args, err_rval) \ PR_BEGIN_MACRO \ if (IsInnerWindow()) { \ nsGlobalWindow *outer = GetOuterWindowInternal(); \ if (!outer) { \ NS_WARNING("No outer window available!"); \ return err_rval; \ } \ return ((nsGlobalChromeWindow *)outer)->method args; \ } \ PR_END_MACRO #define FORWARD_TO_INNER_CHROME(method, args, err_rval) \ PR_BEGIN_MACRO \ if (IsOuterWindow()) { \ if (!mInnerWindow) { \ NS_WARNING("No inner window available!"); \ return err_rval; \ } \ return ((nsGlobalChromeWindow *)mInnerWindow)->method args; \ } \ PR_END_MACRO #define FORWARD_TO_OUTER_MODAL_CONTENT_WINDOW(method, args, err_rval) \ PR_BEGIN_MACRO \ if (IsInnerWindow()) { \ nsGlobalWindow *outer = GetOuterWindowInternal(); \ if (!outer) { \ NS_WARNING("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 doc; \ nsresult fwdic_nr = GetDocument(getter_AddRefs(doc)); \ NS_ENSURE_SUCCESS(fwdic_nr, err_rval); \ if (!mInnerWindow) { \ return err_rval; \ } \ } \ return GetCurrentInnerWindowInternal()->method args; \ } \ PR_END_MACRO // CIDs static NS_DEFINE_CID(kXULControllersCID, NS_XULCONTROLLERS_CID); static const char sJSStackContractID[] = "@mozilla.org/js/xpc/ContextStack;1"; #ifndef MOZ_DISABLE_DOMCRYPTO static const char kCryptoContractID[] = NS_CRYPTO_CONTRACTID; static const char kPkcs11ContractID[] = NS_PKCS11_CONTRACTID; #endif static const char sPopStatePrefStr[] = "browser.history.allowPopState"; #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 MOZ_FINAL : public nsIObserver, public nsIInterfaceRequestor { public: nsGlobalWindowObserver(nsGlobalWindow* aWindow) : mWindow(aWindow) {} NS_DECL_ISUPPORTS NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic, const PRUnichar* aData) { if (!mWindow) return NS_OK; return mWindow->Observe(aSubject, aTopic, aData); } void Forget() { mWindow = nullptr; } NS_IMETHODIMP GetInterface(const nsIID& aIID, void** aResult) { if (mWindow && aIID.Equals(NS_GET_IID(nsIDOMWindow)) && mWindow) { return mWindow->QueryInterface(aIID, aResult); } return NS_NOINTERFACE; } private: nsGlobalWindow* mWindow; }; NS_IMPL_ISUPPORTS2(nsGlobalWindowObserver, nsIObserver, nsIInterfaceRequestor) nsTimeout::nsTimeout() : mCleared(false), mRunning(false), mIsInterval(false), mPublicId(0), mInterval(0), mFiringDepth(0), mNestingLevel(0), mPopupState(openAllowed) { #ifdef DEBUG_jst { extern int gTimeoutCnt; ++gTimeoutCnt; } #endif MOZ_COUNT_CTOR(nsTimeout); } nsTimeout::~nsTimeout() { #ifdef DEBUG_jst { extern int gTimeoutCnt; --gTimeoutCnt; } #endif MOZ_COUNT_DTOR(nsTimeout); } NS_IMPL_CYCLE_COLLECTION_UNLINK_0(nsTimeout) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsTimeout) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindow) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPrincipal) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mScriptHandler) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(nsTimeout, AddRef) NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(nsTimeout, Release) nsPIDOMWindow::nsPIDOMWindow(nsPIDOMWindow *aOuterWindow) : mFrameElement(nullptr), mDocShell(nullptr), mModalStateDepth(0), mRunningTimeout(nullptr), mMutationBits(0), mIsDocumentLoaded(false), mIsHandlingResizeEvent(false), mIsInnerWindow(aOuterWindow != nullptr), mMayHavePaintEventListener(false), mMayHaveTouchEventListener(false), mMayHaveMouseEnterLeaveEventListener(false), mIsModalContentWindow(false), mIsActive(false), mIsBackground(false), mInnerWindow(nullptr), mOuterWindow(aOuterWindow), // Make sure no actual window ends up with mWindowID == 0 mWindowID(++gNextWindowID), mHasNotifiedGlobalCreated(false) {} nsPIDOMWindow::~nsPIDOMWindow() {} //***************************************************************************** // nsOuterWindowProxy: Outer Window Proxy //***************************************************************************** class nsOuterWindowProxy : public js::Wrapper { public: nsOuterWindowProxy() : js::Wrapper(0) { setSafeToUnwrap(false); } virtual bool isOuterWindow() { return true; } virtual JSString *obj_toString(JSContext *cx, JSObject *wrapper) MOZ_OVERRIDE; virtual void finalize(JSFreeOp *fop, JSObject *proxy) MOZ_OVERRIDE; // Fundamental traps virtual bool getPropertyDescriptor(JSContext* cx, JSObject* proxy, jsid id, JSPropertyDescriptor* desc, unsigned flags) MOZ_OVERRIDE; virtual bool getOwnPropertyDescriptor(JSContext* cx, JSObject* proxy, jsid id, JSPropertyDescriptor* desc, unsigned flags) MOZ_OVERRIDE; virtual bool defineProperty(JSContext* cx, JSObject* proxy, jsid id, JSPropertyDescriptor* desc) MOZ_OVERRIDE; virtual bool getOwnPropertyNames(JSContext *cx, JSObject *proxy, JS::AutoIdVector &props) MOZ_OVERRIDE; virtual bool delete_(JSContext *cx, JSObject *proxy, jsid id, bool *bp) MOZ_OVERRIDE; virtual bool enumerate(JSContext *cx, JSObject *proxy, JS::AutoIdVector &props) MOZ_OVERRIDE; // Derived traps virtual bool has(JSContext *cx, JSObject *proxy, jsid id, bool *bp) MOZ_OVERRIDE; virtual bool hasOwn(JSContext *cx, JSObject *proxy, jsid id, bool *bp) MOZ_OVERRIDE; virtual bool get(JSContext *cx, JSObject *wrapper, JSObject *receiver, jsid id, JS::Value *vp) MOZ_OVERRIDE; virtual bool set(JSContext *cx, JSObject *proxy, JSObject *receiver, jsid id, bool strict, JS::Value *vp) MOZ_OVERRIDE; virtual bool keys(JSContext *cx, JSObject *proxy, JS::AutoIdVector &props) MOZ_OVERRIDE; virtual bool iterate(JSContext *cx, JSObject *proxy, unsigned flags, JS::Value *vp) MOZ_OVERRIDE; static nsOuterWindowProxy singleton; protected: nsGlobalWindow* GetWindow(JSObject *proxy) { return nsGlobalWindow::FromSupports( static_cast(js::GetProxyExtra(proxy, 0).toPrivate())); } // 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, JSObject *proxy, jsid id, JS::Value *vp, bool &found); // Returns a non-null window only if id is an index and we have a // window at that index. already_AddRefed GetSubframeWindow(JSContext *cx, JSObject *proxy, jsid id); bool AppendIndexedPropertyNames(JSContext *cx, JSObject *proxy, JS::AutoIdVector &props); }; JSString * nsOuterWindowProxy::obj_toString(JSContext *cx, JSObject *proxy) { MOZ_ASSERT(js::IsProxy(proxy)); return JS_NewStringCopyZ(cx, "[object Window]"); } void nsOuterWindowProxy::finalize(JSFreeOp *fop, JSObject *proxy) { nsGlobalWindow* global = GetWindow(proxy); if (global) { global->ClearWrapper(); } } bool nsOuterWindowProxy::getPropertyDescriptor(JSContext* cx, JSObject* proxy, jsid id, JSPropertyDescriptor* desc, unsigned flags) { // 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->obj = nullptr; if (!getOwnPropertyDescriptor(cx, proxy, id, desc, flags)) { return false; } if (desc->obj) { return true; } return js::Wrapper::getPropertyDescriptor(cx, proxy, id, desc, flags); } bool nsOuterWindowProxy::getOwnPropertyDescriptor(JSContext* cx, JSObject* proxy, jsid id, JSPropertyDescriptor* desc, unsigned flags) { 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, flags); } bool nsOuterWindowProxy::defineProperty(JSContext* cx, JSObject* proxy, jsid id, JSPropertyDescriptor* desc) { int32_t index = GetArrayIndexFromId(cx, id); if (IsArrayIndex(index)) { // Spec says to Reject whether this is a supported index or not, // since we have no indexed setter or indexed creator. That means // throwing in strict mode (FIXME: Bug 828137), doing nothing in // non-strict mode. return true; } return js::Wrapper::defineProperty(cx, proxy, id, desc); } bool nsOuterWindowProxy::getOwnPropertyNames(JSContext *cx, JSObject *proxy, JS::AutoIdVector &props) { // 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::getOwnPropertyNames(cx, proxy, innerProps)) { return false; } return js::AppendUnique(cx, props, innerProps); } bool nsOuterWindowProxy::delete_(JSContext *cx, JSObject *proxy, jsid id, bool *bp) { if (nsCOMPtr frame = GetSubframeWindow(cx, proxy, id)) { // Reject (which means throw if strict, else return false) the delete. // Except we don't even know whether we're strict. See bug 803157. *bp = false; return true; } int32_t index = GetArrayIndexFromId(cx, id); if (IsArrayIndex(index)) { // Indexed, but not supported. Spec says return true. *bp = true; return true; } return js::Wrapper::delete_(cx, proxy, id, bp); } bool nsOuterWindowProxy::enumerate(JSContext *cx, JSObject *proxy, JS::AutoIdVector &props) { // 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::enumerate(cx, proxy, innerProps)) { return false; } return js::AppendUnique(cx, props, innerProps); } bool nsOuterWindowProxy::has(JSContext *cx, JSObject *proxy, jsid id, bool *bp) { if (nsCOMPtr frame = GetSubframeWindow(cx, proxy, id)) { *bp = true; return true; } return js::Wrapper::has(cx, proxy, id, bp); } bool nsOuterWindowProxy::hasOwn(JSContext *cx, JSObject *proxy, jsid id, bool *bp) { if (nsCOMPtr frame = GetSubframeWindow(cx, proxy, id)) { *bp = true; return true; } return js::Wrapper::hasOwn(cx, proxy, id, bp); } bool nsOuterWindowProxy::get(JSContext *cx, JSObject *wrapper, JSObject *receiver, jsid id, JS::Value *vp) { if (id == nsDOMClassInfo::sWrappedJSObject_id && xpc::AccessCheck::isChrome(js::GetContextCompartment(cx))) { *vp = JS::ObjectValue(*wrapper); return true; } bool found; if (!GetSubframeWindow(cx, wrapper, id, vp, found)) { return false; } if (found) { return true; } // Else fall through to js::Wrapper return js::Wrapper::get(cx, wrapper, receiver, id, vp); } bool nsOuterWindowProxy::set(JSContext *cx, JSObject *proxy, JSObject *receiver, jsid id, bool strict, JS::Value *vp) { int32_t index = GetArrayIndexFromId(cx, id); if (IsArrayIndex(index)) { // Reject (which means throw if and only if strict) the set. if (strict) { // XXXbz This needs to throw, but see bug 828137. } return true; } return js::Wrapper::set(cx, proxy, receiver, id, strict, vp); } bool nsOuterWindowProxy::keys(JSContext *cx, JSObject *proxy, JS::AutoIdVector &props) { // BaseProxyHandler::keys seems to do what we want here: call // getOwnPropertyNames and then filter out the non-enumerable properties. return js::BaseProxyHandler::keys(cx, proxy, props); } bool nsOuterWindowProxy::iterate(JSContext *cx, JSObject *proxy, unsigned flags, JS::Value *vp) { // BaseProxyHandler::iterate seems to do what we want here: fall // back on the property names returned from keys() and enumerate(). return js::BaseProxyHandler::iterate(cx, proxy, flags, vp); } bool nsOuterWindowProxy::GetSubframeWindow(JSContext *cx, JSObject *proxy, jsid id, JS::Value* vp, bool& found) { nsCOMPtr frame = GetSubframeWindow(cx, proxy, id); if (!frame) { found = false; return true; } found = true; // Just return the window's global nsGlobalWindow* global = static_cast(frame.get()); global->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); } *vp = JS::ObjectValue(*obj); return JS_WrapValue(cx, vp); } already_AddRefed nsOuterWindowProxy::GetSubframeWindow(JSContext *cx, JSObject *proxy, jsid id) { int32_t index = GetArrayIndexFromId(cx, id); if (!IsArrayIndex(index)) { return nullptr; } nsGlobalWindow* win = GetWindow(proxy); bool unused; return win->IndexedGetter(index, unused); } bool nsOuterWindowProxy::AppendIndexedPropertyNames(JSContext *cx, JSObject *proxy, JS::AutoIdVector &props) { uint32_t length = GetWindow(proxy)->GetLength(); MOZ_ASSERT(int32_t(length) >= 0); if (!props.reserve(props.length() + length)) { return false; } for (int32_t i = 0; i < int32_t(length); ++i) { props.append(INT_TO_JSID(i)); } return true; } nsOuterWindowProxy nsOuterWindowProxy::singleton; class nsChromeOuterWindowProxy : public nsOuterWindowProxy { public: nsChromeOuterWindowProxy() : nsOuterWindowProxy() {} virtual JSString *obj_toString(JSContext *cx, JSObject *wrapper); static nsChromeOuterWindowProxy singleton; }; JSString * nsChromeOuterWindowProxy::obj_toString(JSContext *cx, JSObject *proxy) { MOZ_ASSERT(js::IsProxy(proxy)); return JS_NewStringCopyZ(cx, "[object ChromeWindow]"); } nsChromeOuterWindowProxy nsChromeOuterWindowProxy::singleton; static JSObject* NewOuterWindowProxy(JSContext *cx, JSObject *parent, bool isChrome) { JSAutoCompartment ac(cx, parent); JSObject *proto; if (!js::GetObjectProto(cx, parent, &proto)) return nullptr; JSObject *obj = js::Wrapper::New(cx, parent, proto, parent, isChrome ? &nsChromeOuterWindowProxy::singleton : &nsOuterWindowProxy::singleton); NS_ASSERTION(js::GetObjectClass(obj)->ext.innerObject, "bad class"); return obj; } //***************************************************************************** //*** nsGlobalWindow: Object Management //***************************************************************************** nsGlobalWindow::nsGlobalWindow(nsGlobalWindow *aOuterWindow) : nsPIDOMWindow(aOuterWindow), mIdleFuzzFactor(0), mIdleCallbackIndex(-1), mCurrentlyIdle(false), mAddActiveEventFuzzTime(true), mIsFrozen(false), mFullScreen(false), mIsClosed(false), mInClose(false), mHavePendingClose(false), mHadOriginalOpener(false), mIsPopupSpam(false), mBlockScriptedClosingFlag(false), mFireOfflineStatusChangeEventOnThaw(false), mNotifyIdleObserversIdleOnThaw(false), mNotifyIdleObserversActiveOnThaw(false), mCreatingInnerWindow(false), mIsChrome(false), mCleanMessageManager(false), mNeedsFocus(true), mHasFocus(false), #if defined(XP_MACOSX) mShowAccelerators(false), mShowFocusRings(false), #else mShowAccelerators(true), mShowFocusRings(true), #endif mShowFocusRingForContent(false), mFocusByKeyOccurred(false), mNotifiedIDDestroyed(false), mAllowScriptsToClose(false), mTimeoutInsertionPoint(nullptr), mTimeoutPublicIdCounter(1), mTimeoutFiringDepth(0), mJSObject(nullptr), mTimeoutsSuspendDepth(0), mFocusMethod(0), mSerial(0), #ifdef DEBUG mSetOpenerWindowCalled(false), #endif mCleanedUp(false), mCallCleanUpAfterModalDialogCloses(false), mDialogAbuseCount(0), mStopAbuseDialogs(false), mDialogsPermanentlyDisabled(false) { 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) { NS_ADDREF(mObserver); nsCOMPtr 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); // Watch for dom-storage2-changed so we can fire storage // events. Use a strong reference. os->AddObserver(mObserver, "dom-storage2-changed", false); } } } else { // |this| is an outer window. Outer windows start out frozen and // remain frozen until they get an inner window, so freeze this // outer window here. Freeze(); mObserver = nullptr; SetIsDOMBinding(); } // 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++; if (gRefCnt == 1) { #if !(defined(DEBUG) || defined(MOZ_ENABLE_JS_DUMP)) Preferences::AddBoolVarCache(&gDOMWindowDumpEnabled, "browser.dom.window.dump.enabled"); #endif Preferences::AddIntVarCache(&gMinTimeoutValue, "dom.min_timeout_value", DEFAULT_MIN_TIMEOUT_VALUE); Preferences::AddIntVarCache(&gMinBackgroundTimeoutValue, "dom.min_background_timeout_value", DEFAULT_MIN_BACKGROUND_TIMEOUT_VALUE); Preferences::AddBoolVarCache(&sIdleObserversAPIFuzzTimeDisabled, "dom.idle-observers-api.fuzz_time.disabled", false); } if (gDumpFile == nullptr) { const nsAdoptingCString& fname = Preferences::GetCString("browser.dom.window.dump.file"); if (!fname.IsEmpty()) { // if this fails to open, Dump() knows to just go to stdout // on null. gDumpFile = fopen(fname, "wb+"); } else { gDumpFile = stdout; } } mSerial = ++gSerialCounter; #ifdef DEBUG if (!PR_GetEnv("MOZ_QUIET")) { printf("++DOMWINDOW == %d (%p) [serial = %d] [outer = %p]\n", gRefCnt, static_cast(static_cast(this)), gSerialCounter, static_cast(static_cast(aOuterWindow))); } #endif #ifdef PR_LOGGING if (gDOMLeakPRLog) PR_LOG(gDOMLeakPRLog, PR_LOG_DEBUG, ("DOMWINDOW %p created outer=%p", this, aOuterWindow)); #endif 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); } mEventTargetObjects.Init(); } /* static */ void nsGlobalWindow::Init() { CallGetService(NS_ENTROPYCOLLECTOR_CONTRACTID, &gEntropyCollector); NS_ASSERTION(gEntropyCollector, "gEntropyCollector should have been initialized!"); #ifdef PR_LOGGING gDOMLeakPRLog = PR_NewLogModule("DOMLeak"); NS_ASSERTION(gDOMLeakPRLog, "gDOMLeakPRLog should have been initialized!"); #endif sWindowsById = new WindowByIdTable(); sWindowsById->Init(); } static PLDHashOperator DisconnectEventTargetObjects(nsPtrHashKey* aKey, void* aClosure) { nsRefPtr target = aKey->GetKey(); target->DisconnectFromOwner(); return PL_DHASH_NEXT; } nsGlobalWindow::~nsGlobalWindow() { mEventTargetObjects.EnumerateEntries(DisconnectEventTargetObjects, nullptr); mEventTargetObjects.Clear(); // 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) { mLastOpenedURI->GetSpec(url); // 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 = static_cast(mOuterWindow.get()); printf("--DOMWINDOW == %d (%p) [serial = %d] [outer = %p] [url = %s]\n", gRefCnt, static_cast(static_cast(this)), mSerial, static_cast(static_cast(outer)), url.get()); } #endif #ifdef PR_LOGGING if (gDOMLeakPRLog) PR_LOG(gDOMLeakPRLog, PR_LOG_DEBUG, ("DOMWINDOW %p destroyed", this)); #endif if (IsOuterWindow()) { JSObject *proxy = GetWrapperPreserveColor(); if (proxy) { js::SetProxyExtra(proxy, 0, js::PrivateValue(NULL)); } // 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); } } 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); } } mDocument = nullptr; // Forces Release mDoc = nullptr; NS_ASSERTION(!mArguments, "mArguments wasn't cleaned up properly!"); CleanUp(true); nsCOMPtr ac = do_GetService(NS_DEVICE_SENSORS_CONTRACTID); if (ac) ac->RemoveWindowAsListener(this); nsLayoutStatics::Release(); } void nsGlobalWindow::AddEventTargetObject(nsDOMEventTargetHelper* aObject) { mEventTargetObjects.PutEntry(aObject); } void nsGlobalWindow::RemoveEventTargetObject(nsDOMEventTargetHelper* aObject) { mEventTargetObjects.RemoveEntry(aObject); } // static void nsGlobalWindow::ShutDown() { if (gDumpFile && gDumpFile != stdout) { fclose(gDumpFile); } gDumpFile = nullptr; NS_IF_RELEASE(gEntropyCollector); delete sWindowsById; sWindowsById = nullptr; } // static void nsGlobalWindow::CleanupCachedXBLHandlers(nsGlobalWindow* aWindow) { if (aWindow->mCachedXBLPrototypeHandlers.IsInitialized() && aWindow->mCachedXBLPrototypeHandlers.Count() > 0) { aWindow->mCachedXBLPrototypeHandlers.Clear(); nsISupports* supports; aWindow->QueryInterface(NS_GET_IID(nsCycleCollectionISupports), reinterpret_cast(&supports)); NS_ASSERTION(supports, "Failed to QI to nsCycleCollectionISupports?!"); nsContentUtils::DropJSObjects(supports); } } void nsGlobalWindow::MaybeForgiveSpamCount() { if (IsOuterWindow() && IsPopupSpamWindow()) { SetPopupSpamWindow(false); --gOpenPopupSpamCount; NS_ASSERTION(gOpenPopupSpamCount >= 0, "Unbalanced decrement of gOpenPopupSpamCount"); } } void nsGlobalWindow::CleanUp(bool aIgnoreModalDialog) { if (IsOuterWindow() && !aIgnoreModalDialog) { nsGlobalWindow* inner = GetCurrentInnerWindowInternal(); nsCOMPtr dlg(do_QueryObject(inner)); if (dlg) { // The window we're trying to clean up is the outer window of a // modal dialog. Defer cleanup until the window closes, and let // ShowModalDialog take care of calling CleanUp. mCallCleanUpAfterModalDialogCloses = true; return; } } // Guarantee idempotence. if (mCleanedUp) return; mCleanedUp = true; mEventTargetObjects.EnumerateEntries(DisconnectEventTargetObjects, nullptr); mEventTargetObjects.Clear(); if (mObserver) { nsCOMPtr os = mozilla::services::GetObserverService(); if (os) { os->RemoveObserver(mObserver, NS_IOSERVICE_OFFLINE_STATUS_TOPIC); os->RemoveObserver(mObserver, "dom-storage2-changed"); } #ifdef MOZ_B2G DisableNetworkEvent(NS_NETWORK_UPLOAD_EVENT); DisableNetworkEvent(NS_NETWORK_DOWNLOAD_EVENT); #endif // MOZ_B2G if (mIdleService) { mIdleService->RemoveIdleObserver(mObserver, MIN_IDLE_NOTIFICATION_TIME_S); } // Drop its reference to this dying window, in case for some bogus reason // the object stays around. mObserver->Forget(); NS_RELEASE(mObserver); } mNavigator = nullptr; mScreen = nullptr; mMenubar = nullptr; mToolbar = nullptr; mLocationbar = nullptr; mPersonalbar = nullptr; mStatusbar = nullptr; mScrollbars = nullptr; mLocation = nullptr; mHistory = nullptr; mFrames = nullptr; mWindowUtils = nullptr; mApplicationCache = nullptr; mIndexedDB = nullptr; mPerformance = nullptr; ClearControllers(); mOpener = nullptr; // Forces Release if (mContext) { mContext = nullptr; // Forces Release } mChromeEventHandler = nullptr; // Forces Release mParentTarget = nullptr; nsGlobalWindow *inner = GetCurrentInnerWindowInternal(); if (inner) { inner->CleanUp(aIgnoreModalDialog); } if (mCleanMessageManager) { NS_ABORT_IF_FALSE(mIsChrome, "only chrome should have msg manager cleaned"); nsGlobalChromeWindow *asChrome = static_cast(this); if (asChrome->mMessageManager) { static_cast( asChrome->mMessageManager.get())->Disconnect(); } } mInnerWindowHolder = nullptr; mArguments = nullptr; mArgumentsLast = nullptr; mArgumentsOrigin = nullptr; CleanupCachedXBLHandlers(this); if (mIdleTimer) { mIdleTimer->Cancel(); mIdleTimer = nullptr; } DisableTimeChangeNotifications(); } void nsGlobalWindow::ClearControllers() { if (mControllers) { uint32_t count; mControllers->GetControllerCount(&count); while (count--) { nsCOMPtr controller; mControllers->GetControllerAt(count, getter_AddRefs(controller)); nsCOMPtr 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); // Kill all of the workers for this window. nsIScriptContext *scx = GetContextInternal(); JSContext *cx = scx ? scx->GetNativeContext() : nullptr; mozilla::dom::workers::CancelWorkersForWindow(cx, this); // Close all IndexedDB databases for this window. indexedDB::IndexedDatabaseManager* idbManager = indexedDB::IndexedDatabaseManager::Get(); if (idbManager) { idbManager->AbortCloseDatabasesForWindow(this); } ClearAllTimeouts(); if (mIdleTimer) { mIdleTimer->Cancel(); mIdleTimer = nullptr; } mIdleObservers.Clear(); mChromeEventHandler = nullptr; if (mListenerManager) { mListenerManager->Disconnect(); mListenerManager = nullptr; } mLocation = nullptr; mHistory = nullptr; if (mNavigator) { mNavigator->OnNavigation(); mNavigator->Invalidate(); mNavigator = nullptr; } if (mScreen) { mScreen->Reset(); mScreen = nullptr; } if (mDocument) { NS_ASSERTION(mDoc, "Why is mDoc null?"); // Remember the document's principal and URI. mDocumentPrincipal = mDoc->NodePrincipal(); mDocumentURI = mDoc->GetDocumentURI(); mDocBaseURI = mDoc->GetDocBaseURI(); } // Remove our reference to the document and the document principal. mDocument = nullptr; mDoc = nullptr; mFocusedNode = nullptr; if (mApplicationCache) { static_cast(mApplicationCache.get())->Disconnect(); mApplicationCache = nullptr; } mIndexedDB = nullptr; NotifyWindowIDDestroyed("inner-window-destroyed"); CleanupCachedXBLHandlers(this); for (uint32_t i = 0; i < mAudioContexts.Length(); ++i) { mAudioContexts[i]->Shutdown(); } mAudioContexts.Clear(); } //***************************************************************************** // nsGlobalWindow::nsISupports //***************************************************************************** #define OUTER_WINDOW_ONLY \ if (IsOuterWindow()) { #define END_OUTER_WINDOW_ONLY \ foundInterface = 0; \ } else DOMCI_DATA(Window, nsGlobalWindow) // QueryInterface implementation for nsGlobalWindow NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsGlobalWindow) // Make sure this matches the cast in nsGlobalWindow::FromWrapper() NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMEventTarget) NS_INTERFACE_MAP_ENTRY(nsIDOMWindow) #ifdef MOZ_B2G NS_INTERFACE_MAP_ENTRY(nsIDOMWindowB2G) #endif // MOZ_B2G NS_INTERFACE_MAP_ENTRY(nsIDOMJSWindow) if (aIID.Equals(NS_GET_IID(nsIDOMWindowInternal))) { foundInterface = static_cast(this); if (!sWarnedAboutWindowInternal) { sWarnedAboutWindowInternal = true; nsContentUtils::ReportToConsole(nsIScriptError::warningFlag, "Extensions", mDoc, nsContentUtils::eDOM_PROPERTIES, "nsIDOMWindowInternalWarning"); } } else NS_INTERFACE_MAP_ENTRY(nsIScriptGlobalObject) NS_INTERFACE_MAP_ENTRY(nsIScriptObjectPrincipal) NS_INTERFACE_MAP_ENTRY(nsIDOMEventTarget) NS_INTERFACE_MAP_ENTRY(mozilla::dom::EventTarget) NS_INTERFACE_MAP_ENTRY(nsPIDOMWindow) NS_INTERFACE_MAP_ENTRY(nsIDOMStorageIndexedDB) NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor) NS_INTERFACE_MAP_ENTRY(nsIDOMWindowPerformance) NS_INTERFACE_MAP_ENTRY(nsITouchEventReceiver) NS_INTERFACE_MAP_ENTRY(nsIInlineEventHandlers) NS_INTERFACE_MAP_ENTRY(nsIWindowCrypto) NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(Window) OUTER_WINDOW_ONLY NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY END_OUTER_WINDOW_ONLY NS_INTERFACE_MAP_END NS_IMPL_CYCLE_COLLECTING_ADDREF(nsGlobalWindow) NS_IMPL_CYCLE_COLLECTING_RELEASE(nsGlobalWindow) static PLDHashOperator MarkXBLHandlers(nsXBLPrototypeHandler* aKey, JSObject* aData, void* aClosure) { xpc_UnmarkGrayObject(aData); return PL_DHASH_NEXT; } NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsGlobalWindow) if (tmp->IsBlackForCC()) { if (tmp->mCachedXBLPrototypeHandlers.IsInitialized()) { tmp->mCachedXBLPrototypeHandlers.EnumerateRead(MarkXBLHandlers, nullptr); } nsEventListenerManager* elm = tmp->GetListenerManager(false); if (elm) { elm->MarkForCC(); } tmp->UnmarkGrayTimers(); return true; } NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(nsGlobalWindow) return tmp->IsBlackForCC(); NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(nsGlobalWindow) return tmp->IsBlackForCC(); 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_TRAVERSE_BEGIN_INTERNAL(nsGlobalWindow) if (MOZ_UNLIKELY(cb.WantDebugInfo())) { char name[512]; PR_snprintf(name, sizeof(name), "nsGlobalWindow #%ld", tmp->mWindowID); cb.DescribeRefCountedNode(tmp->mRefCnt.get(), name); } else { NS_IMPL_CYCLE_COLLECTION_DESCRIBE(nsGlobalWindow, tmp->mRefCnt.get()) } if (!cb.WantAllTraces() && tmp->IsBlackForCC()) { return NS_SUCCESS_INTERRUPTED_TRAVERSE; } NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mContext) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mControllers) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mArguments) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mArgumentsLast) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPerformance) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mInnerWindowHolder) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOuterWindow) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mListenerManager) for (nsTimeout* timeout = tmp->mTimeouts.getFirst(); timeout; timeout = timeout->getNext()) { cb.NoteNativeChild(timeout, NS_CYCLE_COLLECTION_PARTICIPANT(nsTimeout)); } NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLocalStorage) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSessionStorage) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mApplicationCache) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocumentPrincipal) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDoc) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIdleService) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPendingStorageEvents) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIdleObservers) // Traverse stuff from nsPIDOMWindow NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChromeEventHandler) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParentTarget) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocument) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFrameElement) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFocusedNode) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAudioContexts) 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(mArgumentsLast) NS_IMPL_CYCLE_COLLECTION_UNLINK(mPerformance) NS_IMPL_CYCLE_COLLECTION_UNLINK(mInnerWindowHolder) if (tmp->mOuterWindow) { static_cast(tmp->mOuterWindow.get())->MaybeClearInnerWindow(tmp); NS_IMPL_CYCLE_COLLECTION_UNLINK(mOuterWindow) } if (tmp->mListenerManager) { tmp->mListenerManager->Disconnect(); NS_IMPL_CYCLE_COLLECTION_UNLINK(mListenerManager) } NS_IMPL_CYCLE_COLLECTION_UNLINK(mLocalStorage) NS_IMPL_CYCLE_COLLECTION_UNLINK(mSessionStorage) NS_IMPL_CYCLE_COLLECTION_UNLINK(mApplicationCache) NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocumentPrincipal) NS_IMPL_CYCLE_COLLECTION_UNLINK(mDoc) NS_IMPL_CYCLE_COLLECTION_UNLINK(mIdleService) NS_IMPL_CYCLE_COLLECTION_UNLINK(mPendingStorageEvents) NS_IMPL_CYCLE_COLLECTION_UNLINK(mIdleObservers) // Unlink stuff from nsPIDOMWindow NS_IMPL_CYCLE_COLLECTION_UNLINK(mChromeEventHandler) NS_IMPL_CYCLE_COLLECTION_UNLINK(mParentTarget) NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocument) NS_IMPL_CYCLE_COLLECTION_UNLINK(mFrameElement) NS_IMPL_CYCLE_COLLECTION_UNLINK(mFocusedNode) NS_IMPL_CYCLE_COLLECTION_UNLINK(mAudioContexts) NS_IMPL_CYCLE_COLLECTION_UNLINK_END struct TraceData { TraceData(TraceCallback& aCallback, void* aClosure) : callback(aCallback), closure(aClosure) {} TraceCallback& callback; void* closure; }; static PLDHashOperator TraceXBLHandlers(nsXBLPrototypeHandler* aKey, JSObject* aData, void* aClosure) { TraceData* data = static_cast(aClosure); data->callback(aData, "Cached XBL prototype handler", data->closure); return PL_DHASH_NEXT; } NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(nsGlobalWindow) if (tmp->mCachedXBLPrototypeHandlers.IsInitialized()) { TraceData data(aCallback, aClosure); tmp->mCachedXBLPrototypeHandlers.EnumerateRead(TraceXBLHandlers, &data); } NS_IMPL_CYCLE_COLLECTION_TRACE_END bool nsGlobalWindow::IsBlackForCC() { return (mDoc && nsCCUncollectableMarker::InGeneration(mDoc->GetMarkedCCGeneration())) || (nsCCUncollectableMarker::sGeneration && IsBlack()); } void nsGlobalWindow::UnmarkGrayTimers() { for (nsTimeout* timeout = mTimeouts.getFirst(); timeout; timeout = timeout->getNext()) { if (timeout->mScriptHandler) { JSObject* o = timeout->mScriptHandler->GetScriptObject(); xpc_UnmarkGrayObject(o); } } } //***************************************************************************** // nsGlobalWindow::nsIScriptGlobalObject //***************************************************************************** nsresult nsGlobalWindow::EnsureScriptEnvironment() { FORWARD_TO_OUTER(EnsureScriptEnvironment, (), NS_ERROR_NOT_INITIALIZED); if (mJSObject) { return NS_OK; } NS_ASSERTION(!GetCurrentInnerWindowInternal(), "mJSObject is null, but we have an inner window?"); nsCOMPtr scriptRuntime; nsresult rv = NS_GetJSRuntime(getter_AddRefs(scriptRuntime)); NS_ENSURE_SUCCESS(rv, rv); // 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 context = scriptRuntime->CreateContext(!IsFrame(), this); NS_ASSERTION(!mContext, "Will overwrite mContext!"); // should probably assert the context is clean??? context->WillInitializeContext(); rv = context->InitContext(); NS_ENSURE_SUCCESS(rv, rv); mContext = context; return NS_OK; } nsIScriptContext * nsGlobalWindow::GetScriptContext() { FORWARD_TO_OUTER(GetScriptContext, (), nullptr); return mContext; } nsIScriptContext * nsGlobalWindow::GetContext() { FORWARD_TO_OUTER(GetContext, (), nullptr); // check GetContext is indeed identical to GetScriptContext() NS_ASSERTION(mContext == GetScriptContext(), "GetContext confused?"); return mContext; } JSObject * nsGlobalWindow::GetGlobalJSObject() { return FastGetGlobalJSObject(); } bool nsGlobalWindow::WouldReuseInnerWindow(nsIDocument *aNewDocument) { // 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; } NS_ASSERTION(NS_IsAboutBlank(mDoc->GetDocumentURI()), "How'd this happen?"); // 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() { FORWARD_TO_OUTER_VOID(SetInitialPrincipalToSubject, ()); // First, grab the subject principal. These methods never fail. nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager(); nsCOMPtr newWindowPrincipal, systemPrincipal; ssm->GetSubjectPrincipal(getter_AddRefs(newWindowPrincipal)); ssm->GetSystemPrincipal(getter_AddRefs(systemPrincipal)); if (!newWindowPrincipal) { newWindowPrincipal = systemPrincipal; } // Now, if we're about to use the system principal, make sure we're not using // it for a content docshell. if (newWindowPrincipal == systemPrincipal) { int32_t itemType; nsCOMPtr item = do_QueryInterface(GetDocShell()); nsresult rv = item->GetItemType(&itemType); if (NS_FAILED(rv) || 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. nsCOMPtr uri; mDoc->NodePrincipal()->GetURI(getter_AddRefs(uri)); NS_ASSERTION(uri && NS_IsAboutBlank(uri) && NS_IsAboutBlank(mDoc->GetDocumentURI()), "Unexpected original document"); #endif } GetDocShell()->CreateAboutBlankContentViewer(newWindowPrincipal); mDoc->SetIsInitialDocument(true); nsCOMPtr 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) { PopupControlState oldState = gPopupControlState; if (aState < gPopupControlState || aForce) { gPopupControlState = aState; } return oldState; } void PopPopupControlState(PopupControlState aState) { 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 { return gPopupControlState; } #define WINDOWSTATEHOLDER_IID \ {0x0b917c3e, 0xbd50, 0x4683, {0xaf, 0xc9, 0xc7, 0x81, 0x07, 0xae, 0x33, 0x26}} class WindowStateHolder MOZ_FINAL : public nsISupports { public: NS_DECLARE_STATIC_IID_ACCESSOR(WINDOWSTATEHOLDER_IID) NS_DECL_ISUPPORTS WindowStateHolder(nsGlobalWindow *aWindow, nsIXPConnectJSObjectHolder *aHolder); nsGlobalWindow* GetInnerWindow() { return mInnerWindow; } nsIXPConnectJSObjectHolder *GetInnerWindowHolder() { return mInnerWindowHolder; } void DidRestoreWindow() { mInnerWindow = nullptr; mInnerWindowHolder = 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. nsCOMPtr mInnerWindowHolder; }; NS_DEFINE_STATIC_IID_ACCESSOR(WindowStateHolder, WINDOWSTATEHOLDER_IID) WindowStateHolder::WindowStateHolder(nsGlobalWindow *aWindow, nsIXPConnectJSObjectHolder *aHolder) : mInnerWindow(aWindow) { NS_PRECONDITION(aWindow, "null window"); NS_PRECONDITION(aWindow->IsInnerWindow(), "Saving an outer window"); mInnerWindowHolder = aHolder; aWindow->SuspendTimeouts(); } 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_ISUPPORTS1(WindowStateHolder, WindowStateHolder) nsresult nsGlobalWindow::CreateOuterObject(nsGlobalWindow* aNewInner) { JSContext* cx = mContext->GetNativeContext(); JSObject* outer = NewOuterWindowProxy(cx, aNewInner->FastGetGlobalJSObject(), IsChromeWindow()); if (!outer) { return NS_ERROR_FAILURE; } js::SetProxyExtra(outer, 0, js::PrivateValue(ToSupports(this))); return SetOuterObject(cx, outer); } nsresult nsGlobalWindow::SetOuterObject(JSContext* aCx, JSObject* aOuterObject) { // Force our context's global object to be the outer. // NB: JS_SetGlobalObject sets aCx->compartment. JS_SetGlobalObject(aCx, aOuterObject); // Set up the prototype for the outer object. JSObject* inner = JS_GetParent(aOuterObject); JSObject* proto; if (!JS_GetPrototype(aCx, inner, &proto)) { return NS_ERROR_FAILURE; } JS_SetPrototype(aCx, aOuterObject, proto); return NS_OK; } /** * 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, JSObject** aNativeGlobal, nsIXPConnectJSObjectHolder** aHolder) { MOZ_ASSERT(aCx); MOZ_ASSERT(aNewInner); MOZ_ASSERT(aNewInner->IsInnerWindow()); MOZ_ASSERT(aPrincipal); MOZ_ASSERT(aNativeGlobal); MOZ_ASSERT(aHolder); nsIXPConnect* xpc = nsContentUtils::XPConnect(); nsRefPtr jsholder; nsresult rv = xpc->InitClassesWithNewWrappedGlobal( aCx, ToSupports(aNewInner), aPrincipal, 0, getter_AddRefs(jsholder)); NS_ENSURE_SUCCESS(rv, rv); MOZ_ASSERT(jsholder); jsholder->GetJSObject(aNativeGlobal); jsholder.forget(aHolder); // Set the location information for the new global, so that tools like // about:memory may use that information MOZ_ASSERT(*aNativeGlobal); xpc::SetLocationForGlobal(*aNativeGlobal, aURI); 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() != this) { return NS_ERROR_NOT_AVAILABLE; } return GetOuterWindowInternal()->SetNewDocument(aDocument, aState, aForceReuseInnerWindow); } NS_PRECONDITION(IsOuterWindow(), "Must only be called on outer windows"); if (IsFrozen()) { // This outer is now getting its first inner, thaw the outer now // that it's ready and is getting an inner window. Thaw(); } NS_ASSERTION(!GetCurrentInnerWindow() || GetCurrentInnerWindow()->GetExtantDocument() == mDocument, "Uh, mDocument 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 oldDoc(do_QueryInterface(mDocument)); nsIScriptContext *scx = GetContextInternal(); NS_ENSURE_TRUE(scx, NS_ERROR_NOT_INITIALIZED); JSContext *cx = scx->GetNativeContext(); #ifndef MOZ_DISABLE_DOMCRYPTO // clear smartcard events, our document has gone away. if (mCrypto) { mCrypto->SetEnableSmartCardEvents(false); } #endif if (!mDocument) { // 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. nsIDOMWindow* privateRoot = nsGlobalWindow::GetPrivateRoot(); if (privateRoot == static_cast(this)) { 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( NS_NewRunnableMethod(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; // Set mDocument even if this is an outer window to avoid // having to *always* reach into the inner window to find the // document. mDocument = do_QueryInterface(aDocument); mDoc = aDocument; #ifdef DEBUG mLastOpenedURI = aDocument->GetDocumentURI(); #endif mContext->WillInitializeContext(); nsGlobalWindow *currentInner = GetCurrentInnerWindowInternal(); if (currentInner && currentInner->mNavigator) { currentInner->mNavigator->OnNavigation(); } nsRefPtr newInnerWindow; bool createdInnerWindow = false; bool thisChrome = IsChromeWindow(); nsCxPusher cxPusher; if (!cxPusher.Push(cx)) { return NS_ERROR_FAILURE; } XPCAutoRequest ar(cx); nsCOMPtr wsh = do_QueryInterface(aState); NS_ASSERTION(!aState || wsh, "What kind of weird state are you giving me here?"); if (reUseInnerWindow) { // We're reusing the current inner window. NS_ASSERTION(!currentInner->IsFrozen(), "We should never be reusing a shared inner window"); newInnerWindow = currentInner; if (aDocument != oldDoc) { xpc_UnmarkGrayObject(currentInner->mJSObject); if (!nsWindowSH::InvalidateGlobalScopePolluter(cx, currentInner->mJSObject)) { return NS_ERROR_FAILURE; } } // 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. xpc_UnmarkGrayObject(mJSObject); if (!JS_RefreshCrossCompartmentWrappers(cx, mJSObject)) { 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(currentInner->mJSObject); #ifdef DEBUG bool sameOrigin = false; nsIPrincipal *existing = nsJSPrincipals::get(JS_GetCompartmentPrincipals(compartment)); aDocument->NodePrincipal()->Equals(existing, &sameOrigin); MOZ_ASSERT(sameOrigin); #endif JS_SetCompartmentPrincipals(compartment, nsJSPrincipals::get(aDocument->NodePrincipal())); } else { if (aState) { newInnerWindow = wsh->GetInnerWindow(); mInnerWindowHolder = wsh->GetInnerWindowHolder(); NS_ASSERTION(newInnerWindow, "Got a state without inner window"); } else if (thisChrome) { newInnerWindow = new nsGlobalChromeWindow(this); } else if (mIsModalContentWindow) { newInnerWindow = new nsGlobalModalWindow(this); } else { newInnerWindow = new nsGlobalWindow(this); } if (!aState) { // Freeze the outer window and null out the inner window so // that initializing classes on the new inner doesn'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; Freeze(); mCreatingInnerWindow = true; // Every script context we are initialized with must create a // new global. rv = CreateNativeGlobalForInner(cx, newInnerWindow, aDocument->GetDocumentURI(), aDocument->NodePrincipal(), &newInnerWindow->mJSObject, getter_AddRefs(mInnerWindowHolder)); NS_ASSERTION(NS_SUCCEEDED(rv) && newInnerWindow->mJSObject && mInnerWindowHolder, "Failed to get script global and holder"); mCreatingInnerWindow = false; createdInnerWindow = true; Thaw(); NS_ENSURE_SUCCESS(rv, rv); } if (currentInner && currentInner->mJSObject) { if (oldDoc == aDocument) { // Move the navigator from the old inner window to the new one since // this is a document.write. This is safe from a same-origin point of // view because document.write can only be used by the same origin. newInnerWindow->mNavigator = currentInner->mNavigator; currentInner->mNavigator = nullptr; if (newInnerWindow->mNavigator) { newInnerWindow->mNavigator->SetWindow(newInnerWindow); } // 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->CreatePerformanceObjectIfNeeded(); if (currentInner->mPerformance) { newInnerWindow->mPerformance = new nsPerformance(newInnerWindow, 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; if (!mJSObject) { CreateOuterObject(newInnerWindow); mContext->DidInitializeContext(); mJSObject = mContext->GetNativeGlobal(); SetWrapper(mJSObject); } else { JSObject *outerObject = NewOuterWindowProxy(cx, xpc_UnmarkGrayObject(newInnerWindow->mJSObject), thisChrome); if (!outerObject) { NS_ERROR("out of memory"); return NS_ERROR_FAILURE; } js::SetProxyExtra(mJSObject, 0, js::PrivateValue(NULL)); outerObject = xpc::TransplantObject(cx, mJSObject, outerObject); if (!outerObject) { NS_ERROR("unable to transplant wrappers, probably OOM"); return NS_ERROR_FAILURE; } js::SetProxyExtra(outerObject, 0, js::PrivateValue(ToSupports(this))); mJSObject = outerObject; SetWrapper(mJSObject); { JSAutoCompartment ac(cx, mJSObject); JS_SetParent(cx, mJSObject, newInnerWindow->mJSObject); rv = SetOuterObject(cx, mJSObject); NS_ENSURE_SUCCESS(rv, rv); NS_ASSERTION(!JS_IsExceptionPending(cx), "We might overwrite a pending exception!"); XPCWrappedNativeScope* scope = xpc::GetObjectScope(mJSObject); if (scope->mWaiverWrapperMap) { scope->mWaiverWrapperMap->Reparent(cx, newInnerWindow->mJSObject); } } } // Enter the new global's compartment. JSAutoCompartment ac(cx, mJSObject); // If we created a new inner window above, we need to do the last little bit // of initialization now that the dust has settled. if (createdInnerWindow) { nsIXPConnect *xpc = nsContentUtils::XPConnect(); nsCOMPtr wrapper; nsresult rv = xpc->GetWrappedNativeOfJSObject(cx, newInnerWindow->mJSObject, getter_AddRefs(wrapper)); NS_ENSURE_SUCCESS(rv, rv); NS_ABORT_IF_FALSE(wrapper, "bad wrapper"); rv = wrapper->FinishInitForWrappedGlobal(); NS_ENSURE_SUCCESS(rv, rv); } if (!aState) { if (!JS_DefineProperty(cx, newInnerWindow->mJSObject, "window", OBJECT_TO_JSVAL(mJSObject), JS_PropertyStub, JS_StrictPropertyStub, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT)) { NS_ERROR("can't create the 'window' property"); return NS_ERROR_FAILURE; } } } JSAutoCompartment ac(cx, mJSObject); 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. #ifdef DEBUG JSObject* newInnerJSObject = newInnerWindow->FastGetGlobalJSObject(); #endif // Now that we're connecting the outer global to the inner one, // we must have transplanted it. The JS engine tries to maintain // the global object's compartment as its default compartment, // so update that now since it might have changed. JS_SetGlobalObject(cx, mJSObject); #ifdef DEBUG JSObject *proto1, *proto2; JS_GetPrototype(cx, mJSObject, &proto1); JS_GetPrototype(cx, newInnerJSObject, &proto2); NS_ASSERTION(proto1 == proto2, "outer and inner globals should have the same prototype"); #endif nsCOMPtr frame = do_QueryInterface(GetFrameElementInternal()); if (frame) { nsPIDOMWindow* parentWindow = frame->OwnerDoc()->GetWindow(); if (parentWindow && parentWindow->TimeoutSuspendCount()) { SuspendTimeouts(parentWindow->TimeoutSuspendCount()); } } } // Add an extra ref in case we release mContext during GC. nsCOMPtr kungFuDeathGrip(mContext); // Now that the prototype is all set up, install the global scope // polluter. This must happen after the above prototype fixup. If // the GSP was to be installed on the inner window's real // prototype (as it would be if this was done before the prototype // fixup above) we would end up holding the GSP alive (through // XPConnect's internal marking of wrapper prototypes) as long as // the inner window was around, and if the GSP had properties on // it that held an element alive we'd hold the document alive, // which could hold event handlers alive, which hold the context // alive etc. if ((!reUseInnerWindow || aDocument != oldDoc) && !aState) { nsCOMPtr html_doc(do_QueryInterface(mDocument)); nsWindowSH::InstallGlobalScopePolluter(cx, newInnerWindow->mJSObject, html_doc); } aDocument->SetScriptGlobalObject(newInnerWindow); if (!aState) { if (reUseInnerWindow) { if (newInnerWindow->mDoc != aDocument) { newInnerWindow->mDocument = do_QueryInterface(aDocument); newInnerWindow->mDoc = aDocument; // We're reusing the inner window for a new document. In this // case we don't clear the inner window's scope, but we must // make sure the cached document property gets updated. // XXXmarkh - tell other languages about this? ::JS_DeleteProperty(cx, currentInner->mJSObject, "document"); } } else { newInnerWindow->InnerSetNewDocument(aDocument); // Initialize DOM classes etc on the inner window. rv = mContext->InitClasses(newInnerWindow->mJSObject); NS_ENSURE_SUCCESS(rv, rv); } if (mArguments) { newInnerWindow->DefineArgumentsProperty(mArguments); newInnerWindow->mArguments = mArguments; newInnerWindow->mArgumentsOrigin = mArgumentsOrigin; mArguments = nullptr; mArgumentsOrigin = nullptr; } // Give the new inner window our chrome event handler (since it // doesn't have one). newInnerWindow->mChromeEventHandler = mChromeEventHandler; } mContext->GC(js::gcreason::SET_NEW_DOCUMENT); mContext->DidInitializeContext(); 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. nsCOMPtr treeItem(do_QueryInterface(mDocShell)); int32_t itemType = nsIDocShellTreeItem::typeContent; if (treeItem) { treeItem->GetItemType(&itemType); } if (itemType != nsIDocShellTreeItem::typeChrome || nsContentUtils::IsSystemPrincipal(mDoc->NodePrincipal())) { newInnerWindow->mHasNotifiedGlobalCreated = true; nsContentUtils::AddScriptRunner( NS_NewRunnableMethod(this, &nsGlobalWindow::DispatchDOMWindowCreated)); } } return NS_OK; } void nsGlobalWindow::DispatchDOMWindowCreated() { if (!mDoc || !mDocument) { return; } // Fire DOMWindowCreated at chrome event listeners nsContentUtils::DispatchChromeEvent(mDoc, mDocument, NS_LITERAL_STRING("DOMWindowCreated"), true /* bubbles */, false /* not cancellable */); nsCOMPtr observerService = mozilla::services::GetObserverService(); if (observerService) { nsAutoString origin; nsIPrincipal* principal = mDoc->NodePrincipal(); nsContentUtils::GetUTFOrigin(principal, origin); observerService-> NotifyObservers(static_cast(this), nsContentUtils::IsSystemPrincipal(principal) ? "chrome-document-global-created" : "content-document-global-created", origin.get()); } } void nsGlobalWindow::ClearStatus() { SetStatus(EmptyString()); SetDefaultStatus(EmptyString()); } void nsGlobalWindow::InnerSetNewDocument(nsIDocument* aDocument) { NS_PRECONDITION(IsInnerWindow(), "Must only be called on inner windows"); MOZ_ASSERT(aDocument); #ifdef PR_LOGGING if (gDOMLeakPRLog && PR_LOG_TEST(gDOMLeakPRLog, PR_LOG_DEBUG)) { nsIURI *uri = aDocument->GetDocumentURI(); nsAutoCString spec; if (uri) uri->GetSpec(spec); PR_LogPrint("DOMWINDOW %p SetNewDocument %s", this, spec.get()); } #endif mDocument = do_QueryInterface(aDocument); mDoc = aDocument; 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 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 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 parentWindow; GetParent(getter_AddRefs(parentWindow)); if (parentWindow.get() != static_cast(this)) { nsCOMPtr piWindow(do_QueryInterface(parentWindow)); mChromeEventHandler = piWindow->GetChromeEventHandler(); } else { NS_NewWindowRoot(this, getter_AddRefs(mChromeEventHandler)); } } bool docShellActive; mDocShell->GetIsActive(&docShellActive); mIsBackground = !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 // (mJSObject) so that it can be retrieved later (until it is // finalized by the JS GC). NS_ASSERTION(mTimeouts.isEmpty(), "Uh, outer window holds timeouts!"); // Call FreeInnerObjects on all inner windows, not just the current // one, since some could be held by WindowStateHolder objects that // are GC-owned. for (nsRefPtr inner = (nsGlobalWindow *)PR_LIST_HEAD(this); inner != this; inner = (nsGlobalWindow*)PR_NEXT_LINK(inner)) { NS_ASSERTION(!inner->mOuterWindow || inner->mOuterWindow == this, "bad outer window pointer"); inner->FreeInnerObjects(); } // Make sure that this is called before we null out the document. NotifyDOMWindowDestroyed(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 mDocument = nullptr; mDoc = nullptr; mFocusedNode = nullptr; } ClearControllers(); mChromeEventHandler = nullptr; // force release now if (mArguments) { // We got no new document after someone called // SetArguments(), drop our reference to the arguments. mArguments = nullptr; mArgumentsLast = nullptr; mArgumentsOrigin = nullptr; } if (mContext) { mContext->GC(js::gcreason::SET_DOC_SHELL); mContext = nullptr; } mDocShell = nullptr; // Weak Reference NS_ASSERTION(!mNavigator, "Non-null mNavigator in outer window!"); if (mFrames) { mFrames->SetDocShell(nullptr); } MaybeForgiveSpamCount(); CleanUp(false); if (mLocalStorage) { nsCOMPtr obs = do_GetInterface(mLocalStorage); if (obs) { mDocShell->AddWeakPrivacyTransitionObserver(obs); } } if (mSessionStorage) { nsCOMPtr obs = do_GetInterface(mSessionStorage); if (obs) { mDocShell->AddWeakPrivacyTransitionObserver(obs); } } } void nsGlobalWindow::SetOpenerWindow(nsIDOMWindow* aOpener, bool aOriginalOpener) { FORWARD_TO_OUTER_VOID(SetOpenerWindow, (aOpener, aOriginalOpener)); 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 = do_GetWeakReference(aOpener); NS_ASSERTION(mOpener || !aOpener, "Opener must support weak references!"); if (aOriginalOpener) { mHadOriginalOpener = true; } #ifdef DEBUG mSetOpenerWindowCalled = true; #endif } static already_AddRefed TryGetTabChildGlobalAsEventTarget(nsISupports *aFrom) { nsCOMPtr frameLoaderOwner = do_QueryInterface(aFrom); if (!frameLoaderOwner) { return NULL; } nsRefPtr frameLoader = frameLoaderOwner->GetFrameLoader(); if (!frameLoader) { return NULL; } nsCOMPtr eventTarget = frameLoader->GetTabChildGlobalAsEventTarget(); return eventTarget.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 frameElement = GetFrameElementInternal(); nsCOMPtr eventTarget = TryGetTabChildGlobalAsEventTarget(frameElement); if (!eventTarget) { eventTarget = TryGetTabChildGlobalAsEventTarget(mChromeEventHandler); } if (!eventTarget) { eventTarget = mChromeEventHandler; } mParentTarget = eventTarget; } bool nsGlobalWindow::GetIsTabModalPromptAllowed() { bool allowTabModal = true; if (mDocShell) { nsCOMPtr cv; mDocShell->GetContentViewer(getter_AddRefs(cv)); cv->GetIsTabModalPromptAllowed(&allowTabModal); } return allowTabModal; } nsIDOMEventTarget* nsGlobalWindow::GetTargetForDOMEvent() { return static_cast(GetOuterWindowInternal()); } nsIDOMEventTarget* nsGlobalWindow::GetTargetForEventTargetChain() { return IsInnerWindow() ? this : static_cast(GetCurrentInnerWindowInternal()); } nsresult nsGlobalWindow::WillHandleEvent(nsEventChainPostVisitor& aVisitor) { return NS_OK; } JSContext* nsGlobalWindow::GetJSContextForEventHandlers() { return nullptr; } nsresult nsGlobalWindow::PreHandleEvent(nsEventChainPreVisitor& aVisitor) { NS_PRECONDITION(IsInnerWindow(), "PreHandleEvent is used on outer window!?"); static uint32_t count = 0; uint32_t msg = aVisitor.mEvent->message; aVisitor.mCanHandle = true; aVisitor.mForceContentDispatch = true; //FIXME! Bug 329119 if ((msg == NS_MOUSE_MOVE) && gEntropyCollector) { //Chances are this counter will overflow during the life of the //process, but that's OK for our case. Means we get a little //more entropy. if (count++ % 100 == 0) { //Since the high bits seem to be zero's most of the time, //let's only take the lowest half of the point structure. int16_t myCoord[2]; myCoord[0] = aVisitor.mEvent->refPoint.x; myCoord[1] = aVisitor.mEvent->refPoint.y; gEntropyCollector->RandomUpdate((void*)myCoord, sizeof(myCoord)); gEntropyCollector->RandomUpdate((void*)&(aVisitor.mEvent->time), sizeof(uint32_t)); } } else if (msg == NS_RESIZE_EVENT) { mIsHandlingResizeEvent = true; } else if (msg == NS_MOUSE_BUTTON_DOWN && aVisitor.mEvent->mFlags.mIsTrusted) { gMouseDown = true; } else if ((msg == NS_MOUSE_BUTTON_UP || msg == NS_DRAGDROP_END) && aVisitor.mEvent->mFlags.mIsTrusted) { gMouseDown = false; if (gDragServiceDisabled) { nsCOMPtr 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->mFlags.mIsTrusted && (NS_IS_MOUSE_EVENT(aVisitor.mEvent) || NS_IS_DRAG_EVENT(aVisitor.mEvent))) { mAddActiveEventFuzzTime = false; } return NS_OK; } bool nsGlobalWindow::DialogsAreBlocked(bool *aBeingAbused) { *aBeingAbused = false; nsGlobalWindow *topWindow = GetScriptableTop(); if (!topWindow) { NS_ASSERTION(!mDocShell, "DialogsAreBlocked() called without a top window?"); return true; } topWindow = topWindow->GetCurrentInnerWindowInternal(); if (!topWindow) { return true; } if (topWindow->mDialogsPermanentlyDisabled) { return true; } // Dialogs are blocked if the content viewer is hidden if (mDocShell) { nsCOMPtr cv; mDocShell->GetContentViewer(getter_AddRefs(cv)); bool isHidden; cv->GetIsHidden(&isHidden); if (isHidden) { return true; } } *aBeingAbused = topWindow->DialogsAreBeingAbused(); return topWindow->mStopAbuseDialogs && *aBeingAbused; } bool nsGlobalWindow::DialogsAreBeingAbused() { NS_ASSERTION(GetScriptableTop() && GetScriptableTop()->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() { FORWARD_TO_OUTER(ConfirmDialogIfNeeded, (), false); NS_ENSURE_TRUE(mDocShell, false); nsCOMPtr 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; nsXPIDLString label, title; nsContentUtils::GetLocalizedString(nsContentUtils::eCOMMON_DIALOG_PROPERTIES, "ScriptDialogLabel", label); nsContentUtils::GetLocalizedString(nsContentUtils::eCOMMON_DIALOG_PROPERTIES, "ScriptDialogPreventTitle", title); promptSvc->Confirm(this, title.get(), label.get(), &disableDialog); if (disableDialog) { PreventFurtherDialogs(false); return false; } return true; } void nsGlobalWindow::PreventFurtherDialogs(bool aPermanent) { nsGlobalWindow *topWindow = GetScriptableTop(); if (!topWindow) { NS_ERROR("PreventFurtherDialogs() called without a top window?"); return; } topWindow = topWindow->GetCurrentInnerWindowInternal(); if (topWindow) { topWindow->mStopAbuseDialogs = true; if (aPermanent) { topWindow->mDialogsPermanentlyDisabled = true; } } } nsresult nsGlobalWindow::PostHandleEvent(nsEventChainPostVisitor& aVisitor) { NS_PRECONDITION(IsInnerWindow(), "PostHandleEvent is used on outer window!?"); // Return early if there is nothing to do. switch (aVisitor.mEvent->message) { case NS_RESIZE_EVENT: case NS_PAGE_UNLOAD: case NS_LOAD: 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 kungFuDeathGrip1(mChromeEventHandler); nsCOMPtr kungFuDeathGrip2(GetContextInternal()); if (aVisitor.mEvent->message == NS_RESIZE_EVENT) { mIsHandlingResizeEvent = false; } else if (aVisitor.mEvent->message == NS_PAGE_UNLOAD && aVisitor.mEvent->mFlags.mIsTrusted) { // Execute bindingdetached handlers before we tear ourselves // down. if (mDocument) { NS_ASSERTION(mDoc, "Must have doc"); mDoc->BindingManager()->ExecuteDetachedHandlers(); } mIsDocumentLoaded = false; } else if (aVisitor.mEvent->message == NS_LOAD && aVisitor.mEvent->mFlags.mIsTrusted) { // This is page load event since load events don't propagate to |window|. // @see nsDocument::PreHandleEvent. mIsDocumentLoaded = true; nsCOMPtr content(do_QueryInterface(GetFrameElementInternal())); nsCOMPtr treeItem = do_QueryInterface(GetDocShell()); int32_t itemType = nsIDocShellTreeItem::typeChrome; if (treeItem) { treeItem->GetItemType(&itemType); } if (content && GetParentInternal() && 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; nsEvent event(aVisitor.mEvent->mFlags.mIsTrusted, NS_LOAD); event.mFlags.mBubbles = 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. nsEventDispatcher::Dispatch(content, nullptr, &event, nullptr, &status); } } return NS_OK; } nsresult nsGlobalWindow::DispatchDOMEvent(nsEvent* aEvent, nsIDOMEvent* aDOMEvent, nsPresContext* aPresContext, nsEventStatus* aEventStatus) { return nsEventDispatcher::DispatchDOMEvent(static_cast(this), aEvent, aDOMEvent, aPresContext, aEventStatus); } void nsGlobalWindow::OnFinalize(JSObject* aObject) { if (aObject == mJSObject) { mJSObject = NULL; } } void nsGlobalWindow::SetScriptsEnabled(bool aEnabled, bool aFireTimeouts) { FORWARD_TO_INNER_VOID(SetScriptsEnabled, (aEnabled, aFireTimeouts)); if (aEnabled && aFireTimeouts) { // Scripts are enabled (again?) on this context, run timeouts that // fired on this context while scripts were disabled. void (nsGlobalWindow::*run)() = &nsGlobalWindow::RunTimeout; NS_DispatchToCurrentThread(NS_NewRunnableMethod(this, run)); } } nsresult nsGlobalWindow::SetArguments(nsIArray *aArguments, nsIPrincipal *aOrigin) { FORWARD_TO_OUTER(SetArguments, (aArguments, aOrigin), NS_ERROR_NOT_INITIALIZED); // Hold on to the arguments so that we can re-set them once the next // document is loaded. mArguments = aArguments; mArgumentsOrigin = aOrigin; nsGlobalWindow *currentInner = GetCurrentInnerWindowInternal(); if (!mIsModalContentWindow) { mArgumentsLast = aArguments; } else if (currentInner) { // SetArguments() is being called on a modal content window that // already has an inner window. This can happen when loading // javascript: URIs as modal content dialogs. In this case, we'll // set up the dialog window, both inner and outer, before we call // SetArguments() on the window, so to deal with that, make sure // here that the arguments are propagated to the inner window. currentInner->mArguments = aArguments; currentInner->mArgumentsOrigin = aOrigin; } return currentInner ? currentInner->DefineArgumentsProperty(aArguments) : NS_OK; } nsresult nsGlobalWindow::DefineArgumentsProperty(nsIArray *aArguments) { JSContext *cx; nsIScriptContext *ctx = GetOuterWindowInternal()->mContext; NS_ENSURE_TRUE(aArguments && ctx && (cx = ctx->GetNativeContext()), NS_ERROR_NOT_INITIALIZED); if (mIsModalContentWindow) { // Modal content windows don't have an "arguments" property, they // have a "dialogArguments" property which is handled // separately. See nsWindowSH::NewResolve(). return NS_OK; } return GetContextInternal()->SetProperty(mJSObject, "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 , in // that case the global window is used in JS before we've loaded // a document into the window. nsCOMPtr objPrincipal = do_QueryInterface(GetParentInternal()); if (objPrincipal) { return objPrincipal->GetPrincipal(); } return nullptr; } //***************************************************************************** // nsGlobalWindow::nsIDOMWindow //***************************************************************************** nsIURI* nsPIDOMWindow::GetDocumentURI() const { return mDoc ? mDoc->GetDocumentURI() : mDocumentURI.get(); } nsIURI* nsPIDOMWindow::GetDocBaseURI() const { return mDoc ? mDoc->GetDocBaseURI() : mDocBaseURI.get(); } void nsPIDOMWindow::MaybeCreateDoc() { MOZ_ASSERT(!mDoc); if (nsIDocShell* docShell = GetDocShell()) { // Note that |document| here is the same thing as our mDocument, but we // don't have to explicitly set the member variable because the docshell // has already called SetNewDocument(). nsCOMPtr document = do_GetInterface(docShell); } } void nsPIDOMWindow::AddAudioContext(AudioContext* aAudioContext) { mAudioContexts.AppendElement(aAudioContext); } NS_IMETHODIMP nsGlobalWindow::GetDocument(nsIDOMDocument** aDocument) { nsCOMPtr document = do_QueryInterface(GetDoc()); document.forget(aDocument); return NS_OK; } NS_IMETHODIMP nsGlobalWindow::GetWindow(nsIDOMWindow** aWindow) { FORWARD_TO_OUTER(GetWindow, (aWindow), NS_ERROR_NOT_INITIALIZED); *aWindow = static_cast(this); NS_ADDREF(*aWindow); return NS_OK; } NS_IMETHODIMP nsGlobalWindow::GetSelf(nsIDOMWindow** aWindow) { FORWARD_TO_OUTER(GetSelf, (aWindow), NS_ERROR_NOT_INITIALIZED); *aWindow = static_cast(this); NS_ADDREF(*aWindow); return NS_OK; } NS_IMETHODIMP nsGlobalWindow::GetNavigator(nsIDOMNavigator** aNavigator) { FORWARD_TO_INNER(GetNavigator, (aNavigator), NS_ERROR_NOT_INITIALIZED); *aNavigator = nullptr; if (!mNavigator) { mNavigator = new Navigator(this); } NS_ADDREF(*aNavigator = mNavigator); return NS_OK; } NS_IMETHODIMP nsGlobalWindow::GetScreen(nsIDOMScreen** aScreen) { FORWARD_TO_INNER(GetScreen, (aScreen), NS_ERROR_NOT_INITIALIZED); *aScreen = nullptr; if (!mScreen) { mScreen = nsScreen::Create(this); if (!mScreen) { return NS_ERROR_UNEXPECTED; } } NS_IF_ADDREF(*aScreen = mScreen); return NS_OK; } NS_IMETHODIMP nsGlobalWindow::GetHistory(nsIDOMHistory** aHistory) { FORWARD_TO_INNER(GetHistory, (aHistory), NS_ERROR_NOT_INITIALIZED); *aHistory = nullptr; if (!mHistory) { mHistory = new nsHistory(this); if (!mHistory) { return NS_ERROR_OUT_OF_MEMORY; } } NS_IF_ADDREF(*aHistory = mHistory); return NS_OK; } NS_IMETHODIMP nsGlobalWindow::GetPerformance(nsISupports** aPerformance) { FORWARD_TO_INNER(GetPerformance, (aPerformance), NS_ERROR_NOT_INITIALIZED); NS_IF_ADDREF(*aPerformance = nsPIDOMWindow::GetPerformance()); return NS_OK; } nsPerformance* nsPIDOMWindow::GetPerformance() { MOZ_ASSERT(IsInnerWindow()); if (HasPerformanceSupport()) { CreatePerformanceObjectIfNeeded(); return mPerformance; } return nullptr; } void nsPIDOMWindow::CreatePerformanceObjectIfNeeded() { if (mPerformance || !mDoc) { return; } nsRefPtr timing = mDoc->GetNavigationTiming(); nsCOMPtr timedChannel(do_QueryInterface(mDoc->GetChannel())); bool timingEnabled = false; if (!timedChannel || !NS_SUCCEEDED(timedChannel->GetTimingEnabled(&timingEnabled)) || !timingEnabled) { timedChannel = nullptr; } if (timing) { mPerformance = new nsPerformance(this, timing, timedChannel); } } /** * GetScriptableParent is called when script reads window.parent. * * In contrast to GetRealParent, GetScriptableParent respects