dom/base/nsGlobalWindowInner.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsGlobalWindowInner.h"
   8
   9 #include <inttypes.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <cstdint>
  14 #include <new>
  15 #include <type_traits>
  16 #include <utility>
  17 #include "AudioChannelService.h"
  18 #include "AutoplayPolicy.h"
  19 #include "Crypto.h"
  20 #include "MainThreadUtils.h"
  21 #include "Navigator.h"
  22 #include "PaintWorkletImpl.h"
  23 #include "SessionStorageCache.h"
  24 #include "Units.h"
  25 #include "VRManagerChild.h"
  26 #include "WindowDestroyedEvent.h"
  27 #include "WindowNamedPropertiesHandler.h"
  28 #include "js/ComparisonOperators.h"
  29 #include "js/CompileOptions.h"
  30 #include "js/friend/PerformanceHint.h"
  31 #include "js/Id.h"
  32 #include "js/loader/LoadedScript.h"
  33 #include "js/PropertyAndElement.h"  // JS_DefineProperty, JS_GetProperty
  34 #include "js/PropertyDescriptor.h"
  35 #include "js/RealmOptions.h"
  36 #include "js/RootingAPI.h"
  37 #include "js/TypeDecls.h"
  38 #include "js/Value.h"
  39 #include "js/Warnings.h"
  40 #include "js/shadow/String.h"
  41 #include "jsapi.h"
  42 #include "jsfriendapi.h"
  43 #include "mozIDOMWindow.h"
  44 #include "moz_external_vr.h"
  45 #include "mozilla/AlreadyAddRefed.h"
  46 #include "mozilla/ArrayIterator.h"
  47 #include "mozilla/ArrayUtils.h"
  48 #include "mozilla/Attributes.h"
  49 #include "mozilla/BaseProfilerMarkersPrerequisites.h"
  50 #include "mozilla/BasicEvents.h"
  51 #include "mozilla/CallState.h"
  52 #include "mozilla/CycleCollectedJSContext.h"
  53 #include "mozilla/DOMEventTargetHelper.h"
  54 #include "mozilla/ErrorResult.h"
  55 #include "mozilla/EventDispatcher.h"
  56 #include "mozilla/EventListenerManager.h"
  57 #include "mozilla/EventQueue.h"
  58 #include "mozilla/ExtensionPolicyService.h"
  59 #include "mozilla/FloatingPoint.h"
  60 #include "mozilla/FlushType.h"
  61 #include "mozilla/Likely.h"
  62 #include "mozilla/LinkedList.h"
  63 #include "mozilla/LookAndFeel.h"
  64 #include "mozilla/Logging.h"
  65 #include "mozilla/MacroForEach.h"
  66 #include "mozilla/Maybe.h"
  67 #include "mozilla/OwningNonNull.h"
  68 #include "mozilla/PermissionDelegateHandler.h"
  69 #include "mozilla/Preferences.h"
  70 #include "mozilla/PresShell.h"
  71 #include "mozilla/ProcessHangMonitor.h"
  72 #include "mozilla/RefPtr.h"
  73 #include "mozilla/Result.h"
  74 #include "mozilla/ScrollTypes.h"
  75 #include "mozilla/Components.h"
  76 #include "mozilla/SizeOfState.h"
  77 #include "mozilla/Span.h"
  78 #include "mozilla/SpinEventLoopUntil.h"
  79 #include "mozilla/Sprintf.h"
  80 #include "mozilla/StaticPrefs_browser.h"
  81 #include "mozilla/StaticPrefs_docshell.h"
  82 #include "mozilla/StaticPrefs_dom.h"
  83 #include "mozilla/StaticPrefs_extensions.h"
  84 #include "mozilla/StaticPrefs_privacy.h"
  85 #include "mozilla/StorageAccess.h"
  86 #include "mozilla/StoragePrincipalHelper.h"
  87 #include "mozilla/Telemetry.h"
  88 #include "mozilla/TelemetryHistogramEnums.h"
  89 #include "mozilla/TimeStamp.h"
  90 #include "mozilla/UniquePtr.h"
  91 #include "mozilla/Unused.h"
  92 #include "mozilla/dom/AudioContext.h"
  93 #include "mozilla/dom/AutoEntryScript.h"
  94 #include "mozilla/dom/BarProps.h"
  95 #include "mozilla/dom/BindingDeclarations.h"
  96 #include "mozilla/dom/BindingUtils.h"
  97 #include "mozilla/dom/BrowserChild.h"
  98 #include "mozilla/dom/BrowsingContext.h"
  99 #include "mozilla/dom/CSPEvalChecker.h"
 100 #include "mozilla/dom/CallbackDebuggerNotification.h"
 101 #include "mozilla/dom/ChromeMessageBroadcaster.h"
 102 #include "mozilla/dom/ClientInfo.h"
 103 #include "mozilla/dom/ClientManager.h"
 104 #include "mozilla/dom/ClientSource.h"
 105 #include "mozilla/dom/ClientState.h"
 106 #include "mozilla/dom/ClientsBinding.h"
 107 #include "mozilla/dom/Console.h"
 108 #include "mozilla/dom/ContentFrameMessageManager.h"
 109 #include "mozilla/dom/ContentMediaController.h"
 110 #include "mozilla/dom/CustomElementRegistry.h"
 111 #include "mozilla/dom/DebuggerNotification.h"
 112 #include "mozilla/dom/DebuggerNotificationBinding.h"
 113 #include "mozilla/dom/DebuggerNotificationManager.h"
 114 #include "mozilla/dom/DocGroup.h"
 115 #include "mozilla/dom/Document.h"
 116 #include "mozilla/dom/DocumentInlines.h"
 117 #include "mozilla/dom/Element.h"
 118 #include "mozilla/dom/Event.h"
 119 #include "mozilla/dom/EventTarget.h"
 120 #include "mozilla/dom/External.h"
 121 #include "mozilla/dom/Fetch.h"
 122 #include "mozilla/dom/Gamepad.h"
 123 #include "mozilla/dom/GamepadHandle.h"
 124 #include "mozilla/dom/GamepadManager.h"
 125 #include "mozilla/dom/HashChangeEvent.h"
 126 #include "mozilla/dom/HashChangeEventBinding.h"
 127 #include "mozilla/dom/IDBFactory.h"
 128 #include "mozilla/dom/IdleRequest.h"
 129 #include "mozilla/dom/ImageBitmap.h"
 130 #include "mozilla/dom/ImageBitmapSource.h"
 131 #include "mozilla/dom/InstallTriggerBinding.h"
 132 #include "mozilla/dom/IntlUtils.h"
 133 #include "mozilla/dom/JSExecutionContext.h"
 134 #include "mozilla/dom/LSObject.h"
 135 #include "mozilla/dom/LocalStorage.h"
 136 #include "mozilla/dom/LocalStorageCommon.h"
 137 #include "mozilla/dom/Location.h"
 138 #include "mozilla/dom/MediaDevices.h"
 139 #include "mozilla/dom/MediaKeys.h"
 140 #include "mozilla/dom/NavigatorBinding.h"
 141 #include "mozilla/dom/Nullable.h"
 142 #include "mozilla/dom/PartitionedLocalStorage.h"
 143 #include "mozilla/dom/Performance.h"
 144 #include "mozilla/dom/PopStateEvent.h"
 145 #include "mozilla/dom/PopStateEventBinding.h"
 146 #include "mozilla/dom/PopupBlocker.h"
 147 #include "mozilla/dom/PrimitiveConversions.h"
 148 #include "mozilla/dom/Promise.h"
 149 #include "mozilla/dom/RootedDictionary.h"
 150 #include "mozilla/dom/WebTaskSchedulerMainThread.h"
 151 #include "mozilla/dom/ScriptLoader.h"
 152 #include "mozilla/dom/ScriptSettings.h"
 153 #include "mozilla/dom/ServiceWorker.h"
 154 #include "mozilla/dom/ServiceWorkerDescriptor.h"
 155 #include "mozilla/dom/ServiceWorkerRegistration.h"
 156 #include "mozilla/dom/SessionStorageManager.h"
 157 #include "mozilla/dom/SharedWorker.h"
 158 #include "mozilla/dom/Storage.h"
 159 #include "mozilla/dom/StorageEvent.h"
 160 #include "mozilla/dom/StorageEventBinding.h"
 161 #include "mozilla/dom/StorageNotifierService.h"
 162 #include "mozilla/dom/StorageUtils.h"
 163 #include "mozilla/dom/TabMessageTypes.h"
 164 #include "mozilla/dom/Timeout.h"
 165 #include "mozilla/dom/TimeoutHandler.h"
 166 #include "mozilla/dom/TimeoutManager.h"
 167 #include "mozilla/dom/ToJSValue.h"
 168 #include "mozilla/dom/VRDisplay.h"
 169 #include "mozilla/dom/VRDisplayEvent.h"
 170 #include "mozilla/dom/VRDisplayEventBinding.h"
 171 #include "mozilla/dom/VREventObserver.h"
 172 #include "mozilla/dom/VisualViewport.h"
 173 #include "mozilla/dom/WebIDLGlobalNameHash.h"
 174 #include "mozilla/dom/WindowBinding.h"
 175 #include "mozilla/dom/WindowContext.h"
 176 #include "mozilla/dom/WindowGlobalChild.h"
 177 #include "mozilla/dom/WindowProxyHolder.h"
 178 #include "mozilla/dom/WorkerCommon.h"
 179 #include "mozilla/dom/Worklet.h"
 180 #include "mozilla/dom/XRPermissionRequest.h"
 181 #include "mozilla/dom/cache/CacheStorage.h"
 182 #include "mozilla/dom/cache/Types.h"
 183 #include "mozilla/glean/bindings/Glean.h"
 184 #include "mozilla/glean/bindings/GleanPings.h"
 185 #include "mozilla/extensions/WebExtensionPolicy.h"
 186 #include "mozilla/fallible.h"
 187 #include "mozilla/gfx/BasePoint.h"
 188 #include "mozilla/gfx/BaseRect.h"
 189 #include "mozilla/gfx/BaseSize.h"
 190 #include "mozilla/gfx/Rect.h"
 191 #include "mozilla/gfx/Types.h"
 192 #include "mozilla/intl/LocaleService.h"
 193 #include "mozilla/ipc/BackgroundUtils.h"
 194 #include "mozilla/ipc/PBackgroundSharedTypes.h"
 195 #include "mozilla/net/CookieJarSettings.h"
 196 #include "nsAtom.h"
 197 #include "nsBaseHashtable.h"
 198 #include "nsCCUncollectableMarker.h"
 199 #include "nsCOMPtr.h"
 200 #include "nsCRT.h"
 201 #include "nsCRTGlue.h"
 202 #include "nsCanvasFrame.h"
 203 #include "nsCharTraits.h"
 204 #include "nsCheapSets.h"
 205 #include "nsContentUtils.h"
 206 #include "nsCoord.h"
 207 #include "nsCycleCollectionNoteChild.h"
 208 #include "nsCycleCollectionTraversalCallback.h"
 209 #include "nsDOMNavigationTiming.h"
 210 #include "nsDebug.h"
 211 #include "nsDeviceContext.h"
 212 #include "nsDocShell.h"
 213 #include "nsFocusManager.h"
 214 #include "nsFrameMessageManager.h"
 215 #include "nsGkAtoms.h"
 216 #include "nsGlobalWindowOuter.h"
 217 #include "nsHashKeys.h"
 218 #include "nsHistory.h"
 219 #include "nsIAddonPolicyService.h"
 220 #include "nsIArray.h"
 221 #include "nsIBaseWindow.h"
 222 #include "nsIBrowserChild.h"
 223 #include "nsICancelableRunnable.h"
 224 #include "nsIChannel.h"
 225 #include "nsIContentSecurityPolicy.h"
 226 #include "nsIControllers.h"
 227 #include "nsICookieJarSettings.h"
 228 #include "nsICookieService.h"
 229 #include "nsID.h"
 230 #include "nsIDOMStorageManager.h"
 231 #include "nsIDeviceSensors.h"
 232 #include "nsIDocShell.h"
 233 #include "nsIDocShellTreeItem.h"
 234 #include "nsIDocShellTreeOwner.h"
 235 #include "nsIDocumentLoader.h"
 236 #include "nsIDragService.h"
 237 #include "nsIFocusManager.h"
 238 #include "nsIFrame.h"
 239 #include "nsIGlobalObject.h"
 240 #include "nsIIOService.h"
 241 #include "nsIIdleRunnable.h"
 242 #include "nsIInterfaceRequestorUtils.h"
 243 #include "nsILoadContext.h"
 244 #include "nsILoadGroup.h"
 245 #include "nsILoadInfo.h"
 246 #include "nsINamed.h"
 247 #include "nsINode.h"
 248 #include "nsIObserver.h"
 249 #include "nsIObserverService.h"
 250 #include "nsIPermission.h"
 251 #include "nsIPermissionManager.h"
 252 #include "nsIPrefBranch.h"
 253 #include "nsIPrincipal.h"
 254 #include "nsIPrompt.h"
 255 #include "nsIRunnable.h"
 256 #include "nsIScreen.h"
 257 #include "nsIScreenManager.h"
 258 #include "nsIScriptContext.h"
 259 #include "nsIScriptGlobalObject.h"
 260 #include "nsIScriptObjectPrincipal.h"
 261 #include "nsIScrollableFrame.h"
 262 #include "nsISerialEventTarget.h"
 263 #include "nsISimpleEnumerator.h"
 264 #include "nsISizeOfEventTarget.h"
 265 #include "nsISlowScriptDebug.h"
 266 #include "nsISupportsUtils.h"
 267 #include "nsIThread.h"
 268 #include "nsITimedChannel.h"
 269 #include "nsIURI.h"
 270 #include "nsIWeakReference.h"
 271 #include "nsIWebBrowserChrome.h"
 272 #include "nsIWebNavigation.h"
 273 #include "nsIWebProgressListener.h"
 274 #include "nsIWidget.h"
 275 #include "nsIWidgetListener.h"
 276 #include "nsIXULRuntime.h"
 277 #include "nsJSPrincipals.h"
 278 #include "nsJSUtils.h"
 279 #include "nsLayoutStatics.h"
 280 #include "nsLiteralString.h"
 281 #include "nsNetUtil.h"
 282 #include "nsPIDOMWindow.h"
 283 #include "nsPIDOMWindowInlines.h"
 284 #include "nsPIWindowRoot.h"
 285 #include "nsPoint.h"
 286 #include "nsPresContext.h"
 287 #include "nsQueryObject.h"
 288 #include "nsSandboxFlags.h"
 289 #include "nsScreen.h"
 290 #include "nsServiceManagerUtils.h"
 291 #include "nsString.h"
 292 #include "nsStringFlags.h"
 293 #include "nsStringFwd.h"
 294 #include "nsTArray.h"
 295 #include "nsTLiteralString.h"
 296 #include "nsTObserverArray.h"
 297 #include "nsTStringRepr.h"
 298 #include "nsThreadUtils.h"
 299 #include "nsWeakReference.h"
 300 #include "nsWindowMemoryReporter.h"
 301 #include "nsWindowSizes.h"
 302 #include "nsWrapperCache.h"
 303 #include "nsWrapperCacheInlines.h"
 304 #include "nsXULAppAPI.h"
 305 #include "nsrootidl.h"
 306 #include "prclist.h"
 307 #include "prtypes.h"
 308 #include "xpcprivate.h"
 309 #include "xpcpublic.h"
 310
 311 #include "nsIDOMXULControlElement.h"
 312
 313 #ifdef NS_PRINTING
 314 #  include "nsIPrintSettings.h"
 315 #endif
 316
 317 #ifdef MOZ_WEBSPEECH
 318 #  include "mozilla/dom/SpeechSynthesis.h"
 319 #endif
 320
 321 #ifdef ANDROID
 322 #  include <android/log.h>
 323 #endif
 324
 325 #ifdef XP_WIN
 326 #  include "mozilla/Debug.h"
 327 #  include <process.h>
 328 #  define getpid _getpid
 329 #else
 330 #  include <unistd.h>  // for getpid()
 331 #endif
 332
 333 using namespace mozilla;
 334 using namespace mozilla::dom;
 335 using namespace mozilla::dom::ipc;
 336 using mozilla::TimeDuration;
 337 using mozilla::TimeStamp;
 338 using mozilla::dom::GamepadHandle;
 339 using mozilla::dom::cache::CacheStorage;
 340
 341 #define FORWARD_TO_OUTER(method, args, err_rval)                     \
 342   PR_BEGIN_MACRO                                                     \
 343   RefPtr<nsGlobalWindowOuter> outer = GetOuterWindowInternal();      \
 344   if (!HasActiveDocument()) {                                        \
 345     NS_WARNING(outer ? "Inner window does not have active document." \
 346                      : "No outer window available!");                \
 347     return err_rval;                                                 \
 348   }                                                                  \
 349   return outer->method args;                                         \
 350   PR_END_MACRO
 351
 352 static nsGlobalWindowOuter* GetOuterWindowForForwarding(
 353     nsGlobalWindowInner* aInner, ErrorResult& aError) {
 354   nsGlobalWindowOuter* outer = aInner->GetOuterWindowInternal();
 355   if (MOZ_LIKELY(aInner->HasActiveDocument())) {
 356     return outer;
 357   }
 358   if (!outer) {
 359     NS_WARNING("No outer window available!");
 360     aError.Throw(NS_ERROR_NOT_INITIALIZED);
 361   } else {
 362     aError.Throw(NS_ERROR_XPC_SECURITY_MANAGER_VETO);
 363   }
 364   return nullptr;
 365 }
 366
 367 #define FORWARD_TO_OUTER_OR_THROW(method, args, rv, err_rval)                \
 368   PR_BEGIN_MACRO                                                             \
 369   RefPtr<nsGlobalWindowOuter> outer = GetOuterWindowForForwarding(this, rv); \
 370   if (MOZ_LIKELY(outer)) {                                                   \
 371     return outer->method args;                                               \
 372   }                                                                          \
 373   return err_rval;                                                           \
 374   PR_END_MACRO
 375
 376 #define FORWARD_TO_OUTER_VOID(method, args)                          \
 377   PR_BEGIN_MACRO                                                     \
 378   RefPtr<nsGlobalWindowOuter> outer = GetOuterWindowInternal();      \
 379   if (!HasActiveDocument()) {                                        \
 380     NS_WARNING(outer ? "Inner window does not have active document." \
 381                      : "No outer window available!");                \
 382     return;                                                          \
 383   }                                                                  \
 384   outer->method args;                                                \
 385   return;                                                            \
 386   PR_END_MACRO
 387
 388 #define ENSURE_ACTIVE_DOCUMENT(errorresult, err_rval) \
 389   PR_BEGIN_MACRO                                      \
 390   if (MOZ_UNLIKELY(!HasActiveDocument())) {           \
 391     aError.Throw(NS_ERROR_XPC_SECURITY_MANAGER_VETO); \
 392     return err_rval;                                  \
 393   }                                                   \
 394   PR_END_MACRO
 395
 396 #define DOM_TOUCH_LISTENER_ADDED "dom-touch-listener-added"
 397 #define MEMORY_PRESSURE_OBSERVER_TOPIC "memory-pressure"
 398 #define PERMISSION_CHANGED_TOPIC "perm-changed"
 399
 400 static LazyLogModule gDOMLeakPRLogInner("DOMLeakInner");
 401 extern mozilla::LazyLogModule gTimeoutLog;
 402
 403 #ifdef DEBUG
 404 static LazyLogModule gDocShellAndDOMWindowLeakLogging(
 405     "DocShellAndDOMWindowLeak");
 406 #endif
 407
 408 static FILE* gDumpFile = nullptr;
 409
 410 nsGlobalWindowInner::InnerWindowByIdTable*
 411     nsGlobalWindowInner::sInnerWindowsById = nullptr;
 412
 413 bool nsGlobalWindowInner::sDragServiceDisabled = false;
 414 bool nsGlobalWindowInner::sMouseDown = false;
 415
 416 /**
 417  * An indirect observer object that means we don't have to implement nsIObserver
 418  * on nsGlobalWindow, where any script could see it.
 419  */
 420 class nsGlobalWindowObserver final : public nsIObserver,
 421                                      public nsIInterfaceRequestor,
 422                                      public StorageNotificationObserver {
 423  public:
 424   explicit nsGlobalWindowObserver(nsGlobalWindowInner* aWindow)
 425       : mWindow(aWindow) {}
 426   NS_DECL_ISUPPORTS
 427   NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic,
 428                      const char16_t* aData) override {
 429     if (!mWindow) return NS_OK;
 430     return mWindow->Observe(aSubject, aTopic, aData);
 431   }
 432   void Forget() { mWindow = nullptr; }
 433   NS_IMETHOD GetInterface(const nsIID& aIID, void** aResult) override {
 434     if (mWindow && aIID.Equals(NS_GET_IID(nsIDOMWindow)) && mWindow) {
 435       return mWindow->QueryInterface(aIID, aResult);
 436     }
 437     return NS_NOINTERFACE;
 438   }
 439
 440   void ObserveStorageNotification(StorageEvent* aEvent,
 441                                   const char16_t* aStorageType,
 442                                   bool aPrivateBrowsing) override {
 443     if (mWindow) {
 444       mWindow->ObserveStorageNotification(aEvent, aStorageType,
 445                                           aPrivateBrowsing);
 446     }
 447   }
 448
 449   nsIPrincipal* GetEffectiveCookiePrincipal() const override {
 450     return mWindow ? mWindow->GetEffectiveCookiePrincipal() : nullptr;
 451   }
 452
 453   nsIPrincipal* GetEffectiveStoragePrincipal() const override {
 454     return mWindow ? mWindow->GetEffectiveStoragePrincipal() : nullptr;
 455   }
 456
 457   bool IsPrivateBrowsing() const override {
 458     return mWindow ? mWindow->IsPrivateBrowsing() : false;
 459   }
 460
 461   nsIEventTarget* GetEventTarget() const override {
 462     return mWindow ? mWindow->SerialEventTarget() : nullptr;
 463   }
 464
 465  private:
 466   ~nsGlobalWindowObserver() = default;
 467
 468   // This reference is non-owning and safe because it's cleared by
 469   // nsGlobalWindowInner::FreeInnerObjects().
 470   nsGlobalWindowInner* MOZ_NON_OWNING_REF mWindow;
 471 };
 472
 473 NS_IMPL_ISUPPORTS(nsGlobalWindowObserver, nsIObserver, nsIInterfaceRequestor)
 474
 475 class IdleRequestExecutor;
 476
 477 class IdleRequestExecutorTimeoutHandler final : public TimeoutHandler {
 478  public:
 479   explicit IdleRequestExecutorTimeoutHandler(IdleRequestExecutor* aExecutor)
 480       : mExecutor(aExecutor) {}
 481
 482   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 483   NS_DECL_CYCLE_COLLECTION_CLASS(IdleRequestExecutorTimeoutHandler)
 484
 485   bool Call(const char* /* unused */) override;
 486
 487  private:
 488   ~IdleRequestExecutorTimeoutHandler() override = default;
 489   RefPtr<IdleRequestExecutor> mExecutor;
 490 };
 491
 492 NS_IMPL_CYCLE_COLLECTION(IdleRequestExecutorTimeoutHandler, mExecutor)
 493
 494 NS_IMPL_CYCLE_COLLECTING_ADDREF(IdleRequestExecutorTimeoutHandler)
 495 NS_IMPL_CYCLE_COLLECTING_RELEASE(IdleRequestExecutorTimeoutHandler)
 496
 497 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(IdleRequestExecutorTimeoutHandler)
 498   NS_INTERFACE_MAP_ENTRY(nsISupports)
 499 NS_INTERFACE_MAP_END
 500
 501 class IdleRequestExecutor final : public nsIRunnable,
 502                                   public nsICancelableRunnable,
 503                                   public nsINamed,
 504                                   public nsIIdleRunnable {
 505  public:
 506   explicit IdleRequestExecutor(nsGlobalWindowInner* aWindow)
 507       : mDispatched(false), mDeadline(TimeStamp::Now()), mWindow(aWindow) {
 508     MOZ_DIAGNOSTIC_ASSERT(mWindow);
 509
 510     mIdlePeriodLimit = {mDeadline, mWindow->LastIdleRequestHandle()};
 511     mDelayedExecutorDispatcher = new IdleRequestExecutorTimeoutHandler(this);
 512   }
 513
 514   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 515   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(IdleRequestExecutor, nsIRunnable)
 516
 517   NS_DECL_NSIRUNNABLE
 518   NS_DECL_NSINAMED
 519   nsresult Cancel() override;
 520   void SetDeadline(TimeStamp aDeadline) override;
 521
 522   bool IsCancelled() const { return !mWindow || mWindow->IsDying(); }
 523   // Checks if aRequest shouldn't execute in the current idle period
 524   // since it has been queued from a chained call to
 525   // requestIdleCallback from within a running idle callback.
 526   bool IneligibleForCurrentIdlePeriod(IdleRequest* aRequest) const {
 527     return aRequest->Handle() >= mIdlePeriodLimit.mLastRequestIdInIdlePeriod &&
 528            TimeStamp::Now() <= mIdlePeriodLimit.mEndOfIdlePeriod;
 529   }
 530
 531   void MaybeUpdateIdlePeriodLimit();
 532
 533   // Maybe dispatch the IdleRequestExecutor. MabyeDispatch will
 534   // schedule a delayed dispatch if the associated window is in the
 535   // background or if given a time to wait until dispatching.
 536   void MaybeDispatch(TimeStamp aDelayUntil = TimeStamp());
 537   void ScheduleDispatch();
 538
 539  private:
 540   struct IdlePeriodLimit {
 541     TimeStamp mEndOfIdlePeriod;
 542     uint32_t mLastRequestIdInIdlePeriod;
 543   };
 544
 545   void DelayedDispatch(uint32_t aDelay);
 546
 547   ~IdleRequestExecutor() override = default;
 548
 549   bool mDispatched;
 550   TimeStamp mDeadline;
 551   IdlePeriodLimit mIdlePeriodLimit;
 552   RefPtr<nsGlobalWindowInner> mWindow;
 553   // The timeout handler responsible for dispatching this executor in
 554   // the case of immediate dispatch to the idle queue isn't
 555   // desirable. This is used if we've dispatched all idle callbacks
 556   // that are allowed to run in the current idle period, or if the
 557   // associated window is currently in the background.
 558   RefPtr<TimeoutHandler> mDelayedExecutorDispatcher;
 559   // If not Nothing() then this value is the handle to the currently
 560   // scheduled delayed executor dispatcher. This is needed to be able
 561   // to cancel the timeout handler in case of the executor being
 562   // cancelled.
 563   Maybe<int32_t> mDelayedExecutorHandle;
 564 };
 565
 566 NS_IMPL_CYCLE_COLLECTION(IdleRequestExecutor, mWindow,
 567                          mDelayedExecutorDispatcher)
 568
 569 NS_IMPL_CYCLE_COLLECTING_ADDREF(IdleRequestExecutor)
 570 NS_IMPL_CYCLE_COLLECTING_RELEASE(IdleRequestExecutor)
 571
 572 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(IdleRequestExecutor)
 573   NS_INTERFACE_MAP_ENTRY(nsIRunnable)
 574   NS_INTERFACE_MAP_ENTRY(nsICancelableRunnable)
 575   NS_INTERFACE_MAP_ENTRY(nsINamed)
 576   NS_INTERFACE_MAP_ENTRY(nsIIdleRunnable)
 577   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIRunnable)
 578 NS_INTERFACE_MAP_END
 579
 580 NS_IMETHODIMP
 581 IdleRequestExecutor::GetName(nsACString& aName) {
 582   aName.AssignLiteral("IdleRequestExecutor");
 583   return NS_OK;
 584 }
 585
 586 // MOZ_CAN_RUN_SCRIPT_BOUNDARY until nsIRunnable::Run is MOZ_CAN_RUN_SCRIPT.
 587 // See bug 1535398.
 588 MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHODIMP IdleRequestExecutor::Run() {
 589   MOZ_ASSERT(NS_IsMainThread());
 590
 591   mDispatched = false;
 592   if (mWindow) {
 593     RefPtr<nsGlobalWindowInner> window(mWindow);
 594     window->ExecuteIdleRequest(mDeadline);
 595   }
 596
 597   return NS_OK;
 598 }
 599
 600 nsresult IdleRequestExecutor::Cancel() {
 601   MOZ_ASSERT(NS_IsMainThread());
 602
 603   if (mDelayedExecutorHandle && mWindow) {
 604     mWindow->TimeoutManager().ClearTimeout(
 605         mDelayedExecutorHandle.value(), Timeout::Reason::eIdleCallbackTimeout);
 606   }
 607
 608   mWindow = nullptr;
 609   return NS_OK;
 610 }
 611
 612 void IdleRequestExecutor::SetDeadline(TimeStamp aDeadline) {
 613   MOZ_ASSERT(NS_IsMainThread());
 614
 615   if (!mWindow) {
 616     return;
 617   }
 618
 619   mDeadline = aDeadline;
 620 }
 621
 622 void IdleRequestExecutor::MaybeUpdateIdlePeriodLimit() {
 623   if (TimeStamp::Now() > mIdlePeriodLimit.mEndOfIdlePeriod) {
 624     mIdlePeriodLimit = {mDeadline, mWindow->LastIdleRequestHandle()};
 625   }
 626 }
 627
 628 void IdleRequestExecutor::MaybeDispatch(TimeStamp aDelayUntil) {
 629   // If we've already dispatched the executor we don't want to do it
 630   // again. Also, if we've called IdleRequestExecutor::Cancel mWindow
 631   // will be null, which indicates that we shouldn't dispatch this
 632   // executor either.
 633   if (mDispatched || IsCancelled()) {
 634     return;
 635   }
 636
 637   mDispatched = true;
 638
 639   nsPIDOMWindowOuter* outer = mWindow->GetOuterWindow();
 640   if (outer && outer->IsBackground()) {
 641     // Set a timeout handler with a timeout of 0 ms to throttle idle
 642     // callback requests coming from a backround window using
 643     // background timeout throttling.
 644     DelayedDispatch(0);
 645     return;
 646   }
 647
 648   TimeStamp now = TimeStamp::Now();
 649   if (!aDelayUntil || aDelayUntil < now) {
 650     ScheduleDispatch();
 651     return;
 652   }
 653
 654   TimeDuration delay = aDelayUntil - now;
 655   DelayedDispatch(static_cast<uint32_t>(delay.ToMilliseconds()));
 656 }
 657
 658 void IdleRequestExecutor::ScheduleDispatch() {
 659   MOZ_ASSERT(mWindow);
 660   mDelayedExecutorHandle = Nothing();
 661   RefPtr<IdleRequestExecutor> request = this;
 662   NS_DispatchToCurrentThreadQueue(request.forget(), EventQueuePriority::Idle);
 663 }
 664
 665 void IdleRequestExecutor::DelayedDispatch(uint32_t aDelay) {
 666   MOZ_ASSERT(mWindow);
 667   MOZ_ASSERT(mDelayedExecutorHandle.isNothing());
 668   int32_t handle;
 669   mWindow->TimeoutManager().SetTimeout(
 670       mDelayedExecutorDispatcher, aDelay, false,
 671       Timeout::Reason::eIdleCallbackTimeout, &handle);
 672   mDelayedExecutorHandle = Some(handle);
 673 }
 674
 675 bool IdleRequestExecutorTimeoutHandler::Call(const char* /* unused */) {
 676   if (!mExecutor->IsCancelled()) {
 677     mExecutor->ScheduleDispatch();
 678   }
 679   return true;
 680 }
 681
 682 void nsGlobalWindowInner::ScheduleIdleRequestDispatch() {
 683   AssertIsOnMainThread();
 684
 685   if (!mIdleRequestExecutor) {
 686     mIdleRequestExecutor = new IdleRequestExecutor(this);
 687   }
 688
 689   mIdleRequestExecutor->MaybeDispatch();
 690 }
 691
 692 void nsGlobalWindowInner::SuspendIdleRequests() {
 693   if (mIdleRequestExecutor) {
 694     mIdleRequestExecutor->Cancel();
 695     mIdleRequestExecutor = nullptr;
 696   }
 697 }
 698
 699 void nsGlobalWindowInner::ResumeIdleRequests() {
 700   MOZ_ASSERT(!mIdleRequestExecutor);
 701
 702   ScheduleIdleRequestDispatch();
 703 }
 704
 705 void nsGlobalWindowInner::RemoveIdleCallback(
 706     mozilla::dom::IdleRequest* aRequest) {
 707   AssertIsOnMainThread();
 708
 709   if (aRequest->HasTimeout()) {
 710     mTimeoutManager->ClearTimeout(aRequest->GetTimeoutHandle(),
 711                                   Timeout::Reason::eIdleCallbackTimeout);
 712   }
 713
 714   aRequest->removeFrom(mIdleRequestCallbacks);
 715 }
 716
 717 void nsGlobalWindowInner::RunIdleRequest(IdleRequest* aRequest,
 718                                          DOMHighResTimeStamp aDeadline,
 719                                          bool aDidTimeout) {
 720   AssertIsOnMainThread();
 721   // XXXbz Do we still need this RefPtr?  MOZ_CAN_RUN_SCRIPT should
 722   // guarantee that caller is holding a strong ref on the stack.
 723   RefPtr<IdleRequest> request(aRequest);
 724   RemoveIdleCallback(request);
 725   request->IdleRun(this, aDeadline, aDidTimeout);
 726 }
 727
 728 void nsGlobalWindowInner::ExecuteIdleRequest(TimeStamp aDeadline) {
 729   AssertIsOnMainThread();
 730   RefPtr<IdleRequest> request = mIdleRequestCallbacks.getFirst();
 731
 732   if (!request) {
 733     // There are no more idle requests, so stop scheduling idle
 734     // request callbacks.
 735     return;
 736   }
 737
 738   // If the request that we're trying to execute has been queued
 739   // during the current idle period, then dispatch it again at the end
 740   // of the idle period.
 741   if (mIdleRequestExecutor->IneligibleForCurrentIdlePeriod(request)) {
 742     mIdleRequestExecutor->MaybeDispatch(aDeadline);
 743     return;
 744   }
 745
 746   DOMHighResTimeStamp deadline = 0.0;
 747
 748   if (Performance* perf = GetPerformance()) {
 749     deadline = perf->GetDOMTiming()->TimeStampToDOMHighRes(aDeadline);
 750   }
 751
 752   mIdleRequestExecutor->MaybeUpdateIdlePeriodLimit();
 753   RunIdleRequest(request, deadline, false);
 754
 755   // Running the idle callback could've suspended the window, in which
 756   // case mIdleRequestExecutor will be null.
 757   if (mIdleRequestExecutor) {
 758     mIdleRequestExecutor->MaybeDispatch();
 759   }
 760 }
 761
 762 class IdleRequestTimeoutHandler final : public TimeoutHandler {
 763  public:
 764   IdleRequestTimeoutHandler(JSContext* aCx, IdleRequest* aIdleRequest,
 765                             nsPIDOMWindowInner* aWindow)
 766       : TimeoutHandler(aCx), mIdleRequest(aIdleRequest), mWindow(aWindow) {}
 767
 768   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 769   NS_DECL_CYCLE_COLLECTION_CLASS(IdleRequestTimeoutHandler)
 770
 771   MOZ_CAN_RUN_SCRIPT bool Call(const char* /* unused */) override {
 772     RefPtr<nsGlobalWindowInner> window(nsGlobalWindowInner::Cast(mWindow));
 773     RefPtr<IdleRequest> request(mIdleRequest);
 774     window->RunIdleRequest(request, 0.0, true);
 775     return true;
 776   }
 777
 778  private:
 779   ~IdleRequestTimeoutHandler() override = default;
 780
 781   RefPtr<IdleRequest> mIdleRequest;
 782   nsCOMPtr<nsPIDOMWindowInner> mWindow;
 783 };
 784
 785 NS_IMPL_CYCLE_COLLECTION(IdleRequestTimeoutHandler, mIdleRequest, mWindow)
 786
 787 NS_IMPL_CYCLE_COLLECTING_ADDREF(IdleRequestTimeoutHandler)
 788 NS_IMPL_CYCLE_COLLECTING_RELEASE(IdleRequestTimeoutHandler)
 789
 790 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(IdleRequestTimeoutHandler)
 791   NS_INTERFACE_MAP_ENTRY(nsISupports)
 792 NS_INTERFACE_MAP_END
 793
 794 uint32_t nsGlobalWindowInner::RequestIdleCallback(
 795     JSContext* aCx, IdleRequestCallback& aCallback,
 796     const IdleRequestOptions& aOptions, ErrorResult& aError) {
 797   AssertIsOnMainThread();
 798
 799   if (IsDying()) {
 800     return 0;
 801   }
 802
 803   uint32_t handle = mIdleRequestCallbackCounter++;
 804
 805   RefPtr<IdleRequest> request = new IdleRequest(&aCallback, handle);
 806
 807   if (aOptions.mTimeout.WasPassed()) {
 808     int32_t timeoutHandle;
 809     RefPtr<TimeoutHandler> handler(
 810         new IdleRequestTimeoutHandler(aCx, request, this));
 811
 812     nsresult rv = mTimeoutManager->SetTimeout(
 813         handler, aOptions.mTimeout.Value(), false,
 814         Timeout::Reason::eIdleCallbackTimeout, &timeoutHandle);
 815
 816     if (NS_WARN_IF(NS_FAILED(rv))) {
 817       return 0;
 818     }
 819
 820     request->SetTimeoutHandle(timeoutHandle);
 821   }
 822
 823   mIdleRequestCallbacks.insertBack(request);
 824
 825   if (!IsSuspended()) {
 826     ScheduleIdleRequestDispatch();
 827   }
 828
 829   return handle;
 830 }
 831
 832 void nsGlobalWindowInner::CancelIdleCallback(uint32_t aHandle) {
 833   for (IdleRequest* r : mIdleRequestCallbacks) {
 834     if (r->Handle() == aHandle) {
 835       RemoveIdleCallback(r);
 836       break;
 837     }
 838   }
 839 }
 840
 841 void nsGlobalWindowInner::DisableIdleCallbackRequests() {
 842   if (mIdleRequestExecutor) {
 843     mIdleRequestExecutor->Cancel();
 844     mIdleRequestExecutor = nullptr;
 845   }
 846
 847   while (!mIdleRequestCallbacks.isEmpty()) {
 848     RefPtr<IdleRequest> request = mIdleRequestCallbacks.getFirst();
 849     RemoveIdleCallback(request);
 850   }
 851 }
 852
 853 bool nsGlobalWindowInner::IsBackgroundInternal() const {
 854   return !mOuterWindow || mOuterWindow->IsBackground();
 855 }
 856
 857 class PromiseDocumentFlushedResolver final {
 858  public:
 859   PromiseDocumentFlushedResolver(Promise* aPromise,
 860                                  PromiseDocumentFlushedCallback& aCallback)
 861       : mPromise(aPromise), mCallback(&aCallback) {}
 862
 863   virtual ~PromiseDocumentFlushedResolver() = default;
 864
 865   void Call() {
 866     nsMutationGuard guard;
 867     ErrorResult error;
 868     JS::Rooted<JS::Value> returnVal(RootingCx());
 869     mCallback->Call(&returnVal, error);
 870
 871     if (error.Failed()) {
 872       mPromise->MaybeReject(std::move(error));
 873     } else if (guard.Mutated(0)) {
 874       // Something within the callback mutated the DOM.
 875       mPromise->MaybeRejectWithNoModificationAllowedError(
 876           "DOM mutated from promiseDocumentFlushed callbacks");
 877     } else {
 878       mPromise->MaybeResolve(returnVal);
 879     }
 880   }
 881
 882   RefPtr<Promise> mPromise;
 883   RefPtr<PromiseDocumentFlushedCallback> mCallback;
 884 };
 885
 886 //*****************************************************************************
 887 //***    nsGlobalWindowInner: Object Management
 888 //*****************************************************************************
 889
 890 nsGlobalWindowInner::nsGlobalWindowInner(nsGlobalWindowOuter* aOuterWindow,
 891                                          WindowGlobalChild* aActor)
 892     : nsPIDOMWindowInner(aOuterWindow, aActor),
 893       mHasOrientationChangeListeners(false),
 894       mWasOffline(false),
 895       mHasHadSlowScript(false),
 896       mIsChrome(false),
 897       mCleanMessageManager(false),
 898       mNeedsFocus(true),
 899       mHasFocus(false),
 900       mFocusByKeyOccurred(false),
 901       mDidFireDocElemInserted(false),
 902       mHasGamepad(false),
 903       mHasXRSession(false),
 904       mHasVRDisplayActivateEvents(false),
 905       mXRRuntimeDetectionInFlight(false),
 906       mXRPermissionRequestInFlight(false),
 907       mXRPermissionGranted(false),
 908       mWasCurrentInnerWindow(false),
 909       mHasSeenGamepadInput(false),
 910       mHintedWasLoading(false),
 911       mHasOpenedExternalProtocolFrame(false),
 912       mScrollMarksOnHScrollbar(false),
 913       mStorageAllowedReasonCache(0),
 914       mSuspendDepth(0),
 915       mFreezeDepth(0),
 916 #ifdef DEBUG
 917       mSerial(0),
 918 #endif
 919       mFocusMethod(0),
 920       mIdleRequestCallbackCounter(1),
 921       mIdleRequestExecutor(nullptr),
 922       mObservingRefresh(false),
 923       mIteratingDocumentFlushedResolvers(false),
 924       mCanSkipCCGeneration(0) {
 925   mIsInnerWindow = true;
 926
 927   AssertIsOnMainThread();
 928   SetIsOnMainThread();
 929   nsLayoutStatics::AddRef();
 930
 931   // Initialize the PRCList (this).
 932   PR_INIT_CLIST(this);
 933
 934   // add this inner window to the outer window list of inners.
 935   PR_INSERT_AFTER(this, aOuterWindow);
 936
 937   mTimeoutManager = MakeUnique<dom::TimeoutManager>(
 938       *this, StaticPrefs::dom_timeout_max_idle_defer_ms());
 939
 940   mObserver = new nsGlobalWindowObserver(this);
 941   if (nsCOMPtr<nsIObserverService> os = services::GetObserverService()) {
 942     // Watch for online/offline status changes so we can fire events. Use
 943     // a strong reference.
 944     os->AddObserver(mObserver, NS_IOSERVICE_OFFLINE_STATUS_TOPIC, false);
 945     os->AddObserver(mObserver, MEMORY_PRESSURE_OBSERVER_TOPIC, false);
 946     os->AddObserver(mObserver, PERMISSION_CHANGED_TOPIC, false);
 947     os->AddObserver(mObserver, "screen-information-changed", false);
 948   }
 949
 950   Preferences::AddStrongObserver(mObserver, "intl.accept_languages");
 951
 952   // Watch for storage notifications so we can fire storage events.
 953   RefPtr<StorageNotifierService> sns = StorageNotifierService::GetOrCreate();
 954   if (sns) {
 955     sns->Register(mObserver);
 956   }
 957
 958   if (XRE_IsContentProcess()) {
 959     nsCOMPtr<nsIDocShell> docShell = GetDocShell();
 960     if (docShell) {
 961       mBrowserChild = docShell->GetBrowserChild();
 962     }
 963   }
 964
 965   if (gDumpFile == nullptr) {
 966     nsAutoCString fname;
 967     Preferences::GetCString("browser.dom.window.dump.file", fname);
 968     if (!fname.IsEmpty()) {
 969       // If this fails to open, Dump() knows to just go to stdout on null.
 970       gDumpFile = fopen(fname.get(), "wb+");
 971     } else {
 972       gDumpFile = stdout;
 973     }
 974   }
 975
 976 #ifdef DEBUG
 977   mSerial = nsContentUtils::InnerOrOuterWindowCreated();
 978
 979   MOZ_LOG(gDocShellAndDOMWindowLeakLogging, LogLevel::Info,
 980           ("++DOMWINDOW == %d (%p) [pid = %d] [serial = %d] [outer = %p]\n",
 981            nsContentUtils::GetCurrentInnerOrOuterWindowCount(),
 982            static_cast<void*>(ToCanonicalSupports(this)), getpid(), mSerial,
 983            static_cast<void*>(ToCanonicalSupports(aOuterWindow))));
 984 #endif
 985
 986   MOZ_LOG(gDOMLeakPRLogInner, LogLevel::Debug,
 987           ("DOMWINDOW %p created outer=%p", this, aOuterWindow));
 988
 989   // Add ourselves to the inner windows list.
 990   MOZ_ASSERT(sInnerWindowsById, "Inner Windows hash table must be created!");
 991   MOZ_ASSERT(!sInnerWindowsById->Contains(mWindowID),
 992              "This window shouldn't be in the hash table yet!");
 993   // We seem to see crashes in release builds because of null
 994   // |sInnerWindowsById|.
 995   if (sInnerWindowsById) {
 996     sInnerWindowsById->InsertOrUpdate(mWindowID, this);
 997   }
 998 }
 999
1000 #ifdef DEBUG
1001
1002 /* static */
1003 void nsGlobalWindowInner::AssertIsOnMainThread() {
1004   MOZ_ASSERT(NS_IsMainThread());
1005 }
1006
1007 #endif  // DEBUG
1008
1009 /* static */
1010 void nsGlobalWindowInner::Init() {
1011   AssertIsOnMainThread();
1012
1013   NS_ASSERTION(gDOMLeakPRLogInner,
1014                "gDOMLeakPRLogInner should have been initialized!");
1015
1016   sInnerWindowsById = new InnerWindowByIdTable();
1017 }
1018
1019 nsGlobalWindowInner::~nsGlobalWindowInner() {
1020   AssertIsOnMainThread();
1021   MOZ_ASSERT(!mHintedWasLoading);
1022
1023   if (IsChromeWindow()) {
1024     MOZ_ASSERT(mCleanMessageManager,
1025                "chrome windows may always disconnect the msg manager");
1026
1027     DisconnectAndClearGroupMessageManagers();
1028
1029     if (mChromeFields.mMessageManager) {
1030       static_cast<nsFrameMessageManager*>(mChromeFields.mMessageManager.get())
1031           ->Disconnect();
1032     }
1033
1034     mCleanMessageManager = false;
1035   }
1036
1037   // In most cases this should already have been called, but call it again
1038   // here to catch any corner cases.
1039   FreeInnerObjects();
1040
1041   if (sInnerWindowsById) {
1042     sInnerWindowsById->Remove(mWindowID);
1043   }
1044
1045   nsContentUtils::InnerOrOuterWindowDestroyed();
1046
1047 #ifdef DEBUG
1048   if (MOZ_LOG_TEST(gDocShellAndDOMWindowLeakLogging, LogLevel::Info)) {
1049     nsAutoCString url;
1050     if (mLastOpenedURI) {
1051       url = mLastOpenedURI->GetSpecOrDefault();
1052
1053       // Data URLs can be very long, so truncate to avoid flooding the log.
1054       const uint32_t maxURLLength = 1000;
1055       if (url.Length() > maxURLLength) {
1056         url.Truncate(maxURLLength);
1057       }
1058     }
1059
1060     nsGlobalWindowOuter* outer = nsGlobalWindowOuter::Cast(mOuterWindow);
1061     MOZ_LOG(
1062         gDocShellAndDOMWindowLeakLogging, LogLevel::Info,
1063         ("--DOMWINDOW == %d (%p) [pid = %d] [serial = %d] [outer = %p] [url = "
1064          "%s]\n",
1065          nsContentUtils::GetCurrentInnerOrOuterWindowCount(),
1066          static_cast<void*>(ToCanonicalSupports(this)), getpid(), mSerial,
1067          static_cast<void*>(ToCanonicalSupports(outer)), url.get()));
1068   }
1069 #endif
1070   MOZ_LOG(gDOMLeakPRLogInner, LogLevel::Debug,
1071           ("DOMWINDOW %p destroyed", this));
1072
1073   Telemetry::Accumulate(Telemetry::INNERWINDOWS_WITH_MUTATION_LISTENERS,
1074                         mMutationBits ? 1 : 0);
1075
1076   // An inner window is destroyed, pull it out of the outer window's
1077   // list if inner windows.
1078
1079   PR_REMOVE_LINK(this);
1080
1081   // If our outer window's inner window is this window, null out the
1082   // outer window's reference to this window that's being deleted.
1083   nsGlobalWindowOuter* outer = GetOuterWindowInternal();
1084   if (outer) {
1085     outer->MaybeClearInnerWindow(this);
1086   }
1087
1088   // We don't have to leave the tab group if we are an inner window.
1089
1090   nsCOMPtr<nsIDeviceSensors> ac = do_GetService(NS_DEVICE_SENSORS_CONTRACTID);
1091   if (ac) ac->RemoveWindowAsListener(this);
1092
1093   nsLayoutStatics::Release();
1094 }
1095
1096 // static
1097 void nsGlobalWindowInner::ShutDown() {
1098   AssertIsOnMainThread();
1099
1100   if (gDumpFile && gDumpFile != stdout) {
1101     fclose(gDumpFile);
1102   }
1103   gDumpFile = nullptr;
1104
1105   delete sInnerWindowsById;
1106   sInnerWindowsById = nullptr;
1107 }
1108
1109 void nsGlobalWindowInner::FreeInnerObjects() {
1110   if (IsDying()) {
1111     return;
1112   }
1113   StartDying();
1114
1115   if (mDoc && mDoc->GetWindowContext()) {
1116     // The document is about to lose its window, so this is a good time to send
1117     // our page use counters.
1118     //
1119     // (We also do this in Document::SetScriptGlobalObject(nullptr), which
1120     // catches most cases of documents losing their window, but not all.)
1121     mDoc->SendPageUseCounters();
1122   }
1123
1124   // Make sure that this is called before we null out the document and
1125   // other members that the window destroyed observers could
1126   // re-create.
1127   NotifyDOMWindowDestroyed(this);
1128   if (auto* reporter = nsWindowMemoryReporter::Get()) {
1129     reporter->ObserveDOMWindowDetached(this);
1130   }
1131
1132   // Kill all of the workers for this window.
1133   CancelWorkersForWindow(*this);
1134
1135   for (RefPtr<mozilla::dom::SharedWorker> pinnedWorker :
1136        mSharedWorkers.ForwardRange()) {
1137     pinnedWorker->Close();
1138   }
1139
1140   if (mTimeoutManager) {
1141     mTimeoutManager->ClearAllTimeouts();
1142   }
1143
1144   DisableIdleCallbackRequests();
1145
1146   mChromeEventHandler = nullptr;
1147
1148   if (mListenerManager) {
1149     mListenerManager->RemoveAllListeners();
1150     mListenerManager->Disconnect();
1151     mListenerManager = nullptr;
1152   }
1153
1154   mHistory = nullptr;
1155
1156   if (mNavigator) {
1157     mNavigator->OnNavigation();
1158     mNavigator->Invalidate();
1159     mNavigator = nullptr;
1160   }
1161
1162   mScreen = nullptr;
1163
1164   if (mDoc) {
1165     // Remember the document's principal, URI, and CSP.
1166     mDocumentPrincipal = mDoc->NodePrincipal();
1167     mDocumentCookiePrincipal = mDoc->EffectiveCookiePrincipal();
1168     mDocumentStoragePrincipal = mDoc->EffectiveStoragePrincipal();
1169     mDocumentPartitionedPrincipal = mDoc->PartitionedPrincipal();
1170     mDocumentURI = mDoc->GetDocumentURI();
1171     mDocBaseURI = mDoc->GetDocBaseURI();
1172     mDocumentCsp = mDoc->GetCsp();
1173
1174     while (mDoc->EventHandlingSuppressed()) {
1175       mDoc->UnsuppressEventHandlingAndFireEvents(false);
1176     }
1177   }
1178
1179   // Remove our reference to the document and the document principal.
1180   mFocusedElement = nullptr;
1181
1182   if (mIndexedDB) {
1183     mIndexedDB->DisconnectFromGlobal(this);
1184     mIndexedDB = nullptr;
1185   }
1186
1187   nsIGlobalObject::UnlinkObjectsInGlobal();
1188
1189   NotifyWindowIDDestroyed("inner-window-destroyed");
1190
1191   for (uint32_t i = 0; i < mAudioContexts.Length(); ++i) {
1192     mAudioContexts[i]->OnWindowDestroy();
1193   }
1194   mAudioContexts.Clear();
1195
1196   for (MediaKeys* mediaKeys : mMediaKeysInstances) {
1197     mediaKeys->OnInnerWindowDestroy();
1198   }
1199   mMediaKeysInstances.Clear();
1200
1201   DisableGamepadUpdates();
1202   mHasGamepad = false;
1203   mGamepads.Clear();
1204   DisableVRUpdates();
1205   mHasXRSession = false;
1206   mHasVRDisplayActivateEvents = false;
1207   mXRRuntimeDetectionInFlight = false;
1208   mXRPermissionRequestInFlight = false;
1209   mXRPermissionGranted = false;
1210   mVRDisplays.Clear();
1211
1212   // This breaks a cycle between the window and the ClientSource object.
1213   mClientSource.reset();
1214
1215   if (mWindowGlobalChild) {
1216     // Remove any remaining listeners.
1217     int64_t nListeners = mWindowGlobalChild->BeforeUnloadListeners();
1218     for (int64_t i = 0; i < nListeners; ++i) {
1219       mWindowGlobalChild->BeforeUnloadRemoved();
1220     }
1221     MOZ_ASSERT(mWindowGlobalChild->BeforeUnloadListeners() == 0);
1222   }
1223
1224   // If we have any promiseDocumentFlushed callbacks, fire them now so
1225   // that the Promises can resolve.
1226   CallDocumentFlushedResolvers(/* aUntilExhaustion = */ true);
1227
1228   DisconnectEventTargetObjects();
1229
1230 #ifdef MOZ_WIDGET_ANDROID
1231   DisableOrientationChangeListener();
1232 #endif
1233
1234   if (mObserver) {
1235     if (nsCOMPtr<nsIObserverService> os = services::GetObserverService()) {
1236       os->RemoveObserver(mObserver, NS_IOSERVICE_OFFLINE_STATUS_TOPIC);
1237       os->RemoveObserver(mObserver, MEMORY_PRESSURE_OBSERVER_TOPIC);
1238       os->RemoveObserver(mObserver, PERMISSION_CHANGED_TOPIC);
1239       os->RemoveObserver(mObserver, "screen-information-changed");
1240     }
1241
1242     RefPtr<StorageNotifierService> sns = StorageNotifierService::GetOrCreate();
1243     if (sns) {
1244       sns->Unregister(mObserver);
1245     }
1246
1247     Preferences::RemoveObserver(mObserver, "intl.accept_languages");
1248
1249     // Drop its reference to this dying window, in case for some bogus reason
1250     // the object stays around.
1251     mObserver->Forget();
1252   }
1253
1254   mMenubar = nullptr;
1255   mToolbar = nullptr;
1256   mLocationbar = nullptr;
1257   mPersonalbar = nullptr;
1258   mStatusbar = nullptr;
1259   mScrollbars = nullptr;
1260
1261   mConsole = nullptr;
1262
1263   mPaintWorklet = nullptr;
1264
1265   mExternal = nullptr;
1266   mInstallTrigger = nullptr;
1267
1268   if (mLocalStorage) {
1269     mLocalStorage->Disconnect();
1270     mLocalStorage = nullptr;
1271   }
1272   mSessionStorage = nullptr;
1273   mPerformance = nullptr;
1274
1275   mContentMediaController = nullptr;
1276
1277   if (mWebTaskScheduler) {
1278     mWebTaskScheduler->Disconnect();
1279     mWebTaskScheduler = nullptr;
1280   }
1281
1282   mSharedWorkers.Clear();
1283
1284 #ifdef MOZ_WEBSPEECH
1285   mSpeechSynthesis = nullptr;
1286 #endif
1287
1288   mGlean = nullptr;
1289   mGleanPings = nullptr;
1290
1291   mParentTarget = nullptr;
1292
1293   if (mCleanMessageManager) {
1294     MOZ_ASSERT(mIsChrome, "only chrome should have msg manager cleaned");
1295     if (mChromeFields.mMessageManager) {
1296       mChromeFields.mMessageManager->Disconnect();
1297     }
1298   }
1299
1300   if (mWindowGlobalChild && !mWindowGlobalChild->IsClosed()) {
1301     mWindowGlobalChild->Destroy();
1302   }
1303
1304   mIntlUtils = nullptr;
1305
1306   HintIsLoading(false);
1307 }
1308
1309 //*****************************************************************************
1310 // nsGlobalWindowInner::nsISupports
1311 //*****************************************************************************
1312
1313 // QueryInterface implementation for nsGlobalWindowInner
1314 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsGlobalWindowInner)
1315   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
1316   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, EventTarget)
1317   NS_INTERFACE_MAP_ENTRY(nsIDOMWindow)
1318   NS_INTERFACE_MAP_ENTRY(nsIGlobalObject)
1319   NS_INTERFACE_MAP_ENTRY(nsIScriptGlobalObject)
1320   NS_INTERFACE_MAP_ENTRY(nsIScriptObjectPrincipal)
1321   NS_INTERFACE_MAP_ENTRY(mozilla::dom::EventTarget)
1322   NS_INTERFACE_MAP_ENTRY(nsPIDOMWindowInner)
1323   NS_INTERFACE_MAP_ENTRY(mozIDOMWindow)
1324   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
1325   NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
1326 NS_INTERFACE_MAP_END
1327
1328 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsGlobalWindowInner)
1329 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsGlobalWindowInner)
1330
1331 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsGlobalWindowInner)
1332   if (tmp->IsBlackForCC(false)) {
1333     if (nsCCUncollectableMarker::InGeneration(tmp->mCanSkipCCGeneration)) {
1334       return true;
1335     }
1336     tmp->mCanSkipCCGeneration = nsCCUncollectableMarker::sGeneration;
1337     if (EventListenerManager* elm = tmp->GetExistingListenerManager()) {
1338       elm->MarkForCC();
1339     }
1340     if (tmp->mTimeoutManager) {
1341       tmp->mTimeoutManager->UnmarkGrayTimers();
1342     }
1343     return true;
1344   }
1345 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END
1346
1347 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(nsGlobalWindowInner)
1348   return tmp->IsBlackForCC(true);
1349 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END
1350
1351 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(nsGlobalWindowInner)
1352   return tmp->IsBlackForCC(false);
1353 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
1354
1355 NS_IMPL_CYCLE_COLLECTION_CLASS(nsGlobalWindowInner)
1356
1357 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INTERNAL(nsGlobalWindowInner)
1358   if (MOZ_UNLIKELY(cb.WantDebugInfo())) {
1359     char name[512];
1360     nsAutoCString uri;
1361     if (tmp->mDoc && tmp->mDoc->GetDocumentURI()) {
1362       uri = tmp->mDoc->GetDocumentURI()->GetSpecOrDefault();
1363     }
1364     SprintfLiteral(name, "nsGlobalWindowInner # %" PRIu64 " inner %s",
1365                    tmp->mWindowID, uri.get());
1366     cb.DescribeRefCountedNode(tmp->mRefCnt.get(), name);
1367   } else {
1368     NS_IMPL_CYCLE_COLLECTION_DESCRIBE(nsGlobalWindowInner, tmp->mRefCnt.get())
1369   }
1370
1371   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mNavigator)
1372
1373   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPerformance)
1374
1375   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWebTaskScheduler)
1376
1377 #ifdef MOZ_WEBSPEECH
1378   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSpeechSynthesis)
1379 #endif
1380
1381   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mGlean)
1382   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mGleanPings)
1383
1384   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOuterWindow)
1385
1386   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTopInnerWindow)
1387
1388   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mListenerManager)
1389
1390   if (tmp->mTimeoutManager) {
1391     tmp->mTimeoutManager->ForEachUnorderedTimeout([&cb](Timeout* timeout) {
1392       cb.NoteNativeChild(timeout, NS_CYCLE_COLLECTION_PARTICIPANT(Timeout));
1393     });
1394   }
1395
1396   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLocation)
1397   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mHistory)
1398   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCustomElements)
1399   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSharedWorkers)
1400   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLocalStorage)
1401   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSessionStorage)
1402   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIndexedDB)
1403   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocumentPrincipal)
1404   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocumentCookiePrincipal)
1405   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocumentStoragePrincipal)
1406   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocumentPartitionedPrincipal)
1407   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocumentCsp)
1408   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBrowserChild)
1409   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDoc)
1410
1411   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIdleRequestExecutor)
1412   for (IdleRequest* request : tmp->mIdleRequestCallbacks) {
1413     cb.NoteNativeChild(request, NS_CYCLE_COLLECTION_PARTICIPANT(IdleRequest));
1414   }
1415
1416   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mClientSource)
1417
1418   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mGamepads)
1419
1420   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCacheStorage)
1421   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mVRDisplays)
1422
1423   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDebuggerNotificationManager)
1424
1425   // Traverse stuff from nsPIDOMWindow
1426   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChromeEventHandler)
1427   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParentTarget)
1428   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFocusedElement)
1429   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBrowsingContext)
1430   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindowGlobalChild)
1431
1432   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMenubar)
1433   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mToolbar)
1434   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLocationbar)
1435   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPersonalbar)
1436   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStatusbar)
1437   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mScrollbars)
1438   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCrypto)
1439   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mConsole)
1440   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPaintWorklet)
1441   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mExternal)
1442   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mInstallTrigger)
1443   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIntlUtils)
1444   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mVisualViewport)
1445
1446   tmp->TraverseObjectsInGlobal(cb);
1447
1448   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChromeFields.mMessageManager)
1449   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChromeFields.mGroupMessageManagers)
1450
1451   for (size_t i = 0; i < tmp->mDocumentFlushedResolvers.Length(); i++) {
1452     NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocumentFlushedResolvers[i]->mPromise);
1453     NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocumentFlushedResolvers[i]->mCallback);
1454   }
1455
1456 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
1457
1458 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsGlobalWindowInner)
1459   NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_REFERENCE
1460   if (sInnerWindowsById) {
1461     sInnerWindowsById->Remove(tmp->mWindowID);
1462   }
1463
1464   JSObject* wrapper = tmp->GetWrapperPreserveColor();
1465   if (wrapper) {
1466     // Mark our realm as dead, so the JS engine won't hand out our
1467     // global after this point.
1468     JS::SetRealmNonLive(js::GetNonCCWObjectRealm(wrapper));
1469   }
1470
1471   NS_IMPL_CYCLE_COLLECTION_UNLINK(mNavigator)
1472
1473   NS_IMPL_CYCLE_COLLECTION_UNLINK(mPerformance)
1474
1475   if (tmp->mWebTaskScheduler) {
1476     tmp->mWebTaskScheduler->Disconnect();
1477     NS_IMPL_CYCLE_COLLECTION_UNLINK(mWebTaskScheduler)
1478   }
1479
1480 #ifdef MOZ_WEBSPEECH
1481   NS_IMPL_CYCLE_COLLECTION_UNLINK(mSpeechSynthesis)
1482 #endif
1483
1484   NS_IMPL_CYCLE_COLLECTION_UNLINK(mGlean)
1485   NS_IMPL_CYCLE_COLLECTION_UNLINK(mGleanPings)
1486
1487   if (tmp->mOuterWindow) {
1488     nsGlobalWindowOuter::Cast(tmp->mOuterWindow)->MaybeClearInnerWindow(tmp);
1489     NS_IMPL_CYCLE_COLLECTION_UNLINK(mOuterWindow)
1490   }
1491
1492   if (tmp->mListenerManager) {
1493     tmp->mListenerManager->Disconnect();
1494     NS_IMPL_CYCLE_COLLECTION_UNLINK(mListenerManager)
1495   }
1496
1497   // Here the Timeouts list would've been unlinked, but we rely on
1498   // that Timeout objects have been traced and will remove themselves
1499   // while unlinking.
1500
1501   tmp->UpdateTopInnerWindow();
1502   NS_IMPL_CYCLE_COLLECTION_UNLINK(mTopInnerWindow)
1503
1504   NS_IMPL_CYCLE_COLLECTION_UNLINK(mLocation)
1505   NS_IMPL_CYCLE_COLLECTION_UNLINK(mHistory)
1506   NS_IMPL_CYCLE_COLLECTION_UNLINK(mCustomElements)
1507   NS_IMPL_CYCLE_COLLECTION_UNLINK(mSharedWorkers)
1508   if (tmp->mLocalStorage) {
1509     tmp->mLocalStorage->Disconnect();
1510     NS_IMPL_CYCLE_COLLECTION_UNLINK(mLocalStorage)
1511   }
1512   NS_IMPL_CYCLE_COLLECTION_UNLINK(mSessionStorage)
1513   if (tmp->mIndexedDB) {
1514     tmp->mIndexedDB->DisconnectFromGlobal(tmp);
1515     NS_IMPL_CYCLE_COLLECTION_UNLINK(mIndexedDB)
1516   }
1517   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocumentPrincipal)
1518   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocumentCookiePrincipal)
1519   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocumentStoragePrincipal)
1520   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocumentPartitionedPrincipal)
1521   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocumentCsp)
1522   NS_IMPL_CYCLE_COLLECTION_UNLINK(mBrowserChild)
1523   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDoc)
1524
1525   NS_IMPL_CYCLE_COLLECTION_UNLINK(mGamepads)
1526
1527   NS_IMPL_CYCLE_COLLECTION_UNLINK(mCacheStorage)
1528   NS_IMPL_CYCLE_COLLECTION_UNLINK(mVRDisplays)
1529
1530   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDebuggerNotificationManager)
1531
1532   // Unlink stuff from nsPIDOMWindow
1533   NS_IMPL_CYCLE_COLLECTION_UNLINK(mChromeEventHandler)
1534   NS_IMPL_CYCLE_COLLECTION_UNLINK(mParentTarget)
1535   NS_IMPL_CYCLE_COLLECTION_UNLINK(mFocusedElement)
1536   NS_IMPL_CYCLE_COLLECTION_UNLINK(mBrowsingContext)
1537
1538   MOZ_DIAGNOSTIC_ASSERT(
1539       !tmp->mWindowGlobalChild || tmp->mWindowGlobalChild->IsClosed(),
1540       "How are we unlinking a window before its actor has been destroyed?");
1541   NS_IMPL_CYCLE_COLLECTION_UNLINK(mWindowGlobalChild)
1542
1543   NS_IMPL_CYCLE_COLLECTION_UNLINK(mMenubar)
1544   NS_IMPL_CYCLE_COLLECTION_UNLINK(mToolbar)
1545   NS_IMPL_CYCLE_COLLECTION_UNLINK(mLocationbar)
1546   NS_IMPL_CYCLE_COLLECTION_UNLINK(mPersonalbar)
1547   NS_IMPL_CYCLE_COLLECTION_UNLINK(mStatusbar)
1548   NS_IMPL_CYCLE_COLLECTION_UNLINK(mScrollbars)
1549   NS_IMPL_CYCLE_COLLECTION_UNLINK(mCrypto)
1550   NS_IMPL_CYCLE_COLLECTION_UNLINK(mConsole)
1551   NS_IMPL_CYCLE_COLLECTION_UNLINK(mPaintWorklet)
1552   NS_IMPL_CYCLE_COLLECTION_UNLINK(mExternal)
1553   NS_IMPL_CYCLE_COLLECTION_UNLINK(mInstallTrigger)
1554   NS_IMPL_CYCLE_COLLECTION_UNLINK(mIntlUtils)
1555   NS_IMPL_CYCLE_COLLECTION_UNLINK(mVisualViewport)
1556
1557   tmp->UnlinkObjectsInGlobal();
1558
1559   NS_IMPL_CYCLE_COLLECTION_UNLINK(mIdleRequestExecutor)
1560
1561   // Here the IdleRequest list would've been unlinked, but we rely on
1562   // that IdleRequest objects have been traced and will remove
1563   // themselves while unlinking.
1564
1565   NS_IMPL_CYCLE_COLLECTION_UNLINK(mClientSource)
1566
1567   if (tmp->IsChromeWindow()) {
1568     if (tmp->mChromeFields.mMessageManager) {
1569       static_cast<nsFrameMessageManager*>(
1570           tmp->mChromeFields.mMessageManager.get())
1571           ->Disconnect();
1572       NS_IMPL_CYCLE_COLLECTION_UNLINK(mChromeFields.mMessageManager)
1573     }
1574     tmp->DisconnectAndClearGroupMessageManagers();
1575     NS_IMPL_CYCLE_COLLECTION_UNLINK(mChromeFields.mGroupMessageManagers)
1576   }
1577
1578   for (size_t i = 0; i < tmp->mDocumentFlushedResolvers.Length(); i++) {
1579     NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocumentFlushedResolvers[i]->mPromise);
1580     NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocumentFlushedResolvers[i]->mCallback);
1581   }
1582   tmp->mDocumentFlushedResolvers.Clear();
1583
1584   NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
1585 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
1586
1587 #ifdef DEBUG
1588 void nsGlobalWindowInner::RiskyUnlink() {
1589   NS_CYCLE_COLLECTION_INNERNAME.Unlink(this);
1590 }
1591 #endif
1592
1593 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(nsGlobalWindowInner)
1594   NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
1595 NS_IMPL_CYCLE_COLLECTION_TRACE_END
1596
1597 bool nsGlobalWindowInner::IsBlackForCC(bool aTracingNeeded) {
1598   if (!nsCCUncollectableMarker::sGeneration) {
1599     return false;
1600   }
1601
1602   return (nsCCUncollectableMarker::InGeneration(GetMarkedCCGeneration()) ||
1603           HasKnownLiveWrapper()) &&
1604          (!aTracingNeeded || HasNothingToTrace(ToSupports(this)));
1605 }
1606
1607 //*****************************************************************************
1608 // nsGlobalWindowInner::nsIScriptGlobalObject
1609 //*****************************************************************************
1610
1611 bool nsGlobalWindowInner::ShouldResistFingerprinting(RFPTarget aTarget) const {
1612   if (mDoc) {
1613     return mDoc->ShouldResistFingerprinting(aTarget);
1614   }
1615   return nsContentUtils::ShouldResistFingerprinting(
1616       "If we do not have a document then we do not have any context"
1617       "to make an informed RFP choice, so we fall back to the global pref",
1618       aTarget);
1619 }
1620
1621 OriginTrials nsGlobalWindowInner::Trials() const {
1622   return OriginTrials::FromWindow(this);
1623 }
1624
1625 FontFaceSet* nsGlobalWindowInner::GetFonts() {
1626   if (mDoc) {
1627     return mDoc->Fonts();
1628   }
1629   return nullptr;
1630 }
1631
1632 mozilla::Result<mozilla::ipc::PrincipalInfo, nsresult>
1633 nsGlobalWindowInner::GetStorageKey() {
1634   MOZ_ASSERT(NS_IsMainThread());
1635
1636   nsIPrincipal* principal = GetEffectiveStoragePrincipal();
1637   if (!principal) {
1638     return mozilla::Err(NS_ERROR_FAILURE);
1639   }
1640
1641   mozilla::ipc::PrincipalInfo principalInfo;
1642   nsresult rv = PrincipalToPrincipalInfo(principal, &principalInfo);
1643   if (NS_FAILED(rv)) {
1644     return mozilla::Err(rv);
1645   }
1646
1647   // Block expanded and null principals, let content and system through.
1648   if (principalInfo.type() !=
1649           mozilla::ipc::PrincipalInfo::TContentPrincipalInfo &&
1650       principalInfo.type() !=
1651           mozilla::ipc::PrincipalInfo::TSystemPrincipalInfo) {
1652     return Err(NS_ERROR_DOM_SECURITY_ERR);
1653   }
1654
1655   return std::move(principalInfo);
1656 }
1657
1658 mozilla::dom::StorageManager* nsGlobalWindowInner::GetStorageManager() {
1659   return Navigator()->Storage();
1660 }
1661
1662 // https://html.spec.whatwg.org/multipage/web-messaging.html#eligible-for-messaging
1663 // * a Window object whose associated Document is fully active
1664 bool nsGlobalWindowInner::IsEligibleForMessaging() { return IsFullyActive(); }
1665
1666 nsresult nsGlobalWindowInner::EnsureScriptEnvironment() {
1667   // NOTE: We can't use FORWARD_TO_OUTER here because we don't want to fail if
1668   // we're called on an inactive inner window.
1669   nsGlobalWindowOuter* outer = GetOuterWindowInternal();
1670   if (!outer) {
1671     NS_WARNING("No outer window available!");
1672     return NS_ERROR_FAILURE;
1673   }
1674   return outer->EnsureScriptEnvironment();
1675 }
1676
1677 nsIScriptContext* nsGlobalWindowInner::GetScriptContext() {
1678   nsGlobalWindowOuter* outer = GetOuterWindowInternal();
1679   if (!outer) {
1680     return nullptr;
1681   }
1682   return outer->GetScriptContext();
1683 }
1684
1685 void nsGlobalWindowInner::TraceGlobalJSObject(JSTracer* aTrc) {
1686   TraceWrapper(aTrc, "active window global");
1687 }
1688
1689 void nsGlobalWindowInner::UpdateAutoplayPermission() {
1690   if (!GetWindowContext()) {
1691     return;
1692   }
1693   uint32_t perm =
1694       media::AutoplayPolicy::GetSiteAutoplayPermission(GetPrincipal());
1695   if (GetWindowContext()->GetAutoplayPermission() == perm) {
1696     return;
1697   }
1698
1699   // Setting autoplay permission on a discarded context has no effect.
1700   Unused << GetWindowContext()->SetAutoplayPermission(perm);
1701 }
1702
1703 void nsGlobalWindowInner::UpdateShortcutsPermission() {
1704   if (!GetWindowContext() ||
1705       !GetWindowContext()->GetBrowsingContext()->IsTop()) {
1706     // We only cache the shortcuts permission on top-level WindowContexts
1707     // since we always check the top-level principal for the permission.
1708     return;
1709   }
1710
1711   uint32_t perm = GetShortcutsPermission(GetPrincipal());
1712
1713   if (GetWindowContext()->GetShortcutsPermission() == perm) {
1714     return;
1715   }
1716
1717   // If the WindowContext is discarded this has no effect.
1718   Unused << GetWindowContext()->SetShortcutsPermission(perm);
1719 }
1720
1721 /* static */
1722 uint32_t nsGlobalWindowInner::GetShortcutsPermission(nsIPrincipal* aPrincipal) {
1723   uint32_t perm = nsIPermissionManager::DENY_ACTION;
1724   nsCOMPtr<nsIPermissionManager> permMgr =
1725       mozilla::components::PermissionManager::Service();
1726   if (aPrincipal && permMgr) {
1727     permMgr->TestExactPermissionFromPrincipal(aPrincipal, "shortcuts"_ns,
1728                                               &perm);
1729   }
1730   return perm;
1731 }
1732
1733 void nsGlobalWindowInner::UpdatePopupPermission() {
1734   if (!GetWindowContext()) {
1735     return;
1736   }
1737
1738   uint32_t perm = PopupBlocker::GetPopupPermission(GetPrincipal());
1739   if (GetWindowContext()->GetPopupPermission() == perm) {
1740     return;
1741   }
1742
1743   // If the WindowContext is discarded this has no effect.
1744   Unused << GetWindowContext()->SetPopupPermission(perm);
1745 }
1746
1747 void nsGlobalWindowInner::UpdatePermissions() {
1748   if (!GetWindowContext()) {
1749     return;
1750   }
1751
1752   nsCOMPtr<nsIPrincipal> principal = GetPrincipal();
1753   RefPtr<WindowContext> windowContext = GetWindowContext();
1754
1755   WindowContext::Transaction txn;
1756   txn.SetAutoplayPermission(
1757       media::AutoplayPolicy::GetSiteAutoplayPermission(principal));
1758   txn.SetPopupPermission(PopupBlocker::GetPopupPermission(principal));
1759
1760   if (windowContext->IsTop()) {
1761     txn.SetShortcutsPermission(GetShortcutsPermission(principal));
1762   }
1763
1764   // Setting permissions on a discarded WindowContext has no effect
1765   Unused << txn.Commit(windowContext);
1766 }
1767
1768 void nsGlobalWindowInner::InitDocumentDependentState(JSContext* aCx) {
1769   MOZ_ASSERT(mDoc);
1770
1771   if (MOZ_LOG_TEST(gDOMLeakPRLogInner, LogLevel::Debug)) {
1772     nsIURI* uri = mDoc->GetDocumentURI();
1773     MOZ_LOG(gDOMLeakPRLogInner, LogLevel::Debug,
1774             ("DOMWINDOW %p SetNewDocument %s", this,
1775              uri ? uri->GetSpecOrDefault().get() : ""));
1776   }
1777
1778   mFocusedElement = nullptr;
1779   mLocalStorage = nullptr;
1780   mSessionStorage = nullptr;
1781   mPerformance = nullptr;
1782   if (mWebTaskScheduler) {
1783     mWebTaskScheduler->Disconnect();
1784     mWebTaskScheduler = nullptr;
1785   }
1786
1787   // This must be called after nullifying the internal objects because here we
1788   // could recreate them, calling the getter methods, and store them into the JS
1789   // slots. If we nullify them after, the slot values and the objects will be
1790   // out of sync.
1791   ClearDocumentDependentSlots(aCx);
1792
1793   if (!mWindowGlobalChild) {
1794     mWindowGlobalChild = WindowGlobalChild::Create(this);
1795   }
1796   MOZ_ASSERT(!GetWindowContext()->HasBeenUserGestureActivated(),
1797              "WindowContext should always not have user gesture activation at "
1798              "this point.");
1799
1800   UpdatePermissions();
1801
1802   RefPtr<PermissionDelegateHandler> permDelegateHandler =
1803       mDoc->GetPermissionDelegateHandler();
1804
1805   if (permDelegateHandler) {
1806     permDelegateHandler->PopulateAllDelegatedPermissions();
1807   }
1808
1809 #if defined(MOZ_WIDGET_ANDROID)
1810   // When we insert the new document to the window in the top-level browsing
1811   // context, we should reset the status of the request which is used for the
1812   // previous document.
1813   if (mWindowGlobalChild && GetBrowsingContext() &&
1814       !GetBrowsingContext()->GetParent()) {
1815     // Return value of setting synced field should be checked. See bug 1656492.
1816     Unused << GetBrowsingContext()->ResetGVAutoplayRequestStatus();
1817   }
1818 #endif
1819
1820 #ifdef DEBUG
1821   mLastOpenedURI = mDoc->GetDocumentURI();
1822 #endif
1823
1824   Telemetry::Accumulate(Telemetry::INNERWINDOWS_WITH_MUTATION_LISTENERS,
1825                         mMutationBits ? 1 : 0);
1826
1827   // Clear our mutation bitfield.
1828   mMutationBits = 0;
1829 }
1830
1831 nsresult nsGlobalWindowInner::EnsureClientSource() {
1832   MOZ_DIAGNOSTIC_ASSERT(mDoc);
1833
1834   bool newClientSource = false;
1835
1836   // Get the load info for the document if we performed a load.  Be careful not
1837   // to look at local URLs, though. Local URLs are those that have a scheme of:
1838   //  * about:
1839   //  * data:
1840   //  * blob:
1841   // We also do an additional check here so that we only treat about:blank
1842   // and about:srcdoc as local URLs.  Other internal firefox about: URLs should
1843   // not be treated this way.
1844   nsCOMPtr<nsILoadInfo> loadInfo;
1845   nsCOMPtr<nsIChannel> channel = mDoc->GetChannel();
1846   if (channel) {
1847     nsCOMPtr<nsIURI> uri;
1848     Unused << channel->GetURI(getter_AddRefs(uri));
1849
1850     bool ignoreLoadInfo = false;
1851
1852     // Note, this is mostly copied from NS_IsAboutBlank().  Its duplicated
1853     // here so we can efficiently check about:srcdoc as well.
1854     if (uri->SchemeIs("about")) {
1855       nsCString spec = uri->GetSpecOrDefault();
1856       ignoreLoadInfo = spec.EqualsLiteral("about:blank") ||
1857                        spec.EqualsLiteral("about:srcdoc");
1858     } else {
1859       // Its not an about: URL, so now check for our other URL types.
1860       ignoreLoadInfo = uri->SchemeIs("data") || uri->SchemeIs("blob");
1861     }
1862
1863     if (!ignoreLoadInfo) {
1864       loadInfo = channel->LoadInfo();
1865     }
1866   }
1867
1868   // Take the initial client source from the docshell immediately.  Even if we
1869   // don't end up using it here we should consume it.
1870   UniquePtr<ClientSource> initialClientSource;
1871   nsIDocShell* docshell = GetDocShell();
1872   if (docshell) {
1873     initialClientSource = docshell->TakeInitialClientSource();
1874   }
1875
1876   // Try to get the reserved client from the LoadInfo.  A Client is
1877   // reserved at the start of the channel load if there is not an
1878   // initial about:blank document that will be reused.  It is also
1879   // created if the channel load encounters a cross-origin redirect.
1880   if (loadInfo) {
1881     UniquePtr<ClientSource> reservedClient =
1882         loadInfo->TakeReservedClientSource();
1883     if (reservedClient) {
1884       mClientSource.reset();
1885       mClientSource = std::move(reservedClient);
1886       newClientSource = true;
1887     }
1888   }
1889
1890   // We don't have a LoadInfo reserved client, but maybe we should
1891   // be inheriting an initial one from the docshell.  This means
1892   // that the docshell started the channel load before creating the
1893   // initial about:blank document.  This is an optimization, though,
1894   // and it created an initial Client as a placeholder for the document.
1895   // In this case we want to inherit this placeholder Client here.
1896   if (!mClientSource) {
1897     mClientSource = std::move(initialClientSource);
1898     if (mClientSource) {
1899       newClientSource = true;
1900     }
1901   }
1902
1903   nsCOMPtr<nsIPrincipal> foreignPartitionedPrincipal;
1904
1905   nsresult rv = StoragePrincipalHelper::GetPrincipal(
1906       this,
1907       StaticPrefs::privacy_partition_serviceWorkers()
1908           ? StoragePrincipalHelper::eForeignPartitionedPrincipal
1909           : StoragePrincipalHelper::eRegularPrincipal,
1910       getter_AddRefs(foreignPartitionedPrincipal));
1911   NS_ENSURE_SUCCESS(rv, rv);
1912
1913   // Verify the final ClientSource principal matches the final document
1914   // principal.  The ClientChannelHelper handles things like network
1915   // redirects, but there are other ways the document principal can change.
1916   // For example, if something sets the nsIChannel.owner property, then
1917   // the final channel principal can be anything.  Unfortunately there is
1918   // no good way to detect this until after the channel completes loading.
1919   //
1920   // For now we handle this just by reseting the ClientSource.  This will
1921   // result in a new ClientSource with the correct principal being created.
1922   // To APIs like ServiceWorker and Clients API it will look like there was
1923   // an initial content page created that was then immediately replaced.
1924   // This is pretty close to what we are actually doing.
1925   if (mClientSource) {
1926     auto principalOrErr = mClientSource->Info().GetPrincipal();
1927     nsCOMPtr<nsIPrincipal> clientPrincipal =
1928         principalOrErr.isOk() ? principalOrErr.unwrap() : nullptr;
1929     if (!clientPrincipal ||
1930         !clientPrincipal->Equals(foreignPartitionedPrincipal)) {
1931       mClientSource.reset();
1932     }
1933   }
1934
1935   // If we don't have a reserved client or an initial client, then create
1936   // one now.  This can happen in certain cases where we avoid preallocating
1937   // the client in the docshell.  This mainly occurs in situations where
1938   // the principal is not clearly inherited from the parent; e.g. sandboxed
1939   // iframes, window.open(), etc.
1940   //
1941   // We also do this late ClientSource creation if the final document ended
1942   // up with a different principal.
1943   //
1944   // TODO: We may not be marking initial about:blank documents created
1945   //       this way as controlled by a service worker properly.  The
1946   //       controller should be coming from the same place as the inheritted
1947   //       principal.  We do this in docshell, but as mentioned we aren't
1948   //       smart enough to handle all cases yet.  For example, a
1949   //       window.open() with new URL should inherit the controller from
1950   //       the opener, but we probably don't handle that yet.
1951   if (!mClientSource) {
1952     mClientSource = ClientManager::CreateSource(
1953         ClientType::Window, SerialEventTarget(), foreignPartitionedPrincipal);
1954     MOZ_DIAGNOSTIC_ASSERT(mClientSource);
1955     newClientSource = true;
1956
1957     // Note, we don't apply the loadinfo controller below if we create
1958     // the ClientSource here.
1959   }
1960
1961   // The load may have started controlling the Client as well.  If
1962   // so, mark it as controlled immediately here.  The actor may
1963   // or may not have been notified by the parent side about being
1964   // controlled yet.
1965   //
1966   // Note: We should be careful not to control a client that was created late.
1967   //       These clients were not seen by the ServiceWorkerManager when it
1968   //       marked the LoadInfo controlled and it won't know about them.  Its
1969   //       also possible we are creating the client late due to the final
1970   //       principal changing and these clients should definitely not be
1971   //       controlled by a service worker with a different principal.
1972   else if (loadInfo) {
1973     const Maybe<ServiceWorkerDescriptor> controller = loadInfo->GetController();
1974     if (controller.isSome()) {
1975       mClientSource->SetController(controller.ref());
1976     }
1977
1978     // We also have to handle the case where te initial about:blank is
1979     // controlled due to inheritting the service worker from its parent,
1980     // but the actual nsIChannel load is not covered by any service worker.
1981     // In this case we want the final page to be uncontrolled.  There is
1982     // an open spec issue about how exactly this should be handled, but for
1983     // now we just force creation of a new ClientSource to clear the
1984     // controller.
1985     //
1986     //  https://github.com/w3c/ServiceWorker/issues/1232
1987     //
1988     else if (mClientSource->GetController().isSome()) {
1989       mClientSource.reset();
1990       mClientSource = ClientManager::CreateSource(
1991           ClientType::Window, SerialEventTarget(), foreignPartitionedPrincipal);
1992       MOZ_DIAGNOSTIC_ASSERT(mClientSource);
1993       newClientSource = true;
1994     }
1995   }
1996
1997   if (mClientSource) {
1998     // Generally the CSP is stored within the Client and cached on the document.
1999     // At the time of CSP parsing however, the Client has not been created yet,
2000     // hence we store the CSP on the document and propagate/sync the CSP with
2001     // Client here when we create the Client.
2002     mClientSource->SetCsp(mDoc->GetCsp());
2003
2004     DocGroup* docGroup = GetDocGroup();
2005     MOZ_DIAGNOSTIC_ASSERT(docGroup);
2006     mClientSource->SetAgentClusterId(docGroup->AgentClusterId());
2007
2008     if (mWindowGlobalChild) {
2009       mWindowGlobalChild->SendSetClientInfo(mClientSource->Info().ToIPC());
2010     }
2011   }
2012
2013   // Its possible that we got a client just after being frozen in
2014   // the bfcache.  In that case freeze the client immediately.
2015   if (newClientSource && IsFrozen()) {
2016     mClientSource->Freeze();
2017   }
2018
2019   return NS_OK;
2020 }
2021
2022 nsresult nsGlobalWindowInner::ExecutionReady() {
2023   nsresult rv = EnsureClientSource();
2024   NS_ENSURE_SUCCESS(rv, rv);
2025
2026   rv = mClientSource->WindowExecutionReady(this);
2027   NS_ENSURE_SUCCESS(rv, rv);
2028
2029   return NS_OK;
2030 }
2031
2032 void nsGlobalWindowInner::UpdateParentTarget() {
2033   // NOTE: This method is identical to
2034   // nsGlobalWindowOuter::UpdateParentTarget(). IF YOU UPDATE THIS METHOD,
2035   // UPDATE THE OTHER ONE TOO!
2036
2037   // Try to get our frame element's tab child global (its in-process message
2038   // manager).  If that fails, fall back to the chrome event handler's tab
2039   // child global, and if it doesn't have one, just use the chrome event
2040   // handler itself.
2041
2042   nsPIDOMWindowOuter* outer = GetOuterWindow();
2043   if (!outer) {
2044     return;
2045   }
2046   nsCOMPtr<Element> frameElement = outer->GetFrameElementInternal();
2047   nsCOMPtr<EventTarget> eventTarget =
2048       nsContentUtils::TryGetBrowserChildGlobal(frameElement);
2049
2050   if (!eventTarget) {
2051     nsGlobalWindowOuter* topWin = GetInProcessScriptableTopInternal();
2052     if (topWin) {
2053       frameElement = topWin->GetFrameElementInternal();
2054       eventTarget = nsContentUtils::TryGetBrowserChildGlobal(frameElement);
2055     }
2056   }
2057
2058   if (!eventTarget) {
2059     eventTarget = nsContentUtils::TryGetBrowserChildGlobal(mChromeEventHandler);
2060   }
2061
2062   if (!eventTarget) {
2063     eventTarget = mChromeEventHandler;
2064   }
2065
2066   mParentTarget = eventTarget;
2067 }
2068
2069 EventTarget* nsGlobalWindowInner::GetTargetForDOMEvent() {
2070   return GetOuterWindowInternal();
2071 }
2072
2073 void nsGlobalWindowInner::GetEventTargetParent(EventChainPreVisitor& aVisitor) {
2074   EventMessage msg = aVisitor.mEvent->mMessage;
2075
2076   aVisitor.mCanHandle = true;
2077   aVisitor.mForceContentDispatch = true;  // FIXME! Bug 329119
2078   if (msg == eResize && aVisitor.mEvent->IsTrusted()) {
2079     // Checking whether the event target is an inner window or not, so we can
2080     // keep the old behavior also in case a child window is handling resize.
2081     if (aVisitor.mEvent->mOriginalTarget &&
2082         aVisitor.mEvent->mOriginalTarget->IsInnerWindow()) {
2083       mIsHandlingResizeEvent = true;
2084     }
2085   } else if (msg == eMouseDown && aVisitor.mEvent->IsTrusted()) {
2086     sMouseDown = true;
2087   } else if ((msg == eMouseUp || msg == eDragEnd) &&
2088              aVisitor.mEvent->IsTrusted()) {
2089     sMouseDown = false;
2090     if (sDragServiceDisabled) {
2091       nsCOMPtr<nsIDragService> ds =
2092           do_GetService("@mozilla.org/widget/dragservice;1");
2093       if (ds) {
2094         sDragServiceDisabled = false;
2095         ds->Unsuppress();
2096       }
2097     }
2098   }
2099
2100   aVisitor.SetParentTarget(GetParentTarget(), true);
2101 }
2102
2103 void nsGlobalWindowInner::FireFrameLoadEvent() {
2104   // If we're not in a content frame, or are at a BrowsingContext tree boundary,
2105   // such as the content-chrome boundary, don't fire the "load" event.
2106   if (GetBrowsingContext()->IsTopContent() ||
2107       GetBrowsingContext()->IsChrome()) {
2108     return;
2109   }
2110
2111   // If embedder is same-process, fire the event on our embedder element.
2112   //
2113   // XXX: Bug 1440212 is looking into potentially changing this behaviour to act
2114   // more like the remote case when in-process.
2115   RefPtr<Element> element = GetBrowsingContext()->GetEmbedderElement();
2116   if (element) {
2117     nsEventStatus status = nsEventStatus_eIgnore;
2118     WidgetEvent event(/* aIsTrusted = */ true, eLoad);
2119     event.mFlags.mBubbles = false;
2120     event.mFlags.mCancelable = false;
2121
2122     if (mozilla::dom::DocGroup::TryToLoadIframesInBackground()) {
2123       nsDocShell* ds = nsDocShell::Cast(GetDocShell());
2124
2125       if (ds && !ds->HasFakeOnLoadDispatched()) {
2126         EventDispatcher::Dispatch(element, nullptr, &event, nullptr, &status);
2127       }
2128     } else {
2129       // Most of the time we could get a pres context to pass in here,
2130       // but not always (i.e. if this window is not shown there won't
2131       // be a pres context available). Since we're not firing a GUI
2132       // event we don't need a pres context anyway so we just pass
2133       // null as the pres context all the time here.
2134       EventDispatcher::Dispatch(element, nullptr, &event, nullptr, &status);
2135     }
2136     return;
2137   }
2138
2139   // We don't have an in-process embedder. Try to get our `BrowserChild` actor
2140   // to send a message to that embedder. We want to double-check that our outer
2141   // window is actually the one at the root of this browserChild though, just in
2142   // case.
2143   RefPtr<BrowserChild> browserChild =
2144       BrowserChild::GetFrom(static_cast<nsPIDOMWindowInner*>(this));
2145   if (browserChild) {
2146     // Double-check that our outer window is actually at the root of this
2147     // `BrowserChild`, in case we're in an odd maybe-unhosted situation like a
2148     // print preview dialog.
2149     nsCOMPtr<nsPIDOMWindowOuter> rootOuter =
2150         do_GetInterface(browserChild->WebNavigation());
2151     if (!rootOuter || rootOuter != GetOuterWindow()) {
2152       return;
2153     }
2154
2155     mozilla::Unused << browserChild->SendMaybeFireEmbedderLoadEvents(
2156         EmbedderElementEventType::LoadEvent);
2157   }
2158 }
2159
2160 nsresult nsGlobalWindowInner::PostHandleEvent(EventChainPostVisitor& aVisitor) {
2161   // Return early if there is nothing to do.
2162   switch (aVisitor.mEvent->mMessage) {
2163     case eResize:
2164     case eUnload:
2165     case eLoad:
2166       break;
2167     default:
2168       return NS_OK;
2169   }
2170
2171   /* mChromeEventHandler and mContext go dangling in the middle of this
2172    function under some circumstances (events that destroy the window)
2173    without this addref. */
2174   RefPtr<EventTarget> kungFuDeathGrip1(mChromeEventHandler);
2175   mozilla::Unused
2176       << kungFuDeathGrip1;  // These aren't referred to through the function
2177   nsCOMPtr<nsIScriptContext> kungFuDeathGrip2(GetContextInternal());
2178   mozilla::Unused
2179       << kungFuDeathGrip2;  // These aren't referred to through the function
2180
2181   if (aVisitor.mEvent->mMessage == eResize) {
2182     mIsHandlingResizeEvent = false;
2183   } else if (aVisitor.mEvent->mMessage == eUnload &&
2184              aVisitor.mEvent->IsTrusted()) {
2185     // If any VR display presentation is active at unload, the next page
2186     // will receive a vrdisplayactive event to indicate that it should
2187     // immediately begin vr presentation. This should occur when navigating
2188     // forwards, navigating backwards, and on page reload.
2189     for (const auto& display : mVRDisplays) {
2190       if (display->IsPresenting()) {
2191         display->StartVRNavigation();
2192         // Save this VR display ID to trigger vrdisplayactivate event
2193         // after the next load event.
2194         nsGlobalWindowOuter* outer = GetOuterWindowInternal();
2195         if (outer) {
2196           outer->SetAutoActivateVRDisplayID(display->DisplayId());
2197         }
2198
2199         // XXX The WebVR 1.1 spec does not define which of multiple VR
2200         // presenting VR displays will be chosen during navigation.
2201         // As the underlying platform VR API's currently only allow a single
2202         // VR display, it is safe to choose the first VR display for now.
2203         break;
2204       }
2205     }
2206     mIsDocumentLoaded = false;
2207     // Tell the parent process that the document is not loaded.
2208     if (mWindowGlobalChild) {
2209       mWindowGlobalChild->SendUpdateDocumentHasLoaded(mIsDocumentLoaded);
2210     }
2211   } else if (aVisitor.mEvent->mMessage == eLoad &&
2212              aVisitor.mEvent->IsTrusted()) {
2213     // This is page load event since load events don't propagate to |window|.
2214     // @see Document::GetEventTargetParent.
2215     mIsDocumentLoaded = true;
2216     // Tell the parent process that the document is loaded.
2217     if (mWindowGlobalChild) {
2218       mWindowGlobalChild->SendUpdateDocumentHasLoaded(mIsDocumentLoaded);
2219     }
2220
2221     mTimeoutManager->OnDocumentLoaded();
2222
2223     MOZ_ASSERT(aVisitor.mEvent->IsTrusted());
2224     FireFrameLoadEvent();
2225
2226     if (mVREventObserver) {
2227       mVREventObserver->NotifyAfterLoad();
2228     }
2229
2230     uint32_t autoActivateVRDisplayID = 0;
2231     nsGlobalWindowOuter* outer = GetOuterWindowInternal();
2232     if (outer) {
2233       autoActivateVRDisplayID = outer->GetAutoActivateVRDisplayID();
2234     }
2235     if (autoActivateVRDisplayID) {
2236       DispatchVRDisplayActivate(autoActivateVRDisplayID,
2237                                 VRDisplayEventReason::Navigation);
2238     }
2239   }
2240
2241   return NS_OK;
2242 }
2243
2244 nsresult nsGlobalWindowInner::DefineArgumentsProperty(nsIArray* aArguments) {
2245   nsIScriptContext* ctx = GetOuterWindowInternal()->mContext;
2246   NS_ENSURE_TRUE(aArguments && ctx, NS_ERROR_NOT_INITIALIZED);
2247
2248   JS::Rooted<JSObject*> obj(RootingCx(), GetWrapperPreserveColor());
2249   return ctx->SetProperty(obj, "arguments", aArguments);
2250 }
2251
2252 //*****************************************************************************
2253 // nsGlobalWindowInner::nsIScriptObjectPrincipal
2254 //*****************************************************************************
2255
2256 nsIPrincipal* nsGlobalWindowInner::GetPrincipal() {
2257   if (mDoc) {
2258     // If we have a document, get the principal from the document
2259     return mDoc->NodePrincipal();
2260   }
2261
2262   if (mDocumentPrincipal) {
2263     return mDocumentPrincipal;
2264   }
2265
2266   // If we don't have a principal and we don't have a document we
2267   // ask the parent window for the principal. This can happen when
2268   // loading a frameset that has a <frame src="javascript:xxx">, in
2269   // that case the global window is used in JS before we've loaded
2270   // a document into the window.
2271
2272   nsCOMPtr<nsIScriptObjectPrincipal> objPrincipal =
2273       do_QueryInterface(GetInProcessParentInternal());
2274
2275   if (objPrincipal) {
2276     return objPrincipal->GetPrincipal();
2277   }
2278
2279   return nullptr;
2280 }
2281
2282 nsIPrincipal* nsGlobalWindowInner::GetEffectiveCookiePrincipal() {
2283   if (mDoc) {
2284     // If we have a document, get the principal from the document
2285     return mDoc->EffectiveCookiePrincipal();
2286   }
2287
2288   if (mDocumentCookiePrincipal) {
2289     return mDocumentCookiePrincipal;
2290   }
2291
2292   // If we don't have a cookie principal and we don't have a document we ask
2293   // the parent window for the cookie principal.
2294
2295   nsCOMPtr<nsIScriptObjectPrincipal> objPrincipal =
2296       do_QueryInterface(GetInProcessParentInternal());
2297
2298   if (objPrincipal) {
2299     return objPrincipal->GetEffectiveCookiePrincipal();
2300   }
2301
2302   return nullptr;
2303 }
2304
2305 nsIPrincipal* nsGlobalWindowInner::GetEffectiveStoragePrincipal() {
2306   if (mDoc) {
2307     // If we have a document, get the principal from the document
2308     return mDoc->EffectiveStoragePrincipal();
2309   }
2310
2311   if (mDocumentStoragePrincipal) {
2312     return mDocumentStoragePrincipal;
2313   }
2314
2315   // If we don't have a cookie principal and we don't have a document we ask
2316   // the parent window for the cookie principal.
2317
2318   nsCOMPtr<nsIScriptObjectPrincipal> objPrincipal =
2319       do_QueryInterface(GetInProcessParentInternal());
2320
2321   if (objPrincipal) {
2322     return objPrincipal->GetEffectiveStoragePrincipal();
2323   }
2324
2325   return nullptr;
2326 }
2327
2328 nsIPrincipal* nsGlobalWindowInner::PartitionedPrincipal() {
2329   if (mDoc) {
2330     // If we have a document, get the principal from the document
2331     return mDoc->PartitionedPrincipal();
2332   }
2333
2334   if (mDocumentPartitionedPrincipal) {
2335     return mDocumentPartitionedPrincipal;
2336   }
2337
2338   // If we don't have a partitioned principal and we don't have a document we
2339   // ask the parent window for the partitioned principal.
2340
2341   nsCOMPtr<nsIScriptObjectPrincipal> objPrincipal =
2342       do_QueryInterface(GetInProcessParentInternal());
2343
2344   if (objPrincipal) {
2345     return objPrincipal->PartitionedPrincipal();
2346   }
2347
2348   return nullptr;
2349 }
2350
2351 //*****************************************************************************
2352 // nsGlobalWindowInner::nsIDOMWindow
2353 //*****************************************************************************
2354
2355 bool nsPIDOMWindowInner::AddAudioContext(AudioContext* aAudioContext) {
2356   mAudioContexts.AppendElement(aAudioContext);
2357
2358   // Return true if the context should be muted and false if not.
2359   nsIDocShell* docShell = GetDocShell();
2360   return docShell && !docShell->GetAllowMedia() && !aAudioContext->IsOffline();
2361 }
2362
2363 void nsPIDOMWindowInner::RemoveAudioContext(AudioContext* aAudioContext) {
2364   mAudioContexts.RemoveElement(aAudioContext);
2365 }
2366
2367 void nsPIDOMWindowInner::MuteAudioContexts() {
2368   for (uint32_t i = 0; i < mAudioContexts.Length(); ++i) {
2369     if (!mAudioContexts[i]->IsOffline()) {
2370       mAudioContexts[i]->Mute();
2371     }
2372   }
2373 }
2374
2375 void nsPIDOMWindowInner::UnmuteAudioContexts() {
2376   for (uint32_t i = 0; i < mAudioContexts.Length(); ++i) {
2377     if (!mAudioContexts[i]->IsOffline()) {
2378       mAudioContexts[i]->Unmute();
2379     }
2380   }
2381 }
2382
2383 WindowProxyHolder nsGlobalWindowInner::Window() {
2384   return WindowProxyHolder(GetBrowsingContext());
2385 }
2386
2387 Navigator* nsPIDOMWindowInner::Navigator() {
2388   if (!mNavigator) {
2389     mNavigator = new mozilla::dom::Navigator(this);
2390   }
2391
2392   return mNavigator;
2393 }
2394
2395 MediaDevices* nsPIDOMWindowInner::GetExtantMediaDevices() const {
2396   return mNavigator ? mNavigator->GetExtantMediaDevices() : nullptr;
2397 }
2398
2399 VisualViewport* nsGlobalWindowInner::VisualViewport() {
2400   if (!mVisualViewport) {
2401     mVisualViewport = new mozilla::dom::VisualViewport(this);
2402   }
2403
2404   return mVisualViewport;
2405 }
2406
2407 nsScreen* nsGlobalWindowInner::GetScreen(ErrorResult& aError) {
2408   if (!mScreen) {
2409     mScreen = nsScreen::Create(this);
2410     if (!mScreen) {
2411       aError.Throw(NS_ERROR_UNEXPECTED);
2412       return nullptr;
2413     }
2414   }
2415
2416   return mScreen;
2417 }
2418
2419 nsHistory* nsGlobalWindowInner::GetHistory(ErrorResult& aError) {
2420   if (!mHistory) {
2421     mHistory = new nsHistory(this);
2422   }
2423
2424   return mHistory;
2425 }
2426
2427 CustomElementRegistry* nsGlobalWindowInner::CustomElements() {
2428   if (!mCustomElements) {
2429     mCustomElements = new CustomElementRegistry(this);
2430   }
2431
2432   return mCustomElements;
2433 }
2434
2435 CustomElementRegistry* nsGlobalWindowInner::GetExistingCustomElements() {
2436   return mCustomElements;
2437 }
2438
2439 Performance* nsPIDOMWindowInner::GetPerformance() {
2440   CreatePerformanceObjectIfNeeded();
2441   return mPerformance;
2442 }
2443
2444 void nsPIDOMWindowInner::QueuePerformanceNavigationTiming() {
2445   CreatePerformanceObjectIfNeeded();
2446   if (mPerformance) {
2447     mPerformance->QueueNavigationTimingEntry();
2448   }
2449 }
2450
2451 void nsPIDOMWindowInner::CreatePerformanceObjectIfNeeded() {
2452   if (mPerformance || !mDoc) {
2453     return;
2454   }
2455   RefPtr<nsDOMNavigationTiming> timing = mDoc->GetNavigationTiming();
2456   nsCOMPtr<nsITimedChannel> timedChannel(do_QueryInterface(mDoc->GetChannel()));
2457   bool timingEnabled = false;
2458   if (!timedChannel ||
2459       !NS_SUCCEEDED(timedChannel->GetTimingEnabled(&timingEnabled)) ||
2460       !timingEnabled) {
2461     timedChannel = nullptr;
2462   }
2463   if (timing) {
2464     mPerformance = Performance::CreateForMainThread(this, mDoc->NodePrincipal(),
2465                                                     timing, timedChannel);
2466   }
2467 }
2468
2469 bool nsPIDOMWindowInner::IsSecureContext() const {
2470   return nsGlobalWindowInner::Cast(this)->IsSecureContext();
2471 }
2472
2473 void nsPIDOMWindowInner::Suspend(bool aIncludeSubWindows) {
2474   nsGlobalWindowInner::Cast(this)->Suspend(aIncludeSubWindows);
2475 }
2476
2477 void nsPIDOMWindowInner::Resume(bool aIncludeSubWindows) {
2478   nsGlobalWindowInner::Cast(this)->Resume(aIncludeSubWindows);
2479 }
2480
2481 void nsPIDOMWindowInner::SyncStateFromParentWindow() {
2482   nsGlobalWindowInner::Cast(this)->SyncStateFromParentWindow();
2483 }
2484
2485 Maybe<ClientInfo> nsPIDOMWindowInner::GetClientInfo() const {
2486   return nsGlobalWindowInner::Cast(this)->GetClientInfo();
2487 }
2488
2489 Maybe<ClientState> nsPIDOMWindowInner::GetClientState() const {
2490   return nsGlobalWindowInner::Cast(this)->GetClientState();
2491 }
2492
2493 Maybe<ServiceWorkerDescriptor> nsPIDOMWindowInner::GetController() const {
2494   return nsGlobalWindowInner::Cast(this)->GetController();
2495 }
2496
2497 void nsPIDOMWindowInner::SetCsp(nsIContentSecurityPolicy* aCsp) {
2498   return nsGlobalWindowInner::Cast(this)->SetCsp(aCsp);
2499 }
2500
2501 void nsPIDOMWindowInner::SetPreloadCsp(nsIContentSecurityPolicy* aPreloadCsp) {
2502   return nsGlobalWindowInner::Cast(this)->SetPreloadCsp(aPreloadCsp);
2503 }
2504
2505 nsIContentSecurityPolicy* nsPIDOMWindowInner::GetCsp() {
2506   return nsGlobalWindowInner::Cast(this)->GetCsp();
2507 }
2508
2509 void nsPIDOMWindowInner::NoteCalledRegisterForServiceWorkerScope(
2510     const nsACString& aScope) {
2511   nsGlobalWindowInner::Cast(this)->NoteCalledRegisterForServiceWorkerScope(
2512       aScope);
2513 }
2514
2515 void nsPIDOMWindowInner::NoteDOMContentLoaded() {
2516   nsGlobalWindowInner::Cast(this)->NoteDOMContentLoaded();
2517 }
2518
2519 bool nsGlobalWindowInner::ShouldReportForServiceWorkerScope(
2520     const nsAString& aScope) {
2521   bool result = false;
2522
2523   nsPIDOMWindowOuter* topOuter = GetInProcessScriptableTop();
2524   NS_ENSURE_TRUE(topOuter, false);
2525
2526   nsGlobalWindowInner* topInner =
2527       nsGlobalWindowInner::Cast(topOuter->GetCurrentInnerWindow());
2528   NS_ENSURE_TRUE(topInner, false);
2529
2530   topInner->ShouldReportForServiceWorkerScopeInternal(
2531       NS_ConvertUTF16toUTF8(aScope), &result);
2532   return result;
2533 }
2534
2535 InstallTriggerImpl* nsGlobalWindowInner::GetInstallTrigger() {
2536   if (!mInstallTrigger &&
2537       !StaticPrefs::extensions_InstallTriggerImpl_enabled()) {
2538     // Return nullptr when InstallTriggerImpl is disabled by pref,
2539     // which does not yet break the "typeof InstallTrigger !== 'undefined"
2540     // "UA detection" use case, but prevents access to the InstallTriggerImpl
2541     // methods and properties.
2542     //
2543     // NOTE: a separate pref ("extensions.InstallTrigger.enabled"), associated
2544     // to this property using the [Pref] extended attribute in Window.webidl,
2545     // does instead hide the entire InstallTrigger property.
2546     //
2547     // See Bug 1754441 for more details about this deprecation.
2548     return nullptr;
2549   }
2550   if (!mInstallTrigger) {
2551     ErrorResult rv;
2552     mInstallTrigger = ConstructJSImplementation<InstallTriggerImpl>(
2553         "@mozilla.org/addons/installtrigger;1", this, rv);
2554     if (rv.Failed()) {
2555       rv.SuppressException();
2556       return nullptr;
2557     }
2558   }
2559
2560   return mInstallTrigger;
2561 }
2562
2563 nsIDOMWindowUtils* nsGlobalWindowInner::GetWindowUtils(ErrorResult& aRv) {
2564   FORWARD_TO_OUTER_OR_THROW(WindowUtils, (), aRv, nullptr);
2565 }
2566
2567 CallState nsGlobalWindowInner::ShouldReportForServiceWorkerScopeInternal(
2568     const nsACString& aScope, bool* aResultOut) {
2569   MOZ_DIAGNOSTIC_ASSERT(aResultOut);
2570
2571   // First check to see if this window is controlled.  If so, then we have
2572   // found a match and are done.
2573   const Maybe<ServiceWorkerDescriptor> swd = GetController();
2574   if (swd.isSome() && swd.ref().Scope() == aScope) {
2575     *aResultOut = true;
2576     return CallState::Stop;
2577   }
2578
2579   // Next, check to see if this window has called
2580   // navigator.serviceWorker.register() for this scope.  If so, then treat this
2581   // as a match so console reports appear in the devtools console.
2582   if (mClientSource &&
2583       mClientSource->CalledRegisterForServiceWorkerScope(aScope)) {
2584     *aResultOut = true;
2585     return CallState::Stop;
2586   }
2587
2588   // Finally check the current docshell nsILoadGroup to see if there are any
2589   // outstanding navigation requests.  If so, match the scope against the
2590   // channel's URL.  We want to show console reports during the FetchEvent
2591   // intercepting the navigation itself.
2592   nsCOMPtr<nsIDocumentLoader> loader(do_QueryInterface(GetDocShell()));
2593   if (loader) {
2594     nsCOMPtr<nsILoadGroup> loadgroup;
2595     Unused << loader->GetLoadGroup(getter_AddRefs(loadgroup));
2596     if (loadgroup) {
2597       nsCOMPtr<nsISimpleEnumerator> iter;
2598       Unused << loadgroup->GetRequests(getter_AddRefs(iter));
2599       if (iter) {
2600         nsCOMPtr<nsISupports> tmp;
2601         bool hasMore = true;
2602         // Check each network request in the load group.
2603         while (NS_SUCCEEDED(iter->HasMoreElements(&hasMore)) && hasMore) {
2604           iter->GetNext(getter_AddRefs(tmp));
2605           nsCOMPtr<nsIChannel> loadingChannel(do_QueryInterface(tmp));
2606           // Ignore subresource requests.  Logging for a subresource
2607           // FetchEvent should be handled above since the client is
2608           // already controlled.
2609           if (!loadingChannel ||
2610               !nsContentUtils::IsNonSubresourceRequest(loadingChannel)) {
2611             continue;
2612           }
2613           nsCOMPtr<nsIURI> loadingURL;
2614           Unused << loadingChannel->GetURI(getter_AddRefs(loadingURL));
2615           if (!loadingURL) {
2616             continue;
2617           }
2618           nsAutoCString loadingSpec;
2619           Unused << loadingURL->GetSpec(loadingSpec);
2620           // Perform a simple substring comparison to match the scope
2621           // against the channel URL.
2622           if (StringBeginsWith(loadingSpec, aScope)) {
2623             *aResultOut = true;
2624             return CallState::Stop;
2625           }
2626         }
2627       }
2628     }
2629   }
2630
2631   // The current window doesn't care about this service worker, but maybe
2632   // one of our child frames does.
2633   return CallOnInProcessChildren(
2634       &nsGlobalWindowInner::ShouldReportForServiceWorkerScopeInternal, aScope,
2635       aResultOut);
2636 }
2637
2638 void nsGlobalWindowInner::NoteCalledRegisterForServiceWorkerScope(
2639     const nsACString& aScope) {
2640   if (!mClientSource) {
2641     return;
2642   }
2643
2644   mClientSource->NoteCalledRegisterForServiceWorkerScope(aScope);
2645 }
2646
2647 void nsGlobalWindowInner::NoteDOMContentLoaded() {
2648   if (!mClientSource) {
2649     return;
2650   }
2651
2652   mClientSource->NoteDOMContentLoaded();
2653 }
2654
2655 void nsGlobalWindowInner::UpdateTopInnerWindow() {
2656   if (IsTopInnerWindow() || !mTopInnerWindow) {
2657     return;
2658   }
2659
2660   mTopInnerWindow->UpdateWebSocketCount(-(int32_t)mNumOfOpenWebSockets);
2661 }
2662
2663 bool nsGlobalWindowInner::IsInSyncOperation() {
2664   return GetExtantDoc() && GetExtantDoc()->IsInSyncOperation();
2665 }
2666
2667 bool nsGlobalWindowInner::IsSharedMemoryAllowedInternal(
2668     nsIPrincipal* aPrincipal) const {
2669   MOZ_ASSERT(NS_IsMainThread());
2670
2671   if (StaticPrefs::
2672           dom_postMessage_sharedArrayBuffer_bypassCOOP_COEP_insecure_enabled()) {
2673     return true;
2674   }
2675
2676   if (ExtensionPolicyService::GetSingleton().IsExtensionProcess()) {
2677     if (auto* basePrincipal = BasePrincipal::Cast(aPrincipal)) {
2678       if (auto* policy = basePrincipal->AddonPolicy()) {
2679         return policy->IsPrivileged();
2680       }
2681     }
2682   }
2683
2684   return CrossOriginIsolated();
2685 }
2686
2687 bool nsGlobalWindowInner::CrossOriginIsolated() const {
2688   MOZ_ASSERT(NS_IsMainThread());
2689
2690   RefPtr<BrowsingContext> bc = GetBrowsingContext();
2691   MOZ_DIAGNOSTIC_ASSERT(bc);
2692   return bc->CrossOriginIsolated();
2693 }
2694
2695 WindowContext* TopWindowContext(nsPIDOMWindowInner& aWindow) {
2696   WindowContext* wc = aWindow.GetWindowContext();
2697   if (!wc) {
2698     return nullptr;
2699   }
2700
2701   return wc->TopWindowContext();
2702 }
2703
2704 void nsPIDOMWindowInner::AddPeerConnection() {
2705   MOZ_ASSERT(NS_IsMainThread());
2706   ++mActivePeerConnections;
2707   if (mActivePeerConnections == 1 && mWindowGlobalChild) {
2708     mWindowGlobalChild->SendUpdateActivePeerConnectionStatus(
2709         /*aIsAdded*/ true);
2710
2711     // We need to present having active peer connections immediately. If we need
2712     // to wait for the parent process to come back with this information we
2713     // might start throttling.
2714     if (WindowContext* top = TopWindowContext(*this)) {
2715       top->TransientSetHasActivePeerConnections();
2716     }
2717   }
2718 }
2719
2720 void nsPIDOMWindowInner::RemovePeerConnection() {
2721   MOZ_ASSERT(NS_IsMainThread());
2722   MOZ_ASSERT(mActivePeerConnections > 0);
2723   --mActivePeerConnections;
2724   if (mActivePeerConnections == 0 && mWindowGlobalChild) {
2725     mWindowGlobalChild->SendUpdateActivePeerConnectionStatus(
2726         /*aIsAdded*/ false);
2727   }
2728 }
2729
2730 bool nsPIDOMWindowInner::HasActivePeerConnections() {
2731   MOZ_ASSERT(NS_IsMainThread());
2732
2733   WindowContext* topWindowContext = TopWindowContext(*this);
2734   return topWindowContext && topWindowContext->GetHasActivePeerConnections();
2735 }
2736
2737 void nsPIDOMWindowInner::AddMediaKeysInstance(MediaKeys* aMediaKeys) {
2738   MOZ_ASSERT(NS_IsMainThread());
2739   mMediaKeysInstances.AppendElement(aMediaKeys);
2740   if (mWindowGlobalChild && mMediaKeysInstances.Length() == 1) {
2741     mWindowGlobalChild->BlockBFCacheFor(BFCacheStatus::CONTAINS_EME_CONTENT);
2742   }
2743 }
2744
2745 void nsPIDOMWindowInner::RemoveMediaKeysInstance(MediaKeys* aMediaKeys) {
2746   MOZ_ASSERT(NS_IsMainThread());
2747   mMediaKeysInstances.RemoveElement(aMediaKeys);
2748   if (mWindowGlobalChild && mMediaKeysInstances.IsEmpty()) {
2749     mWindowGlobalChild->UnblockBFCacheFor(BFCacheStatus::CONTAINS_EME_CONTENT);
2750   }
2751 }
2752
2753 bool nsPIDOMWindowInner::HasActiveMediaKeysInstance() {
2754   MOZ_ASSERT(NS_IsMainThread());
2755   return !mMediaKeysInstances.IsEmpty();
2756 }
2757
2758 bool nsPIDOMWindowInner::IsPlayingAudio() {
2759   for (uint32_t i = 0; i < mAudioContexts.Length(); i++) {
2760     if (mAudioContexts[i]->IsRunning()) {
2761       return true;
2762     }
2763   }
2764   RefPtr<AudioChannelService> acs = AudioChannelService::Get();
2765   if (!acs) {
2766     return false;
2767   }
2768   auto outer = GetOuterWindow();
2769   if (!outer) {
2770     // We've been unlinked and are about to die.  Not a good time to pretend to
2771     // be playing audio.
2772     return false;
2773   }
2774   return acs->IsWindowActive(outer);
2775 }
2776
2777 bool nsPIDOMWindowInner::IsDocumentLoaded() const { return mIsDocumentLoaded; }
2778
2779 mozilla::dom::TimeoutManager& nsPIDOMWindowInner::TimeoutManager() {
2780   return *mTimeoutManager;
2781 }
2782
2783 bool nsPIDOMWindowInner::IsRunningTimeout() {
2784   return TimeoutManager().IsRunningTimeout();
2785 }
2786
2787 void nsPIDOMWindowInner::TryToCacheTopInnerWindow() {
2788   if (mHasTriedToCacheTopInnerWindow) {
2789     return;
2790   }
2791
2792   nsGlobalWindowInner* window = nsGlobalWindowInner::Cast(this);
2793
2794   MOZ_ASSERT(!window->IsDying());
2795
2796   mHasTriedToCacheTopInnerWindow = true;
2797
2798   MOZ_ASSERT(window);
2799
2800   if (nsCOMPtr<nsPIDOMWindowOuter> topOutter =
2801           window->GetInProcessScriptableTop()) {
2802     mTopInnerWindow = topOutter->GetCurrentInnerWindow();
2803   }
2804 }
2805
2806 void nsPIDOMWindowInner::UpdateActiveIndexedDBDatabaseCount(int32_t aDelta) {
2807   MOZ_ASSERT(NS_IsMainThread());
2808
2809   if (aDelta == 0) {
2810     return;
2811   }
2812
2813   // We count databases but not transactions because only active databases
2814   // could block throttling.
2815   uint32_t& counter = mTopInnerWindow
2816                           ? mTopInnerWindow->mNumOfIndexedDBDatabases
2817                           : mNumOfIndexedDBDatabases;
2818
2819   counter += aDelta;
2820 }
2821
2822 bool nsPIDOMWindowInner::HasActiveIndexedDBDatabases() {
2823   MOZ_ASSERT(NS_IsMainThread());
2824
2825   return mTopInnerWindow ? mTopInnerWindow->mNumOfIndexedDBDatabases > 0
2826                          : mNumOfIndexedDBDatabases > 0;
2827 }
2828
2829 void nsPIDOMWindowInner::UpdateWebSocketCount(int32_t aDelta) {
2830   MOZ_ASSERT(NS_IsMainThread());
2831
2832   if (aDelta == 0) {
2833     return;
2834   }
2835
2836   if (mTopInnerWindow && !IsTopInnerWindow()) {
2837     mTopInnerWindow->UpdateWebSocketCount(aDelta);
2838   }
2839
2840   MOZ_DIAGNOSTIC_ASSERT(
2841       aDelta > 0 || ((aDelta + mNumOfOpenWebSockets) < mNumOfOpenWebSockets));
2842
2843   mNumOfOpenWebSockets += aDelta;
2844 }
2845
2846 bool nsPIDOMWindowInner::HasOpenWebSockets() const {
2847   MOZ_ASSERT(NS_IsMainThread());
2848
2849   return mNumOfOpenWebSockets ||
2850          (mTopInnerWindow && mTopInnerWindow->mNumOfOpenWebSockets);
2851 }
2852
2853 bool nsPIDOMWindowInner::IsCurrentInnerWindow() const {
2854   if (mozilla::SessionHistoryInParent() && mBrowsingContext &&
2855       mBrowsingContext->IsInBFCache()) {
2856     return false;
2857   }
2858
2859   if (!mBrowsingContext || mBrowsingContext->IsDiscarded()) {
2860     // If our BrowsingContext has been discarded, we consider ourselves
2861     // still-current if we were current at the time it was discarded.
2862     return mOuterWindow && WasCurrentInnerWindow();
2863   }
2864
2865   nsPIDOMWindowOuter* outer = mBrowsingContext->GetDOMWindow();
2866   return outer && outer->GetCurrentInnerWindow() == this;
2867 }
2868
2869 bool nsPIDOMWindowInner::IsFullyActive() const {
2870   WindowContext* wc = GetWindowContext();
2871   if (!wc || wc->IsDiscarded() || !wc->IsCurrent()) {
2872     return false;
2873   }
2874   return GetBrowsingContext()->AncestorsAreCurrent();
2875 }
2876
2877 void nsPIDOMWindowInner::SetAudioCapture(bool aCapture) {
2878   RefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate();
2879   if (service) {
2880     service->SetWindowAudioCaptured(GetOuterWindow(), mWindowID, aCapture);
2881   }
2882 }
2883
2884 void nsGlobalWindowInner::SetActiveLoadingState(bool aIsLoading) {
2885   MOZ_LOG(
2886       gTimeoutLog, mozilla::LogLevel::Debug,
2887       ("SetActiveLoadingState innerwindow %p: %d", (void*)this, aIsLoading));
2888   if (GetBrowsingContext()) {
2889     // Setting loading on a discarded context has no effect.
2890     Unused << GetBrowsingContext()->SetLoading(aIsLoading);
2891   }
2892
2893   if (!nsGlobalWindowInner::Cast(this)->IsChromeWindow()) {
2894     mTimeoutManager->SetLoading(aIsLoading);
2895   }
2896
2897   HintIsLoading(aIsLoading);
2898 }
2899
2900 void nsGlobalWindowInner::HintIsLoading(bool aIsLoading) {
2901   // Hint to tell the JS GC to use modified triggers during pageload.
2902   if (mHintedWasLoading != aIsLoading) {
2903     using namespace js::gc;
2904     SetPerformanceHint(danger::GetJSContext(), aIsLoading
2905                                                    ? PerformanceHint::InPageLoad
2906                                                    : PerformanceHint::Normal);
2907     mHintedWasLoading = aIsLoading;
2908   }
2909 }
2910
2911 // nsISpeechSynthesisGetter
2912
2913 #ifdef MOZ_WEBSPEECH
2914 SpeechSynthesis* nsGlobalWindowInner::GetSpeechSynthesis(ErrorResult& aError) {
2915   if (!mSpeechSynthesis) {
2916     mSpeechSynthesis = new SpeechSynthesis(this);
2917   }
2918
2919   return mSpeechSynthesis;
2920 }
2921
2922 bool nsGlobalWindowInner::HasActiveSpeechSynthesis() {
2923   if (mSpeechSynthesis) {
2924     return !mSpeechSynthesis->HasEmptyQueue();
2925   }
2926
2927   return false;
2928 }
2929
2930 #endif
2931
2932 mozilla::glean::Glean* nsGlobalWindowInner::Glean() {
2933   if (!mGlean) {
2934     mGlean = new mozilla::glean::Glean(this);
2935   }
2936
2937   return mGlean;
2938 }
2939
2940 mozilla::glean::GleanPings* nsGlobalWindowInner::GleanPings() {
2941   if (!mGleanPings) {
2942     mGleanPings = new mozilla::glean::GleanPings();
2943   }
2944
2945   return mGleanPings;
2946 }
2947
2948 Nullable<WindowProxyHolder> nsGlobalWindowInner::GetParent(
2949     ErrorResult& aError) {
2950   FORWARD_TO_OUTER_OR_THROW(GetParentOuter, (), aError, nullptr);
2951 }
2952
2953 /**
2954  * GetInProcessScriptableParent used to be called when a script read
2955  * window.parent. Under Fission, that is now handled by
2956  * BrowsingContext::GetParent, and the result is a WindowProxyHolder rather than
2957  * an actual global window. This method still exists for legacy callers which
2958  * relied on the old logic, and require in-process windows. However, it only
2959  * works correctly when no out-of-process frames exist between this window and
2960  * the top-level window, so it should not be used in new code.
2961  *
2962  * In contrast to GetRealParent, GetInProcessScriptableParent respects <iframe
2963  * mozbrowser> boundaries, so if |this| is contained by an <iframe
2964  * mozbrowser>, we will return |this| as its own parent.
2965  */
2966 nsPIDOMWindowOuter* nsGlobalWindowInner::GetInProcessScriptableParent() {
2967   FORWARD_TO_OUTER(GetInProcessScriptableParent, (), nullptr);
2968 }
2969
2970 /**
2971  * GetInProcessScriptableTop used to be called when a script read window.top.
2972  * Under Fission, that is now handled by BrowsingContext::Top, and the result is
2973  * a WindowProxyHolder rather than an actual global window. This method still
2974  * exists for legacy callers which relied on the old logic, and require
2975  * in-process windows. However, it only works correctly when no out-of-process
2976  * frames exist between this window and the top-level window, so it should not
2977  * be used in new code.
2978  *
2979  * In contrast to GetRealTop, GetInProcessScriptableTop respects <iframe
2980  * mozbrowser> boundaries.  If we encounter a window owned by an <iframe
2981  * mozbrowser> while walking up the window hierarchy, we'll stop and return that
2982  * window.
2983  */
2984 nsPIDOMWindowOuter* nsGlobalWindowInner::GetInProcessScriptableTop() {
2985   FORWARD_TO_OUTER(GetInProcessScriptableTop, (), nullptr);
2986 }
2987
2988 void nsGlobalWindowInner::GetContent(JSContext* aCx,
2989                                      JS::MutableHandle<JSObject*> aRetval,
2990                                      CallerType aCallerType,
2991                                      ErrorResult& aError) {
2992   FORWARD_TO_OUTER_OR_THROW(GetContentOuter,
2993                             (aCx, aRetval, aCallerType, aError), aError, );
2994 }
2995
2996 BarProp* nsGlobalWindowInner::GetMenubar(ErrorResult& aError) {
2997   if (!mMenubar) {
2998     mMenubar = new MenubarProp(this);
2999   }
3000
3001   return mMenubar;
3002 }
3003
3004 BarProp* nsGlobalWindowInner::GetToolbar(ErrorResult& aError) {
3005   if (!mToolbar) {
3006     mToolbar = new ToolbarProp(this);
3007   }
3008
3009   return mToolbar;
3010 }
3011
3012 BarProp* nsGlobalWindowInner::GetLocationbar(ErrorResult& aError) {
3013   if (!mLocationbar) {
3014     mLocationbar = new LocationbarProp(this);
3015   }
3016   return mLocationbar;
3017 }
3018
3019 BarProp* nsGlobalWindowInner::GetPersonalbar(ErrorResult& aError) {
3020   if (!mPersonalbar) {
3021     mPersonalbar = new PersonalbarProp(this);
3022   }
3023   return mPersonalbar;
3024 }
3025
3026 BarProp* nsGlobalWindowInner::GetStatusbar(ErrorResult& aError) {
3027   if (!mStatusbar) {
3028     mStatusbar = new StatusbarProp(this);
3029   }
3030   return mStatusbar;
3031 }
3032
3033 BarProp* nsGlobalWindowInner::GetScrollbars(ErrorResult& aError) {
3034   if (!mScrollbars) {
3035     mScrollbars = new ScrollbarsProp(this);
3036   }
3037
3038   return mScrollbars;
3039 }
3040
3041 bool nsGlobalWindowInner::GetClosed(ErrorResult& aError) {
3042   // If we're called from JS (which is the only way we should be getting called
3043   // here) and we reach this point, that means our JS global is the current
3044   // target of the WindowProxy, which means that we are the "current inner"
3045   // of our outer. So if FORWARD_TO_OUTER fails to forward, that means the
3046   // outer is already torn down, which corresponds to the closed state.
3047   FORWARD_TO_OUTER(GetClosedOuter, (), true);
3048 }
3049
3050 Nullable<WindowProxyHolder> nsGlobalWindowInner::IndexedGetter(
3051     uint32_t aIndex) {
3052   FORWARD_TO_OUTER(IndexedGetterOuter, (aIndex), nullptr);
3053 }
3054
3055 namespace {
3056
3057 struct InterfaceShimEntry {
3058   const char* geckoName;
3059   const char* domName;
3060 };
3061
3062 }  // anonymous namespace
3063
3064 // We add shims from Components.interfaces.nsIDOMFoo to window.Foo for each
3065 // interface that has interface constants that sites might be getting off
3066 // of Ci.
3067 const InterfaceShimEntry kInterfaceShimMap[] = {
3068     {"nsIXMLHttpRequest", "XMLHttpRequest"},
3069     {"nsIDOMDOMException", "DOMException"},
3070     {"nsIDOMNode", "Node"},
3071     {"nsIDOMCSSRule", "CSSRule"},
3072     {"nsIDOMEvent", "Event"},
3073     {"nsIDOMNSEvent", "Event"},
3074     {"nsIDOMKeyEvent", "KeyEvent"},
3075     {"nsIDOMMouseEvent", "MouseEvent"},
3076     {"nsIDOMMouseScrollEvent", "MouseScrollEvent"},
3077     {"nsIDOMMutationEvent", "MutationEvent"},
3078     {"nsIDOMUIEvent", "UIEvent"},
3079     {"nsIDOMHTMLMediaElement", "HTMLMediaElement"},
3080     {"nsIDOMRange", "Range"},
3081     // Think about whether Ci.nsINodeFilter can just go away for websites!
3082     {"nsIDOMNodeFilter", "NodeFilter"},
3083     {"nsIDOMXPathResult", "XPathResult"}};
3084
3085 bool nsGlobalWindowInner::ResolveComponentsShim(
3086     JSContext* aCx, JS::Handle<JSObject*> aGlobal,
3087     JS::MutableHandle<mozilla::Maybe<JS::PropertyDescriptor>> aDesc) {
3088   // Keep track of how often this happens.
3089   Telemetry::Accumulate(Telemetry::COMPONENTS_SHIM_ACCESSED_BY_CONTENT, true);
3090
3091   // Warn once.
3092   nsCOMPtr<Document> doc = GetExtantDoc();
3093   if (doc) {
3094     doc->WarnOnceAbout(DeprecatedOperations::eComponents, /* asError = */ true);
3095   }
3096
3097   // Create a fake Components object.
3098   AssertSameCompartment(aCx, aGlobal);
3099   JS::Rooted<JSObject*> components(aCx, JS_NewPlainObject(aCx));
3100   if (NS_WARN_IF(!components)) {
3101     return false;
3102   }
3103
3104   // Create a fake interfaces object.
3105   JS::Rooted<JSObject*> interfaces(aCx, JS_NewPlainObject(aCx));
3106   if (NS_WARN_IF(!interfaces)) {
3107     return false;
3108   }
3109   bool ok =
3110       JS_DefineProperty(aCx, components, "interfaces", interfaces,
3111                         JSPROP_ENUMERATE | JSPROP_PERMANENT | JSPROP_READONLY);
3112   if (NS_WARN_IF(!ok)) {
3113     return false;
3114   }
3115
3116   // Define a bunch of shims from the Ci.nsIDOMFoo to window.Foo for DOM
3117   // interfaces with constants.
3118   for (uint32_t i = 0; i < ArrayLength(kInterfaceShimMap); ++i) {
3119     // Grab the names from the table.
3120     const char* geckoName = kInterfaceShimMap[i].geckoName;
3121     const char* domName = kInterfaceShimMap[i].domName;
3122
3123     // Look up the appopriate interface object on the global.
3124     JS::Rooted<JS::Value> v(aCx, JS::UndefinedValue());
3125     ok = JS_GetProperty(aCx, aGlobal, domName, &v);
3126     if (NS_WARN_IF(!ok)) {
3127       return false;
3128     }
3129     if (!v.isObject()) {
3130       NS_WARNING("Unable to find interface object on global");
3131       continue;
3132     }
3133
3134     // Define the shim on the interfaces object.
3135     ok = JS_DefineProperty(
3136         aCx, interfaces, geckoName, v,
3137         JSPROP_ENUMERATE | JSPROP_PERMANENT | JSPROP_READONLY);
3138     if (NS_WARN_IF(!ok)) {
3139       return false;
3140     }
3141   }
3142
3143   aDesc.set(mozilla::Some(JS::PropertyDescriptor::Data(
3144       JS::ObjectValue(*components),
3145       {JS::PropertyAttribute::Configurable, JS::PropertyAttribute::Enumerable,
3146        JS::PropertyAttribute::Writable})));
3147   return true;
3148 }
3149
3150 #ifdef RELEASE_OR_BETA
3151 #  define USE_CONTROLLERS_SHIM
3152 #endif
3153
3154 #ifdef USE_CONTROLLERS_SHIM
3155 static const JSClass ControllersShimClass = {"Controllers", 0};
3156 static const JSClass XULControllersShimClass = {"XULControllers", 0};
3157 #endif
3158
3159 bool nsGlobalWindowInner::DoResolve(
3160     JSContext* aCx, JS::Handle<JSObject*> aObj, JS::Handle<jsid> aId,
3161     JS::MutableHandle<mozilla::Maybe<JS::PropertyDescriptor>> aDesc) {
3162   // Note: Keep this in sync with MayResolve.
3163
3164   // Note: The infallibleInit call in GlobalResolve depends on this check.
3165   if (!aId.isString()) {
3166     return true;
3167   }
3168
3169   bool found;
3170   if (!WebIDLGlobalNameHash::DefineIfEnabled(aCx, aObj, aId, aDesc, &found)) {
3171     return false;
3172   }
3173
3174   if (found) {
3175     return true;
3176   }
3177
3178   // We support a cut-down Components.interfaces in case websites are
3179   // using Components.interfaces.nsIFoo.CONSTANT_NAME for the ones
3180   // that have constants.
3181   if (StaticPrefs::dom_use_components_shim() &&
3182       aId == XPCJSRuntime::Get()->GetStringID(XPCJSContext::IDX_COMPONENTS)) {
3183     return ResolveComponentsShim(aCx, aObj, aDesc);
3184   }
3185
3186   // We also support a "window.controllers" thing; apparently some
3187   // sites use it for browser-sniffing.  See bug 1010577.
3188 #ifdef USE_CONTROLLERS_SHIM
3189   // Note: We use |aObj| rather than |this| to get the principal here, because
3190   // this is called during Window setup when the Document isn't necessarily
3191   // hooked up yet.
3192   if ((aId == XPCJSRuntime::Get()->GetStringID(XPCJSContext::IDX_CONTROLLERS) ||
3193        aId == XPCJSRuntime::Get()->GetStringID(
3194                   XPCJSContext::IDX_CONTROLLERS_CLASS)) &&
3195       !xpc::IsXrayWrapper(aObj) &&
3196       !nsContentUtils::ObjectPrincipal(aObj)->IsSystemPrincipal()) {
3197     if (GetExtantDoc()) {
3198       GetExtantDoc()->WarnOnceAbout(
3199           DeprecatedOperations::eWindow_Cc_ontrollers);
3200     }
3201     const JSClass* clazz;
3202     if (aId ==
3203         XPCJSRuntime::Get()->GetStringID(XPCJSContext::IDX_CONTROLLERS)) {
3204       clazz = &XULControllersShimClass;
3205     } else {
3206       clazz = &ControllersShimClass;
3207     }
3208     MOZ_ASSERT(JS_IsGlobalObject(aObj));
3209     JS::Rooted<JSObject*> shim(aCx, JS_NewObject(aCx, clazz));
3210     if (NS_WARN_IF(!shim)) {
3211       return false;
3212     }
3213
3214     aDesc.set(mozilla::Some(JS::PropertyDescriptor::Data(
3215         JS::ObjectValue(*shim),
3216         {JS::PropertyAttribute::Configurable, JS::PropertyAttribute::Enumerable,
3217          JS::PropertyAttribute::Writable})));
3218     return true;
3219   }
3220 #endif
3221
3222   return true;
3223 }
3224
3225 /* static */
3226 bool nsGlobalWindowInner::MayResolve(jsid aId) {
3227   // Note: This function does not fail and may not have any side-effects.
3228   // Note: Keep this in sync with DoResolve.
3229   if (!aId.isString()) {
3230     return false;
3231   }
3232
3233   if (aId == XPCJSRuntime::Get()->GetStringID(XPCJSContext::IDX_COMPONENTS)) {
3234     return true;
3235   }
3236
3237   if (aId == XPCJSRuntime::Get()->GetStringID(XPCJSContext::IDX_CONTROLLERS) ||
3238       aId == XPCJSRuntime::Get()->GetStringID(
3239                  XPCJSContext::IDX_CONTROLLERS_CLASS)) {
3240     // We only resolve .controllers/.Controllers in release builds and on
3241     // non-chrome windows, but let's not worry about any of that stuff.
3242     return true;
3243   }
3244
3245   return WebIDLGlobalNameHash::MayResolve(aId);
3246 }
3247
3248 void nsGlobalWindowInner::GetOwnPropertyNames(
3249     JSContext* aCx, JS::MutableHandleVector<jsid> aNames, bool aEnumerableOnly,
3250     ErrorResult& aRv) {
3251   if (aEnumerableOnly) {
3252     // The names we would return from here get defined on the window via one of
3253     // two codepaths.  The ones coming from the WebIDLGlobalNameHash will end up
3254     // in the DefineConstructor function in BindingUtils, which always defines
3255     // things as non-enumerable.  The ones coming from the script namespace
3256     // manager get defined by our resolve hook using FillPropertyDescriptor with
3257     // 0 for the property attributes, so non-enumerable as well.
3258     //
3259     // So in the aEnumerableOnly case we have nothing to do.
3260     return;
3261   }
3262
3263   // "Components" is marked as enumerable but only resolved on demand :-/.
3264   // aNames.AppendElement(u"Components"_ns);
3265
3266   JS::Rooted<JSObject*> wrapper(aCx, GetWrapper());
3267
3268   // There are actually two ways we can get called here: For normal
3269   // enumeration or for Xray enumeration.  In the latter case, we want to
3270   // return all possible WebIDL names, because we don't really support
3271   // deleting these names off our Xray; trying to resolve them will just make
3272   // them come back.  In the former case, we want to avoid returning deleted
3273   // names.  But the JS engine already knows about the non-deleted
3274   // already-resolved names, so we can just return the so-far-unresolved ones.
3275   //
3276   // We can tell which case we're in by whether aCx is in our wrapper's
3277   // compartment.  If not, we're in the Xray case.
3278   WebIDLGlobalNameHash::NameType nameType =
3279       js::IsObjectInContextCompartment(wrapper, aCx)
3280           ? WebIDLGlobalNameHash::UnresolvedNamesOnly
3281           : WebIDLGlobalNameHash::AllNames;
3282   if (!WebIDLGlobalNameHash::GetNames(aCx, wrapper, nameType, aNames)) {
3283     aRv.NoteJSContextException(aCx);
3284   }
3285 }
3286
3287 /* static */
3288 bool nsGlobalWindowInner::IsPrivilegedChromeWindow(JSContext*, JSObject* aObj) {
3289   // For now, have to deal with XPConnect objects here.
3290   nsGlobalWindowInner* win = xpc::WindowOrNull(aObj);
3291   return win && win->IsChromeWindow() &&
3292          nsContentUtils::ObjectPrincipal(aObj) ==
3293              nsContentUtils::GetSystemPrincipal();
3294 }
3295
3296 /* static */
3297 bool nsGlobalWindowInner::DeviceSensorsEnabled(JSContext*, JSObject*) {
3298   return Preferences::GetBool("device.sensors.enabled");
3299 }
3300
3301 /* static */
3302 bool nsGlobalWindowInner::CachesEnabled(JSContext* aCx, JSObject*) {
3303   if (!JS::GetIsSecureContext(js::GetContextRealm(aCx))) {
3304     return StaticPrefs::dom_caches_testing_enabled() ||
3305            StaticPrefs::dom_serviceWorkers_testing_enabled();
3306   }
3307   return true;
3308 }
3309
3310 /* static */
3311 bool nsGlobalWindowInner::IsSizeToContentEnabled(JSContext* aCx, JSObject*) {
3312   return StaticPrefs::dom_window_sizeToContent_enabled() ||
3313          nsContentUtils::IsSystemCaller(aCx);
3314 }
3315
3316 /* static */
3317 bool nsGlobalWindowInner::IsGleanNeeded(JSContext* aCx, JSObject* aObj) {
3318   // Glean is needed in ChromeOnly contexts and also in privileged about pages.
3319   nsIPrincipal* principal = nsContentUtils::SubjectPrincipal(aCx);
3320   if (principal->IsSystemPrincipal()) {
3321     return true;
3322   }
3323
3324   uint32_t flags = 0;
3325   if (NS_FAILED(principal->GetAboutModuleFlags(&flags))) {
3326     return false;
3327   }
3328   return flags & nsIAboutModule::IS_SECURE_CHROME_UI;
3329 }
3330
3331 Crypto* nsGlobalWindowInner::GetCrypto(ErrorResult& aError) {
3332   if (!mCrypto) {
3333     mCrypto = new Crypto(this);
3334   }
3335   return mCrypto;
3336 }
3337
3338 nsIControllers* nsGlobalWindowInner::GetControllers(ErrorResult& aError) {
3339   FORWARD_TO_OUTER_OR_THROW(GetControllersOuter, (aError), aError, nullptr);
3340 }
3341
3342 nsresult nsGlobalWindowInner::GetControllers(nsIControllers** aResult) {
3343   ErrorResult rv;
3344   nsCOMPtr<nsIControllers> controllers = GetControllers(rv);
3345   controllers.forget(aResult);
3346
3347   return rv.StealNSResult();
3348 }
3349
3350 Nullable<WindowProxyHolder> nsGlobalWindowInner::GetOpenerWindow(
3351     ErrorResult& aError) {
3352   FORWARD_TO_OUTER_OR_THROW(GetOpenerWindowOuter, (), aError, nullptr);
3353 }
3354
3355 void nsGlobalWindowInner::GetOpener(JSContext* aCx,
3356                                     JS::MutableHandle<JS::Value> aRetval,
3357                                     ErrorResult& aError) {
3358   Nullable<WindowProxyHolder> opener = GetOpenerWindow(aError);
3359   if (aError.Failed() || opener.IsNull()) {
3360     aRetval.setNull();
3361     return;
3362   }
3363
3364   if (!ToJSValue(aCx, opener.Value(), aRetval)) {
3365     aError.NoteJSContextException(aCx);
3366   }
3367 }
3368
3369 void nsGlobalWindowInner::SetOpener(JSContext* aCx,
3370                                     JS::Handle<JS::Value> aOpener,
3371                                     ErrorResult& aError) {
3372   if (aOpener.isNull()) {
3373     RefPtr<BrowsingContext> bc(GetBrowsingContext());
3374     if (!bc->IsDiscarded()) {
3375       bc->SetOpener(nullptr);
3376     }
3377     return;
3378   }
3379
3380   // If something other than null is passed, just define aOpener on our inner
3381   // window's JS object, wrapped into the current compartment so that for Xrays
3382   // we define on the Xray expando object, but don't set it on the outer window,
3383   // so that it'll get reset on navigation.  This is just like replaceable
3384   // properties, but we're not quite readonly.
3385   RedefineProperty(aCx, "opener", aOpener, aError);
3386 }
3387
3388 void nsGlobalWindowInner::GetEvent(OwningEventOrUndefined& aRetval) {
3389   if (mEvent) {
3390     aRetval.SetAsEvent() = mEvent;
3391   } else {
3392     aRetval.SetUndefined();
3393   }
3394 }
3395
3396 void nsGlobalWindowInner::GetStatus(nsAString& aStatus, ErrorResult& aError) {
3397   FORWARD_TO_OUTER_OR_THROW(GetStatusOuter, (aStatus), aError, );
3398 }
3399
3400 void nsGlobalWindowInner::SetStatus(const nsAString& aStatus,
3401                                     ErrorResult& aError) {
3402   FORWARD_TO_OUTER_OR_THROW(SetStatusOuter, (aStatus), aError, );
3403 }
3404
3405 void nsGlobalWindowInner::GetName(nsAString& aName, ErrorResult& aError) {
3406   FORWARD_TO_OUTER_OR_THROW(GetNameOuter, (aName), aError, );
3407 }
3408
3409 void nsGlobalWindowInner::SetName(const nsAString& aName,
3410                                   mozilla::ErrorResult& aError) {
3411   FORWARD_TO_OUTER_OR_THROW(SetNameOuter, (aName, aError), aError, );
3412 }
3413
3414 double nsGlobalWindowInner::GetInnerWidth(ErrorResult& aError) {
3415   FORWARD_TO_OUTER_OR_THROW(GetInnerWidthOuter, (aError), aError, 0);
3416 }
3417
3418 nsresult nsGlobalWindowInner::GetInnerWidth(double* aWidth) {
3419   ErrorResult rv;
3420   // Callee doesn't care about the caller type, but play it safe.
3421   *aWidth = GetInnerWidth(rv);
3422   return rv.StealNSResult();
3423 }
3424
3425 double nsGlobalWindowInner::GetInnerHeight(ErrorResult& aError) {
3426   // We ignore aCallerType; we only have that argument because some other things
3427   // called by GetReplaceableWindowCoord need it.  If this ever changes, fix
3428   //   nsresult nsGlobalWindowInner::GetInnerHeight(double* aInnerWidth)
3429   // to actually take a useful CallerType and pass it in here.
3430   FORWARD_TO_OUTER_OR_THROW(GetInnerHeightOuter, (aError), aError, 0);
3431 }
3432
3433 nsresult nsGlobalWindowInner::GetInnerHeight(double* aHeight) {
3434   ErrorResult rv;
3435   // Callee doesn't care about the caller type, but play it safe.
3436   *aHeight = GetInnerHeight(rv);
3437   return rv.StealNSResult();
3438 }
3439
3440 int32_t nsGlobalWindowInner::GetOuterWidth(CallerType aCallerType,
3441                                            ErrorResult& aError) {
3442   FORWARD_TO_OUTER_OR_THROW(GetOuterWidthOuter, (aCallerType, aError), aError,
3443                             0);
3444 }
3445
3446 int32_t nsGlobalWindowInner::GetOuterHeight(CallerType aCallerType,
3447                                             ErrorResult& aError) {
3448   FORWARD_TO_OUTER_OR_THROW(GetOuterHeightOuter, (aCallerType, aError), aError,
3449                             0);
3450 }
3451
3452 double nsGlobalWindowInner::ScreenEdgeSlopX() const {
3453   FORWARD_TO_OUTER(ScreenEdgeSlopX, (), 0);
3454 }
3455
3456 double nsGlobalWindowInner::ScreenEdgeSlopY() const {
3457   FORWARD_TO_OUTER(ScreenEdgeSlopY, (), 0);
3458 }
3459
3460 int32_t nsGlobalWindowInner::GetScreenX(CallerType aCallerType,
3461                                         ErrorResult& aError) {
3462   FORWARD_TO_OUTER_OR_THROW(GetScreenXOuter, (aCallerType, aError), aError, 0);
3463 }
3464
3465 int32_t nsGlobalWindowInner::GetScreenY(CallerType aCallerType,
3466                                         ErrorResult& aError) {
3467   FORWARD_TO_OUTER_OR_THROW(GetScreenYOuter, (aCallerType, aError), aError, 0);
3468 }
3469
3470 float nsGlobalWindowInner::GetMozInnerScreenX(CallerType aCallerType,
3471                                               ErrorResult& aError) {
3472   FORWARD_TO_OUTER_OR_THROW(GetMozInnerScreenXOuter, (aCallerType), aError, 0);
3473 }
3474
3475 float nsGlobalWindowInner::GetMozInnerScreenY(CallerType aCallerType,
3476                                               ErrorResult& aError) {
3477   FORWARD_TO_OUTER_OR_THROW(GetMozInnerScreenYOuter, (aCallerType), aError, 0);
3478 }
3479
3480 static nsPresContext* GetPresContextForRatio(Document* aDoc) {
3481   if (nsPresContext* presContext = aDoc->GetPresContext()) {
3482     return presContext;
3483   }
3484   // We're in an undisplayed subdocument... There's not really an awesome way
3485   // to tell what the right DPI is from here, so we try to walk up our parent
3486   // document chain to the extent that the docs can observe each other.
3487   Document* doc = aDoc;
3488   while (doc->StyleOrLayoutObservablyDependsOnParentDocumentLayout()) {
3489     doc = doc->GetInProcessParentDocument();
3490     if (nsPresContext* presContext = doc->GetPresContext()) {
3491       return presContext;
3492     }
3493   }
3494   return nullptr;
3495 }
3496
3497 double nsGlobalWindowInner::GetDevicePixelRatio(CallerType aCallerType,
3498                                                 ErrorResult& aError) {
3499   ENSURE_ACTIVE_DOCUMENT(aError, 0.0);
3500
3501   RefPtr<nsPresContext> presContext = GetPresContextForRatio(mDoc);
3502   if (NS_WARN_IF(!presContext)) {
3503     // Still nothing, oh well.
3504     return 1.0;
3505   }
3506
3507   if (nsIGlobalObject::ShouldResistFingerprinting(
3508           aCallerType, RFPTarget::WindowDevicePixelRatio)) {
3509     // Spoofing the DevicePixelRatio causes blurriness in some situations
3510     // on HiDPI displays. pdf.js is a non-system caller; but it can't
3511     // expose the fingerprintable information, so we can safely disable
3512     // spoofing in this situation. It doesn't address the issue for
3513     // web-rendered content (including pdf.js instances on the web.)
3514     // In the future we hope to have a better solution to fix all HiDPI
3515     // blurriness...
3516     nsAutoCString origin;
3517     nsresult rv = this->GetPrincipal()->GetOrigin(origin);
3518     if (NS_FAILED(rv) || origin != "resource://pdf.js"_ns) {
3519       return 1.0;
3520     }
3521   }
3522
3523   if (aCallerType == CallerType::NonSystem) {
3524     float overrideDPPX = presContext->GetOverrideDPPX();
3525     if (overrideDPPX > 0.0f) {
3526       return overrideDPPX;
3527     }
3528   }
3529
3530   return double(AppUnitsPerCSSPixel()) /
3531          double(presContext->AppUnitsPerDevPixel());
3532 }
3533
3534 double nsGlobalWindowInner::GetDesktopToDeviceScale(ErrorResult& aError) {
3535   ENSURE_ACTIVE_DOCUMENT(aError, 0.0);
3536   nsPresContext* presContext = GetPresContextForRatio(mDoc);
3537   if (!presContext) {
3538     return 1.0;
3539   }
3540   return presContext->DeviceContext()->GetDesktopToDeviceScale().scale;
3541 }
3542
3543 int32_t nsGlobalWindowInner::RequestAnimationFrame(
3544     FrameRequestCallback& aCallback, ErrorResult& aError) {
3545   if (!mDoc) {
3546     return 0;
3547   }
3548
3549   if (GetWrapperPreserveColor()) {
3550     js::NotifyAnimationActivity(GetWrapperPreserveColor());
3551   }
3552
3553   DebuggerNotificationDispatch(this,
3554                                DebuggerNotificationType::RequestAnimationFrame);
3555
3556   int32_t handle;
3557   aError = mDoc->ScheduleFrameRequestCallback(aCallback, &handle);
3558   return handle;
3559 }
3560
3561 void nsGlobalWindowInner::CancelAnimationFrame(int32_t aHandle,
3562                                                ErrorResult& aError) {
3563   if (!mDoc) {
3564     return;
3565   }
3566
3567   DebuggerNotificationDispatch(this,
3568                                DebuggerNotificationType::CancelAnimationFrame);
3569
3570   mDoc->CancelFrameRequestCallback(aHandle);
3571 }
3572
3573 already_AddRefed<MediaQueryList> nsGlobalWindowInner::MatchMedia(
3574     const nsACString& aMediaQueryList, CallerType aCallerType,
3575     ErrorResult& aError) {
3576   ENSURE_ACTIVE_DOCUMENT(aError, nullptr);
3577   return mDoc->MatchMedia(aMediaQueryList, aCallerType);
3578 }
3579
3580 int32_t nsGlobalWindowInner::GetScrollMinX(ErrorResult& aError) {
3581   FORWARD_TO_OUTER_OR_THROW(GetScrollBoundaryOuter, (eSideLeft), aError, 0);
3582 }
3583
3584 int32_t nsGlobalWindowInner::GetScrollMinY(ErrorResult& aError) {
3585   FORWARD_TO_OUTER_OR_THROW(GetScrollBoundaryOuter, (eSideTop), aError, 0);
3586 }
3587
3588 int32_t nsGlobalWindowInner::GetScrollMaxX(ErrorResult& aError) {
3589   FORWARD_TO_OUTER_OR_THROW(GetScrollBoundaryOuter, (eSideRight), aError, 0);
3590 }
3591
3592 int32_t nsGlobalWindowInner::GetScrollMaxY(ErrorResult& aError) {
3593   FORWARD_TO_OUTER_OR_THROW(GetScrollBoundaryOuter, (eSideBottom), aError, 0);
3594 }
3595
3596 double nsGlobalWindowInner::GetScrollX(ErrorResult& aError) {
3597   FORWARD_TO_OUTER_OR_THROW(GetScrollXOuter, (), aError, 0);
3598 }
3599
3600 double nsGlobalWindowInner::GetScrollY(ErrorResult& aError) {
3601   FORWARD_TO_OUTER_OR_THROW(GetScrollYOuter, (), aError, 0);
3602 }
3603
3604 uint32_t nsGlobalWindowInner::Length() { FORWARD_TO_OUTER(Length, (), 0); }
3605
3606 Nullable<WindowProxyHolder> nsGlobalWindowInner::GetTop(
3607     mozilla::ErrorResult& aError) {
3608   FORWARD_TO_OUTER_OR_THROW(GetTopOuter, (), aError, nullptr);
3609 }
3610
3611 already_AddRefed<BrowsingContext> nsGlobalWindowInner::GetChildWindow(
3612     const nsAString& aName) {
3613   if (GetOuterWindowInternal()) {
3614     return GetOuterWindowInternal()->GetChildWindow(aName);
3615   }
3616   return nullptr;
3617 }
3618
3619 void nsGlobalWindowInner::RefreshRealmPrincipal() {
3620   JS::SetRealmPrincipals(js::GetNonCCWObjectRealm(GetWrapperPreserveColor()),
3621                          nsJSPrincipals::get(mDoc->NodePrincipal()));
3622 }
3623
3624 already_AddRefed<nsIWidget> nsGlobalWindowInner::GetMainWidget() {
3625   FORWARD_TO_OUTER(GetMainWidget, (), nullptr);
3626 }
3627
3628 nsIWidget* nsGlobalWindowInner::GetNearestWidget() const {
3629   if (GetOuterWindowInternal()) {
3630     return GetOuterWindowInternal()->GetNearestWidget();
3631   }
3632   return nullptr;
3633 }
3634
3635 void nsGlobalWindowInner::SetFullScreen(bool aFullscreen,
3636                                         mozilla::ErrorResult& aError) {
3637   FORWARD_TO_OUTER_OR_THROW(SetFullscreenOuter, (aFullscreen, aError), aError,
3638                             /* void */);
3639 }
3640
3641 bool nsGlobalWindowInner::GetFullScreen(ErrorResult& aError) {
3642   FORWARD_TO_OUTER_OR_THROW(GetFullscreenOuter, (), aError, false);
3643 }
3644
3645 bool nsGlobalWindowInner::GetFullScreen() {
3646   ErrorResult dummy;
3647   bool fullscreen = GetFullScreen(dummy);
3648   dummy.SuppressException();
3649   return fullscreen;
3650 }
3651
3652 void nsGlobalWindowInner::Dump(const nsAString& aStr) {
3653   if (!nsJSUtils::DumpEnabled()) {
3654     return;
3655   }
3656
3657   char* cstr = ToNewUTF8String(aStr);
3658
3659 #if defined(XP_MACOSX)
3660   // have to convert \r to \n so that printing to the console works
3661   char *c = cstr, *cEnd = cstr + strlen(cstr);
3662   while (c < cEnd) {
3663     if (*c == '\r') *c = '\n';
3664     c++;
3665   }
3666 #endif
3667
3668   if (cstr) {
3669     MOZ_LOG(nsContentUtils::DOMDumpLog(), LogLevel::Debug,
3670             ("[Window.Dump] %s", cstr));
3671 #ifdef XP_WIN
3672     PrintToDebugger(cstr);
3673 #endif
3674 #ifdef ANDROID
3675     __android_log_write(ANDROID_LOG_INFO, "GeckoDump", cstr);
3676 #endif
3677     FILE* fp = gDumpFile ? gDumpFile : stdout;
3678     fputs(cstr, fp);
3679     fflush(fp);
3680     free(cstr);
3681   }
3682 }
3683
3684 void nsGlobalWindowInner::Alert(nsIPrincipal& aSubjectPrincipal,
3685                                 ErrorResult& aError) {
3686   Alert(u""_ns, aSubjectPrincipal, aError);
3687 }
3688
3689 void nsGlobalWindowInner::Alert(const nsAString& aMessage,
3690                                 nsIPrincipal& aSubjectPrincipal,
3691                                 ErrorResult& aError) {
3692   FORWARD_TO_OUTER_OR_THROW(AlertOuter, (aMessage, aSubjectPrincipal, aError),
3693                             aError, );
3694 }
3695
3696 bool nsGlobalWindowInner::Confirm(const nsAString& aMessage,
3697                                   nsIPrincipal& aSubjectPrincipal,
3698                                   ErrorResult& aError) {
3699   FORWARD_TO_OUTER_OR_THROW(ConfirmOuter, (aMessage, aSubjectPrincipal, aError),
3700                             aError, false);
3701 }
3702
3703 already_AddRefed<Promise> nsGlobalWindowInner::Fetch(
3704     const RequestOrUSVString& aInput, const RequestInit& aInit,
3705     CallerType aCallerType, ErrorResult& aRv) {
3706   return FetchRequest(this, aInput, aInit, aCallerType, aRv);
3707 }
3708
3709 void nsGlobalWindowInner::Prompt(const nsAString& aMessage,
3710                                  const nsAString& aInitial, nsAString& aReturn,
3711                                  nsIPrincipal& aSubjectPrincipal,
3712                                  ErrorResult& aError) {
3713   FORWARD_TO_OUTER_OR_THROW(
3714       PromptOuter, (aMessage, aInitial, aReturn, aSubjectPrincipal, aError),
3715       aError, );
3716 }
3717
3718 void nsGlobalWindowInner::Focus(CallerType aCallerType, ErrorResult& aError) {
3719   FORWARD_TO_OUTER_OR_THROW(FocusOuter,
3720                             (aCallerType, /* aFromOtherProcess */ false,
3721                              nsFocusManager::GenerateFocusActionId()),
3722                             aError, );
3723 }
3724
3725 nsresult nsGlobalWindowInner::Focus(CallerType aCallerType) {
3726   ErrorResult rv;
3727   Focus(aCallerType, rv);
3728
3729   return rv.StealNSResult();
3730 }
3731
3732 void nsGlobalWindowInner::Blur(CallerType aCallerType, ErrorResult& aError) {
3733   FORWARD_TO_OUTER_OR_THROW(BlurOuter, (aCallerType), aError, );
3734 }
3735
3736 void nsGlobalWindowInner::Stop(ErrorResult& aError) {
3737   FORWARD_TO_OUTER_OR_THROW(StopOuter, (aError), aError, );
3738 }
3739
3740 void nsGlobalWindowInner::Print(ErrorResult& aError) {
3741   FORWARD_TO_OUTER_OR_THROW(PrintOuter, (aError), aError, );
3742 }
3743
3744 Nullable<WindowProxyHolder> nsGlobalWindowInner::PrintPreview(
3745     nsIPrintSettings* aSettings, nsIWebProgressListener* aListener,
3746     nsIDocShell* aDocShellToCloneInto, ErrorResult& aError) {
3747   FORWARD_TO_OUTER_OR_THROW(
3748       Print,
3749       (aSettings,
3750        /* aRemotePrintJob = */ nullptr, aListener, aDocShellToCloneInto,
3751        nsGlobalWindowOuter::IsPreview::Yes,
3752        nsGlobalWindowOuter::IsForWindowDotPrint::No,
3753        /* aPrintPreviewCallback = */ nullptr, aError),
3754       aError, nullptr);
3755 }
3756
3757 void nsGlobalWindowInner::MoveTo(int32_t aXPos, int32_t aYPos,
3758                                  CallerType aCallerType, ErrorResult& aError) {
3759   FORWARD_TO_OUTER_OR_THROW(MoveToOuter, (aXPos, aYPos, aCallerType, aError),
3760                             aError, );
3761 }
3762
3763 void nsGlobalWindowInner::MoveBy(int32_t aXDif, int32_t aYDif,
3764                                  CallerType aCallerType, ErrorResult& aError) {
3765   FORWARD_TO_OUTER_OR_THROW(MoveByOuter, (aXDif, aYDif, aCallerType, aError),
3766                             aError, );
3767 }
3768
3769 void nsGlobalWindowInner::ResizeTo(int32_t aWidth, int32_t aHeight,
3770                                    CallerType aCallerType,
3771                                    ErrorResult& aError) {
3772   FORWARD_TO_OUTER_OR_THROW(ResizeToOuter,
3773                             (aWidth, aHeight, aCallerType, aError), aError, );
3774 }
3775
3776 void nsGlobalWindowInner::ResizeBy(int32_t aWidthDif, int32_t aHeightDif,
3777                                    CallerType aCallerType,
3778                                    ErrorResult& aError) {
3779   FORWARD_TO_OUTER_OR_THROW(
3780       ResizeByOuter, (aWidthDif, aHeightDif, aCallerType, aError), aError, );
3781 }
3782
3783 void nsGlobalWindowInner::SizeToContent(CallerType aCallerType,
3784                                         ErrorResult& aError) {
3785   FORWARD_TO_OUTER_OR_THROW(SizeToContentOuter, (aCallerType, {}, aError),
3786                             aError, );
3787 }
3788
3789 void nsGlobalWindowInner::SizeToContentConstrained(
3790     const SizeToContentConstraints& aConstraints, ErrorResult& aError) {
3791   FORWARD_TO_OUTER_OR_THROW(
3792       SizeToContentOuter, (CallerType::System, aConstraints, aError), aError, );
3793 }
3794
3795 already_AddRefed<nsPIWindowRoot> nsGlobalWindowInner::GetTopWindowRoot() {
3796   nsGlobalWindowOuter* outer = GetOuterWindowInternal();
3797   if (!outer) {
3798     return nullptr;
3799   }
3800   return outer->GetTopWindowRoot();
3801 }
3802
3803 void nsGlobalWindowInner::Scroll(double aXScroll, double aYScroll) {
3804   // Convert -Inf, Inf, and NaN to 0; otherwise, convert by C-style cast.
3805   auto scrollPos = CSSIntPoint::Truncate(mozilla::ToZeroIfNonfinite(aXScroll),
3806                                          mozilla::ToZeroIfNonfinite(aYScroll));
3807   ScrollTo(scrollPos, ScrollOptions());
3808 }
3809
3810 void nsGlobalWindowInner::ScrollTo(double aXScroll, double aYScroll) {
3811   // Convert -Inf, Inf, and NaN to 0; otherwise, convert by C-style cast.
3812   auto scrollPos = CSSIntPoint::Truncate(mozilla::ToZeroIfNonfinite(aXScroll),
3813                                          mozilla::ToZeroIfNonfinite(aYScroll));
3814   ScrollTo(scrollPos, ScrollOptions());
3815 }
3816
3817 void nsGlobalWindowInner::ScrollTo(const ScrollToOptions& aOptions) {
3818   // When scrolling to a non-zero offset, we need to determine whether that
3819   // position is within our scrollable range, so we need updated layout
3820   // information which requires a layout flush, otherwise all we need is to
3821   // flush frames to be able to access our scrollable frame here.
3822   FlushType flushType =
3823       ((aOptions.mLeft.WasPassed() && aOptions.mLeft.Value() > 0) ||
3824        (aOptions.mTop.WasPassed() && aOptions.mTop.Value() > 0))
3825           ? FlushType::Layout
3826           : FlushType::Frames;
3827   FlushPendingNotifications(flushType);
3828   nsIScrollableFrame* sf = GetScrollFrame();
3829
3830   if (sf) {
3831     CSSIntPoint scrollPos = sf->GetScrollPositionCSSPixels();
3832     if (aOptions.mLeft.WasPassed()) {
3833       scrollPos.x = static_cast<int32_t>(
3834           mozilla::ToZeroIfNonfinite(aOptions.mLeft.Value()));
3835     }
3836     if (aOptions.mTop.WasPassed()) {
3837       scrollPos.y = static_cast<int32_t>(
3838           mozilla::ToZeroIfNonfinite(aOptions.mTop.Value()));
3839     }
3840
3841     ScrollTo(scrollPos, aOptions);
3842   }
3843 }
3844
3845 void nsGlobalWindowInner::Scroll(const ScrollToOptions& aOptions) {
3846   ScrollTo(aOptions);
3847 }
3848
3849 void nsGlobalWindowInner::ScrollTo(const CSSIntPoint& aScroll,
3850                                    const ScrollOptions& aOptions) {
3851   // When scrolling to a non-zero offset, we need to determine whether that
3852   // position is within our scrollable range, so we need updated layout
3853   // information which requires a layout flush, otherwise all we need is to
3854   // flush frames to be able to access our scrollable frame here.
3855   FlushType flushType =
3856       (aScroll.x || aScroll.y) ? FlushType::Layout : FlushType::Frames;
3857   FlushPendingNotifications(flushType);
3858   nsIScrollableFrame* sf = GetScrollFrame();
3859
3860   if (sf) {
3861     // Here we calculate what the max pixel value is that we can
3862     // scroll to, we do this by dividing maxint with the pixel to
3863     // twips conversion factor, and subtracting 4, the 4 comes from
3864     // experimenting with this value, anything less makes the view
3865     // code not scroll correctly, I have no idea why. -- jst
3866     const int32_t maxpx = nsPresContext::AppUnitsToIntCSSPixels(0x7fffffff) - 4;
3867
3868     CSSIntPoint scroll(aScroll);
3869     if (scroll.x > maxpx) {
3870       scroll.x = maxpx;
3871     }
3872
3873     if (scroll.y > maxpx) {
3874       scroll.y = maxpx;
3875     }
3876
3877     ScrollMode scrollMode = sf->IsSmoothScroll(aOptions.mBehavior)
3878                                 ? ScrollMode::SmoothMsd
3879                                 : ScrollMode::Instant;
3880
3881     sf->ScrollToCSSPixels(scroll, scrollMode);
3882   }
3883 }
3884
3885 void nsGlobalWindowInner::ScrollBy(double aXScrollDif, double aYScrollDif) {
3886   FlushPendingNotifications(FlushType::Layout);
3887   nsIScrollableFrame* sf = GetScrollFrame();
3888
3889   if (sf) {
3890     // It seems like it would make more sense for ScrollBy to use
3891     // SMOOTH mode, but tests seem to depend on the synchronous behaviour.
3892     // Perhaps Web content does too.
3893     ScrollToOptions options;
3894     options.mLeft.Construct(aXScrollDif);
3895     options.mTop.Construct(aYScrollDif);
3896     ScrollBy(options);
3897   }
3898 }
3899
3900 void nsGlobalWindowInner::ScrollBy(const ScrollToOptions& aOptions) {
3901   FlushPendingNotifications(FlushType::Layout);
3902   nsIScrollableFrame* sf = GetScrollFrame();
3903
3904   if (sf) {
3905     CSSIntPoint scrollDelta;
3906     if (aOptions.mLeft.WasPassed()) {
3907       scrollDelta.x = static_cast<int32_t>(
3908           mozilla::ToZeroIfNonfinite(aOptions.mLeft.Value()));
3909     }
3910     if (aOptions.mTop.WasPassed()) {
3911       scrollDelta.y = static_cast<int32_t>(
3912           mozilla::ToZeroIfNonfinite(aOptions.mTop.Value()));
3913     }
3914
3915     ScrollMode scrollMode = sf->IsSmoothScroll(aOptions.mBehavior)
3916                                 ? ScrollMode::SmoothMsd
3917                                 : ScrollMode::Instant;
3918
3919     sf->ScrollByCSSPixels(scrollDelta, scrollMode);
3920   }
3921 }
3922
3923 void nsGlobalWindowInner::ScrollByLines(int32_t numLines,
3924                                         const ScrollOptions& aOptions) {
3925   FlushPendingNotifications(FlushType::Layout);
3926   nsIScrollableFrame* sf = GetScrollFrame();
3927   if (sf) {
3928     // It seems like it would make more sense for ScrollByLines to use
3929     // SMOOTH mode, but tests seem to depend on the synchronous behaviour.
3930     // Perhaps Web content does too.
3931     ScrollMode scrollMode = sf->IsSmoothScroll(aOptions.mBehavior)
3932                                 ? ScrollMode::SmoothMsd
3933                                 : ScrollMode::Instant;
3934
3935     sf->ScrollBy(nsIntPoint(0, numLines), ScrollUnit::LINES, scrollMode);
3936   }
3937 }
3938
3939 void nsGlobalWindowInner::ScrollByPages(int32_t numPages,
3940                                         const ScrollOptions& aOptions) {
3941   FlushPendingNotifications(FlushType::Layout);
3942   nsIScrollableFrame* sf = GetScrollFrame();
3943   if (sf) {
3944     // It seems like it would make more sense for ScrollByPages to use
3945     // SMOOTH mode, but tests seem to depend on the synchronous behaviour.
3946     // Perhaps Web content does too.
3947     ScrollMode scrollMode = sf->IsSmoothScroll(aOptions.mBehavior)
3948                                 ? ScrollMode::SmoothMsd
3949                                 : ScrollMode::Instant;
3950
3951     sf->ScrollBy(nsIntPoint(0, numPages), ScrollUnit::PAGES, scrollMode);
3952   }
3953 }
3954
3955 void nsGlobalWindowInner::MozScrollSnap() {
3956   FlushPendingNotifications(FlushType::Layout);
3957   nsIScrollableFrame* sf = GetScrollFrame();
3958   if (sf) {
3959     sf->ScrollSnap();
3960   }
3961 }
3962
3963 void nsGlobalWindowInner::ClearTimeout(int32_t aHandle) {
3964   DebuggerNotificationDispatch(this, DebuggerNotificationType::ClearTimeout);
3965
3966   if (aHandle > 0) {
3967     mTimeoutManager->ClearTimeout(aHandle, Timeout::Reason::eTimeoutOrInterval);
3968   }
3969 }
3970
3971 void nsGlobalWindowInner::ClearInterval(int32_t aHandle) {
3972   DebuggerNotificationDispatch(this, DebuggerNotificationType::ClearInterval);
3973
3974   if (aHandle > 0) {
3975     mTimeoutManager->ClearTimeout(aHandle, Timeout::Reason::eTimeoutOrInterval);
3976   }
3977 }
3978
3979 void nsGlobalWindowInner::SetResizable(bool aResizable) const {
3980   // nop
3981 }
3982
3983 void nsGlobalWindowInner::CaptureEvents() {
3984   if (mDoc) {
3985     mDoc->WarnOnceAbout(DeprecatedOperations::eUseOfCaptureEvents);
3986   }
3987 }
3988
3989 void nsGlobalWindowInner::ReleaseEvents() {
3990   if (mDoc) {
3991     mDoc->WarnOnceAbout(DeprecatedOperations::eUseOfReleaseEvents);
3992   }
3993 }
3994
3995 Nullable<WindowProxyHolder> nsGlobalWindowInner::Open(const nsAString& aUrl,
3996                                                       const nsAString& aName,
3997                                                       const nsAString& aOptions,
3998                                                       ErrorResult& aError) {
3999   FORWARD_TO_OUTER_OR_THROW(OpenOuter, (aUrl, aName, aOptions, aError), aError,
4000                             nullptr);
4001 }
4002
4003 Nullable<WindowProxyHolder> nsGlobalWindowInner::OpenDialog(
4004     JSContext* aCx, const nsAString& aUrl, const nsAString& aName,
4005     const nsAString& aOptions, const Sequence<JS::Value>& aExtraArgument,
4006     ErrorResult& aError) {
4007   FORWARD_TO_OUTER_OR_THROW(
4008       OpenDialogOuter, (aCx, aUrl, aName, aOptions, aExtraArgument, aError),
4009       aError, nullptr);
4010 }
4011
4012 WindowProxyHolder nsGlobalWindowInner::GetFrames(ErrorResult& aError) {
4013   FORWARD_TO_OUTER_OR_THROW(GetFramesOuter, (), aError, Window());
4014 }
4015
4016 void nsGlobalWindowInner::PostMessageMoz(JSContext* aCx,
4017                                          JS::Handle<JS::Value> aMessage,
4018                                          const nsAString& aTargetOrigin,
4019                                          JS::Handle<JS::Value> aTransfer,
4020                                          nsIPrincipal& aSubjectPrincipal,
4021                                          ErrorResult& aError) {
4022   FORWARD_TO_OUTER_OR_THROW(
4023       PostMessageMozOuter,
4024       (aCx, aMessage, aTargetOrigin, aTransfer, aSubjectPrincipal, aError),
4025       aError, );
4026 }
4027
4028 void nsGlobalWindowInner::PostMessageMoz(JSContext* aCx,
4029                                          JS::Handle<JS::Value> aMessage,
4030                                          const nsAString& aTargetOrigin,
4031                                          const Sequence<JSObject*>& aTransfer,
4032                                          nsIPrincipal& aSubjectPrincipal,
4033                                          ErrorResult& aRv) {
4034   JS::Rooted<JS::Value> transferArray(aCx, JS::UndefinedValue());
4035
4036   aRv = nsContentUtils::CreateJSValueFromSequenceOfObject(aCx, aTransfer,
4037                                                           &transferArray);
4038   if (NS_WARN_IF(aRv.Failed())) {
4039     return;
4040   }
4041
4042   PostMessageMoz(aCx, aMessage, aTargetOrigin, transferArray, aSubjectPrincipal,
4043                  aRv);
4044 }
4045
4046 void nsGlobalWindowInner::PostMessageMoz(
4047     JSContext* aCx, JS::Handle<JS::Value> aMessage,
4048     const WindowPostMessageOptions& aOptions, nsIPrincipal& aSubjectPrincipal,
4049     ErrorResult& aRv) {
4050   JS::Rooted<JS::Value> transferArray(aCx, JS::UndefinedValue());
4051
4052   aRv = nsContentUtils::CreateJSValueFromSequenceOfObject(
4053       aCx, aOptions.mTransfer, &transferArray);
4054   if (NS_WARN_IF(aRv.Failed())) {
4055     return;
4056   }
4057
4058   PostMessageMoz(aCx, aMessage, aOptions.mTargetOrigin, transferArray,
4059                  aSubjectPrincipal, aRv);
4060 }
4061
4062 void nsGlobalWindowInner::Close(CallerType aCallerType, ErrorResult& aError) {
4063   FORWARD_TO_OUTER_OR_THROW(CloseOuter, (aCallerType == CallerType::System),
4064                             aError, );
4065 }
4066
4067 nsresult nsGlobalWindowInner::Close() {
4068   FORWARD_TO_OUTER(Close, (), NS_ERROR_UNEXPECTED);
4069 }
4070
4071 bool nsGlobalWindowInner::IsInModalState() {
4072   FORWARD_TO_OUTER(IsInModalState, (), false);
4073 }
4074
4075 // static
4076 void nsGlobalWindowInner::NotifyDOMWindowDestroyed(
4077     nsGlobalWindowInner* aWindow) {
4078   nsCOMPtr<nsIObserverService> observerService = services::GetObserverService();
4079   if (observerService) {
4080     observerService->NotifyObservers(ToSupports(aWindow),
4081                                      DOM_WINDOW_DESTROYED_TOPIC, nullptr);
4082   }
4083 }
4084
4085 void nsGlobalWindowInner::NotifyWindowIDDestroyed(const char* aTopic) {
4086   nsCOMPtr<nsIRunnable> runnable =
4087       new WindowDestroyedEvent(this, mWindowID, aTopic);
4088   Dispatch(runnable.forget());
4089 }
4090
4091 // static
4092 void nsGlobalWindowInner::NotifyDOMWindowFrozen(nsGlobalWindowInner* aWindow) {
4093   if (aWindow) {
4094     nsCOMPtr<nsIObserverService> observerService =
4095         services::GetObserverService();
4096     if (observerService) {
4097       observerService->NotifyObservers(ToSupports(aWindow),
4098                                        DOM_WINDOW_FROZEN_TOPIC, nullptr);
4099     }
4100   }
4101 }
4102
4103 // static
4104 void nsGlobalWindowInner::NotifyDOMWindowThawed(nsGlobalWindowInner* aWindow) {
4105   if (aWindow) {
4106     nsCOMPtr<nsIObserverService> observerService =
4107         services::GetObserverService();
4108     if (observerService) {
4109       observerService->NotifyObservers(ToSupports(aWindow),
4110                                        DOM_WINDOW_THAWED_TOPIC, nullptr);
4111     }
4112   }
4113 }
4114
4115 Element* nsGlobalWindowInner::GetFrameElement(nsIPrincipal& aSubjectPrincipal,
4116                                               ErrorResult& aError) {
4117   FORWARD_TO_OUTER_OR_THROW(GetFrameElement, (aSubjectPrincipal), aError,
4118                             nullptr);
4119 }
4120
4121 Element* nsGlobalWindowInner::GetRealFrameElement(ErrorResult& aError) {
4122   FORWARD_TO_OUTER_OR_THROW(GetFrameElement, (), aError, nullptr);
4123 }
4124
4125 void nsGlobalWindowInner::UpdateCommands(const nsAString& anAction) {
4126   if (GetOuterWindowInternal()) {
4127     GetOuterWindowInternal()->UpdateCommands(anAction);
4128   }
4129 }
4130
4131 Selection* nsGlobalWindowInner::GetSelection(ErrorResult& aError) {
4132   FORWARD_TO_OUTER_OR_THROW(GetSelectionOuter, (), aError, nullptr);
4133 }
4134
4135 WebTaskScheduler* nsGlobalWindowInner::Scheduler() {
4136   if (!mWebTaskScheduler) {
4137     mWebTaskScheduler = WebTaskScheduler::CreateForMainThread(this);
4138   }
4139   MOZ_ASSERT(mWebTaskScheduler);
4140   return mWebTaskScheduler;
4141 }
4142
4143 bool nsGlobalWindowInner::Find(const nsAString& aString, bool aCaseSensitive,
4144                                bool aBackwards, bool aWrapAround,
4145                                bool aWholeWord, bool aSearchInFrames,
4146                                bool aShowDialog, ErrorResult& aError) {
4147   FORWARD_TO_OUTER_OR_THROW(FindOuter,
4148                             (aString, aCaseSensitive, aBackwards, aWrapAround,
4149                              aWholeWord, aSearchInFrames, aShowDialog, aError),
4150                             aError, false);
4151 }
4152
4153 void nsGlobalWindowInner::GetOrigin(nsAString& aOrigin) {
4154   nsContentUtils::GetWebExposedOriginSerialization(GetPrincipal(), aOrigin);
4155 }
4156
4157 // See also AutoJSAPI::ReportException
4158 void nsGlobalWindowInner::ReportError(JSContext* aCx,
4159                                       JS::Handle<JS::Value> aError,
4160                                       CallerType aCallerType,
4161                                       ErrorResult& aRv) {
4162   if (MOZ_UNLIKELY(!HasActiveDocument())) {
4163     return aRv.Throw(NS_ERROR_XPC_SECURITY_MANAGER_VETO);
4164   }
4165
4166   JS::ErrorReportBuilder jsReport(aCx);
4167   JS::ExceptionStack exnStack(aCx, aError, nullptr);
4168   if (!jsReport.init(aCx, exnStack, JS::ErrorReportBuilder::NoSideEffects)) {
4169     return aRv.NoteJSContextException(aCx);
4170   }
4171
4172   RefPtr<xpc::ErrorReport> xpcReport = new xpc::ErrorReport();
4173   bool isChrome = aCallerType == CallerType::System;
4174   xpcReport->Init(jsReport.report(), jsReport.toStringResult().c_str(),
4175                   isChrome, WindowID());
4176
4177   JS::RootingContext* rcx = JS::RootingContext::get(aCx);
4178   DispatchScriptErrorEvent(this, rcx, xpcReport, exnStack.exception(),
4179                            exnStack.stack());
4180 }
4181
4182 void nsGlobalWindowInner::Atob(const nsAString& aAsciiBase64String,
4183                                nsAString& aBinaryData, ErrorResult& aError) {
4184   aError = nsContentUtils::Atob(aAsciiBase64String, aBinaryData);
4185 }
4186
4187 void nsGlobalWindowInner::Btoa(const nsAString& aBinaryData,
4188                                nsAString& aAsciiBase64String,
4189                                ErrorResult& aError) {
4190   aError = nsContentUtils::Btoa(aBinaryData, aAsciiBase64String);
4191 }
4192
4193 //*****************************************************************************
4194 // EventTarget
4195 //*****************************************************************************
4196
4197 nsPIDOMWindowOuter* nsGlobalWindowInner::GetOwnerGlobalForBindingsInternal() {
4198   return nsPIDOMWindowOuter::GetFromCurrentInner(this);
4199 }
4200
4201 bool nsGlobalWindowInner::DispatchEvent(Event& aEvent, CallerType aCallerType,
4202                                         ErrorResult& aRv) {
4203   if (!IsCurrentInnerWindow()) {
4204     NS_WARNING(
4205         "DispatchEvent called on non-current inner window, dropping. "
4206         "Please check the window in the caller instead.");
4207     aRv.Throw(NS_ERROR_FAILURE);
4208     return false;
4209   }
4210
4211   if (!mDoc) {
4212     aRv.Throw(NS_ERROR_FAILURE);
4213     return false;
4214   }
4215
4216   // Obtain a presentation shell
4217   RefPtr<nsPresContext> presContext = mDoc->GetPresContext();
4218
4219   nsEventStatus status = nsEventStatus_eIgnore;
4220   nsresult rv = EventDispatcher::DispatchDOMEvent(this, nullptr, &aEvent,
4221                                                   presContext, &status);
4222   bool retval = !aEvent.DefaultPrevented(aCallerType);
4223   if (NS_FAILED(rv)) {
4224     aRv.Throw(rv);
4225   }
4226   return retval;
4227 }
4228
4229 mozilla::Maybe<mozilla::dom::EventCallbackDebuggerNotificationType>
4230 nsGlobalWindowInner::GetDebuggerNotificationType() const {
4231   return mozilla::Some(
4232       mozilla::dom::EventCallbackDebuggerNotificationType::Global);
4233 }
4234
4235 bool nsGlobalWindowInner::ComputeDefaultWantsUntrusted(ErrorResult& aRv) {
4236   return !nsContentUtils::IsChromeDoc(mDoc);
4237 }
4238
4239 EventListenerManager* nsGlobalWindowInner::GetOrCreateListenerManager() {
4240   if (!mListenerManager) {
4241     mListenerManager =
4242         new EventListenerManager(static_cast<EventTarget*>(this));
4243   }
4244
4245   return mListenerManager;
4246 }
4247
4248 EventListenerManager* nsGlobalWindowInner::GetExistingListenerManager() const {
4249   return mListenerManager;
4250 }
4251
4252 mozilla::dom::DebuggerNotificationManager*
4253 nsGlobalWindowInner::GetOrCreateDebuggerNotificationManager() {
4254   if (!mDebuggerNotificationManager) {
4255     mDebuggerNotificationManager = new DebuggerNotificationManager(this);
4256   }
4257
4258   return mDebuggerNotificationManager;
4259 }
4260
4261 mozilla::dom::DebuggerNotificationManager*
4262 nsGlobalWindowInner::GetExistingDebuggerNotificationManager() {
4263   return mDebuggerNotificationManager;
4264 }
4265
4266 //*****************************************************************************
4267 // nsGlobalWindowInner::nsPIDOMWindow
4268 //*****************************************************************************
4269
4270 Location* nsGlobalWindowInner::Location() {
4271   if (!mLocation) {
4272     mLocation = new dom::Location(this);
4273   }
4274
4275   return mLocation;
4276 }
4277
4278 void nsGlobalWindowInner::MaybeUpdateTouchState() {
4279   if (mMayHaveTouchEventListener) {
4280     nsCOMPtr<nsIObserverService> observerService =
4281         services::GetObserverService();
4282
4283     if (observerService) {
4284       observerService->NotifyObservers(static_cast<nsIDOMWindow*>(this),
4285                                        DOM_TOUCH_LISTENER_ADDED, nullptr);
4286     }
4287   }
4288 }
4289
4290 void nsGlobalWindowInner::EnableGamepadUpdates() {
4291   if (mHasGamepad) {
4292     RefPtr<GamepadManager> gamepadManager(GamepadManager::GetService());
4293     if (gamepadManager) {
4294       gamepadManager->AddListener(this);
4295     }
4296   }
4297 }
4298
4299 void nsGlobalWindowInner::DisableGamepadUpdates() {
4300   if (mHasGamepad) {
4301     RefPtr<GamepadManager> gamepadManager(GamepadManager::GetService());
4302     if (gamepadManager) {
4303       gamepadManager->RemoveListener(this);
4304     }
4305   }
4306 }
4307
4308 void nsGlobalWindowInner::EnableVRUpdates() {
4309   // We need to create a VREventObserver before we can either detect XR runtimes
4310   // or start an XR session
4311   if (!mVREventObserver && (mHasXRSession || mXRRuntimeDetectionInFlight)) {
4312     // Assert that we are not creating the observer while IsDying() as
4313     // that would result in a leak.  VREventObserver holds a RefPtr to
4314     // this nsGlobalWindowInner and would prevent it from being deallocated.
4315     MOZ_ASSERT(!IsDying(),
4316                "Creating a VREventObserver for an nsGlobalWindow that is "
4317                "dying would cause it to leak.");
4318     mVREventObserver = new VREventObserver(this);
4319   }
4320   // If the content has an XR session, then we need to tell
4321   // VREventObserver that there is VR activity.
4322   if (mHasXRSession) {
4323     nsPIDOMWindowOuter* outer = GetOuterWindow();
4324     if (outer && !outer->IsBackground()) {
4325       StartVRActivity();
4326     }
4327   }
4328 }
4329
4330 void nsGlobalWindowInner::DisableVRUpdates() {
4331   if (mVREventObserver) {
4332     mVREventObserver->DisconnectFromOwner();
4333     mVREventObserver = nullptr;
4334   }
4335 }
4336
4337 void nsGlobalWindowInner::ResetVRTelemetry(bool aUpdate) {
4338   if (mVREventObserver) {
4339     mVREventObserver->UpdateSpentTimeIn2DTelemetry(aUpdate);
4340   }
4341 }
4342
4343 void nsGlobalWindowInner::StartVRActivity() {
4344   /**
4345    * If the content has an XR session, tell
4346    * the VREventObserver that the window is accessing
4347    * VR devices.
4348    *
4349    * It's possible to have a VREventObserver without
4350    * and XR session, if we are using it to get updates
4351    * about XR runtime enumeration.  In this case,
4352    * we would not tell the VREventObserver that
4353    * we are accessing VR devices.
4354    */
4355   if (mVREventObserver && mHasXRSession) {
4356     mVREventObserver->StartActivity();
4357   }
4358 }
4359
4360 void nsGlobalWindowInner::StopVRActivity() {
4361   /**
4362    * If the content has an XR session, tell
4363    * the VReventObserver that the window is no longer
4364    * accessing VR devices.  This does not stop the
4365    * XR session itself, which may be resumed with
4366    * EnableVRUpdates.
4367    * It's possible to have a VREventObserver without
4368    * and XR session, if we are using it to get updates
4369    * about XR runtime enumeration.  In this case,
4370    * we would not tell the VREventObserver that
4371    * we ending an activity that accesses VR devices.
4372    */
4373   if (mVREventObserver && mHasXRSession) {
4374     mVREventObserver->StopActivity();
4375   }
4376 }
4377
4378 void nsGlobalWindowInner::SetFocusedElement(Element* aElement,
4379                                             uint32_t aFocusMethod,
4380                                             bool aNeedsFocus) {
4381   if (aElement && aElement->GetComposedDoc() != mDoc) {
4382     NS_WARNING("Trying to set focus to a node from a wrong document");
4383     return;
4384   }
4385
4386   if (IsDying()) {
4387     NS_ASSERTION(!aElement, "Trying to focus cleaned up window!");
4388     aElement = nullptr;
4389     aNeedsFocus = false;
4390   }
4391   if (mFocusedElement != aElement) {
4392     UpdateCanvasFocus(false, aElement);
4393     mFocusedElement = aElement;
4394     // TODO: Maybe this should be set on refocus too?
4395     mFocusMethod = aFocusMethod & nsIFocusManager::METHOD_MASK;
4396   }
4397
4398   if (mFocusedElement) {
4399     // if a node was focused by a keypress, turn on focus rings for the
4400     // window.
4401     if (mFocusMethod & nsIFocusManager::FLAG_BYKEY) {
4402       mUnknownFocusMethodShouldShowOutline = true;
4403       mFocusByKeyOccurred = true;
4404     } else if (nsFocusManager::GetFocusMoveActionCause(mFocusMethod) !=
4405                widget::InputContextAction::CAUSE_UNKNOWN) {
4406       mUnknownFocusMethodShouldShowOutline = false;
4407     } else if (aFocusMethod & nsIFocusManager::FLAG_NOSHOWRING) {
4408       // If we get focused via script, and script has explicitly opted out of
4409       // outlines via FLAG_NOSHOWRING, we don't want to make a refocus start
4410       // showing outlines.
4411       mUnknownFocusMethodShouldShowOutline = false;
4412     }
4413   }
4414
4415   if (aNeedsFocus) {
4416     mNeedsFocus = aNeedsFocus;
4417   }
4418 }
4419
4420 uint32_t nsGlobalWindowInner::GetFocusMethod() { return mFocusMethod; }
4421
4422 bool nsGlobalWindowInner::ShouldShowFocusRing() {
4423   if (mFocusByKeyOccurred &&
4424       StaticPrefs::browser_display_always_show_rings_after_key_focus()) {
4425     return true;
4426   }
4427   return StaticPrefs::browser_display_show_focus_rings();
4428 }
4429
4430 bool nsGlobalWindowInner::TakeFocus(bool aFocus, uint32_t aFocusMethod) {
4431   if (IsDying()) {
4432     return false;
4433   }
4434
4435   if (aFocus) {
4436     mFocusMethod = aFocusMethod & nsIFocusManager::METHOD_MASK;
4437   }
4438
4439   if (mHasFocus != aFocus) {
4440     mHasFocus = aFocus;
4441     UpdateCanvasFocus(true, mFocusedElement);
4442   }
4443
4444   // if mNeedsFocus is true, then the document has not yet received a
4445   // document-level focus event. If there is a root content node, then return
4446   // true to tell the calling focus manager that a focus event is expected. If
4447   // there is no root content node, the document hasn't loaded enough yet, or
4448   // there isn't one and there is no point in firing a focus event.
4449   if (aFocus && mNeedsFocus && mDoc && mDoc->GetRootElement() != nullptr) {
4450     mNeedsFocus = false;
4451     return true;
4452   }
4453
4454   mNeedsFocus = false;
4455   return false;
4456 }
4457
4458 void nsGlobalWindowInner::SetReadyForFocus() {
4459   bool oldNeedsFocus = mNeedsFocus;
4460   mNeedsFocus = false;
4461
4462   if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
4463     nsCOMPtr<nsPIDOMWindowOuter> outerWindow = GetOuterWindow();
4464     fm->WindowShown(outerWindow, oldNeedsFocus);
4465   }
4466 }
4467
4468 void nsGlobalWindowInner::PageHidden() {
4469   // the window is being hidden, so tell the focus manager that the frame is
4470   // no longer valid. Use the persisted field to determine if the document
4471   // is being destroyed.
4472
4473   if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
4474     nsCOMPtr<nsPIDOMWindowOuter> outerWindow = GetOuterWindow();
4475     fm->WindowHidden(outerWindow, nsFocusManager::GenerateFocusActionId());
4476   }
4477
4478   mNeedsFocus = true;
4479 }
4480
4481 class HashchangeCallback : public Runnable {
4482  public:
4483   HashchangeCallback(const nsAString& aOldURL, const nsAString& aNewURL,
4484                      nsGlobalWindowInner* aWindow)
4485       : mozilla::Runnable("HashchangeCallback"), mWindow(aWindow) {
4486     MOZ_ASSERT(mWindow);
4487     mOldURL.Assign(aOldURL);
4488     mNewURL.Assign(aNewURL);
4489   }
4490
4491   NS_IMETHOD Run() override {
4492     MOZ_ASSERT(NS_IsMainThread(), "Should be called on the main thread.");
4493     return mWindow->FireHashchange(mOldURL, mNewURL);
4494   }
4495
4496  private:
4497   nsString mOldURL;
4498   nsString mNewURL;
4499   RefPtr<nsGlobalWindowInner> mWindow;
4500 };
4501
4502 nsresult nsGlobalWindowInner::DispatchAsyncHashchange(nsIURI* aOldURI,
4503                                                       nsIURI* aNewURI) {
4504   // Make sure that aOldURI and aNewURI are identical up to the '#', and that
4505   // their hashes are different.
4506   bool equal = false;
4507   NS_ENSURE_STATE(NS_SUCCEEDED(aOldURI->EqualsExceptRef(aNewURI, &equal)) &&
4508                   equal);
4509   nsAutoCString oldHash, newHash;
4510   bool oldHasHash, newHasHash;
4511   NS_ENSURE_STATE(NS_SUCCEEDED(aOldURI->GetRef(oldHash)) &&
4512                   NS_SUCCEEDED(aNewURI->GetRef(newHash)) &&
4513                   NS_SUCCEEDED(aOldURI->GetHasRef(&oldHasHash)) &&
4514                   NS_SUCCEEDED(aNewURI->GetHasRef(&newHasHash)) &&
4515                   (oldHasHash != newHasHash || !oldHash.Equals(newHash)));
4516
4517   nsAutoCString oldSpec, newSpec;
4518   nsresult rv = aOldURI->GetSpec(oldSpec);
4519   NS_ENSURE_SUCCESS(rv, rv);
4520   rv = aNewURI->GetSpec(newSpec);
4521   NS_ENSURE_SUCCESS(rv, rv);
4522
4523   NS_ConvertUTF8toUTF16 oldWideSpec(oldSpec);
4524   NS_ConvertUTF8toUTF16 newWideSpec(newSpec);
4525
4526   nsCOMPtr<nsIRunnable> callback =
4527       new HashchangeCallback(oldWideSpec, newWideSpec, this);
4528   return Dispatch(callback.forget());
4529 }
4530
4531 nsresult nsGlobalWindowInner::FireHashchange(const nsAString& aOldURL,
4532                                              const nsAString& aNewURL) {
4533   // Don't do anything if the window is frozen.
4534   if (IsFrozen()) {
4535     return NS_OK;
4536   }
4537
4538   // Get a presentation shell for use in creating the hashchange event.
4539   NS_ENSURE_STATE(IsCurrentInnerWindow());
4540
4541   HashChangeEventInit init;
4542   init.mNewURL = aNewURL;
4543   init.mOldURL = aOldURL;
4544
4545   RefPtr<HashChangeEvent> event =
4546       HashChangeEvent::Constructor(this, u"hashchange"_ns, init);
4547
4548   event->SetTrusted(true);
4549
4550   ErrorResult rv;
4551   DispatchEvent(*event, rv);
4552   return rv.StealNSResult();
4553 }
4554
4555 nsresult nsGlobalWindowInner::DispatchSyncPopState() {
4556   NS_ASSERTION(nsContentUtils::IsSafeToRunScript(),
4557                "Must be safe to run script here.");
4558
4559   // Bail if the window is frozen.
4560   if (IsFrozen()) {
4561     return NS_OK;
4562   }
4563
4564   AutoJSAPI jsapi;
4565   bool result = jsapi.Init(this);
4566   NS_ENSURE_TRUE(result, NS_ERROR_FAILURE);
4567
4568   JSContext* cx = jsapi.cx();
4569
4570   // Get the document's pending state object -- it contains the data we're
4571   // going to send along with the popstate event.  The object is serialized
4572   // using structured clone.
4573   JS::Rooted<JS::Value> stateJSValue(cx);
4574   nsresult rv = mDoc->GetStateObject(&stateJSValue);
4575   NS_ENSURE_SUCCESS(rv, rv);
4576
4577   if (!JS_WrapValue(cx, &stateJSValue)) {
4578     return NS_ERROR_OUT_OF_MEMORY;
4579   }
4580
4581   RootedDictionary<PopStateEventInit> init(cx);
4582   init.mState = stateJSValue;
4583
4584   RefPtr<PopStateEvent> event =
4585       PopStateEvent::Constructor(this, u"popstate"_ns, init);
4586   event->SetTrusted(true);
4587   event->SetTarget(this);
4588
4589   ErrorResult err;
4590   DispatchEvent(*event, err);
4591   return err.StealNSResult();
4592 }
4593
4594 //-------------------------------------------------------
4595 // Tells the HTMLFrame/CanvasFrame that is now has focus
4596 void nsGlobalWindowInner::UpdateCanvasFocus(bool aFocusChanged,
4597                                             nsIContent* aNewContent) {
4598   // this is called from the inner window so use GetDocShell
4599   nsIDocShell* docShell = GetDocShell();
4600   if (!docShell) return;
4601
4602   bool editable;
4603   docShell->GetEditable(&editable);
4604   if (editable) return;
4605
4606   PresShell* presShell = docShell->GetPresShell();
4607   if (!presShell || !mDoc) {
4608     return;
4609   }
4610
4611   Element* rootElement = mDoc->GetRootElement();
4612   if (rootElement) {
4613     if ((mHasFocus || aFocusChanged) &&
4614         (mFocusedElement == rootElement || aNewContent == rootElement)) {
4615       nsCanvasFrame* canvasFrame = presShell->GetCanvasFrame();
4616       if (canvasFrame) {
4617         canvasFrame->SetHasFocus(mHasFocus && rootElement == aNewContent);
4618       }
4619     }
4620   } else {
4621     // XXXbz I would expect that there is never a canvasFrame in this case...
4622     nsCanvasFrame* canvasFrame = presShell->GetCanvasFrame();
4623     if (canvasFrame) {
4624       canvasFrame->SetHasFocus(false);
4625     }
4626   }
4627 }
4628
4629 already_AddRefed<nsICSSDeclaration> nsGlobalWindowInner::GetComputedStyle(
4630     Element& aElt, const nsAString& aPseudoElt, ErrorResult& aError) {
4631   return GetComputedStyleHelper(aElt, aPseudoElt, false, aError);
4632 }
4633
4634 already_AddRefed<nsICSSDeclaration>
4635 nsGlobalWindowInner::GetDefaultComputedStyle(Element& aElt,
4636                                              const nsAString& aPseudoElt,
4637                                              ErrorResult& aError) {
4638   return GetComputedStyleHelper(aElt, aPseudoElt, true, aError);
4639 }
4640
4641 already_AddRefed<nsICSSDeclaration> nsGlobalWindowInner::GetComputedStyleHelper(
4642     Element& aElt, const nsAString& aPseudoElt, bool aDefaultStylesOnly,
4643     ErrorResult& aError) {
4644   FORWARD_TO_OUTER_OR_THROW(GetComputedStyleHelperOuter,
4645                             (aElt, aPseudoElt, aDefaultStylesOnly, aError),
4646                             aError, nullptr);
4647 }
4648
4649 Storage* nsGlobalWindowInner::GetSessionStorage(ErrorResult& aError) {
4650   nsIPrincipal* principal = GetPrincipal();
4651   nsIPrincipal* storagePrincipal;
4652   if (StaticPrefs::
4653           privacy_partition_always_partition_third_party_non_cookie_storage_exempt_sessionstorage()) {
4654     storagePrincipal = GetEffectiveCookiePrincipal();
4655   } else {
4656     storagePrincipal = GetEffectiveStoragePrincipal();
4657   }
4658   BrowsingContext* browsingContext = GetBrowsingContext();
4659
4660   if (!principal || !storagePrincipal || !browsingContext ||
4661       !Storage::StoragePrefIsEnabled()) {
4662     return nullptr;
4663   }
4664
4665   if (mSessionStorage) {
4666     MOZ_LOG(gDOMLeakPRLogInner, LogLevel::Debug,
4667             ("nsGlobalWindowInner %p has %p sessionStorage", this,
4668              mSessionStorage.get()));
4669     bool canAccess =
4670         principal->Subsumes(mSessionStorage->Principal()) &&
4671         storagePrincipal->Subsumes(mSessionStorage->StoragePrincipal());
4672     if (!canAccess) {
4673       mSessionStorage = nullptr;
4674     }
4675   }
4676
4677   if (!mSessionStorage) {
4678     nsString documentURI;
4679     if (mDoc) {
4680       aError = mDoc->GetDocumentURI(documentURI);
4681       if (NS_WARN_IF(aError.Failed())) {
4682         return nullptr;
4683       }
4684     }
4685
4686     if (!mDoc) {
4687       aError.Throw(NS_ERROR_FAILURE);
4688       return nullptr;
4689     }
4690
4691     // If the document's sandboxed origin flag is set, then accessing
4692     // sessionStorage is prohibited.
4693     if (mDoc->GetSandboxFlags() & SANDBOXED_ORIGIN) {
4694       aError.ThrowSecurityError(
4695           "Forbidden in a sandboxed document without the 'allow-same-origin' "
4696           "flag.");
4697       return nullptr;
4698     }
4699
4700     uint32_t rejectedReason = 0;
4701     StorageAccess access = StorageAllowedForWindow(this, &rejectedReason);
4702
4703     // SessionStorage is an ephemeral per-tab per-origin storage that only lives
4704     // as long as the tab is open, although it may survive browser restarts
4705     // thanks to the session store. So we interpret storage access differently
4706     // than we would for persistent per-origin storage like LocalStorage and so
4707     // it may be okay to provide SessionStorage even when we receive a value of
4708     // eDeny.
4709     //
4710     // ContentBlocking::ShouldAllowAccessFor will return false for 3 main
4711     // reasons.
4712     //
4713     // 1. Cookies are entirely blocked due to a per-origin permission
4714     // (nsICookiePermission::ACCESS_DENY for the top-level principal or this
4715     // window's principal) or the very broad BEHAVIOR_REJECT. This will return
4716     // eDeny with a reason of STATE_COOKIES_BLOCKED_BY_PERMISSION or
4717     // STATE_COOKIES_BLOCKED_ALL.
4718     //
4719     // 2. Third-party cookies are limited via BEHAVIOR_REJECT_FOREIGN and
4720     // BEHAVIOR_LIMIT_FOREIGN and this is a third-party window. This will return
4721     // eDeny with a reason of STATE_COOKIES_BLOCKED_FOREIGN.
4722     //
4723     // 3. Tracking protection (BEHAVIOR_REJECT_TRACKER and
4724     // BEHAVIOR_REJECT_TRACKER_AND_PARTITION_FOREIGN) is in effect and
4725     // IsThirdPartyTrackingResourceWindow() returned true and there wasn't a
4726     // permission that allows it. This will return ePartitionTrackersOrDeny with
4727     // a reason of STATE_COOKIES_BLOCKED_TRACKER or
4728     // STATE_COOKIES_BLOCKED_SOCIALTRACKER.
4729     //
4730     // In the 1st case, the user has explicitly indicated that they don't want
4731     // to allow any storage to the origin or all origins and so we throw an
4732     // error and deny access to SessionStorage. In the 2nd case, a legacy
4733     // decision reasoned that there's no harm in providing SessionStorage
4734     // because the information is not durable and cannot escape the current tab.
4735     // The rationale is similar for the 3rd case.
4736     if (access == StorageAccess::eDeny &&
4737         rejectedReason !=
4738             nsIWebProgressListener::STATE_COOKIES_BLOCKED_FOREIGN) {
4739       aError.Throw(NS_ERROR_DOM_SECURITY_ERR);
4740       return nullptr;
4741     }
4742
4743     const RefPtr<SessionStorageManager> storageManager =
4744         browsingContext->GetSessionStorageManager();
4745     if (!storageManager) {
4746       aError.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
4747       return nullptr;
4748     }
4749
4750     RefPtr<Storage> storage;
4751     aError = storageManager->CreateStorage(this, principal, storagePrincipal,
4752                                            documentURI, IsPrivateBrowsing(),
4753                                            getter_AddRefs(storage));
4754     if (aError.Failed()) {
4755       return nullptr;
4756     }
4757
4758     mSessionStorage = storage;
4759     MOZ_ASSERT(mSessionStorage);
4760
4761     MOZ_LOG(gDOMLeakPRLogInner, LogLevel::Debug,
4762             ("nsGlobalWindowInner %p tried to get a new sessionStorage %p",
4763              this, mSessionStorage.get()));
4764
4765     if (!mSessionStorage) {
4766       aError.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
4767       return nullptr;
4768     }
4769   }
4770
4771   MOZ_LOG(gDOMLeakPRLogInner, LogLevel::Debug,
4772           ("nsGlobalWindowInner %p returns %p sessionStorage", this,
4773            mSessionStorage.get()));
4774
4775   return mSessionStorage;
4776 }
4777
4778 Storage* nsGlobalWindowInner::GetLocalStorage(ErrorResult& aError) {
4779   if (!Storage::StoragePrefIsEnabled()) {
4780     return nullptr;
4781   }
4782
4783   // If the document's sandboxed origin flag is set, then accessing localStorage
4784   // is prohibited.
4785   if (mDoc && mDoc->GetSandboxFlags() & SANDBOXED_ORIGIN) {
4786     aError.ThrowSecurityError(
4787         "Forbidden in a sandboxed document without the 'allow-same-origin' "
4788         "flag.");
4789     return nullptr;
4790   }
4791
4792   // LocalStorage needs to be exposed in every context except for sandboxes and
4793   // NullPrincipals (data: URLs, for instance). But we need to keep data
4794   // separate in some scenarios: private-browsing and partitioned trackers.
4795   // In private-browsing, LocalStorage keeps data in memory, and it shares
4796   // StorageEvents just with other origins in the same private-browsing
4797   // environment.
4798   // For Partitioned Trackers, we expose a partitioned LocalStorage, which
4799   // doesn't share data with other contexts, and it's just in memory.
4800   // Partitioned localStorage is available only for trackers listed in the
4801   // privacy.restrict3rdpartystorage.partitionedHosts pref. See
4802   // nsContentUtils::IsURIInPrefList to know the syntax for the pref value.
4803   // This is a temporary web-compatibility hack.
4804
4805   StorageAccess access = StorageAllowedForWindow(this);
4806
4807   // We allow partitioned localStorage only to some hosts.
4808   bool isolated = false;
4809   if (ShouldPartitionStorage(access)) {
4810     if (!mDoc) {
4811       access = StorageAccess::eDeny;
4812     } else if (!StoragePartitioningEnabled(access, mDoc->CookieJarSettings())) {
4813       static const char* kPrefName =
4814           "privacy.restrict3rdpartystorage.partitionedHosts";
4815
4816       bool isInList = false;
4817       mDoc->NodePrincipal()->IsURIInPrefList(kPrefName, &isInList);
4818       if (!isInList) {
4819         access = StorageAccess::eDeny;
4820       } else {
4821         isolated = true;
4822       }
4823     }
4824   }
4825
4826   if (access == StorageAccess::eDeny) {
4827     aError.Throw(NS_ERROR_DOM_SECURITY_ERR);
4828     return nullptr;
4829   }
4830
4831   nsCOMPtr<nsICookieJarSettings> cookieJarSettings;
4832   if (mDoc) {
4833     cookieJarSettings = mDoc->CookieJarSettings();
4834   } else {
4835     cookieJarSettings = net::CookieJarSettings::GetBlockingAll(
4836         ShouldResistFingerprinting(RFPTarget::IsAlwaysEnabledForPrecompute));
4837   }
4838
4839   // Note that this behavior is observable: if we grant storage permission to a
4840   // tracker, we pass from the partitioned LocalStorage (or a partitioned cookie
4841   // jar) to the 'normal' one. The previous data is lost and the 2
4842   // window.localStorage objects, before and after the permission granted, will
4843   // be different.
4844   if (mLocalStorage) {
4845     if ((mLocalStorage->Type() == (isolated ? Storage::ePartitionedLocalStorage
4846                                             : Storage::eLocalStorage)) &&
4847         (mLocalStorage->StoragePrincipal() == GetEffectiveStoragePrincipal())) {
4848       return mLocalStorage;
4849     }
4850
4851     // storage needs change
4852     mLocalStorage = nullptr;
4853   }
4854
4855   MOZ_ASSERT(!mLocalStorage);
4856
4857   if (!isolated) {
4858     RefPtr<Storage> storage;
4859
4860     if (NextGenLocalStorageEnabled()) {
4861       aError = LSObject::CreateForWindow(this, getter_AddRefs(storage));
4862     } else {
4863       nsresult rv;
4864       nsCOMPtr<nsIDOMStorageManager> storageManager =
4865           do_GetService("@mozilla.org/dom/localStorage-manager;1", &rv);
4866       if (NS_FAILED(rv)) {
4867         aError.Throw(rv);
4868         return nullptr;
4869       }
4870
4871       nsString documentURI;
4872       if (mDoc) {
4873         aError = mDoc->GetDocumentURI(documentURI);
4874         if (NS_WARN_IF(aError.Failed())) {
4875           return nullptr;
4876         }
4877       }
4878
4879       nsIPrincipal* principal = GetPrincipal();
4880       if (!principal) {
4881         aError.Throw(NS_ERROR_DOM_SECURITY_ERR);
4882         return nullptr;
4883       }
4884
4885       nsIPrincipal* storagePrincipal = GetEffectiveStoragePrincipal();
4886       if (!storagePrincipal) {
4887         aError.Throw(NS_ERROR_DOM_SECURITY_ERR);
4888         return nullptr;
4889       }
4890
4891       aError = storageManager->CreateStorage(this, principal, storagePrincipal,
4892                                              documentURI, IsPrivateBrowsing(),
4893                                              getter_AddRefs(storage));
4894     }
4895
4896     if (aError.Failed()) {
4897       return nullptr;
4898     }
4899
4900     mLocalStorage = storage;
4901   } else {
4902     nsresult rv;
4903     nsCOMPtr<nsIDOMSessionStorageManager> storageManager =
4904         do_GetService("@mozilla.org/dom/sessionStorage-manager;1", &rv);
4905     if (NS_FAILED(rv)) {
4906       aError.Throw(rv);
4907       return nullptr;
4908     }
4909
4910     nsIPrincipal* principal = GetPrincipal();
4911     if (!principal) {
4912       aError.Throw(NS_ERROR_DOM_SECURITY_ERR);
4913       return nullptr;
4914     }
4915
4916     nsIPrincipal* storagePrincipal = GetEffectiveStoragePrincipal();
4917     if (!storagePrincipal) {
4918       aError.Throw(NS_ERROR_DOM_SECURITY_ERR);
4919       return nullptr;
4920     }
4921
4922     RefPtr<SessionStorageCache> cache;
4923     if (isolated) {
4924       cache = new SessionStorageCache();
4925     } else {
4926       // This will clone the session storage if it exists.
4927       rv = storageManager->GetSessionStorageCache(principal, storagePrincipal,
4928                                                   &cache);
4929       if (NS_FAILED(rv)) {
4930         aError.Throw(rv);
4931         return nullptr;
4932       }
4933     }
4934
4935     mLocalStorage =
4936         new PartitionedLocalStorage(this, principal, storagePrincipal, cache);
4937   }
4938
4939   MOZ_ASSERT(mLocalStorage);
4940   MOZ_ASSERT(
4941       mLocalStorage->Type() ==
4942       (isolated ? Storage::ePartitionedLocalStorage : Storage::eLocalStorage));
4943   return mLocalStorage;
4944 }
4945
4946 IDBFactory* nsGlobalWindowInner::GetIndexedDB(JSContext* aCx,
4947                                               ErrorResult& aError) {
4948   if (!mIndexedDB) {
4949     // This may keep mIndexedDB null without setting an error.
4950     auto res = IDBFactory::CreateForWindow(this);
4951     if (res.isErr()) {
4952       aError = res.unwrapErr();
4953     } else {
4954       mIndexedDB = res.unwrap();
4955     }
4956   }
4957
4958   return mIndexedDB;
4959 }
4960
4961 //*****************************************************************************
4962 // nsGlobalWindowInner::nsIInterfaceRequestor
4963 //*****************************************************************************
4964
4965 NS_IMETHODIMP
4966 nsGlobalWindowInner::GetInterface(const nsIID& aIID, void** aSink) {
4967   nsGlobalWindowOuter* outer = GetOuterWindowInternal();
4968   NS_ENSURE_TRUE(outer, NS_ERROR_NOT_INITIALIZED);
4969
4970   nsresult rv = outer->GetInterfaceInternal(aIID, aSink);
4971   if (rv == NS_ERROR_NO_INTERFACE) {
4972     return QueryInterface(aIID, aSink);
4973   }
4974   return rv;
4975 }
4976
4977 void nsGlobalWindowInner::GetInterface(JSContext* aCx,
4978                                        JS::Handle<JS::Value> aIID,
4979                                        JS::MutableHandle<JS::Value> aRetval,
4980                                        ErrorResult& aError) {
4981   dom::GetInterface(aCx, this, aIID, aRetval, aError);
4982 }
4983
4984 already_AddRefed<CacheStorage> nsGlobalWindowInner::GetCaches(
4985     ErrorResult& aRv) {
4986   if (!mCacheStorage) {
4987     bool forceTrustedOrigin =
4988         GetBrowsingContext() &&
4989         GetBrowsingContext()->Top()->GetServiceWorkersTestingEnabled();
4990     mCacheStorage = CacheStorage::CreateOnMainThread(
4991         cache::DEFAULT_NAMESPACE, this, GetEffectiveStoragePrincipal(),
4992         forceTrustedOrigin, aRv);
4993   }
4994
4995   RefPtr<CacheStorage> ref = mCacheStorage;
4996   return ref.forget();
4997 }
4998
4999 void nsGlobalWindowInner::FireOfflineStatusEventIfChanged() {
5000   if (!IsCurrentInnerWindow()) return;
5001
5002   // Don't fire an event if the status hasn't changed
5003   if (mWasOffline == NS_IsOffline()) {
5004     return;
5005   }
5006
5007   mWasOffline = !mWasOffline;
5008
5009   nsAutoString name;
5010   if (mWasOffline) {
5011     name.AssignLiteral("offline");
5012   } else {
5013     name.AssignLiteral("online");
5014   }
5015   nsContentUtils::DispatchTrustedEvent(mDoc, this, name, CanBubble::eNo,
5016                                        Cancelable::eNo);
5017 }
5018
5019 nsGlobalWindowInner::SlowScriptResponse
5020 nsGlobalWindowInner::ShowSlowScriptDialog(JSContext* aCx,
5021                                           const nsString& aAddonId,
5022                                           const double aDuration) {
5023   nsresult rv;
5024
5025   if (Preferences::GetBool("dom.always_stop_slow_scripts")) {
5026     return KillSlowScript;
5027   }
5028
5029   // If it isn't safe to run script, then it isn't safe to bring up the prompt
5030   // (since that spins the event loop). In that (rare) case, we just kill the
5031   // script and report a warning.
5032   if (!nsContentUtils::IsSafeToRunScript()) {
5033     JS::WarnASCII(aCx, "A long running script was terminated");
5034     return KillSlowScript;
5035   }
5036
5037   // If our document is not active, just kill the script: we've been unloaded
5038   if (!HasActiveDocument()) {
5039     return KillSlowScript;
5040   }
5041
5042   // Check if we should offer the option to debug
5043   JS::AutoFilename filename;
5044   uint32_t lineno;
5045   // Computing the line number can be very expensive (see bug 1330231 for
5046   // example), and we don't use the line number anywhere except than in the
5047   // parent process, so we avoid computing it elsewhere.  This gives us most of
5048   // the wins we are interested in, since the source of the slowness here is
5049   // minified scripts which is more common in Web content that is loaded in the
5050   // content process.
5051   uint32_t* linenop = XRE_IsParentProcess() ? &lineno : nullptr;
5052   bool hasFrame = JS::DescribeScriptedCaller(aCx, &filename, linenop);
5053
5054   // Record the slow script event if we haven't done so already for this inner
5055   // window (which represents a particular page to the user).
5056   if (!mHasHadSlowScript) {
5057     Telemetry::Accumulate(Telemetry::SLOW_SCRIPT_PAGE_COUNT, 1);
5058   }
5059   mHasHadSlowScript = true;
5060
5061   // Override the cursor to something that we're sure the user can see.
5062   SetCursor("auto"_ns, IgnoreErrors());
5063
5064   if (XRE_IsContentProcess() && ProcessHangMonitor::Get()) {
5065     ProcessHangMonitor::SlowScriptAction action;
5066     RefPtr<ProcessHangMonitor> monitor = ProcessHangMonitor::Get();
5067     nsIDocShell* docShell = GetDocShell();
5068     nsCOMPtr<nsIBrowserChild> child =
5069         docShell ? docShell->GetBrowserChild() : nullptr;
5070     action =
5071         monitor->NotifySlowScript(child, filename.get(), aAddonId, aDuration);
5072     if (action == ProcessHangMonitor::Terminate) {
5073       return KillSlowScript;
5074     }
5075
5076     if (action == ProcessHangMonitor::StartDebugger) {
5077       // Spin a nested event loop so that the debugger in the parent can fetch
5078       // any information it needs. Once the debugger has started, return to the
5079       // script.
5080       RefPtr<nsGlobalWindowOuter> outer = GetOuterWindowInternal();
5081       outer->EnterModalState();
5082       SpinEventLoopUntil("nsGlobalWindowInner::ShowSlowScriptDialog"_ns, [&]() {
5083         return monitor->IsDebuggerStartupComplete();
5084       });
5085       outer->LeaveModalState();
5086       return ContinueSlowScript;
5087     }
5088
5089     return ContinueSlowScriptAndKeepNotifying;
5090   }
5091
5092   // Reached only on non-e10s - once per slow script dialog.
5093   // On e10s - we probe once at ProcessHangsMonitor.jsm
5094   Telemetry::Accumulate(Telemetry::SLOW_SCRIPT_NOTICE_COUNT, 1);
5095
5096   // Get the nsIPrompt interface from the docshell
5097   nsCOMPtr<nsIDocShell> ds = GetDocShell();
5098   NS_ENSURE_TRUE(ds, KillSlowScript);
5099   nsCOMPtr<nsIPrompt> prompt = do_GetInterface(ds);
5100   NS_ENSURE_TRUE(prompt, KillSlowScript);
5101
5102   // Prioritize the SlowScriptDebug interface over JSD1.
5103   nsCOMPtr<nsISlowScriptDebugCallback> debugCallback;
5104
5105   if (hasFrame) {
5106     const char* debugCID = "@mozilla.org/dom/slow-script-debug;1";
5107     nsCOMPtr<nsISlowScriptDebug> debugService = do_GetService(debugCID, &rv);
5108     if (NS_SUCCEEDED(rv)) {
5109       debugService->GetActivationHandler(getter_AddRefs(debugCallback));
5110     }
5111   }
5112
5113   bool failed = false;
5114   auto getString = [&](const char* name,
5115                        nsContentUtils::PropertiesFile propFile =
5116                            nsContentUtils::eDOM_PROPERTIES) {
5117     nsAutoString result;
5118     nsresult rv = nsContentUtils::GetLocalizedString(propFile, name, result);
5119
5120     // GetStringFromName can return NS_OK and still give nullptr string
5121     failed = failed || NS_FAILED(rv) || result.IsEmpty();
5122     return result;
5123   };
5124
5125   bool isAddonScript = !aAddonId.IsEmpty();
5126   bool showDebugButton = debugCallback && !isAddonScript;
5127
5128   // Get localizable strings
5129
5130   nsAutoString title, checkboxMsg, debugButton, msg;
5131   if (isAddonScript) {
5132     title = getString("KillAddonScriptTitle");
5133     checkboxMsg = getString("KillAddonScriptGlobalMessage");
5134
5135     auto appName =
5136         getString("brandShortName", nsContentUtils::eBRAND_PROPERTIES);
5137
5138     nsCOMPtr<nsIAddonPolicyService> aps =
5139         do_GetService("@mozilla.org/addons/policy-service;1");
5140     nsString addonName;
5141     if (!aps || NS_FAILED(aps->GetExtensionName(aAddonId, addonName))) {
5142       addonName = aAddonId;
5143     }
5144
5145     rv = nsContentUtils::FormatLocalizedString(
5146         msg, nsContentUtils::eDOM_PROPERTIES, "KillAddonScriptMessage",
5147         addonName, appName);
5148
5149     failed = failed || NS_FAILED(rv);
5150   } else {
5151     title = getString("KillScriptTitle");
5152     checkboxMsg = getString("DontAskAgain");
5153
5154     if (showDebugButton) {
5155       debugButton = getString("DebugScriptButton");
5156       msg = getString("KillScriptWithDebugMessage");
5157     } else {
5158       msg = getString("KillScriptMessage");
5159     }
5160   }
5161
5162   auto stopButton = getString("StopScriptButton");
5163   auto waitButton = getString("WaitForScriptButton");
5164
5165   if (failed) {
5166     NS_ERROR("Failed to get localized strings.");
5167     return ContinueSlowScript;
5168   }
5169
5170   // Append file and line number information, if available
5171   if (filename.get()) {
5172     nsAutoString scriptLocation;
5173     // We want to drop the middle part of too-long locations.  We'll
5174     // define "too-long" as longer than 60 UTF-16 code units.  Just
5175     // have to be a bit careful about unpaired surrogates.
5176     NS_ConvertUTF8toUTF16 filenameUTF16(filename.get());
5177     if (filenameUTF16.Length() > 60) {
5178       // XXXbz Do we need to insert any bidi overrides here?
5179       size_t cutStart = 30;
5180       size_t cutLength = filenameUTF16.Length() - 60;
5181       MOZ_ASSERT(cutLength > 0);
5182       if (NS_IS_LOW_SURROGATE(filenameUTF16[cutStart])) {
5183         // Don't truncate before the low surrogate, in case it's preceded by a
5184         // high surrogate and forms a single Unicode character.  Instead, just
5185         // include the low surrogate.
5186         ++cutStart;
5187         --cutLength;
5188       }
5189       if (NS_IS_LOW_SURROGATE(filenameUTF16[cutStart + cutLength])) {
5190         // Likewise, don't drop a trailing low surrogate here.  We want to
5191         // increase cutLength, since it might be 0 already so we can't very well
5192         // decrease it.
5193         ++cutLength;
5194       }
5195
5196       // Insert U+2026 HORIZONTAL ELLIPSIS
5197       filenameUTF16.ReplaceLiteral(cutStart, cutLength, u"\x2026");
5198     }
5199     rv = nsContentUtils::FormatLocalizedString(
5200         scriptLocation, nsContentUtils::eDOM_PROPERTIES, "KillScriptLocation",
5201         filenameUTF16);
5202
5203     if (NS_SUCCEEDED(rv)) {
5204       msg.AppendLiteral("\n\n");
5205       msg.Append(scriptLocation);
5206       msg.Append(':');
5207       msg.AppendInt(lineno);
5208     }
5209   }
5210
5211   uint32_t buttonFlags = nsIPrompt::BUTTON_POS_1_DEFAULT +
5212                          (nsIPrompt::BUTTON_TITLE_IS_STRING *
5213                           (nsIPrompt::BUTTON_POS_0 + nsIPrompt::BUTTON_POS_1));
5214
5215   // Add a third button if necessary.
5216   if (showDebugButton)
5217     buttonFlags += nsIPrompt::BUTTON_TITLE_IS_STRING * nsIPrompt::BUTTON_POS_2;
5218
5219   bool checkboxValue = false;
5220   int32_t buttonPressed = 0;  // In case the user exits dialog by clicking X.
5221   {
5222     // Null out the operation callback while we're re-entering JS here.
5223     AutoDisableJSInterruptCallback disabler(aCx);
5224
5225     // Open the dialog.
5226     rv = prompt->ConfirmEx(
5227         title.get(), msg.get(), buttonFlags, waitButton.get(), stopButton.get(),
5228         debugButton.get(), checkboxMsg.get(), &checkboxValue, &buttonPressed);
5229   }
5230
5231   if (buttonPressed == 0) {
5232     if (checkboxValue && !isAddonScript && NS_SUCCEEDED(rv))
5233       return AlwaysContinueSlowScript;
5234     return ContinueSlowScript;
5235   }
5236
5237   if (buttonPressed == 2) {
5238     MOZ_RELEASE_ASSERT(debugCallback);
5239
5240     rv = debugCallback->HandleSlowScriptDebug(this);
5241     return NS_SUCCEEDED(rv) ? ContinueSlowScript : KillSlowScript;
5242   }
5243
5244   JS_ClearPendingException(aCx);
5245
5246   return KillSlowScript;
5247 }
5248
5249 nsresult nsGlobalWindowInner::Observe(nsISupports* aSubject, const char* aTopic,
5250                                       const char16_t* aData) {
5251   if (!nsCRT::strcmp(aTopic, NS_IOSERVICE_OFFLINE_STATUS_TOPIC)) {
5252     if (!IsFrozen()) {
5253       // Fires an offline status event if the offline status has changed
5254       FireOfflineStatusEventIfChanged();
5255     }
5256     return NS_OK;
5257   }
5258
5259   if (!nsCRT::strcmp(aTopic, MEMORY_PRESSURE_OBSERVER_TOPIC)) {
5260     if (mPerformance) {
5261       mPerformance->MemoryPressure();
5262     }
5263     RemoveReportRecords();
5264     return NS_OK;
5265   }
5266
5267   if (!nsCRT::strcmp(aTopic, PERMISSION_CHANGED_TOPIC)) {
5268     nsCOMPtr<nsIPermission> perm(do_QueryInterface(aSubject));
5269     if (!perm) {
5270       // A null permission indicates that the entire permission list
5271       // was cleared.
5272       MOZ_ASSERT(!nsCRT::strcmp(aData, u"cleared"));
5273       UpdatePermissions();
5274       return NS_OK;
5275     }
5276
5277     nsAutoCString type;
5278     perm->GetType(type);
5279     if (type == "autoplay-media"_ns) {
5280       UpdateAutoplayPermission();
5281     } else if (type == "shortcuts"_ns) {
5282       UpdateShortcutsPermission();
5283     } else if (type == "popup"_ns) {
5284       UpdatePopupPermission();
5285     }
5286
5287     if (!mDoc) {
5288       return NS_OK;
5289     }
5290
5291     RefPtr<PermissionDelegateHandler> permDelegateHandler =
5292         mDoc->GetPermissionDelegateHandler();
5293
5294     if (permDelegateHandler) {
5295       permDelegateHandler->UpdateDelegatedPermission(type);
5296     }
5297
5298     return NS_OK;
5299   }
5300
5301   if (!nsCRT::strcmp(aTopic, "screen-information-changed")) {
5302     if (mScreen) {
5303       if (RefPtr<ScreenOrientation> orientation =
5304               mScreen->GetOrientationIfExists()) {
5305         orientation->MaybeChanged();
5306       }
5307     }
5308     if (mHasOrientationChangeListeners) {
5309       int32_t oldAngle = mOrientationAngle;
5310       mOrientationAngle = Orientation(CallerType::System);
5311       if (mOrientationAngle != oldAngle && IsCurrentInnerWindow()) {
5312         nsCOMPtr<nsPIDOMWindowOuter> outer = GetOuterWindow();
5313         outer->DispatchCustomEvent(u"orientationchange"_ns);
5314       }
5315     }
5316     return NS_OK;
5317   }
5318
5319   if (!nsCRT::strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) {
5320     MOZ_ASSERT(!NS_strcmp(aData, u"intl.accept_languages"));
5321
5322     // The user preferred languages have changed, we need to fire an event on
5323     // Window object and invalidate the cache for navigator.languages. It is
5324     // done for every change which can be a waste of cycles but those should be
5325     // fairly rare.
5326     // We MUST invalidate navigator.languages before sending the event in the
5327     // very likely situation where an event handler will try to read its value.
5328
5329     if (mNavigator) {
5330       Navigator_Binding::ClearCachedLanguageValue(mNavigator);
5331       Navigator_Binding::ClearCachedLanguagesValue(mNavigator);
5332     }
5333
5334     // The event has to be dispatched only to the current inner window.
5335     if (!IsCurrentInnerWindow()) {
5336       return NS_OK;
5337     }
5338
5339     RefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
5340     event->InitEvent(u"languagechange"_ns, false, false);
5341     event->SetTrusted(true);
5342
5343     ErrorResult rv;
5344     DispatchEvent(*event, rv);
5345     return rv.StealNSResult();
5346   }
5347
5348   NS_WARNING("unrecognized topic in nsGlobalWindowInner::Observe");
5349   return NS_ERROR_FAILURE;
5350 }
5351
5352 void nsGlobalWindowInner::ObserveStorageNotification(
5353     StorageEvent* aEvent, const char16_t* aStorageType, bool aPrivateBrowsing) {
5354   MOZ_ASSERT(aEvent);
5355
5356   // The private browsing check must be done here again because this window
5357   // could have changed its state before the notification check and now. This
5358   // happens in case this window did have a docShell at that time.
5359   if (aPrivateBrowsing != IsPrivateBrowsing()) {
5360     return;
5361   }
5362
5363   // LocalStorage can only exist on an inner window, and we don't want to
5364   // generate events on frozen or otherwise-navigated-away from windows.
5365   // (Actually, this code used to try and buffer events for frozen windows,
5366   // but it never worked, so we've removed it.  See bug 1285898.)
5367   if (!IsCurrentInnerWindow() || IsFrozen()) {
5368     return;
5369   }
5370
5371   nsIPrincipal* principal = GetPrincipal();
5372   if (!principal) {
5373     return;
5374   }
5375
5376   bool fireMozStorageChanged = false;
5377   nsAutoString eventType;
5378   eventType.AssignLiteral("storage");
5379
5380   if (!NS_strcmp(aStorageType, u"sessionStorage")) {
5381     RefPtr<Storage> changingStorage = aEvent->GetStorageArea();
5382     MOZ_ASSERT(changingStorage);
5383
5384     bool check = false;
5385
5386     if (const RefPtr<SessionStorageManager> storageManager =
5387             GetBrowsingContext()->GetSessionStorageManager()) {
5388       nsresult rv = storageManager->CheckStorage(GetEffectiveStoragePrincipal(),
5389                                                  changingStorage, &check);
5390       if (NS_FAILED(rv)) {
5391         return;
5392       }
5393     }
5394
5395     if (!check) {
5396       // This storage event is not coming from our storage or is coming
5397       // from a different docshell, i.e. it is a clone, ignore this event.
5398       return;
5399     }
5400
5401     MOZ_LOG(
5402         gDOMLeakPRLogInner, LogLevel::Debug,
5403         ("nsGlobalWindowInner %p with sessionStorage %p passing event from %p",
5404          this, mSessionStorage.get(), changingStorage.get()));
5405
5406     fireMozStorageChanged = mSessionStorage == changingStorage;
5407     if (fireMozStorageChanged) {
5408       eventType.AssignLiteral("MozSessionStorageChanged");
5409     }
5410   }
5411
5412   else {
5413     MOZ_ASSERT(!NS_strcmp(aStorageType, u"localStorage"));
5414
5415     nsIPrincipal* storagePrincipal = GetEffectiveStoragePrincipal();
5416     if (!storagePrincipal) {
5417       return;
5418     }
5419
5420     MOZ_DIAGNOSTIC_ASSERT(StorageUtils::PrincipalsEqual(aEvent->GetPrincipal(),
5421                                                         storagePrincipal));
5422
5423     fireMozStorageChanged =
5424         mLocalStorage && mLocalStorage == aEvent->GetStorageArea();
5425
5426     if (fireMozStorageChanged) {
5427       eventType.AssignLiteral("MozLocalStorageChanged");
5428     }
5429   }
5430
5431   // Clone the storage event included in the observer notification. We want
5432   // to dispatch clones rather than the original event.
5433   IgnoredErrorResult error;
5434   RefPtr<StorageEvent> clonedEvent =
5435       CloneStorageEvent(eventType, aEvent, error);
5436   if (error.Failed() || !clonedEvent) {
5437     return;
5438   }
5439
5440   clonedEvent->SetTrusted(true);
5441
5442   if (fireMozStorageChanged) {
5443     WidgetEvent* internalEvent = clonedEvent->WidgetEventPtr();
5444     internalEvent->mFlags.mOnlyChromeDispatch = true;
5445   }
5446
5447   DispatchEvent(*clonedEvent);
5448 }
5449
5450 already_AddRefed<StorageEvent> nsGlobalWindowInner::CloneStorageEvent(
5451     const nsAString& aType, const RefPtr<StorageEvent>& aEvent,
5452     ErrorResult& aRv) {
5453   StorageEventInit dict;
5454
5455   dict.mBubbles = aEvent->Bubbles();
5456   dict.mCancelable = aEvent->Cancelable();
5457   aEvent->GetKey(dict.mKey);
5458   aEvent->GetOldValue(dict.mOldValue);
5459   aEvent->GetNewValue(dict.mNewValue);
5460   aEvent->GetUrl(dict.mUrl);
5461
5462   RefPtr<Storage> storageArea = aEvent->GetStorageArea();
5463
5464   RefPtr<Storage> storage;
5465
5466   // If null, this is a localStorage event received by IPC.
5467   if (!storageArea) {
5468     storage = GetLocalStorage(aRv);
5469     if (!NextGenLocalStorageEnabled()) {
5470       if (aRv.Failed() || !storage) {
5471         return nullptr;
5472       }
5473
5474       if (storage->Type() == Storage::eLocalStorage) {
5475         RefPtr<LocalStorage> localStorage =
5476             static_cast<LocalStorage*>(storage.get());
5477
5478         // We must apply the current change to the 'local' localStorage.
5479         localStorage->ApplyEvent(aEvent);
5480       }
5481     }
5482   } else if (storageArea->Type() == Storage::eSessionStorage) {
5483     storage = GetSessionStorage(aRv);
5484   } else {
5485     MOZ_ASSERT(storageArea->Type() == Storage::eLocalStorage);
5486     storage = GetLocalStorage(aRv);
5487   }
5488
5489   if (aRv.Failed() || !storage) {
5490     return nullptr;
5491   }
5492
5493   if (storage->Type() == Storage::ePartitionedLocalStorage) {
5494     // This error message is not exposed.
5495     aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
5496     return nullptr;
5497   }
5498
5499   MOZ_ASSERT(storage);
5500   MOZ_ASSERT_IF(storageArea, storage->IsForkOf(storageArea));
5501
5502   dict.mStorageArea = storage;
5503
5504   RefPtr<StorageEvent> event = StorageEvent::Constructor(this, aType, dict);
5505   return event.forget();
5506 }
5507
5508 void nsGlobalWindowInner::Suspend(bool aIncludeSubWindows) {
5509   MOZ_ASSERT(NS_IsMainThread());
5510
5511   // We can only safely suspend windows that are the current inner window.  If
5512   // its not the current inner, then we are in one of two different cases.
5513   // Either we are in the bfcache or we are doomed window that is going away.
5514   // When a window becomes inactive we purposely avoid placing already suspended
5515   // windows into the bfcache.  It only expects windows suspended due to the
5516   // Freeze() method which occurs while the window is still the current inner.
5517   // So we must not call Suspend() on bfcache windows at this point or this
5518   // invariant will be broken.  If the window is doomed there is no point in
5519   // suspending it since it will soon be gone.
5520   if (!IsCurrentInnerWindow()) {
5521     return;
5522   }
5523
5524   // All in-process descendants are also suspended.  This ensure mSuspendDepth
5525   // is set properly and the timers are properly canceled for each in-process
5526   // descendant.
5527   if (aIncludeSubWindows) {
5528     CallOnInProcessDescendants(&nsGlobalWindowInner::Suspend, false);
5529   }
5530
5531   mSuspendDepth += 1;
5532   if (mSuspendDepth != 1) {
5533     return;
5534   }
5535
5536   if (mWindowGlobalChild) {
5537     mWindowGlobalChild->BlockBFCacheFor(BFCacheStatus::SUSPENDED);
5538   }
5539
5540   nsCOMPtr<nsIDeviceSensors> ac = do_GetService(NS_DEVICE_SENSORS_CONTRACTID);
5541   if (ac) {
5542     for (uint32_t i = 0; i < mEnabledSensors.Length(); i++)
5543       ac->RemoveWindowListener(mEnabledSensors[i], this);
5544   }
5545   DisableGamepadUpdates();
5546   DisableVRUpdates();
5547
5548   SuspendWorkersForWindow(*this);
5549
5550   for (RefPtr<mozilla::dom::SharedWorker> pinnedWorker :
5551        mSharedWorkers.ForwardRange()) {
5552     pinnedWorker->Suspend();
5553   }
5554
5555   SuspendIdleRequests();
5556
5557   mTimeoutManager->Suspend();
5558
5559   // Suspend all of the AudioContexts for this window
5560   for (uint32_t i = 0; i < mAudioContexts.Length(); ++i) {
5561     mAudioContexts[i]->SuspendFromChrome();
5562   }
5563 }
5564
5565 void nsGlobalWindowInner::Resume(bool aIncludeSubWindows) {
5566   MOZ_ASSERT(NS_IsMainThread());
5567
5568   // We can only safely resume a window if its the current inner window.  If
5569   // its not the current inner, then we are in one of two different cases.
5570   // Either we are in the bfcache or we are doomed window that is going away.
5571   // If a window is suspended when it becomes inactive we purposely do not
5572   // put it in the bfcache, so Resume should never be needed in that case.
5573   // If the window is doomed then there is no point in resuming it.
5574   if (!IsCurrentInnerWindow()) {
5575     return;
5576   }
5577
5578   // Resume all in-process descendants.  This restores timers recursively
5579   // canceled in Suspend() and ensures all in-process descendants have the
5580   // correct mSuspendDepth.
5581   if (aIncludeSubWindows) {
5582     CallOnInProcessDescendants(&nsGlobalWindowInner::Resume, false);
5583   }
5584
5585   if (mSuspendDepth == 0) {
5586     // Ignore if the window is not suspended.
5587     return;
5588   }
5589
5590   mSuspendDepth -= 1;
5591
5592   if (mSuspendDepth != 0) {
5593     return;
5594   }
5595
5596   // We should not be able to resume a frozen window.  It must be Thaw()'d
5597   // first.
5598   MOZ_ASSERT(mFreezeDepth == 0);
5599
5600   nsCOMPtr<nsIDeviceSensors> ac = do_GetService(NS_DEVICE_SENSORS_CONTRACTID);
5601   if (ac) {
5602     for (uint32_t i = 0; i < mEnabledSensors.Length(); i++)
5603       ac->AddWindowListener(mEnabledSensors[i], this);
5604   }
5605   EnableGamepadUpdates();
5606   EnableVRUpdates();
5607
5608   // Resume all of the AudioContexts for this window
5609   for (uint32_t i = 0; i < mAudioContexts.Length(); ++i) {
5610     mAudioContexts[i]->ResumeFromChrome();
5611   }
5612
5613   if (RefPtr<MediaDevices> devices = GetExtantMediaDevices()) {
5614     devices->WindowResumed();
5615   }
5616
5617   mTimeoutManager->Resume();
5618
5619   ResumeIdleRequests();
5620
5621   // Resume all of the workers for this window.  We must do this
5622   // after timeouts since workers may have queued events that can trigger
5623   // a setTimeout().
5624   ResumeWorkersForWindow(*this);
5625
5626   for (RefPtr<mozilla::dom::SharedWorker> pinnedWorker :
5627        mSharedWorkers.ForwardRange()) {
5628     pinnedWorker->Resume();
5629   }
5630
5631   if (mWindowGlobalChild) {
5632     mWindowGlobalChild->UnblockBFCacheFor(BFCacheStatus::SUSPENDED);
5633   }
5634 }
5635
5636 bool nsGlobalWindowInner::IsSuspended() const {
5637   MOZ_ASSERT(NS_IsMainThread());
5638   return mSuspendDepth != 0;
5639 }
5640
5641 void nsGlobalWindowInner::Freeze(bool aIncludeSubWindows) {
5642   MOZ_ASSERT(NS_IsMainThread());
5643   Suspend(aIncludeSubWindows);
5644   FreezeInternal(aIncludeSubWindows);
5645 }
5646
5647 void nsGlobalWindowInner::FreezeInternal(bool aIncludeSubWindows) {
5648   MOZ_ASSERT(NS_IsMainThread());
5649   MOZ_DIAGNOSTIC_ASSERT(IsCurrentInnerWindow());
5650   MOZ_DIAGNOSTIC_ASSERT(IsSuspended());
5651
5652   HintIsLoading(false);
5653
5654   if (aIncludeSubWindows) {
5655     CallOnInProcessChildren(&nsGlobalWindowInner::FreezeInternal,
5656                             aIncludeSubWindows);
5657   }
5658
5659   mFreezeDepth += 1;
5660   MOZ_ASSERT(mSuspendDepth >= mFreezeDepth);
5661   if (mFreezeDepth != 1) {
5662     return;
5663   }
5664
5665   FreezeWorkersForWindow(*this);
5666
5667   for (RefPtr<mozilla::dom::SharedWorker> pinnedWorker :
5668        mSharedWorkers.ForwardRange()) {
5669     pinnedWorker->Freeze();
5670   }
5671
5672   mTimeoutManager->Freeze();
5673   if (mClientSource) {
5674     mClientSource->Freeze();
5675   }
5676
5677   NotifyDOMWindowFrozen(this);
5678 }
5679
5680 void nsGlobalWindowInner::Thaw(bool aIncludeSubWindows) {
5681   MOZ_ASSERT(NS_IsMainThread());
5682   ThawInternal(aIncludeSubWindows);
5683   Resume(aIncludeSubWindows);
5684 }
5685
5686 void nsGlobalWindowInner::ThawInternal(bool aIncludeSubWindows) {
5687   MOZ_ASSERT(NS_IsMainThread());
5688   MOZ_DIAGNOSTIC_ASSERT(IsCurrentInnerWindow());
5689   MOZ_DIAGNOSTIC_ASSERT(IsSuspended());
5690
5691   if (aIncludeSubWindows) {
5692     CallOnInProcessChildren(&nsGlobalWindowInner::ThawInternal,
5693                             aIncludeSubWindows);
5694   }
5695
5696   MOZ_ASSERT(mFreezeDepth != 0);
5697   mFreezeDepth -= 1;
5698   MOZ_ASSERT(mSuspendDepth >= mFreezeDepth);
5699   if (mFreezeDepth != 0) {
5700     return;
5701   }
5702
5703   if (mClientSource) {
5704     mClientSource->Thaw();
5705   }
5706   mTimeoutManager->Thaw();
5707
5708   ThawWorkersForWindow(*this);
5709
5710   for (RefPtr<mozilla::dom::SharedWorker> pinnedWorker :
5711        mSharedWorkers.ForwardRange()) {
5712     pinnedWorker->Thaw();
5713   }
5714
5715   NotifyDOMWindowThawed(this);
5716 }
5717
5718 bool nsGlobalWindowInner::IsFrozen() const {
5719   MOZ_ASSERT(NS_IsMainThread());
5720   bool frozen = mFreezeDepth != 0;
5721   MOZ_ASSERT_IF(frozen, IsSuspended());
5722   return frozen;
5723 }
5724
5725 void nsGlobalWindowInner::SyncStateFromParentWindow() {
5726   // This method should only be called on an inner window that has been
5727   // assigned to an outer window already.
5728   MOZ_ASSERT(IsCurrentInnerWindow());
5729   nsPIDOMWindowOuter* outer = GetOuterWindow();
5730   MOZ_ASSERT(outer);
5731
5732   // Attempt to find our parent windows.
5733   nsCOMPtr<Element> frame = outer->GetFrameElementInternal();
5734   nsPIDOMWindowOuter* parentOuter =
5735       frame ? frame->OwnerDoc()->GetWindow() : nullptr;
5736   nsGlobalWindowInner* parentInner =
5737       parentOuter
5738           ? nsGlobalWindowInner::Cast(parentOuter->GetCurrentInnerWindow())
5739           : nullptr;
5740
5741   // If our outer is in a modal state, but our parent is not in a modal
5742   // state, then we must apply the suspend directly.  If our parent is
5743   // in a modal state then we should get the suspend automatically
5744   // via the parentSuspendDepth application below.
5745   if ((!parentInner || !parentInner->IsInModalState()) && IsInModalState()) {
5746     Suspend();
5747   }
5748
5749   uint32_t parentFreezeDepth = parentInner ? parentInner->mFreezeDepth : 0;
5750   uint32_t parentSuspendDepth = parentInner ? parentInner->mSuspendDepth : 0;
5751
5752   // Since every Freeze() calls Suspend(), the suspend count must
5753   // be equal or greater to the freeze count.
5754   MOZ_ASSERT(parentFreezeDepth <= parentSuspendDepth);
5755
5756   // First apply the Freeze() calls.
5757   for (uint32_t i = 0; i < parentFreezeDepth; ++i) {
5758     Freeze();
5759   }
5760
5761   // Now apply only the number of Suspend() calls to reach the target
5762   // suspend count after applying the Freeze() calls.
5763   for (uint32_t i = 0; i < (parentSuspendDepth - parentFreezeDepth); ++i) {
5764     Suspend();
5765   }
5766 }
5767
5768 void nsGlobalWindowInner::UpdateBackgroundState() {
5769   if (RefPtr<MediaDevices> devices = GetExtantMediaDevices()) {
5770     devices->BackgroundStateChanged();
5771   }
5772   mTimeoutManager->UpdateBackgroundState();
5773 }
5774
5775 template <typename Method, typename... Args>
5776 CallState nsGlobalWindowInner::CallOnInProcessDescendantsInternal(
5777     BrowsingContext* aBrowsingContext, bool aChildOnly, Method aMethod,
5778     Args&&... aArgs) {
5779   MOZ_ASSERT(NS_IsMainThread());
5780   MOZ_ASSERT(aBrowsingContext);
5781
5782   CallState state = CallState::Continue;
5783   for (const RefPtr<BrowsingContext>& bc : aBrowsingContext->Children()) {
5784     if (nsCOMPtr<nsPIDOMWindowOuter> pWin = bc->GetDOMWindow()) {
5785       auto* win = nsGlobalWindowOuter::Cast(pWin);
5786       if (nsGlobalWindowInner* inner =
5787               nsGlobalWindowInner::Cast(win->GetCurrentInnerWindow())) {
5788         // Call the descendant method using our helper CallDescendant() template
5789         // method. This allows us to handle both void returning methods and
5790         // methods that return CallState explicitly.  For void returning methods
5791         // we assume CallState::Continue.
5792         using returnType = decltype((inner->*aMethod)(aArgs...));
5793         state = CallDescendant<returnType>(inner, aMethod, aArgs...);
5794
5795         if (state == CallState::Stop) {
5796           return state;
5797         }
5798       }
5799     }
5800
5801     if (!aChildOnly) {
5802       state = CallOnInProcessDescendantsInternal(bc.get(), aChildOnly, aMethod,
5803                                                  aArgs...);
5804       if (state == CallState::Stop) {
5805         return state;
5806       }
5807     }
5808   }
5809
5810   return state;
5811 }
5812
5813 Maybe<ClientInfo> nsGlobalWindowInner::GetClientInfo() const {
5814   MOZ_ASSERT(NS_IsMainThread());
5815   if (mDoc && mDoc->IsStaticDocument()) {
5816     if (Maybe<ClientInfo> info = mDoc->GetOriginalDocument()->GetClientInfo()) {
5817       return info;
5818     }
5819   }
5820
5821   Maybe<ClientInfo> clientInfo;
5822   if (mClientSource) {
5823     clientInfo.emplace(mClientSource->Info());
5824   }
5825   return clientInfo;
5826 }
5827
5828 Maybe<ClientState> nsGlobalWindowInner::GetClientState() const {
5829   MOZ_ASSERT(NS_IsMainThread());
5830   if (mDoc && mDoc->IsStaticDocument()) {
5831     if (Maybe<ClientState> state =
5832             mDoc->GetOriginalDocument()->GetClientState()) {
5833       return state;
5834     }
5835   }
5836
5837   Maybe<ClientState> clientState;
5838   if (mClientSource) {
5839     Result<ClientState, ErrorResult> res = mClientSource->SnapshotState();
5840     if (res.isOk()) {
5841       clientState.emplace(res.unwrap());
5842     } else {
5843       res.unwrapErr().SuppressException();
5844     }
5845   }
5846   return clientState;
5847 }
5848
5849 Maybe<ServiceWorkerDescriptor> nsGlobalWindowInner::GetController() const {
5850   MOZ_ASSERT(NS_IsMainThread());
5851   if (mDoc && mDoc->IsStaticDocument()) {
5852     if (Maybe<ServiceWorkerDescriptor> controller =
5853             mDoc->GetOriginalDocument()->GetController()) {
5854       return controller;
5855     }
5856   }
5857
5858   Maybe<ServiceWorkerDescriptor> controller;
5859   if (mClientSource) {
5860     controller = mClientSource->GetController();
5861   }
5862   return controller;
5863 }
5864
5865 void nsGlobalWindowInner::SetCsp(nsIContentSecurityPolicy* aCsp) {
5866   if (!mClientSource) {
5867     return;
5868   }
5869   mClientSource->SetCsp(aCsp);
5870   // Also cache the CSP within the document
5871   mDoc->SetCsp(aCsp);
5872
5873   if (mWindowGlobalChild) {
5874     mWindowGlobalChild->SendSetClientInfo(mClientSource->Info().ToIPC());
5875   }
5876 }
5877
5878 void nsGlobalWindowInner::SetPreloadCsp(nsIContentSecurityPolicy* aPreloadCsp) {
5879   if (!mClientSource) {
5880     return;
5881   }
5882   mClientSource->SetPreloadCsp(aPreloadCsp);
5883   // Also cache the preload CSP within the document
5884   mDoc->SetPreloadCsp(aPreloadCsp);
5885
5886   if (mWindowGlobalChild) {
5887     mWindowGlobalChild->SendSetClientInfo(mClientSource->Info().ToIPC());
5888   }
5889 }
5890
5891 nsIContentSecurityPolicy* nsGlobalWindowInner::GetCsp() {
5892   if (mDoc) {
5893     return mDoc->GetCsp();
5894   }
5895
5896   // If the window is partially torn down and has its document nulled out,
5897   // we query the CSP we snapshot in FreeInnerObjects.
5898   if (mDocumentCsp) {
5899     return mDocumentCsp;
5900   }
5901   return nullptr;
5902 }
5903
5904 RefPtr<ServiceWorker> nsGlobalWindowInner::GetOrCreateServiceWorker(
5905     const ServiceWorkerDescriptor& aDescriptor) {
5906   MOZ_ASSERT(NS_IsMainThread());
5907   RefPtr<ServiceWorker> ref;
5908   ForEachEventTargetObject([&](DOMEventTargetHelper* aTarget, bool* aDoneOut) {
5909     RefPtr<ServiceWorker> sw = do_QueryObject(aTarget);
5910     if (!sw || !sw->Descriptor().Matches(aDescriptor)) {
5911       return;
5912     }
5913
5914     ref = std::move(sw);
5915     *aDoneOut = true;
5916   });
5917
5918   if (!ref) {
5919     ref = ServiceWorker::Create(this, aDescriptor);
5920   }
5921
5922   return ref;
5923 }
5924
5925 RefPtr<mozilla::dom::ServiceWorkerRegistration>
5926 nsGlobalWindowInner::GetServiceWorkerRegistration(
5927     const mozilla::dom::ServiceWorkerRegistrationDescriptor& aDescriptor)
5928     const {
5929   MOZ_ASSERT(NS_IsMainThread());
5930   RefPtr<ServiceWorkerRegistration> ref;
5931   ForEachEventTargetObject([&](DOMEventTargetHelper* aTarget, bool* aDoneOut) {
5932     RefPtr<ServiceWorkerRegistration> swr = do_QueryObject(aTarget);
5933     if (!swr || !swr->MatchesDescriptor(aDescriptor)) {
5934       return;
5935     }
5936
5937     ref = std::move(swr);
5938     *aDoneOut = true;
5939   });
5940   return ref;
5941 }
5942
5943 RefPtr<ServiceWorkerRegistration>
5944 nsGlobalWindowInner::GetOrCreateServiceWorkerRegistration(
5945     const ServiceWorkerRegistrationDescriptor& aDescriptor) {
5946   MOZ_ASSERT(NS_IsMainThread());
5947   RefPtr<ServiceWorkerRegistration> ref =
5948       GetServiceWorkerRegistration(aDescriptor);
5949   if (!ref) {
5950     ref = ServiceWorkerRegistration::CreateForMainThread(this, aDescriptor);
5951   }
5952   return ref;
5953 }
5954
5955 StorageAccess nsGlobalWindowInner::GetStorageAccess() {
5956   return StorageAllowedForWindow(this);
5957 }
5958
5959 nsresult nsGlobalWindowInner::FireDelayedDOMEvents(bool aIncludeSubWindows) {
5960   // Fires an offline status event if the offline status has changed
5961   FireOfflineStatusEventIfChanged();
5962
5963   if (!aIncludeSubWindows) {
5964     return NS_OK;
5965   }
5966
5967   nsCOMPtr<nsIDocShell> docShell = GetDocShell();
5968   if (docShell) {
5969     int32_t childCount = 0;
5970     docShell->GetInProcessChildCount(&childCount);
5971
5972     // Take a copy of the current children so that modifications to
5973     // the child list don't affect to the iteration.
5974     AutoTArray<nsCOMPtr<nsIDocShellTreeItem>, 8> children;
5975     for (int32_t i = 0; i < childCount; ++i) {
5976       nsCOMPtr<nsIDocShellTreeItem> childShell;
5977       docShell->GetInProcessChildAt(i, getter_AddRefs(childShell));
5978       if (childShell) {
5979         children.AppendElement(childShell);
5980       }
5981     }
5982
5983     for (nsCOMPtr<nsIDocShellTreeItem> childShell : children) {
5984       if (nsCOMPtr<nsPIDOMWindowOuter> pWin = childShell->GetWindow()) {
5985         auto* win = nsGlobalWindowOuter::Cast(pWin);
5986         win->FireDelayedDOMEvents(true);
5987       }
5988     }
5989   }
5990
5991   return NS_OK;
5992 }
5993
5994 //*****************************************************************************
5995 // nsGlobalWindowInner: Window Control Functions
5996 //*****************************************************************************
5997
5998 nsPIDOMWindowOuter* nsGlobalWindowInner::GetInProcessParentInternal() {
5999   nsGlobalWindowOuter* outer = GetOuterWindowInternal();
6000   if (!outer) {
6001     // No outer window available!
6002     return nullptr;
6003   }
6004   return outer->GetInProcessParentInternal();
6005 }
6006
6007 nsIPrincipal* nsGlobalWindowInner::GetTopLevelAntiTrackingPrincipal() {
6008   nsPIDOMWindowOuter* outerWindow = GetOuterWindowInternal();
6009   if (!outerWindow) {
6010     return nullptr;
6011   }
6012
6013   nsPIDOMWindowOuter* topLevelOuterWindow =
6014       GetBrowsingContext()->Top()->GetDOMWindow();
6015   if (!topLevelOuterWindow) {
6016     return nullptr;
6017   }
6018
6019   bool stopAtOurLevel =
6020       mDoc && mDoc->CookieJarSettings()->GetCookieBehavior() ==
6021                   nsICookieService::BEHAVIOR_REJECT_TRACKER;
6022
6023   if (stopAtOurLevel && topLevelOuterWindow == outerWindow) {
6024     return nullptr;
6025   }
6026
6027   nsPIDOMWindowInner* topLevelInnerWindow =
6028       topLevelOuterWindow->GetCurrentInnerWindow();
6029   if (NS_WARN_IF(!topLevelInnerWindow)) {
6030     return nullptr;
6031   }
6032
6033   nsIPrincipal* topLevelPrincipal =
6034       nsGlobalWindowInner::Cast(topLevelInnerWindow)->GetPrincipal();
6035   if (NS_WARN_IF(!topLevelPrincipal)) {
6036     return nullptr;
6037   }
6038
6039   return topLevelPrincipal;
6040 }
6041
6042 nsIPrincipal* nsGlobalWindowInner::GetClientPrincipal() {
6043   return mClientSource ? mClientSource->GetPrincipal() : nullptr;
6044 }
6045
6046 //*****************************************************************************
6047 // nsGlobalWindowInner: Timeout Functions
6048 //*****************************************************************************
6049
6050 class WindowScriptTimeoutHandler final : public ScriptTimeoutHandler {
6051  public:
6052   NS_DECL_ISUPPORTS_INHERITED
6053   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(WindowScriptTimeoutHandler,
6054                                            ScriptTimeoutHandler)
6055
6056   WindowScriptTimeoutHandler(JSContext* aCx, nsIGlobalObject* aGlobal,
6057                              const nsAString& aExpression)
6058       : ScriptTimeoutHandler(aCx, aGlobal, aExpression),
6059         mInitiatingScript(ScriptLoader::GetActiveScript(aCx)) {}
6060
6061   MOZ_CAN_RUN_SCRIPT virtual bool Call(const char* aExecutionReason) override;
6062
6063  private:
6064   virtual ~WindowScriptTimeoutHandler() = default;
6065
6066   // Initiating script for use when evaluating mExpr on the main thread.
6067   RefPtr<JS::loader::LoadedScript> mInitiatingScript;
6068 };
6069
6070 NS_IMPL_CYCLE_COLLECTION_INHERITED(WindowScriptTimeoutHandler,
6071                                    ScriptTimeoutHandler, mInitiatingScript)
6072
6073 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(WindowScriptTimeoutHandler)
6074 NS_INTERFACE_MAP_END_INHERITING(ScriptTimeoutHandler)
6075
6076 NS_IMPL_ADDREF_INHERITED(WindowScriptTimeoutHandler, ScriptTimeoutHandler)
6077 NS_IMPL_RELEASE_INHERITED(WindowScriptTimeoutHandler, ScriptTimeoutHandler)
6078
6079 bool WindowScriptTimeoutHandler::Call(const char* aExecutionReason) {
6080   // New script entry point required, due to the "Create a script" sub-step
6081   // of
6082   // http://www.whatwg.org/specs/web-apps/current-work/#timer-initialisation-steps
6083   nsAutoMicroTask mt;
6084   AutoEntryScript aes(mGlobal, aExecutionReason, true);
6085   JS::CompileOptions options(aes.cx());
6086   options.setFileAndLine(mFileName.get(), mLineNo);
6087   options.setNoScriptRval(true);
6088   options.setIntroductionType("domTimer");
6089   JS::Rooted<JSObject*> global(aes.cx(), mGlobal->GetGlobalJSObject());
6090   {
6091     JSExecutionContext exec(aes.cx(), global, options);
6092     nsresult rv = exec.Compile(mExpr);
6093
6094     JS::Rooted<JSScript*> script(aes.cx(), exec.MaybeGetScript());
6095     if (script) {
6096       if (mInitiatingScript) {
6097         mInitiatingScript->AssociateWithScript(script);
6098       }
6099
6100       rv = exec.ExecScript();
6101     }
6102
6103     if (rv == NS_SUCCESS_DOM_SCRIPT_EVALUATION_THREW_UNCATCHABLE) {
6104       return false;
6105     }
6106   }
6107
6108   return true;
6109 };
6110
6111 nsGlobalWindowInner* nsGlobalWindowInner::InnerForSetTimeoutOrInterval(
6112     ErrorResult& aError) {
6113   nsGlobalWindowOuter* outer = GetOuterWindowInternal();
6114   nsPIDOMWindowInner* currentInner =
6115       outer ? outer->GetCurrentInnerWindow() : this;
6116
6117   // If forwardTo is not the window with an active document then we want the
6118   // call to setTimeout/Interval to be a noop, so return null but don't set an
6119   // error.
6120   return HasActiveDocument() ? nsGlobalWindowInner::Cast(currentInner)
6121                              : nullptr;
6122 }
6123
6124 int32_t nsGlobalWindowInner::SetTimeout(JSContext* aCx, Function& aFunction,
6125                                         int32_t aTimeout,
6126                                         const Sequence<JS::Value>& aArguments,
6127                                         ErrorResult& aError) {
6128   return SetTimeoutOrInterval(aCx, aFunction, aTimeout, aArguments, false,
6129                               aError);
6130 }
6131
6132 int32_t nsGlobalWindowInner::SetTimeout(JSContext* aCx,
6133                                         const nsAString& aHandler,
6134                                         int32_t aTimeout,
6135                                         const Sequence<JS::Value>& /* unused */,
6136                                         ErrorResult& aError) {
6137   return SetTimeoutOrInterval(aCx, aHandler, aTimeout, false, aError);
6138 }
6139
6140 int32_t nsGlobalWindowInner::SetInterval(JSContext* aCx, Function& aFunction,
6141                                          const int32_t aTimeout,
6142                                          const Sequence<JS::Value>& aArguments,
6143                                          ErrorResult& aError) {
6144   return SetTimeoutOrInterval(aCx, aFunction, aTimeout, aArguments, true,
6145                               aError);
6146 }
6147
6148 int32_t nsGlobalWindowInner::SetInterval(
6149     JSContext* aCx, const nsAString& aHandler, const int32_t aTimeout,
6150     const Sequence<JS::Value>& /* unused */, ErrorResult& aError) {
6151   return SetTimeoutOrInterval(aCx, aHandler, aTimeout, true, aError);
6152 }
6153
6154 int32_t nsGlobalWindowInner::SetTimeoutOrInterval(
6155     JSContext* aCx, Function& aFunction, int32_t aTimeout,
6156     const Sequence<JS::Value>& aArguments, bool aIsInterval,
6157     ErrorResult& aError) {
6158   nsGlobalWindowInner* inner = InnerForSetTimeoutOrInterval(aError);
6159   if (!inner) {
6160     return -1;
6161   }
6162
6163   if (inner != this) {
6164     RefPtr<nsGlobalWindowInner> innerRef(inner);
6165     return innerRef->SetTimeoutOrInterval(aCx, aFunction, aTimeout, aArguments,
6166                                           aIsInterval, aError);
6167   }
6168
6169   DebuggerNotificationDispatch(
6170       this, aIsInterval ? DebuggerNotificationType::SetInterval
6171                         : DebuggerNotificationType::SetTimeout);
6172
6173   if (!GetContextInternal() || !HasJSGlobal()) {
6174     // This window was already closed, or never properly initialized,
6175     // don't let a timer be scheduled on such a window.
6176     aError.Throw(NS_ERROR_NOT_INITIALIZED);
6177     return 0;
6178   }
6179
6180   nsTArray<JS::Heap<JS::Value>> args;
6181   if (!args.AppendElements(aArguments, fallible)) {
6182     aError.Throw(NS_ERROR_OUT_OF_MEMORY);
6183     return 0;
6184   }
6185
6186   RefPtr<TimeoutHandler> handler =
6187       new CallbackTimeoutHandler(aCx, this, &aFunction, std::move(args));
6188
6189   int32_t result;
6190   aError =
6191       mTimeoutManager->SetTimeout(handler, aTimeout, aIsInterval,
6192                                   Timeout::Reason::eTimeoutOrInterval, &result);
6193   return result;
6194 }
6195
6196 int32_t nsGlobalWindowInner::SetTimeoutOrInterval(JSContext* aCx,
6197                                                   const nsAString& aHandler,
6198                                                   int32_t aTimeout,
6199                                                   bool aIsInterval,
6200                                                   ErrorResult& aError) {
6201   nsGlobalWindowInner* inner = InnerForSetTimeoutOrInterval(aError);
6202   if (!inner) {
6203     return -1;
6204   }
6205
6206   if (inner != this) {
6207     RefPtr<nsGlobalWindowInner> innerRef(inner);
6208     return innerRef->SetTimeoutOrInterval(aCx, aHandler, aTimeout, aIsInterval,
6209                                           aError);
6210   }
6211
6212   DebuggerNotificationDispatch(
6213       this, aIsInterval ? DebuggerNotificationType::SetInterval
6214                         : DebuggerNotificationType::SetTimeout);
6215
6216   if (!GetContextInternal() || !HasJSGlobal()) {
6217     // This window was already closed, or never properly initialized,
6218     // don't let a timer be scheduled on such a window.
6219     aError.Throw(NS_ERROR_NOT_INITIALIZED);
6220     return 0;
6221   }
6222
6223   bool allowEval = false;
6224   aError = CSPEvalChecker::CheckForWindow(aCx, this, aHandler, &allowEval);
6225   if (NS_WARN_IF(aError.Failed()) || !allowEval) {
6226     return 0;
6227   }
6228
6229   RefPtr<TimeoutHandler> handler =
6230       new WindowScriptTimeoutHandler(aCx, this, aHandler);
6231
6232   int32_t result;
6233   aError =
6234       mTimeoutManager->SetTimeout(handler, aTimeout, aIsInterval,
6235                                   Timeout::Reason::eTimeoutOrInterval, &result);
6236   return result;
6237 }
6238
6239 static const char* GetTimeoutReasonString(Timeout* aTimeout) {
6240   switch (aTimeout->mReason) {
6241     case Timeout::Reason::eTimeoutOrInterval:
6242       if (aTimeout->mIsInterval) {
6243         return "setInterval handler";
6244       }
6245       return "setTimeout handler";
6246     case Timeout::Reason::eIdleCallbackTimeout:
6247       return "setIdleCallback handler (timed out)";
6248     case Timeout::Reason::eAbortSignalTimeout:
6249       return "AbortSignal timeout";
6250     case Timeout::Reason::eDelayedWebTaskTimeout:
6251       return "delayedWebTaskCallback handler (timed out)";
6252     default:
6253       MOZ_CRASH("Unexpected enum value");
6254       return "";
6255   }
6256   MOZ_CRASH("Unexpected enum value");
6257   return "";
6258 }
6259
6260 bool nsGlobalWindowInner::RunTimeoutHandler(Timeout* aTimeout,
6261                                             nsIScriptContext* aScx) {
6262   // Hold on to the timeout in case mExpr or mFunObj releases its
6263   // doc.
6264   // XXXbz Our caller guarantees it'll hold on to the timeout (because
6265   // we're MOZ_CAN_RUN_SCRIPT), so we can probably stop doing that...
6266   RefPtr<Timeout> timeout = aTimeout;
6267   Timeout* last_running_timeout = mTimeoutManager->BeginRunningTimeout(timeout);
6268   timeout->mRunning = true;
6269
6270   // Push this timeout's popup control state, which should only be
6271   // enabled the first time a timeout fires that was created while
6272   // popups were enabled and with a delay less than
6273   // "dom.disable_open_click_delay".
6274   AutoPopupStatePusher popupStatePusher(timeout->mPopupState);
6275
6276   // Clear the timeout's popup state, if any, to prevent interval
6277   // timeouts from repeatedly opening poups.
6278   timeout->mPopupState = PopupBlocker::openAbused;
6279
6280   uint32_t nestingLevel = TimeoutManager::GetNestingLevel();
6281   TimeoutManager::SetNestingLevel(timeout->mNestingLevel);
6282
6283   const char* reason = GetTimeoutReasonString(timeout);
6284
6285   nsCString str;
6286   if (profiler_thread_is_being_profiled_for_markers()) {
6287     TimeDuration originalInterval = timeout->When() - timeout->SubmitTime();
6288     str.Append(reason);
6289     str.Append(" with interval ");
6290     str.AppendInt(int(originalInterval.ToMilliseconds()));
6291     str.Append("ms: ");
6292     nsCString handlerDescription;
6293     timeout->mScriptHandler->GetDescription(handlerDescription);
6294     str.Append(handlerDescription);
6295   }
6296   AUTO_PROFILER_MARKER_TEXT("setTimeout callback", DOM,
6297                             MarkerOptions(MarkerStack::TakeBacktrace(
6298                                               timeout->TakeProfilerBacktrace()),
6299                                           MarkerInnerWindowId(mWindowID)),
6300                             str);
6301
6302   bool abortIntervalHandler;
6303   {
6304     RefPtr<TimeoutHandler> handler(timeout->mScriptHandler);
6305
6306     CallbackDebuggerNotificationGuard guard(
6307         this, timeout->mIsInterval
6308                   ? DebuggerNotificationType::SetIntervalCallback
6309                   : DebuggerNotificationType::SetTimeoutCallback);
6310     abortIntervalHandler = !handler->Call(reason);
6311   }
6312
6313   // If we received an uncatchable exception, do not schedule the timeout again.
6314   // This allows the slow script dialog to break easy DoS attacks like
6315   // setInterval(function() { while(1); }, 100);
6316   if (abortIntervalHandler) {
6317     // If it wasn't an interval timer to begin with, this does nothing.  If it
6318     // was, we'll treat it as a timeout that we just ran and discard it when
6319     // we return.
6320     timeout->mIsInterval = false;
6321   }
6322
6323   // We ignore any failures from calling EvaluateString() on the context or
6324   // Call() on a Function here since we're in a loop
6325   // where we're likely to be running timeouts whose OS timers
6326   // didn't fire in time and we don't want to not fire those timers
6327   // now just because execution of one timer failed. We can't
6328   // propagate the error to anyone who cares about it from this
6329   // point anyway, and the script context should have already reported
6330   // the script error in the usual way - so we just drop it.
6331
6332   TimeoutManager::SetNestingLevel(nestingLevel);
6333
6334   mTimeoutManager->EndRunningTimeout(last_running_timeout);
6335   timeout->mRunning = false;
6336
6337   return timeout->mCleared;
6338 }
6339
6340 //*****************************************************************************
6341 // nsGlobalWindowInner: Helper Functions
6342 //*****************************************************************************
6343
6344 already_AddRefed<nsIDocShellTreeOwner> nsGlobalWindowInner::GetTreeOwner() {
6345   FORWARD_TO_OUTER(GetTreeOwner, (), nullptr);
6346 }
6347
6348 already_AddRefed<nsIWebBrowserChrome>
6349 nsGlobalWindowInner::GetWebBrowserChrome() {
6350   nsCOMPtr<nsIDocShellTreeOwner> treeOwner = GetTreeOwner();
6351
6352   nsCOMPtr<nsIWebBrowserChrome> browserChrome = do_GetInterface(treeOwner);
6353   return browserChrome.forget();
6354 }
6355
6356 nsIScrollableFrame* nsGlobalWindowInner::GetScrollFrame() {
6357   FORWARD_TO_OUTER(GetScrollFrame, (), nullptr);
6358 }
6359
6360 bool nsGlobalWindowInner::IsPrivateBrowsing() {
6361   nsCOMPtr<nsILoadContext> loadContext = do_QueryInterface(GetDocShell());
6362   return loadContext && loadContext->UsePrivateBrowsing();
6363 }
6364
6365 void nsGlobalWindowInner::FlushPendingNotifications(FlushType aType) {
6366   if (mDoc) {
6367     mDoc->FlushPendingNotifications(aType);
6368   }
6369 }
6370
6371 void nsGlobalWindowInner::EnableDeviceSensor(uint32_t aType) {
6372   bool alreadyEnabled = false;
6373   for (uint32_t i = 0; i < mEnabledSensors.Length(); i++) {
6374     if (mEnabledSensors[i] == aType) {
6375       alreadyEnabled = true;
6376       break;
6377     }
6378   }
6379
6380   mEnabledSensors.AppendElement(aType);
6381
6382   if (alreadyEnabled) {
6383     return;
6384   }
6385
6386   nsCOMPtr<nsIDeviceSensors> ac = do_GetService(NS_DEVICE_SENSORS_CONTRACTID);
6387   if (ac) {
6388     ac->AddWindowListener(aType, this);
6389   }
6390 }
6391
6392 void nsGlobalWindowInner::DisableDeviceSensor(uint32_t aType) {
6393   int32_t doomedElement = -1;
6394   int32_t listenerCount = 0;
6395   for (uint32_t i = 0; i < mEnabledSensors.Length(); i++) {
6396     if (mEnabledSensors[i] == aType) {
6397       doomedElement = i;
6398       listenerCount++;
6399     }
6400   }
6401
6402   if (doomedElement == -1) {
6403     return;
6404   }
6405
6406   mEnabledSensors.RemoveElementAt(doomedElement);
6407
6408   if (listenerCount > 1) {
6409     return;
6410   }
6411
6412   nsCOMPtr<nsIDeviceSensors> ac = do_GetService(NS_DEVICE_SENSORS_CONTRACTID);
6413   if (ac) {
6414     ac->RemoveWindowListener(aType, this);
6415   }
6416 }
6417
6418 #if defined(MOZ_WIDGET_ANDROID)
6419 void nsGlobalWindowInner::EnableOrientationChangeListener() {
6420   if (!ShouldResistFingerprinting(RFPTarget::ScreenOrientation)) {
6421     mHasOrientationChangeListeners = true;
6422     mOrientationAngle = Orientation(CallerType::System);
6423   }
6424 }
6425
6426 void nsGlobalWindowInner::DisableOrientationChangeListener() {
6427   mHasOrientationChangeListeners = false;
6428 }
6429 #endif
6430
6431 void nsGlobalWindowInner::SetHasGamepadEventListener(
6432     bool aHasGamepad /* = true*/) {
6433   mHasGamepad = aHasGamepad;
6434   if (aHasGamepad) {
6435     EnableGamepadUpdates();
6436   }
6437 }
6438
6439 void nsGlobalWindowInner::NotifyDetectXRRuntimesCompleted() {
6440   if (!mXRRuntimeDetectionInFlight) {
6441     return;
6442   }
6443   mXRRuntimeDetectionInFlight = false;
6444   if (mXRPermissionRequestInFlight) {
6445     return;
6446   }
6447   gfx::VRManagerChild* vm = gfx::VRManagerChild::Get();
6448   bool supported = vm->RuntimeSupportsVR();
6449   if (!supported) {
6450     // A VR runtime was not installed; we can suppress
6451     // the permission prompt
6452     OnXRPermissionRequestCancel();
6453     return;
6454   }
6455   // A VR runtime was found.  Display a permission prompt before
6456   // allowing it to be accessed.
6457   // Connect to the VRManager in order to receive the runtime
6458   // detection results.
6459   mXRPermissionRequestInFlight = true;
6460   RefPtr<XRPermissionRequest> request =
6461       new XRPermissionRequest(this, WindowID());
6462   Unused << NS_WARN_IF(NS_FAILED(request->Start()));
6463 }
6464
6465 void nsGlobalWindowInner::RequestXRPermission() {
6466   if (IsDying()) {
6467     // Do not proceed if the window is dying, as that will result
6468     // in leaks of objects that get re-allocated after FreeInnerObjects
6469     // has been called, including mVREventObserver.
6470     return;
6471   }
6472   if (mXRPermissionGranted) {
6473     // Don't prompt redundantly once permission to
6474     // access XR devices has been granted.
6475     OnXRPermissionRequestAllow();
6476     return;
6477   }
6478   if (mXRRuntimeDetectionInFlight || mXRPermissionRequestInFlight) {
6479     // Don't allow multiple simultaneous permissions requests;
6480     return;
6481   }
6482   // Before displaying a permission prompt, detect
6483   // if there is any VR runtime installed.
6484   gfx::VRManagerChild* vm = gfx::VRManagerChild::Get();
6485   mXRRuntimeDetectionInFlight = true;
6486   EnableVRUpdates();
6487   vm->DetectRuntimes();
6488 }
6489
6490 void nsGlobalWindowInner::OnXRPermissionRequestAllow() {
6491   mXRPermissionRequestInFlight = false;
6492   if (IsDying()) {
6493     // The window may have started dying while the permission request
6494     // is in flight.
6495     // Do not proceed if the window is dying, as that will result
6496     // in leaks of objects that get re-allocated after FreeInnerObjects
6497     // has been called, including mNavigator.
6498     return;
6499   }
6500   mXRPermissionGranted = true;
6501
6502   NotifyHasXRSession();
6503
6504   dom::Navigator* nav = Navigator();
6505   MOZ_ASSERT(nav != nullptr);
6506   nav->OnXRPermissionRequestAllow();
6507 }
6508
6509 void nsGlobalWindowInner::OnXRPermissionRequestCancel() {
6510   mXRPermissionRequestInFlight = false;
6511   if (IsDying()) {
6512     // The window may have started dying while the permission request
6513     // is in flight.
6514     // Do not proceed if the window is dying, as that will result
6515     // in leaks of objects that get re-allocated after FreeInnerObjects
6516     // has been called, including mNavigator.
6517     return;
6518   }
6519   dom::Navigator* nav = Navigator();
6520   MOZ_ASSERT(nav != nullptr);
6521   nav->OnXRPermissionRequestCancel();
6522 }
6523
6524 void nsGlobalWindowInner::EventListenerAdded(nsAtom* aType) {
6525   if (aType == nsGkAtoms::onvrdisplayactivate ||
6526       aType == nsGkAtoms::onvrdisplayconnect ||
6527       aType == nsGkAtoms::onvrdisplaydeactivate ||
6528       aType == nsGkAtoms::onvrdisplaydisconnect ||
6529       aType == nsGkAtoms::onvrdisplaypresentchange) {
6530     RequestXRPermission();
6531   }
6532
6533   if (aType == nsGkAtoms::onvrdisplayactivate) {
6534     mHasVRDisplayActivateEvents = true;
6535   }
6536
6537   if (aType == nsGkAtoms::onunload && mWindowGlobalChild) {
6538     if (++mUnloadOrBeforeUnloadListenerCount == 1) {
6539       mWindowGlobalChild->BlockBFCacheFor(BFCacheStatus::UNLOAD_LISTENER);
6540     }
6541   }
6542
6543   if (aType == nsGkAtoms::onbeforeunload && mWindowGlobalChild) {
6544     if (!mozilla::SessionHistoryInParent() ||
6545         !StaticPrefs::
6546             docshell_shistory_bfcache_ship_allow_beforeunload_listeners()) {
6547       if (++mUnloadOrBeforeUnloadListenerCount == 1) {
6548         mWindowGlobalChild->BlockBFCacheFor(
6549             BFCacheStatus::BEFOREUNLOAD_LISTENER);
6550       }
6551     }
6552     if (!mDoc || !(mDoc->GetSandboxFlags() & SANDBOXED_MODALS)) {
6553       mWindowGlobalChild->BeforeUnloadAdded();
6554       MOZ_ASSERT(mWindowGlobalChild->BeforeUnloadListeners() > 0);
6555     }
6556   }
6557
6558   // We need to initialize localStorage in order to receive notifications.
6559   if (aType == nsGkAtoms::onstorage) {
6560     ErrorResult rv;
6561     GetLocalStorage(rv);
6562     rv.SuppressException();
6563
6564     if (NextGenLocalStorageEnabled() && mLocalStorage &&
6565         mLocalStorage->Type() == Storage::eLocalStorage) {
6566       auto object = static_cast<LSObject*>(mLocalStorage.get());
6567
6568       Unused << NS_WARN_IF(NS_FAILED(object->EnsureObserver()));
6569     }
6570   }
6571 }
6572
6573 void nsGlobalWindowInner::EventListenerRemoved(nsAtom* aType) {
6574   if (aType == nsGkAtoms::onunload && mWindowGlobalChild) {
6575     MOZ_ASSERT(mUnloadOrBeforeUnloadListenerCount > 0);
6576     if (--mUnloadOrBeforeUnloadListenerCount == 0) {
6577       mWindowGlobalChild->UnblockBFCacheFor(BFCacheStatus::UNLOAD_LISTENER);
6578     }
6579   }
6580
6581   if (aType == nsGkAtoms::onbeforeunload && mWindowGlobalChild) {
6582     if (!mozilla::SessionHistoryInParent() ||
6583         !StaticPrefs::
6584             docshell_shistory_bfcache_ship_allow_beforeunload_listeners()) {
6585       if (--mUnloadOrBeforeUnloadListenerCount == 0) {
6586         mWindowGlobalChild->UnblockBFCacheFor(
6587             BFCacheStatus::BEFOREUNLOAD_LISTENER);
6588       }
6589     }
6590     if (!mDoc || !(mDoc->GetSandboxFlags() & SANDBOXED_MODALS)) {
6591       mWindowGlobalChild->BeforeUnloadRemoved();
6592       MOZ_ASSERT(mWindowGlobalChild->BeforeUnloadListeners() >= 0);
6593     }
6594   }
6595
6596   if (aType == nsGkAtoms::onstorage) {
6597     if (NextGenLocalStorageEnabled() && mLocalStorage &&
6598         mLocalStorage->Type() == Storage::eLocalStorage &&
6599         // The remove event is fired even if this isn't the last listener, so
6600         // only remove if there are no other listeners left.
6601         mListenerManager &&
6602         !mListenerManager->HasListenersFor(nsGkAtoms::onstorage)) {
6603       auto object = static_cast<LSObject*>(mLocalStorage.get());
6604
6605       object->DropObserver();
6606     }
6607   }
6608 }
6609
6610 void nsGlobalWindowInner::NotifyHasXRSession() {
6611   if (IsDying()) {
6612     // Do not proceed if the window is dying, as that will result
6613     // in leaks of objects that get re-allocated after FreeInnerObjects
6614     // has been called, including mVREventObserver.
6615     return;
6616   }
6617   if (mWindowGlobalChild && !mHasXRSession) {
6618     mWindowGlobalChild->BlockBFCacheFor(BFCacheStatus::HAS_USED_VR);
6619   }
6620   mHasXRSession = true;
6621   EnableVRUpdates();
6622 }
6623
6624 bool nsGlobalWindowInner::HasUsedVR() const {
6625   // Returns true only if content has enumerated and activated
6626   // XR devices.  Detection of XR runtimes without activation
6627   // will not cause true to be returned.
6628   return mHasXRSession;
6629 }
6630
6631 bool nsGlobalWindowInner::IsVRContentDetected() const {
6632   // Returns true only if the content will respond to
6633   // the VRDisplayActivate event.
6634   return mHasVRDisplayActivateEvents;
6635 }
6636
6637 bool nsGlobalWindowInner::IsVRContentPresenting() const {
6638   for (const auto& display : mVRDisplays) {
6639     if (display->IsAnyPresenting(gfx::kVRGroupAll)) {
6640       return true;
6641     }
6642   }
6643   return false;
6644 }
6645
6646 void nsGlobalWindowInner::AddSizeOfIncludingThis(
6647     nsWindowSizes& aWindowSizes) const {
6648   aWindowSizes.mDOMSizes.mDOMOtherSize +=
6649       aWindowSizes.mState.mMallocSizeOf(this);
6650   aWindowSizes.mDOMSizes.mDOMOtherSize +=
6651       nsIGlobalObject::ShallowSizeOfExcludingThis(
6652           aWindowSizes.mState.mMallocSizeOf);
6653
6654   EventListenerManager* elm = GetExistingListenerManager();
6655   if (elm) {
6656     aWindowSizes.mDOMSizes.mDOMOtherSize +=
6657         elm->SizeOfIncludingThis(aWindowSizes.mState.mMallocSizeOf);
6658     aWindowSizes.mDOMEventListenersCount += elm->ListenerCount();
6659   }
6660   if (mDoc) {
6661     // Multiple global windows can share a document. So only measure the
6662     // document if it (a) doesn't have a global window, or (b) it's the
6663     // primary document for the window.
6664     if (!mDoc->GetInnerWindow() || mDoc->GetInnerWindow() == this) {
6665       mDoc->DocAddSizeOfIncludingThis(aWindowSizes);
6666     }
6667   }
6668
6669   if (mNavigator) {
6670     aWindowSizes.mDOMSizes.mDOMOtherSize +=
6671         mNavigator->SizeOfIncludingThis(aWindowSizes.mState.mMallocSizeOf);
6672   }
6673
6674   ForEachEventTargetObject([&](DOMEventTargetHelper* et, bool* aDoneOut) {
6675     if (nsCOMPtr<nsISizeOfEventTarget> iSizeOf = do_QueryObject(et)) {
6676       aWindowSizes.mDOMSizes.mDOMEventTargetsSize +=
6677           iSizeOf->SizeOfEventTargetIncludingThis(
6678               aWindowSizes.mState.mMallocSizeOf);
6679     }
6680     if (EventListenerManager* elm = et->GetExistingListenerManager()) {
6681       aWindowSizes.mDOMEventListenersCount += elm->ListenerCount();
6682     }
6683     ++aWindowSizes.mDOMEventTargetsCount;
6684   });
6685
6686   if (mPerformance) {
6687     aWindowSizes.mDOMSizes.mDOMPerformanceUserEntries =
6688         mPerformance->SizeOfUserEntries(aWindowSizes.mState.mMallocSizeOf);
6689     aWindowSizes.mDOMSizes.mDOMPerformanceResourceEntries =
6690         mPerformance->SizeOfResourceEntries(aWindowSizes.mState.mMallocSizeOf);
6691     aWindowSizes.mDOMSizes.mDOMPerformanceEventEntries =
6692         mPerformance->SizeOfEventEntries(aWindowSizes.mState.mMallocSizeOf);
6693   }
6694 }
6695
6696 void nsGlobalWindowInner::RegisterDataDocumentForMemoryReporting(
6697     Document* aDocument) {
6698   aDocument->SetAddedToMemoryReportAsDataDocument();
6699   mDataDocumentsForMemoryReporting.AppendElement(
6700       do_GetWeakReference(aDocument));
6701 }
6702
6703 void nsGlobalWindowInner::UnregisterDataDocumentForMemoryReporting(
6704     Document* aDocument) {
6705   nsWeakPtr doc = do_GetWeakReference(aDocument);
6706   MOZ_ASSERT(mDataDocumentsForMemoryReporting.Contains(doc));
6707   mDataDocumentsForMemoryReporting.RemoveElement(doc);
6708 }
6709
6710 void nsGlobalWindowInner::CollectDOMSizesForDataDocuments(
6711     nsWindowSizes& aSize) const {
6712   for (const nsWeakPtr& ptr : mDataDocumentsForMemoryReporting) {
6713     if (nsCOMPtr<Document> doc = do_QueryReferent(ptr)) {
6714       doc->DocAddSizeOfIncludingThis(aSize);
6715     }
6716   }
6717 }
6718
6719 void nsGlobalWindowInner::AddGamepad(GamepadHandle aHandle, Gamepad* aGamepad) {
6720   // Create the index we will present to content based on which indices are
6721   // already taken, as required by the spec.
6722   // https://w3c.github.io/gamepad/gamepad.html#widl-Gamepad-index
6723   int index = 0;
6724   while (mGamepadIndexSet.Contains(index)) {
6725     ++index;
6726   }
6727   mGamepadIndexSet.Put(index);
6728   aGamepad->SetIndex(index);
6729   mGamepads.InsertOrUpdate(aHandle, RefPtr{aGamepad});
6730 }
6731
6732 void nsGlobalWindowInner::RemoveGamepad(GamepadHandle aHandle) {
6733   RefPtr<Gamepad> gamepad;
6734   if (!mGamepads.Get(aHandle, getter_AddRefs(gamepad))) {
6735     return;
6736   }
6737   // Free up the index we were using so it can be reused
6738   mGamepadIndexSet.Remove(gamepad->Index());
6739   mGamepads.Remove(aHandle);
6740 }
6741
6742 void nsGlobalWindowInner::GetGamepads(nsTArray<RefPtr<Gamepad>>& aGamepads) {
6743   aGamepads.Clear();
6744
6745   // navigator.getGamepads() always returns an empty array when
6746   // privacy.resistFingerprinting is true.
6747   if (ShouldResistFingerprinting(RFPTarget::Gamepad)) {
6748     return;
6749   }
6750
6751   // mGamepads.Count() may not be sufficient, but it's not harmful.
6752   aGamepads.SetCapacity(mGamepads.Count());
6753   for (const auto& entry : mGamepads) {
6754     Gamepad* gamepad = entry.GetWeak();
6755     aGamepads.EnsureLengthAtLeast(gamepad->Index() + 1);
6756     aGamepads[gamepad->Index()] = gamepad;
6757   }
6758 }
6759
6760 already_AddRefed<Gamepad> nsGlobalWindowInner::GetGamepad(
6761     GamepadHandle aHandle) {
6762   RefPtr<Gamepad> gamepad;
6763
6764   if (mGamepads.Get(aHandle, getter_AddRefs(gamepad))) {
6765     return gamepad.forget();
6766   }
6767
6768   return nullptr;
6769 }
6770
6771 void nsGlobalWindowInner::SetHasSeenGamepadInput(bool aHasSeen) {
6772   mHasSeenGamepadInput = aHasSeen;
6773 }
6774
6775 bool nsGlobalWindowInner::HasSeenGamepadInput() { return mHasSeenGamepadInput; }
6776
6777 void nsGlobalWindowInner::SyncGamepadState() {
6778   if (mHasSeenGamepadInput) {
6779     RefPtr<GamepadManager> gamepadManager(GamepadManager::GetService());
6780     for (const auto& entry : mGamepads) {
6781       gamepadManager->SyncGamepadState(entry.GetKey(), this, entry.GetWeak());
6782     }
6783   }
6784 }
6785
6786 void nsGlobalWindowInner::StopGamepadHaptics() {
6787   if (mHasSeenGamepadInput) {
6788     RefPtr<GamepadManager> gamepadManager(GamepadManager::GetService());
6789     gamepadManager->StopHaptics();
6790   }
6791 }
6792
6793 bool nsGlobalWindowInner::UpdateVRDisplays(
6794     nsTArray<RefPtr<mozilla::dom::VRDisplay>>& aDevices) {
6795   VRDisplay::UpdateVRDisplays(mVRDisplays, this);
6796   aDevices = mVRDisplays.Clone();
6797   return true;
6798 }
6799
6800 void nsGlobalWindowInner::NotifyActiveVRDisplaysChanged() {
6801   if (mNavigator) {
6802     mNavigator->NotifyActiveVRDisplaysChanged();
6803   }
6804 }
6805
6806 void nsGlobalWindowInner::NotifyPresentationGenerationChanged(
6807     uint32_t aDisplayID) {
6808   for (const auto& display : mVRDisplays) {
6809     if (display->DisplayId() == aDisplayID) {
6810       display->OnPresentationGenerationChanged();
6811     }
6812   }
6813 }
6814
6815 void nsGlobalWindowInner::DispatchVRDisplayActivate(
6816     uint32_t aDisplayID, mozilla::dom::VRDisplayEventReason aReason) {
6817   // Ensure that our list of displays is up to date
6818   VRDisplay::UpdateVRDisplays(mVRDisplays, this);
6819
6820   // Search for the display identified with aDisplayID and fire the
6821   // event if found.
6822   for (const auto& display : mVRDisplays) {
6823     if (display->DisplayId() == aDisplayID) {
6824       if (aReason != VRDisplayEventReason::Navigation &&
6825           display->IsAnyPresenting(gfx::kVRGroupContent)) {
6826         // We only want to trigger this event if nobody is presenting to the
6827         // display already or when a page is loaded by navigating away
6828         // from a page with an active VR Presentation.
6829         continue;
6830       }
6831
6832       VRDisplayEventInit init;
6833       init.mBubbles = false;
6834       init.mCancelable = false;
6835       init.mDisplay = display;
6836       init.mReason.Construct(aReason);
6837
6838       RefPtr<VRDisplayEvent> event =
6839           VRDisplayEvent::Constructor(this, u"vrdisplayactivate"_ns, init);
6840       // vrdisplayactivate is a trusted event, allowing VRDisplay.requestPresent
6841       // to be used in response to link traversal, user request (chrome UX), and
6842       // HMD mounting detection sensors.
6843       event->SetTrusted(true);
6844       // VRDisplay.requestPresent normally requires a user gesture; however, an
6845       // exception is made to allow it to be called in response to
6846       // vrdisplayactivate during VR link traversal.
6847       display->StartHandlingVRNavigationEvent();
6848       DispatchEvent(*event);
6849       display->StopHandlingVRNavigationEvent();
6850       // Once we dispatch the event, we must not access any members as an event
6851       // listener can do anything, including closing windows.
6852       return;
6853     }
6854   }
6855 }
6856
6857 void nsGlobalWindowInner::DispatchVRDisplayDeactivate(
6858     uint32_t aDisplayID, mozilla::dom::VRDisplayEventReason aReason) {
6859   // Ensure that our list of displays is up to date
6860   VRDisplay::UpdateVRDisplays(mVRDisplays, this);
6861
6862   // Search for the display identified with aDisplayID and fire the
6863   // event if found.
6864   for (const auto& display : mVRDisplays) {
6865     if (display->DisplayId() == aDisplayID && display->IsPresenting()) {
6866       // We only want to trigger this event to content that is presenting to
6867       // the display already.
6868
6869       VRDisplayEventInit init;
6870       init.mBubbles = false;
6871       init.mCancelable = false;
6872       init.mDisplay = display;
6873       init.mReason.Construct(aReason);
6874
6875       RefPtr<VRDisplayEvent> event =
6876           VRDisplayEvent::Constructor(this, u"vrdisplaydeactivate"_ns, init);
6877       event->SetTrusted(true);
6878       DispatchEvent(*event);
6879       // Once we dispatch the event, we must not access any members as an event
6880       // listener can do anything, including closing windows.
6881       return;
6882     }
6883   }
6884 }
6885
6886 void nsGlobalWindowInner::DispatchVRDisplayConnect(uint32_t aDisplayID) {
6887   // Ensure that our list of displays is up to date
6888   VRDisplay::UpdateVRDisplays(mVRDisplays, this);
6889
6890   // Search for the display identified with aDisplayID and fire the
6891   // event if found.
6892   for (const auto& display : mVRDisplays) {
6893     if (display->DisplayId() == aDisplayID) {
6894       // Fire event even if not presenting to the display.
6895       VRDisplayEventInit init;
6896       init.mBubbles = false;
6897       init.mCancelable = false;
6898       init.mDisplay = display;
6899       // VRDisplayEvent.reason is not set for vrdisplayconnect
6900
6901       RefPtr<VRDisplayEvent> event =
6902           VRDisplayEvent::Constructor(this, u"vrdisplayconnect"_ns, init);
6903       event->SetTrusted(true);
6904       DispatchEvent(*event);
6905       // Once we dispatch the event, we must not access any members as an event
6906       // listener can do anything, including closing windows.
6907       return;
6908     }
6909   }
6910 }
6911
6912 void nsGlobalWindowInner::DispatchVRDisplayDisconnect(uint32_t aDisplayID) {
6913   // Ensure that our list of displays is up to date
6914   VRDisplay::UpdateVRDisplays(mVRDisplays, this);
6915
6916   // Search for the display identified with aDisplayID and fire the
6917   // event if found.
6918   for (const auto& display : mVRDisplays) {
6919     if (display->DisplayId() == aDisplayID) {
6920       // Fire event even if not presenting to the display.
6921       VRDisplayEventInit init;
6922       init.mBubbles = false;
6923       init.mCancelable = false;
6924       init.mDisplay = display;
6925       // VRDisplayEvent.reason is not set for vrdisplaydisconnect
6926
6927       RefPtr<VRDisplayEvent> event =
6928           VRDisplayEvent::Constructor(this, u"vrdisplaydisconnect"_ns, init);
6929       event->SetTrusted(true);
6930       DispatchEvent(*event);
6931       // Once we dispatch the event, we must not access any members as an event
6932       // listener can do anything, including closing windows.
6933       return;
6934     }
6935   }
6936 }
6937
6938 void nsGlobalWindowInner::DispatchVRDisplayPresentChange(uint32_t aDisplayID) {
6939   // Ensure that our list of displays is up to date
6940   VRDisplay::UpdateVRDisplays(mVRDisplays, this);
6941
6942   // Search for the display identified with aDisplayID and fire the
6943   // event if found.
6944   for (const auto& display : mVRDisplays) {
6945     if (display->DisplayId() == aDisplayID) {
6946       // Fire event even if not presenting to the display.
6947       VRDisplayEventInit init;
6948       init.mBubbles = false;
6949       init.mCancelable = false;
6950       init.mDisplay = display;
6951       // VRDisplayEvent.reason is not set for vrdisplaypresentchange
6952       RefPtr<VRDisplayEvent> event =
6953           VRDisplayEvent::Constructor(this, u"vrdisplaypresentchange"_ns, init);
6954       event->SetTrusted(true);
6955       DispatchEvent(*event);
6956       // Once we dispatch the event, we must not access any members as an event
6957       // listener can do anything, including closing windows.
6958       return;
6959     }
6960   }
6961 }
6962
6963 enum WindowState {
6964   // These constants need to match the constants in Window.webidl
6965   STATE_MAXIMIZED = 1,
6966   STATE_MINIMIZED = 2,
6967   STATE_NORMAL = 3,
6968   STATE_FULLSCREEN = 4
6969 };
6970
6971 uint16_t nsGlobalWindowInner::WindowState() {
6972   nsCOMPtr<nsIWidget> widget = GetMainWidget();
6973
6974   int32_t mode = widget ? widget->SizeMode() : 0;
6975
6976   switch (mode) {
6977     case nsSizeMode_Minimized:
6978       return STATE_MINIMIZED;
6979     case nsSizeMode_Maximized:
6980       return STATE_MAXIMIZED;
6981     case nsSizeMode_Fullscreen:
6982       return STATE_FULLSCREEN;
6983     case nsSizeMode_Normal:
6984       return STATE_NORMAL;
6985     default:
6986       NS_WARNING("Illegal window state for this chrome window");
6987       break;
6988   }
6989
6990   return STATE_NORMAL;
6991 }
6992
6993 bool nsGlobalWindowInner::IsFullyOccluded() {
6994   nsCOMPtr<nsIWidget> widget = GetMainWidget();
6995   return widget && widget->IsFullyOccluded();
6996 }
6997
6998 void nsGlobalWindowInner::Maximize() {
6999   if (nsCOMPtr<nsIWidget> widget = GetMainWidget()) {
7000     widget->SetSizeMode(nsSizeMode_Maximized);
7001   }
7002 }
7003
7004 void nsGlobalWindowInner::Minimize() {
7005   if (nsCOMPtr<nsIWidget> widget = GetMainWidget()) {
7006     widget->SetSizeMode(nsSizeMode_Minimized);
7007   }
7008 }
7009
7010 void nsGlobalWindowInner::Restore() {
7011   if (nsCOMPtr<nsIWidget> widget = GetMainWidget()) {
7012     widget->SetSizeMode(nsSizeMode_Normal);
7013   }
7014 }
7015
7016 void nsGlobalWindowInner::GetWorkspaceID(nsAString& workspaceID) {
7017   workspaceID.Truncate();
7018   if (nsCOMPtr<nsIWidget> widget = GetMainWidget()) {
7019     return widget->GetWorkspaceID(workspaceID);
7020   }
7021 }
7022
7023 void nsGlobalWindowInner::MoveToWorkspace(const nsAString& workspaceID) {
7024   if (nsCOMPtr<nsIWidget> widget = GetMainWidget()) {
7025     widget->MoveToWorkspace(workspaceID);
7026   }
7027 }
7028
7029 void nsGlobalWindowInner::GetAttention(ErrorResult& aResult) {
7030   return GetAttentionWithCycleCount(-1, aResult);
7031 }
7032
7033 void nsGlobalWindowInner::GetAttentionWithCycleCount(int32_t aCycleCount,
7034                                                      ErrorResult& aError) {
7035   nsCOMPtr<nsIWidget> widget = GetMainWidget();
7036
7037   if (widget) {
7038     aError = widget->GetAttention(aCycleCount);
7039   }
7040 }
7041
7042 already_AddRefed<Promise> nsGlobalWindowInner::PromiseDocumentFlushed(
7043     PromiseDocumentFlushedCallback& aCallback, ErrorResult& aError) {
7044   MOZ_RELEASE_ASSERT(IsChromeWindow());
7045
7046   if (!IsCurrentInnerWindow()) {
7047     aError.ThrowInvalidStateError("Not the current inner window");
7048     return nullptr;
7049   }
7050   if (!mDoc) {
7051     aError.ThrowInvalidStateError("No document");
7052     return nullptr;
7053   }
7054
7055   if (mIteratingDocumentFlushedResolvers) {
7056     aError.ThrowInvalidStateError("Already iterating through resolvers");
7057     return nullptr;
7058   }
7059
7060   PresShell* presShell = mDoc->GetPresShell();
7061   if (!presShell) {
7062     aError.ThrowInvalidStateError("No pres shell");
7063     return nullptr;
7064   }
7065
7066   // We need to associate the lifetime of the Promise to the lifetime
7067   // of the caller's global. That way, if the window we're observing
7068   // refresh driver ticks on goes away before our observer is fired,
7069   // we can still resolve the Promise.
7070   nsIGlobalObject* global = GetIncumbentGlobal();
7071   if (!global) {
7072     aError.ThrowInvalidStateError("No incumbent global");
7073     return nullptr;
7074   }
7075
7076   RefPtr<Promise> resultPromise = Promise::Create(global, aError);
7077   if (aError.Failed()) {
7078     return nullptr;
7079   }
7080
7081   UniquePtr<PromiseDocumentFlushedResolver> flushResolver(
7082       new PromiseDocumentFlushedResolver(resultPromise, aCallback));
7083
7084   if (!presShell->NeedStyleFlush() && !presShell->NeedLayoutFlush()) {
7085     flushResolver->Call();
7086     return resultPromise.forget();
7087   }
7088
7089   if (!TryToObserveRefresh()) {
7090     aError.ThrowInvalidStateError("Couldn't observe refresh");
7091     return nullptr;
7092   }
7093
7094   mDocumentFlushedResolvers.AppendElement(std::move(flushResolver));
7095   return resultPromise.forget();
7096 }
7097
7098 bool nsGlobalWindowInner::TryToObserveRefresh() {
7099   if (mObservingRefresh) {
7100     return true;
7101   }
7102
7103   if (!mDoc) {
7104     return false;
7105   }
7106
7107   nsPresContext* pc = mDoc->GetPresContext();
7108   if (!pc) {
7109     return false;
7110   }
7111
7112   mObservingRefresh = true;
7113   auto observer = MakeRefPtr<ManagedPostRefreshObserver>(
7114       pc, [win = RefPtr{this}](bool aWasCanceled) {
7115         if (win->MaybeCallDocumentFlushedResolvers(
7116                 /* aUntilExhaustion = */ aWasCanceled)) {
7117           return ManagedPostRefreshObserver::Unregister::No;
7118         }
7119         win->mObservingRefresh = false;
7120         return ManagedPostRefreshObserver::Unregister::Yes;
7121       });
7122   pc->RegisterManagedPostRefreshObserver(observer.get());
7123   return mObservingRefresh;
7124 }
7125
7126 void nsGlobalWindowInner::CallDocumentFlushedResolvers(bool aUntilExhaustion) {
7127   while (true) {
7128     {
7129       // To coalesce MicroTask checkpoints inside callback call, enclose the
7130       // inner loop with nsAutoMicroTask, and perform a MicroTask checkpoint
7131       // after the loop.
7132       nsAutoMicroTask mt;
7133
7134       mIteratingDocumentFlushedResolvers = true;
7135
7136       auto resolvers = std::move(mDocumentFlushedResolvers);
7137       for (const auto& resolver : resolvers) {
7138         resolver->Call();
7139       }
7140
7141       mIteratingDocumentFlushedResolvers = false;
7142     }
7143
7144     // Leaving nsAutoMicroTask above will perform MicroTask checkpoint, and
7145     // Promise callbacks there may create mDocumentFlushedResolvers items.
7146
7147     // If there's no new resolvers, or we're not exhausting the queue, there's
7148     // nothing to do (we'll keep observing if there's any new observer).
7149     //
7150     // Otherwise, keep looping to call all promises. This case can happen while
7151     // destroying the window.  This violates the constraint that the
7152     // promiseDocumentFlushed callback only ever run when no flush is needed,
7153     // but it's necessary to resolve the Promise returned by that.
7154     if (!aUntilExhaustion || mDocumentFlushedResolvers.IsEmpty()) {
7155       break;
7156     }
7157   }
7158 }
7159
7160 bool nsGlobalWindowInner::MaybeCallDocumentFlushedResolvers(
7161     bool aUntilExhaustion) {
7162   MOZ_ASSERT(mDoc);
7163
7164   PresShell* presShell = mDoc->GetPresShell();
7165   if (!presShell || aUntilExhaustion) {
7166     CallDocumentFlushedResolvers(/* aUntilExhaustion = */ true);
7167     return false;
7168   }
7169
7170   if (presShell->NeedStyleFlush() || presShell->NeedLayoutFlush()) {
7171     // By the time our observer fired, something has already invalidated
7172     // style or layout - or perhaps we're still in the middle of a flush that
7173     // was interrupted. In either case, we'll wait until the next refresh driver
7174     // tick instead and try again.
7175     return true;
7176   }
7177
7178   CallDocumentFlushedResolvers(/* aUntilExhaustion = */ false);
7179   return !mDocumentFlushedResolvers.IsEmpty();
7180 }
7181
7182 already_AddRefed<nsWindowRoot> nsGlobalWindowInner::GetWindowRoot(
7183     mozilla::ErrorResult& aError) {
7184   FORWARD_TO_OUTER_OR_THROW(GetWindowRootOuter, (), aError, nullptr);
7185 }
7186
7187 void nsGlobalWindowInner::SetCursor(const nsACString& aCursor,
7188                                     ErrorResult& aError) {
7189   FORWARD_TO_OUTER_OR_THROW(SetCursorOuter, (aCursor, aError), aError, );
7190 }
7191
7192 nsIBrowserDOMWindow* nsGlobalWindowInner::GetBrowserDOMWindow(
7193     ErrorResult& aError) {
7194   FORWARD_TO_OUTER_OR_THROW(GetBrowserDOMWindow, (), aError, nullptr);
7195 }
7196
7197 void nsGlobalWindowInner::SetBrowserDOMWindow(
7198     nsIBrowserDOMWindow* aBrowserWindow, ErrorResult& aError) {
7199   FORWARD_TO_OUTER_OR_THROW(SetBrowserDOMWindowOuter, (aBrowserWindow),
7200                             aError, );
7201 }
7202
7203 void nsGlobalWindowInner::NotifyDefaultButtonLoaded(Element& aDefaultButton,
7204                                                     ErrorResult& aError) {
7205   // Don't snap to a disabled button.
7206   nsCOMPtr<nsIDOMXULControlElement> xulControl = aDefaultButton.AsXULControl();
7207   if (!xulControl) {
7208     aError.Throw(NS_ERROR_FAILURE);
7209     return;
7210   }
7211   bool disabled;
7212   aError = xulControl->GetDisabled(&disabled);
7213   if (aError.Failed() || disabled) {
7214     return;
7215   }
7216
7217   // Get the button rect in screen coordinates.
7218   nsIFrame* frame = aDefaultButton.GetPrimaryFrame();
7219   if (!frame) {
7220     aError.Throw(NS_ERROR_FAILURE);
7221     return;
7222   }
7223   LayoutDeviceIntRect buttonRect = LayoutDeviceIntRect::FromAppUnitsToNearest(
7224       frame->GetScreenRectInAppUnits(),
7225       frame->PresContext()->AppUnitsPerDevPixel());
7226
7227   // Get the widget rect in screen coordinates.
7228   nsIWidget* widget = GetNearestWidget();
7229   if (!widget) {
7230     aError.Throw(NS_ERROR_FAILURE);
7231     return;
7232   }
7233   LayoutDeviceIntRect widgetRect = widget->GetScreenBounds();
7234
7235   // Convert the buttonRect coordinates from screen to the widget.
7236   buttonRect -= widgetRect.TopLeft();
7237   nsresult rv = widget->OnDefaultButtonLoaded(buttonRect);
7238   if (NS_FAILED(rv) && rv != NS_ERROR_NOT_IMPLEMENTED) {
7239     aError.Throw(rv);
7240   }
7241 }
7242
7243 ChromeMessageBroadcaster* nsGlobalWindowInner::MessageManager() {
7244   MOZ_ASSERT(IsChromeWindow());
7245   if (!mChromeFields.mMessageManager) {
7246     RefPtr<ChromeMessageBroadcaster> globalMM =
7247         nsFrameMessageManager::GetGlobalMessageManager();
7248     mChromeFields.mMessageManager = new ChromeMessageBroadcaster(globalMM);
7249   }
7250   return mChromeFields.mMessageManager;
7251 }
7252
7253 ChromeMessageBroadcaster* nsGlobalWindowInner::GetGroupMessageManager(
7254     const nsAString& aGroup) {
7255   MOZ_ASSERT(IsChromeWindow());
7256
7257   return mChromeFields.mGroupMessageManagers
7258       .LookupOrInsertWith(
7259           aGroup,
7260           [&] {
7261             return MakeAndAddRef<ChromeMessageBroadcaster>(MessageManager());
7262           })
7263       .get();
7264 }
7265
7266 void nsGlobalWindowInner::InitWasOffline() { mWasOffline = NS_IsOffline(); }
7267
7268 int16_t nsGlobalWindowInner::Orientation(CallerType aCallerType) {
7269   // GetOrientationAngle() returns 0, 90, 180 or 270.
7270   // window.orientation returns -90, 0, 90 or 180.
7271   if (nsIGlobalObject::ShouldResistFingerprinting(
7272           aCallerType, RFPTarget::ScreenOrientation)) {
7273     return 0;
7274   }
7275   nsScreen* s = GetScreen(IgnoreErrors());
7276   if (!s) {
7277     return 0;
7278   }
7279   int16_t angle = AssertedCast<int16_t>(s->GetOrientationAngle());
7280   return angle <= 180 ? angle : angle - 360;
7281 }
7282
7283 already_AddRefed<Console> nsGlobalWindowInner::GetConsole(JSContext* aCx,
7284                                                           ErrorResult& aRv) {
7285   if (!mConsole) {
7286     mConsole = Console::Create(aCx, this, aRv);
7287     if (NS_WARN_IF(aRv.Failed())) {
7288       return nullptr;
7289     }
7290   }
7291
7292   RefPtr<Console> console = mConsole;
7293   return console.forget();
7294 }
7295
7296 bool nsGlobalWindowInner::IsSecureContext() const {
7297   JS::Realm* realm = js::GetNonCCWObjectRealm(GetWrapperPreserveColor());
7298   return JS::GetIsSecureContext(realm);
7299 }
7300
7301 External* nsGlobalWindowInner::External() {
7302   if (!mExternal) {
7303     mExternal = new dom::External(ToSupports(this));
7304   }
7305
7306   return mExternal;
7307 }
7308
7309 void nsGlobalWindowInner::ClearDocumentDependentSlots(JSContext* aCx) {
7310   // If JSAPI OOMs here, there is basically nothing we can do to recover safely.
7311   if (!Window_Binding::ClearCachedDocumentValue(aCx, this) ||
7312       !Window_Binding::ClearCachedPerformanceValue(aCx, this)) {
7313     MOZ_CRASH("Unhandlable OOM while clearing document dependent slots.");
7314   }
7315 }
7316
7317 /* static */
7318 JSObject* nsGlobalWindowInner::CreateNamedPropertiesObject(
7319     JSContext* aCx, JS::Handle<JSObject*> aProto) {
7320   return WindowNamedPropertiesHandler::Create(aCx, aProto);
7321 }
7322
7323 void nsGlobalWindowInner::RedefineProperty(JSContext* aCx,
7324                                            const char* aPropName,
7325                                            JS::Handle<JS::Value> aValue,
7326                                            ErrorResult& aError) {
7327   JS::Rooted<JSObject*> thisObj(aCx, GetWrapperPreserveColor());
7328   if (!thisObj) {
7329     aError.Throw(NS_ERROR_UNEXPECTED);
7330     return;
7331   }
7332
7333   if (!JS_WrapObject(aCx, &thisObj) ||
7334       !JS_DefineProperty(aCx, thisObj, aPropName, aValue, JSPROP_ENUMERATE)) {
7335     aError.Throw(NS_ERROR_FAILURE);
7336   }
7337 }
7338
7339 void nsGlobalWindowInner::FireOnNewGlobalObject() {
7340   // AutoEntryScript required to invoke debugger hook, which is a
7341   // Gecko-specific concept at present.
7342   AutoEntryScript aes(this, "nsGlobalWindowInner report new global");
7343   JS::Rooted<JSObject*> global(aes.cx(), GetWrapper());
7344   JS_FireOnNewGlobalObject(aes.cx(), global);
7345 }
7346
7347 #if defined(_WINDOWS_) && !defined(MOZ_WRAPPED_WINDOWS_H)
7348 #  pragma message( \
7349       "wrapper failure reason: " MOZ_WINDOWS_WRAPPER_DISABLED_REASON)
7350 #  error "Never include unwrapped windows.h in this file!"
7351 #endif
7352
7353 already_AddRefed<Promise> nsGlobalWindowInner::CreateImageBitmap(
7354     const ImageBitmapSource& aImage, const ImageBitmapOptions& aOptions,
7355     ErrorResult& aRv) {
7356   return ImageBitmap::Create(this, aImage, Nothing(), aOptions, aRv);
7357 }
7358
7359 already_AddRefed<Promise> nsGlobalWindowInner::CreateImageBitmap(
7360     const ImageBitmapSource& aImage, int32_t aSx, int32_t aSy, int32_t aSw,
7361     int32_t aSh, const ImageBitmapOptions& aOptions, ErrorResult& aRv) {
7362   return ImageBitmap::Create(
7363       this, aImage, Some(gfx::IntRect(aSx, aSy, aSw, aSh)), aOptions, aRv);
7364 }
7365
7366 // https://html.spec.whatwg.org/#structured-cloning
7367 void nsGlobalWindowInner::StructuredClone(
7368     JSContext* aCx, JS::Handle<JS::Value> aValue,
7369     const StructuredSerializeOptions& aOptions,
7370     JS::MutableHandle<JS::Value> aRetval, ErrorResult& aError) {
7371   nsContentUtils::StructuredClone(aCx, this, aValue, aOptions, aRetval, aError);
7372 }
7373
7374 nsresult nsGlobalWindowInner::Dispatch(
7375     already_AddRefed<nsIRunnable>&& aRunnable) const {
7376   MOZ_RELEASE_ASSERT(NS_IsMainThread());
7377   return NS_DispatchToCurrentThread(std::move(aRunnable));
7378 }
7379
7380 nsISerialEventTarget* nsGlobalWindowInner::SerialEventTarget() const {
7381   MOZ_RELEASE_ASSERT(NS_IsMainThread());
7382   return GetMainThreadSerialEventTarget();
7383 }
7384
7385 Worklet* nsGlobalWindowInner::GetPaintWorklet(ErrorResult& aRv) {
7386   if (!mPaintWorklet) {
7387     nsIPrincipal* principal = GetPrincipal();
7388     if (!principal) {
7389       aRv.Throw(NS_ERROR_FAILURE);
7390       return nullptr;
7391     }
7392
7393     mPaintWorklet = PaintWorkletImpl::CreateWorklet(this, principal);
7394   }
7395
7396   return mPaintWorklet;
7397 }
7398
7399 void nsGlobalWindowInner::GetRegionalPrefsLocales(
7400     nsTArray<nsString>& aLocales) {
7401   MOZ_ASSERT(mozilla::intl::LocaleService::GetInstance());
7402
7403   AutoTArray<nsCString, 10> rpLocales;
7404   mozilla::intl::LocaleService::GetInstance()->GetRegionalPrefsLocales(
7405       rpLocales);
7406
7407   for (const auto& loc : rpLocales) {
7408     aLocales.AppendElement(NS_ConvertUTF8toUTF16(loc));
7409   }
7410 }
7411
7412 void nsGlobalWindowInner::GetWebExposedLocales(nsTArray<nsString>& aLocales) {
7413   MOZ_ASSERT(mozilla::intl::LocaleService::GetInstance());
7414
7415   AutoTArray<nsCString, 10> rpLocales;
7416   mozilla::intl::LocaleService::GetInstance()->GetWebExposedLocales(rpLocales);
7417
7418   for (const auto& loc : rpLocales) {
7419     aLocales.AppendElement(NS_ConvertUTF8toUTF16(loc));
7420   }
7421 }
7422
7423 IntlUtils* nsGlobalWindowInner::GetIntlUtils(ErrorResult& aError) {
7424   if (!mIntlUtils) {
7425     mIntlUtils = new IntlUtils(this);
7426   }
7427
7428   return mIntlUtils;
7429 }
7430
7431 void nsGlobalWindowInner::StoreSharedWorker(SharedWorker* aSharedWorker) {
7432   MOZ_ASSERT(aSharedWorker);
7433   MOZ_ASSERT(!mSharedWorkers.Contains(aSharedWorker));
7434
7435   mSharedWorkers.AppendElement(aSharedWorker);
7436 }
7437
7438 void nsGlobalWindowInner::ForgetSharedWorker(SharedWorker* aSharedWorker) {
7439   MOZ_ASSERT(aSharedWorker);
7440   MOZ_ASSERT(mSharedWorkers.Contains(aSharedWorker));
7441
7442   mSharedWorkers.RemoveElement(aSharedWorker);
7443 }
7444
7445 void nsGlobalWindowInner::StorageAccessPermissionChanged() {
7446   // Invalidate cached StorageAllowed field so that calls to GetLocalStorage
7447   // give us the updated localStorage object.
7448   ClearStorageAllowedCache();
7449
7450   // If we're always partitioning non-cookie third party storage then
7451   // there is no need to clear it when the user accepts requestStorageAccess.
7452   if (StaticPrefs::
7453           privacy_partition_always_partition_third_party_non_cookie_storage()) {
7454     // Just reset the active cookie and storage principals
7455     nsCOMPtr<nsICookieJarSettings> cjs;
7456     if (mDoc) {
7457       cjs = mDoc->CookieJarSettings();
7458     }
7459     StorageAccess storageAccess = StorageAllowedForWindow(this);
7460     if (ShouldPartitionStorage(storageAccess) &&
7461         StoragePartitioningEnabled(storageAccess, cjs)) {
7462       if (mDoc) {
7463         mDoc->ClearActiveCookieAndStoragePrincipals();
7464       }
7465       return;
7466     }
7467   }
7468
7469   PropagateStorageAccessPermissionGrantedToWorkers(*this);
7470
7471   // If we have a partitioned localStorage, it's time to replace it with a real
7472   // one in order to receive notifications.
7473
7474   if (mLocalStorage) {
7475     IgnoredErrorResult error;
7476     GetLocalStorage(error);
7477     if (NS_WARN_IF(error.Failed())) {
7478       return;
7479     }
7480
7481     MOZ_ASSERT(mLocalStorage &&
7482                mLocalStorage->Type() == Storage::eLocalStorage);
7483
7484     if (NextGenLocalStorageEnabled() && mListenerManager &&
7485         mListenerManager->HasListenersFor(nsGkAtoms::onstorage)) {
7486       auto object = static_cast<LSObject*>(mLocalStorage.get());
7487
7488       object->EnsureObserver();
7489     }
7490   }
7491
7492   // Reset the IndexedDB factory.
7493   mIndexedDB = nullptr;
7494
7495   // Reset DOM Cache
7496   mCacheStorage = nullptr;
7497
7498   // Reset the active cookie and storage principals
7499   if (mDoc) {
7500     mDoc->ClearActiveCookieAndStoragePrincipals();
7501     if (mWindowGlobalChild) {
7502       // XXX(farre): This is a bit backwards, but clearing the cookie
7503       // principal might make us end up with a new effective storage
7504       // principal on the child side than on the parent side, which
7505       // means that we need to sync it. See bug 1705359.
7506       mWindowGlobalChild->SetDocumentPrincipal(
7507           mDoc->NodePrincipal(), mDoc->EffectiveStoragePrincipal());
7508     }
7509   }
7510 }
7511
7512 ContentMediaController* nsGlobalWindowInner::GetContentMediaController() {
7513   if (mContentMediaController) {
7514     return mContentMediaController;
7515   }
7516   if (!mBrowsingContext) {
7517     return nullptr;
7518   }
7519
7520   mContentMediaController = new ContentMediaController(mBrowsingContext->Id());
7521   return mContentMediaController;
7522 }
7523
7524 void nsGlobalWindowInner::SetScrollMarks(const nsTArray<uint32_t>& aScrollMarks,
7525                                          bool aOnHScrollbar) {
7526   mScrollMarks.Assign(aScrollMarks);
7527   mScrollMarksOnHScrollbar = aOnHScrollbar;
7528
7529   // Mark the scrollbar for repainting.
7530   if (mDoc) {
7531     PresShell* presShell = mDoc->GetPresShell();
7532     if (presShell) {
7533       nsIScrollableFrame* sf = presShell->GetRootScrollFrameAsScrollable();
7534       if (sf) {
7535         sf->InvalidateScrollbars();
7536       }
7537     }
7538   }
7539 }
7540
7541 /* static */
7542 already_AddRefed<nsGlobalWindowInner> nsGlobalWindowInner::Create(
7543     nsGlobalWindowOuter* aOuterWindow, bool aIsChrome,
7544     WindowGlobalChild* aActor) {
7545   RefPtr<nsGlobalWindowInner> window =
7546       new nsGlobalWindowInner(aOuterWindow, aActor);
7547   if (aIsChrome) {
7548     window->mIsChrome = true;
7549     window->mCleanMessageManager = true;
7550   }
7551
7552   if (aActor) {
7553     aActor->InitWindowGlobal(window);
7554   }
7555
7556   window->InitWasOffline();
7557   return window.forget();
7558 }
7559
7560 JS::loader::ModuleLoaderBase* nsGlobalWindowInner::GetModuleLoader(
7561     JSContext* aCx) {
7562   Document* document = GetDocument();
7563   if (!document) {
7564     return nullptr;
7565   }
7566
7567   ScriptLoader* loader = document->ScriptLoader();
7568   if (!loader) {
7569     return nullptr;
7570   }
7571
7572   return loader->GetModuleLoader();
7573 }
7574
7575 nsIURI* nsPIDOMWindowInner::GetDocumentURI() const {
7576   return mDoc ? mDoc->GetDocumentURI() : mDocumentURI.get();
7577 }
7578
7579 nsIURI* nsPIDOMWindowInner::GetDocBaseURI() const {
7580   return mDoc ? mDoc->GetDocBaseURI() : mDocBaseURI.get();
7581 }
7582
7583 mozilla::dom::WindowContext* nsPIDOMWindowInner::GetWindowContext() const {
7584   return mWindowGlobalChild ? mWindowGlobalChild->WindowContext() : nullptr;
7585 }
7586
7587 bool nsPIDOMWindowInner::RemoveFromBFCacheSync() {
7588   if (Document* doc = GetExtantDoc()) {
7589     return doc->RemoveFromBFCacheSync();
7590   }
7591   return false;
7592 }
7593
7594 void nsPIDOMWindowInner::MaybeCreateDoc() {
7595   // XXX: Forward to outer?
7596   MOZ_ASSERT(!mDoc);
7597   if (nsIDocShell* docShell = GetDocShell()) {
7598     // Note that |document| here is the same thing as our mDoc, but we
7599     // don't have to explicitly set the member variable because the docshell
7600     // has already called SetNewDocument().
7601     nsCOMPtr<Document> document = docShell->GetDocument();
7602     Unused << document;
7603   }
7604 }
7605
7606 mozilla::dom::DocGroup* nsPIDOMWindowInner::GetDocGroup() const {
7607   Document* doc = GetExtantDoc();
7608   if (doc) {
7609     return doc->GetDocGroup();
7610   }
7611   return nullptr;
7612 }
7613
7614 mozilla::dom::BrowsingContextGroup*
7615 nsPIDOMWindowInner::GetBrowsingContextGroup() const {
7616   return mBrowsingContext ? mBrowsingContext->Group() : nullptr;
7617 }
7618
7619 nsIGlobalObject* nsPIDOMWindowInner::AsGlobal() {
7620   return nsGlobalWindowInner::Cast(this);
7621 }
7622
7623 const nsIGlobalObject* nsPIDOMWindowInner::AsGlobal() const {
7624   return nsGlobalWindowInner::Cast(this);
7625 }
7626
7627 void nsPIDOMWindowInner::SaveStorageAccessPermissionGranted() {
7628   WindowContext* wc = GetWindowContext();
7629   if (wc) {
7630     Unused << wc->SetUsingStorageAccess(true);
7631   }
7632
7633   nsGlobalWindowInner::Cast(this)->StorageAccessPermissionChanged();
7634 }
7635
7636 void nsPIDOMWindowInner::SaveStorageAccessPermissionRevoked() {
7637   WindowContext* wc = GetWindowContext();
7638   if (wc) {
7639     Unused << wc->SetUsingStorageAccess(false);
7640   }
7641
7642   nsGlobalWindowInner::Cast(this)->StorageAccessPermissionChanged();
7643 }
7644
7645 bool nsPIDOMWindowInner::UsingStorageAccess() {
7646   WindowContext* wc = GetWindowContext();
7647   if (!wc) {
7648     return false;
7649   }
7650
7651   return wc->GetUsingStorageAccess();
7652 }
7653
7654 nsPIDOMWindowInner::nsPIDOMWindowInner(nsPIDOMWindowOuter* aOuterWindow,
7655                                        WindowGlobalChild* aActor)
7656     : mMutationBits(0),
7657       mIsDocumentLoaded(false),
7658       mIsHandlingResizeEvent(false),
7659       mMayHaveDOMActivateEventListeners(false),
7660       mMayHavePaintEventListener(false),
7661       mMayHaveTouchEventListener(false),
7662       mMayHaveSelectionChangeEventListener(false),
7663       mMayHaveFormSelectEventListener(false),
7664       mMayHaveMouseEnterLeaveEventListener(false),
7665       mMayHavePointerEnterLeaveEventListener(false),
7666       mMayHaveTransitionEventListener(false),
7667       mMayHaveBeforeInputEventListenerForTelemetry(false),
7668       mMutationObserverHasObservedNodeForTelemetry(false),
7669       mOuterWindow(aOuterWindow),
7670       mWindowID(0),
7671       mHasNotifiedGlobalCreated(false),
7672       mMarkedCCGeneration(0),
7673       mHasTriedToCacheTopInnerWindow(false),
7674       mNumOfIndexedDBDatabases(0),
7675       mNumOfOpenWebSockets(0),
7676       mEvent(nullptr),
7677       mWindowGlobalChild(aActor),
7678       mWasSuspendedByGroup(false) {
7679   MOZ_ASSERT(aOuterWindow);
7680   mBrowsingContext = aOuterWindow->GetBrowsingContext();
7681
7682   if (mWindowGlobalChild) {
7683     mWindowID = aActor->InnerWindowId();
7684
7685     MOZ_ASSERT(mWindowGlobalChild->BrowsingContext() == mBrowsingContext);
7686   } else {
7687     mWindowID = nsContentUtils::GenerateWindowId();
7688   }
7689 }
7690
7691 nsPIDOMWindowInner::~nsPIDOMWindowInner() = default;
7692
7693 #undef FORWARD_TO_OUTER
7694 #undef FORWARD_TO_OUTER_OR_THROW
7695 #undef FORWARD_TO_OUTER_VOID