layout/base/nsPresContext.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 /* a presentation of a document, part 1 */
   8
   9 #include "nsPresContext.h"
  10 #include "nsPresContextInlines.h"
  11
  12 #include "mozilla/ArrayUtils.h"
  13 #if defined(MOZ_WIDGET_ANDROID)
  14 #  include "mozilla/AsyncEventDispatcher.h"
  15 #endif
  16 #include "mozilla/CycleCollectedJSContext.h"
  17 #include "mozilla/DebugOnly.h"
  18 #include "mozilla/Encoding.h"
  19 #include "mozilla/EventDispatcher.h"
  20 #include "mozilla/EventStateManager.h"
  21 #include "mozilla/PresShell.h"
  22 #include "mozilla/PresShellInlines.h"
  23
  24 #include "base/basictypes.h"
  25 #include "nsCRT.h"
  26 #include "nsCOMPtr.h"
  27 #include "nsCSSFrameConstructor.h"
  28 #include "nsDocShell.h"
  29 #include "nsIConsoleService.h"
  30 #include "nsIContentViewer.h"
  31 #include "nsPIDOMWindow.h"
  32 #include "mozilla/ServoStyleSet.h"
  33 #include "mozilla/MediaFeatureChange.h"
  34 #include "nsIContent.h"
  35 #include "nsIFrame.h"
  36 #include "mozilla/dom/BrowsingContext.h"
  37 #include "mozilla/dom/Document.h"
  38 #include "mozilla/dom/DocumentInlines.h"
  39 #include "nsIPrintSettings.h"
  40 #include "nsLanguageAtomService.h"
  41 #include "mozilla/LookAndFeel.h"
  42 #include "nsIInterfaceRequestorUtils.h"
  43 #include "nsHTMLDocument.h"
  44 #include "nsIWeakReferenceUtils.h"
  45 #include "nsThreadUtils.h"
  46 #include "nsLayoutUtils.h"
  47 #include "nsViewManager.h"
  48 #include "mozilla/RestyleManager.h"
  49 #include "gfxPlatform.h"
  50 #include "nsFontFaceLoader.h"
  51 #include "mozilla/AnimationEventDispatcher.h"
  52 #include "mozilla/EffectCompositor.h"
  53 #include "mozilla/EventListenerManager.h"
  54 #include "prenv.h"
  55 #include "nsTransitionManager.h"
  56 #include "nsAnimationManager.h"
  57 #include "CounterStyleManager.h"
  58 #include "mozilla/MemoryReporting.h"
  59 #include "mozilla/dom/Element.h"
  60 #include "nsIMessageManager.h"
  61 #include "mozilla/dom/HTMLBodyElement.h"
  62 #include "mozilla/dom/MediaQueryList.h"
  63 #include "mozilla/SMILAnimationController.h"
  64 #include "mozilla/css/ImageLoader.h"
  65 #include "mozilla/dom/PBrowserParent.h"
  66 #include "mozilla/dom/BrowserChild.h"
  67 #include "mozilla/dom/BrowserParent.h"
  68 #include "mozilla/dom/FontFaceSet.h"
  69 #include "mozilla/StaticPresData.h"
  70 #include "nsRefreshDriver.h"
  71 #include "LayerUserData.h"
  72 #include "mozilla/dom/NotifyPaintEvent.h"
  73 #include "nsFontCache.h"
  74 #include "nsFrameLoader.h"
  75 #include "nsContentUtils.h"
  76 #include "nsPIWindowRoot.h"
  77 #include "mozilla/Preferences.h"
  78 #include "gfxTextRun.h"
  79 #include "nsFontFaceUtils.h"
  80 #include "mozilla/GlobalStyleSheetCache.h"
  81 #include "mozilla/ServoBindings.h"
  82 #include "mozilla/StaticPrefs_bidi.h"
  83 #include "mozilla/StaticPrefs_layout.h"
  84 #include "mozilla/StaticPrefs_widget.h"
  85 #include "mozilla/StaticPrefs_zoom.h"
  86 #include "mozilla/StyleSheet.h"
  87 #include "mozilla/StyleSheetInlines.h"
  88 #include "mozilla/Telemetry.h"
  89 #include "mozilla/TimelineManager.h"
  90 #include "mozilla/dom/Performance.h"
  91 #include "mozilla/dom/PerformanceTiming.h"
  92 #include "mozilla/dom/PerformancePaintTiming.h"
  93 #include "mozilla/layers/APZThreadUtils.h"
  94 #include "MobileViewportManager.h"
  95 #include "mozilla/dom/ImageTracker.h"
  96 #ifdef ACCESSIBILITY
  97 #  include "mozilla/a11y/DocAccessible.h"
  98 #endif
  99
 100 // Needed for Start/Stop of Image Animation
 101 #include "imgIContainer.h"
 102 #include "nsIImageLoadingContent.h"
 103
 104 #include "nsBidiUtils.h"
 105 #include "nsServiceManagerUtils.h"
 106
 107 #include "mozilla/dom/URL.h"
 108 #include "mozilla/ServoCSSParser.h"
 109
 110 using namespace mozilla;
 111 using namespace mozilla::dom;
 112 using namespace mozilla::gfx;
 113 using namespace mozilla::layers;
 114
 115 /**
 116  * Layer UserData for ContainerLayers that want to be notified
 117  * of local invalidations of them and their descendant layers.
 118  * Pass a callback to ComputeDifferences to have these called.
 119  */
 120 class ContainerLayerPresContext : public LayerUserData {
 121  public:
 122   nsPresContext* mPresContext;
 123 };
 124
 125 bool nsPresContext::IsDOMPaintEventPending() {
 126   if (!mTransactions.IsEmpty()) {
 127     return true;
 128   }
 129
 130   nsRootPresContext* drpc = GetRootPresContext();
 131   if (drpc && drpc->mRefreshDriver->ViewManagerFlushIsPending()) {
 132     // Since we're promising that there will be a MozAfterPaint event
 133     // fired, we record an empty invalidation in case display list
 134     // invalidation doesn't invalidate anything further.
 135     NotifyInvalidation(drpc->mRefreshDriver->LastTransactionId().Next(),
 136                        nsRect(0, 0, 0, 0));
 137     return true;
 138   }
 139   return false;
 140 }
 141
 142 struct WeakRunnableMethod : Runnable {
 143   using Method = void (nsPresContext::*)();
 144
 145   WeakRunnableMethod(const char* aName, nsPresContext* aPc, Method aMethod)
 146       : Runnable(aName), mPresContext(aPc), mMethod(aMethod) {}
 147
 148   NS_IMETHOD Run() override {
 149     if (nsPresContext* pc = mPresContext.get()) {
 150       (pc->*mMethod)();
 151     }
 152     return NS_OK;
 153   }
 154
 155  private:
 156   WeakPtr<nsPresContext> mPresContext;
 157   Method mMethod;
 158 };
 159
 160 // When forcing a font-info-update reflow from style, we don't need to reframe,
 161 // but we'll need to restyle to pick up updated font metrics. In order to avoid
 162 // synchronously having to deal with multiple restyles, we use an early refresh
 163 // driver runner, which should prevent flashing for users.
 164 //
 165 // We might do a bit of extra work if the page flushes layout between the
 166 // restyle and when this happens, which is a bit unfortunate, but not worse than
 167 // what we used to do...
 168 //
 169 // A better solution would be to be able to synchronously initialize font
 170 // information from style worker threads, perhaps...
 171 void nsPresContext::ForceReflowForFontInfoUpdateFromStyle() {
 172   if (mPendingFontInfoUpdateReflowFromStyle) {
 173     return;
 174   }
 175
 176   mPendingFontInfoUpdateReflowFromStyle = true;
 177   nsCOMPtr<nsIRunnable> ev = new WeakRunnableMethod(
 178       "nsPresContext::DoForceReflowForFontInfoUpdateFromStyle", this,
 179       &nsPresContext::DoForceReflowForFontInfoUpdateFromStyle);
 180   RefreshDriver()->AddEarlyRunner(ev);
 181 }
 182
 183 void nsPresContext::DoForceReflowForFontInfoUpdateFromStyle() {
 184   mPendingFontInfoUpdateReflowFromStyle = false;
 185   ForceReflowForFontInfoUpdate(false);
 186 }
 187
 188 void nsPresContext::ForceReflowForFontInfoUpdate(bool aNeedsReframe) {
 189   // In the case of a static-clone document used for printing or print-preview,
 190   // this is undesirable because the nsPrintJob is holding weak refs to frames
 191   // that will get blown away unexpectedly by this reconstruction. So the
 192   // prescontext for a print/preview doc ignores the font-list update.
 193   //
 194   // This means the print document may still be using cached fonts that are no
 195   // longer present in the font list, but that should be safe given that all the
 196   // required font instances have already been created, so it won't be depending
 197   // on access to the font-list entries.
 198   //
 199   // XXX Actually, I think it's probably a bad idea to do *any* restyling of
 200   // print documents in response to pref changes. We could be in the middle
 201   // of printing the document, and reflowing all the frames might cause some
 202   // kind of unwanted mid-document discontinuity.
 203   if (IsPrintingOrPrintPreview()) {
 204     return;
 205   }
 206
 207   // If there's a user font set, discard any src:local() faces it may have
 208   // loaded because their font entries may no longer be valid.
 209   if (auto* fonts = Document()->GetFonts()) {
 210     fonts->GetImpl()->ForgetLocalFaces();
 211   }
 212
 213   FlushFontCache();
 214
 215   nsChangeHint changeHint =
 216       aNeedsReframe ? nsChangeHint_ReconstructFrame : NS_STYLE_HINT_REFLOW;
 217
 218   // We also need to trigger restyling for ex/ch units changes to take effect,
 219   // if needed.
 220   auto restyleHint = StyleSet()->UsesFontMetrics()
 221                          ? RestyleHint::RecascadeSubtree()
 222                          : RestyleHint{0};
 223
 224   RebuildAllStyleData(changeHint, restyleHint);
 225 }
 226
 227 static bool IsVisualCharset(NotNull<const Encoding*> aCharset) {
 228   return aCharset == ISO_8859_8_ENCODING;
 229 }
 230
 231 nsPresContext::nsPresContext(dom::Document* aDocument, nsPresContextType aType)
 232     : mPresShell(nullptr),
 233       mDocument(aDocument),
 234       mMedium(aType == eContext_Galley ? nsGkAtoms::screen : nsGkAtoms::print),
 235       mSystemFontScale(1.0),
 236       mTextZoom(1.0),
 237       mEffectiveTextZoom(1.0),
 238       mFullZoom(1.0),
 239       mLastFontInflationScreenSize(gfxSize(-1.0, -1.0)),
 240       mCurAppUnitsPerDevPixel(0),
 241       mAutoQualityMinFontSizePixelsPref(0),
 242       mDynamicToolbarMaxHeight(0),
 243       mDynamicToolbarHeight(0),
 244       mPageSize(-1, -1),
 245       mPageScale(0.0),
 246       mPPScale(1.0f),
 247       mViewportScrollOverrideElement(nullptr),
 248       mElementsRestyled(0),
 249       mFramesConstructed(0),
 250       mFramesReflowed(0),
 251       mInterruptChecksToSkip(0),
 252       mNextFrameRateMultiplier(0),
 253       mViewportScrollStyles(StyleOverflow::Auto, StyleOverflow::Auto),
 254       // mImageAnimationMode is initialised below, in constructor body
 255       mImageAnimationModePref(imgIContainer::kNormalAnimMode),
 256       mType(aType),
 257       mInflationDisabledForShrinkWrap(false),
 258       mInteractionTimeEnabled(true),
 259       mHasPendingInterrupt(false),
 260       mHasEverBuiltInvisibleText(false),
 261       mPendingInterruptFromTest(false),
 262       mInterruptsEnabled(false),
 263       mSendAfterPaintToContent(false),
 264       mDrawImageBackground(true),  // always draw the background
 265       mDrawColorBackground(true),
 266       // mNeverAnimate is initialised below, in constructor body
 267       mPaginated(aType != eContext_Galley),
 268       mCanPaginatedScroll(false),
 269       mDoScaledTwips(true),
 270       mIsRootPaginatedDocument(false),
 271       mPrefBidiDirection(false),
 272       mPrefScrollbarSide(0),
 273       mPendingThemeChanged(false),
 274       mPendingThemeChangeKind(0),
 275       mPendingUIResolutionChanged(false),
 276       mPendingFontInfoUpdateReflowFromStyle(false),
 277       mIsGlyph(false),
 278       mCounterStylesDirty(true),
 279       mFontFeatureValuesDirty(true),
 280       mFontPaletteValuesDirty(true),
 281       mIsVisual(false),
 282       mInRDMPane(false),
 283       mHasWarnedAboutTooLargeDashedOrDottedRadius(false),
 284       mQuirkSheetAdded(false),
 285       mHadNonBlankPaint(false),
 286       mHadContentfulPaint(false),
 287       mHadNonTickContentfulPaint(false),
 288       mHadContentfulPaintComposite(false),
 289 #ifdef DEBUG
 290       mInitialized(false),
 291 #endif
 292       mOverriddenOrEmbedderColorScheme(dom::PrefersColorSchemeOverride::None) {
 293 #ifdef DEBUG
 294   PodZero(&mLayoutPhaseCount);
 295 #endif
 296
 297   if (!IsDynamic()) {
 298     mImageAnimationMode = imgIContainer::kDontAnimMode;
 299     mNeverAnimate = true;
 300   } else {
 301     mImageAnimationMode = imgIContainer::kNormalAnimMode;
 302     mNeverAnimate = false;
 303   }
 304   NS_ASSERTION(mDocument, "Null document");
 305
 306   // if text perf logging enabled, init stats struct
 307   if (MOZ_LOG_TEST(gfxPlatform::GetLog(eGfxLog_textperf), LogLevel::Warning)) {
 308     mTextPerf = MakeUnique<gfxTextPerfMetrics>();
 309   }
 310
 311   if (StaticPrefs::gfx_missing_fonts_notify()) {
 312     mMissingFonts = MakeUnique<gfxMissingFontRecorder>();
 313   }
 314
 315   if (StaticPrefs::layout_dynamic_toolbar_max_height() > 0) {
 316     // The pref for dynamic toolbar max height is only used in reftests so it's
 317     // fine to set here.
 318     mDynamicToolbarMaxHeight = StaticPrefs::layout_dynamic_toolbar_max_height();
 319   }
 320
 321   UpdateFontVisibility();
 322 }
 323
 324 static const char* gExactCallbackPrefs[] = {
 325     "browser.active_color",
 326     "browser.anchor_color",
 327     "browser.underline_anchors",
 328     "browser.visited_color",
 329     "dom.meta-viewport.enabled",
 330     "dom.send_after_paint_to_content",
 331     "image.animation_mode",
 332     "intl.accept_languages",
 333     "layout.css.devPixelsPerPx",
 334     "layout.css.dpi",
 335     "privacy.trackingprotection.enabled",
 336     "ui.use_standins_for_native_colors",
 337     nullptr,
 338 };
 339
 340 static const char* gPrefixCallbackPrefs[] = {
 341     "bidi.", "browser.display.",    "browser.viewport.",
 342     "font.", "gfx.font_rendering.", "layout.css.font-visibility.",
 343     nullptr,
 344 };
 345
 346 void nsPresContext::Destroy() {
 347   if (mEventManager) {
 348     // unclear if these are needed, but can't hurt
 349     mEventManager->NotifyDestroyPresContext(this);
 350     mEventManager->SetPresContext(nullptr);
 351     mEventManager = nullptr;
 352   }
 353
 354   if (mFontCache) {
 355     mFontCache->Destroy();
 356     mFontCache = nullptr;
 357   }
 358
 359   // Unregister preference callbacks
 360   Preferences::UnregisterPrefixCallbacks(nsPresContext::PreferenceChanged,
 361                                          gPrefixCallbackPrefs, this);
 362   Preferences::UnregisterCallbacks(nsPresContext::PreferenceChanged,
 363                                    gExactCallbackPrefs, this);
 364
 365   mRefreshDriver = nullptr;
 366   MOZ_ASSERT(mManagedPostRefreshObservers.IsEmpty());
 367 }
 368
 369 nsPresContext::~nsPresContext() {
 370   MOZ_ASSERT(!mPresShell, "Presshell forgot to clear our mPresShell pointer");
 371   DetachPresShell();
 372
 373   Destroy();
 374 }
 375
 376 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsPresContext)
 377   NS_INTERFACE_MAP_ENTRY(nsISupports)
 378 NS_INTERFACE_MAP_END
 379
 380 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsPresContext)
 381 NS_IMPL_CYCLE_COLLECTING_RELEASE_WITH_LAST_RELEASE(nsPresContext, LastRelease())
 382
 383 void nsPresContext::LastRelease() {
 384   if (mMissingFonts) {
 385     mMissingFonts->Clear();
 386   }
 387 }
 388
 389 NS_IMPL_CYCLE_COLLECTION_CLASS(nsPresContext)
 390
 391 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsPresContext)
 392   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAnimationEventDispatcher);
 393   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocument);
 394   // NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(mDeviceContext); // not xpcom
 395   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEffectCompositor);
 396   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEventManager);
 397   // NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(mLanguage); // an atom
 398
 399   // NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTheme); // a service
 400   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPrintSettings);
 401 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 402
 403 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsPresContext)
 404   NS_IMPL_CYCLE_COLLECTION_UNLINK(mAnimationEventDispatcher);
 405   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocument);
 406   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDeviceContext);  // worth bothering?
 407   NS_IMPL_CYCLE_COLLECTION_UNLINK(mEffectCompositor);
 408   // NS_RELEASE(tmp->mLanguage); // an atom
 409   // NS_IMPL_CYCLE_COLLECTION_UNLINK(mTheme); // a service
 410   NS_IMPL_CYCLE_COLLECTION_UNLINK(mPrintSettings);
 411   NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_PTR
 412
 413   tmp->Destroy();
 414 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 415
 416 bool nsPresContext::IsChrome() const {
 417   return Document()->IsInChromeDocShell();
 418 }
 419
 420 void nsPresContext::GetUserPreferences() {
 421   if (!GetPresShell()) {
 422     // No presshell means nothing to do here.  We'll do this when we
 423     // get a presshell.
 424     return;
 425   }
 426
 427   mAutoQualityMinFontSizePixelsPref =
 428       Preferences::GetInt("browser.display.auto_quality_min_font_size");
 429
 430   PreferenceSheet::EnsureInitialized();
 431
 432   mSendAfterPaintToContent = Preferences::GetBool(
 433       "dom.send_after_paint_to_content", mSendAfterPaintToContent);
 434
 435   mPrefScrollbarSide = Preferences::GetInt("layout.scrollbar.side");
 436
 437   Document()->SetMayNeedFontPrefsUpdate();
 438
 439   // * image animation
 440   nsAutoCString animatePref;
 441   Preferences::GetCString("image.animation_mode", animatePref);
 442   if (animatePref.EqualsLiteral("normal"))
 443     mImageAnimationModePref = imgIContainer::kNormalAnimMode;
 444   else if (animatePref.EqualsLiteral("none"))
 445     mImageAnimationModePref = imgIContainer::kDontAnimMode;
 446   else if (animatePref.EqualsLiteral("once"))
 447     mImageAnimationModePref = imgIContainer::kLoopOnceAnimMode;
 448   else  // dynamic change to invalid value should act like it does initially
 449     mImageAnimationModePref = imgIContainer::kNormalAnimMode;
 450
 451   uint32_t bidiOptions = GetBidi();
 452
 453   mPrefBidiDirection = StaticPrefs::bidi_direction();
 454   SET_BIDI_OPTION_DIRECTION(bidiOptions, mPrefBidiDirection);
 455   SET_BIDI_OPTION_TEXTTYPE(bidiOptions, StaticPrefs::bidi_texttype());
 456   SET_BIDI_OPTION_NUMERAL(bidiOptions, StaticPrefs::bidi_numeral());
 457
 458   // We don't need to force reflow: either we are initializing a new
 459   // prescontext or we are being called from PreferenceChanged()
 460   // which triggers a reflow anyway.
 461   SetBidi(bidiOptions);
 462 }
 463
 464 void nsPresContext::InvalidatePaintedLayers() {
 465   if (!mPresShell) {
 466     return;
 467   }
 468   if (nsIFrame* rootFrame = mPresShell->GetRootFrame()) {
 469     // FrameLayerBuilder caches invalidation-related values that depend on the
 470     // appunits-per-dev-pixel ratio, so ensure that all PaintedLayer drawing
 471     // is completely flushed.
 472     rootFrame->InvalidateFrameSubtree();
 473   }
 474 }
 475
 476 void nsPresContext::AppUnitsPerDevPixelChanged() {
 477   int32_t oldAppUnitsPerDevPixel = mCurAppUnitsPerDevPixel;
 478
 479   InvalidatePaintedLayers();
 480
 481   FlushFontCache();
 482
 483   MediaFeatureValuesChanged(
 484       {RestyleHint::RecascadeSubtree(), NS_STYLE_HINT_REFLOW,
 485        MediaFeatureChangeReason::ResolutionChange},
 486       MediaFeatureChangePropagation::JustThisDocument);
 487
 488   mCurAppUnitsPerDevPixel = mDeviceContext->AppUnitsPerDevPixel();
 489
 490 #ifdef ACCESSIBILITY
 491   if (mCurAppUnitsPerDevPixel != oldAppUnitsPerDevPixel) {
 492     if (nsAccessibilityService* accService = GetAccService()) {
 493       accService->NotifyOfDevPixelRatioChange(mPresShell,
 494                                               mCurAppUnitsPerDevPixel);
 495     }
 496   }
 497 #endif
 498
 499   // Recompute the size for vh units since it's changed by the dynamic toolbar
 500   // max height which is stored in screen coord.
 501   if (IsRootContentDocumentCrossProcess()) {
 502     AdjustSizeForViewportUnits();
 503   }
 504
 505   // nsSubDocumentFrame uses a AppUnitsPerDevPixel difference between parent and
 506   // child document to determine if it needs to build a nsDisplayZoom item. So
 507   // if we that changes then we need to invalidate the subdoc frame so that
 508   // item gets created/removed.
 509   if (mPresShell) {
 510     if (nsIFrame* frame = mPresShell->GetRootFrame()) {
 511       frame = nsLayoutUtils::GetCrossDocParentFrameInProcess(frame);
 512       if (frame) {
 513         int32_t parentAPD = frame->PresContext()->AppUnitsPerDevPixel();
 514         if ((parentAPD == oldAppUnitsPerDevPixel) !=
 515             (parentAPD == mCurAppUnitsPerDevPixel)) {
 516           frame->InvalidateFrame();
 517         }
 518       }
 519     }
 520   }
 521
 522   // We would also have to look at all of our child subdocuments but the
 523   // InvalidatePaintedLayers call above calls InvalidateFrameSubtree which
 524   // would invalidate all subdocument frames already.
 525 }
 526
 527 // static
 528 void nsPresContext::PreferenceChanged(const char* aPrefName, void* aSelf) {
 529   static_cast<nsPresContext*>(aSelf)->PreferenceChanged(aPrefName);
 530 }
 531
 532 void nsPresContext::PreferenceChanged(const char* aPrefName) {
 533   nsDependentCString prefName(aPrefName);
 534   if (prefName.EqualsLiteral("layout.css.dpi") ||
 535       prefName.EqualsLiteral("layout.css.devPixelsPerPx")) {
 536     int32_t oldAppUnitsPerDevPixel = mDeviceContext->AppUnitsPerDevPixel();
 537     // We need to assume the DPI changes, since `mDeviceContext` is shared with
 538     // other documents, and we'd need to save the return value of the first call
 539     // for all of them.
 540     Unused << mDeviceContext->CheckDPIChange();
 541     if (mPresShell) {
 542       OwningNonNull<mozilla::PresShell> presShell(*mPresShell);
 543       // Re-fetch the view manager's window dimensions in case there's a
 544       // deferred resize which hasn't affected our mVisibleArea yet
 545       nscoord oldWidthAppUnits, oldHeightAppUnits;
 546       RefPtr<nsViewManager> vm = presShell->GetViewManager();
 547       if (!vm) {
 548         return;
 549       }
 550       vm->GetWindowDimensions(&oldWidthAppUnits, &oldHeightAppUnits);
 551       float oldWidthDevPixels = oldWidthAppUnits / oldAppUnitsPerDevPixel;
 552       float oldHeightDevPixels = oldHeightAppUnits / oldAppUnitsPerDevPixel;
 553
 554       UIResolutionChangedInternal();
 555
 556       nscoord width = NSToCoordRound(oldWidthDevPixels * AppUnitsPerDevPixel());
 557       nscoord height =
 558           NSToCoordRound(oldHeightDevPixels * AppUnitsPerDevPixel());
 559       vm->SetWindowDimensions(width, height);
 560     }
 561     return;
 562   }
 563
 564   if (StringBeginsWith(prefName, "browser.viewport."_ns) ||
 565       StringBeginsWith(prefName, "font.size.inflation."_ns) ||
 566       prefName.EqualsLiteral("dom.meta-viewport.enabled")) {
 567     if (mPresShell) {
 568       mPresShell->MaybeReflowForInflationScreenSizeChange();
 569     }
 570   }
 571
 572   auto changeHint = nsChangeHint{0};
 573   auto restyleHint = RestyleHint{0};
 574   // Changing any of these potentially changes the value of @media
 575   // (prefers-contrast).
 576   // The layout.css.prefers-contrast.enabled pref itself is not handled here,
 577   // because that pref doesn't just affect the "live" value of the media query;
 578   // it affects whether it is parsed at all.
 579   if (prefName.EqualsLiteral("browser.display.document_color_use") ||
 580       prefName.EqualsLiteral("browser.display.foreground_color") ||
 581       prefName.EqualsLiteral("browser.display.background_color")) {
 582     MediaFeatureValuesChanged({MediaFeatureChangeReason::PreferenceChange},
 583                               MediaFeatureChangePropagation::JustThisDocument);
 584   }
 585   if (prefName.EqualsLiteral(GFX_MISSING_FONTS_NOTIFY_PREF)) {
 586     if (StaticPrefs::gfx_missing_fonts_notify()) {
 587       if (!mMissingFonts) {
 588         mMissingFonts = MakeUnique<gfxMissingFontRecorder>();
 589         // trigger reflow to detect missing fonts on the current page
 590         changeHint |= NS_STYLE_HINT_REFLOW;
 591       }
 592     } else {
 593       if (mMissingFonts) {
 594         mMissingFonts->Clear();
 595       }
 596       mMissingFonts = nullptr;
 597     }
 598   }
 599
 600   if (StringBeginsWith(prefName, "font."_ns) ||
 601       // Changes to font family preferences don't change anything in the
 602       // computed style data, so the style system won't generate a reflow hint
 603       // for us.  We need to do that manually.
 604       prefName.EqualsLiteral("intl.accept_languages") ||
 605       // Changes to bidi prefs need to trigger a reflow (see bug 443629)
 606       StringBeginsWith(prefName, "bidi."_ns) ||
 607       // Changes to font_rendering prefs need to trigger a reflow
 608       StringBeginsWith(prefName, "gfx.font_rendering."_ns)) {
 609     changeHint |= NS_STYLE_HINT_REFLOW;
 610     if (StyleSet()->UsesFontMetrics()) {
 611       restyleHint |= RestyleHint::RecascadeSubtree();
 612     }
 613   }
 614
 615   // We will end up calling InvalidatePreferenceSheets one from each pres
 616   // context, but all it's doing is clearing its cached sheet pointers, so it
 617   // won't be wastefully recreating the sheet multiple times.
 618   //
 619   // The first pres context that flushes will be the one to cause the
 620   // reconstruction of the pref style sheet via the UpdatePreferenceStyles call
 621   // in FlushPendingNotifications.
 622   if (GlobalStyleSheetCache::AffectedByPref(prefName)) {
 623     restyleHint |= RestyleHint::RestyleSubtree();
 624     GlobalStyleSheetCache::InvalidatePreferenceSheets();
 625   }
 626
 627   if (PreferenceSheet::AffectedByPref(prefName)) {
 628     restyleHint |= RestyleHint::RestyleSubtree();
 629     PreferenceSheet::Refresh();
 630   }
 631
 632   // Same, this just frees a bunch of memory.
 633   StaticPresData::Get()->InvalidateFontPrefs();
 634   Document()->SetMayNeedFontPrefsUpdate();
 635
 636   // Initialize our state from the user preferences.
 637   GetUserPreferences();
 638
 639   FlushFontCache();
 640   if (UpdateFontVisibility()) {
 641     changeHint |= NS_STYLE_HINT_REFLOW;
 642   }
 643
 644   // Preferences require rerunning selector matching because we rebuild
 645   // the pref style sheet for some preference changes.
 646   if (changeHint || restyleHint) {
 647     RebuildAllStyleData(changeHint, restyleHint);
 648   }
 649
 650   InvalidatePaintedLayers();
 651 }
 652
 653 nsresult nsPresContext::Init(nsDeviceContext* aDeviceContext) {
 654   NS_ASSERTION(!mInitialized, "attempt to reinit pres context");
 655   NS_ENSURE_ARG(aDeviceContext);
 656
 657   mDeviceContext = aDeviceContext;
 658
 659   // In certain rare cases (such as changing page mode), we tear down layout
 660   // state and re-initialize a new prescontext for a document. Given that we
 661   // hang style state off the DOM, we detect that re-initialization case and
 662   // lazily drop the servo data. We don't do this eagerly during layout teardown
 663   // because that would incur an extra whole-tree traversal that's unnecessary
 664   // most of the time.
 665   //
 666   // FIXME(emilio): I'm pretty sure this doesn't happen after bug 1414999.
 667   Element* root = mDocument->GetRootElement();
 668   if (root && root->HasServoData()) {
 669     RestyleManager::ClearServoDataFromSubtree(root);
 670   }
 671
 672   if (mDeviceContext->SetFullZoom(mFullZoom)) {
 673     FlushFontCache();
 674   }
 675   mCurAppUnitsPerDevPixel = mDeviceContext->AppUnitsPerDevPixel();
 676
 677   mEventManager = new mozilla::EventStateManager();
 678
 679   mAnimationEventDispatcher = new mozilla::AnimationEventDispatcher(this);
 680   mEffectCompositor = new mozilla::EffectCompositor(this);
 681   mTransitionManager = MakeUnique<nsTransitionManager>(this);
 682   mAnimationManager = MakeUnique<nsAnimationManager>(this);
 683   mTimelineManager = MakeUnique<mozilla::TimelineManager>(this);
 684
 685   if (mDocument->GetDisplayDocument()) {
 686     NS_ASSERTION(mDocument->GetDisplayDocument()->GetPresContext(),
 687                  "Why are we being initialized?");
 688     mRefreshDriver =
 689         mDocument->GetDisplayDocument()->GetPresContext()->RefreshDriver();
 690   } else {
 691     dom::Document* parent = mDocument->GetInProcessParentDocument();
 692     // Unfortunately, sometimes |parent| here has no presshell because
 693     // printing screws up things.  Assert that in other cases it does,
 694     // but whenever the shell is null just fall back on using our own
 695     // refresh driver.
 696     NS_ASSERTION(
 697         !parent || mDocument->IsStaticDocument() || parent->GetPresShell(),
 698         "How did we end up with a presshell if our parent doesn't "
 699         "have one?");
 700     if (parent && parent->GetPresContext()) {
 701       // XXX the document can change in AttachPresShell, does this work?
 702       dom::BrowsingContext* browsingContext = mDocument->GetBrowsingContext();
 703       if (browsingContext && !browsingContext->IsTop()) {
 704         Element* containingElement = mDocument->GetEmbedderElement();
 705         if (!containingElement->IsXULElement() ||
 706             !containingElement->HasAttr(kNameSpaceID_None,
 707                                         nsGkAtoms::forceOwnRefreshDriver)) {
 708           mRefreshDriver = parent->GetPresContext()->RefreshDriver();
 709         }
 710       }
 711     }
 712
 713     if (!mRefreshDriver) {
 714       mRefreshDriver = new nsRefreshDriver(this);
 715     }
 716   }
 717
 718   // Register callbacks so we're notified when the preferences change
 719   Preferences::RegisterPrefixCallbacks(nsPresContext::PreferenceChanged,
 720                                        gPrefixCallbackPrefs, this);
 721   Preferences::RegisterCallbacks(nsPresContext::PreferenceChanged,
 722                                  gExactCallbackPrefs, this);
 723
 724   nsresult rv = mEventManager->Init();
 725   NS_ENSURE_SUCCESS(rv, rv);
 726
 727   mEventManager->SetPresContext(this);
 728
 729 #if defined(MOZ_WIDGET_ANDROID)
 730   if (IsRootContentDocumentCrossProcess() &&
 731       MOZ_LIKELY(
 732           !Preferences::HasUserValue("layout.dynamic-toolbar-max-height"))) {
 733     if (BrowserChild* browserChild =
 734             BrowserChild::GetFrom(mDocument->GetDocShell())) {
 735       mDynamicToolbarMaxHeight = browserChild->GetDynamicToolbarMaxHeight();
 736       mDynamicToolbarHeight = mDynamicToolbarMaxHeight;
 737     }
 738   }
 739 #endif
 740
 741 #ifdef DEBUG
 742   mInitialized = true;
 743 #endif
 744
 745   return NS_OK;
 746 }
 747
 748 bool nsPresContext::UpdateFontVisibility() {
 749   FontVisibility oldValue = mFontVisibility;
 750
 751   // Is this a private browsing context?
 752   bool isPrivate = false;
 753   if (nsCOMPtr<nsILoadContext> loadContext = mDocument->GetLoadContext()) {
 754     isPrivate = loadContext->UsePrivateBrowsing();
 755   }
 756
 757   // Read the relevant pref depending on RFP/trackingProtection state
 758   // to determine the visibility level to use.
 759   int32_t level;
 760   if (mDocument->ShouldResistFingerprinting()) {
 761     level = StaticPrefs::layout_css_font_visibility_resistFingerprinting();
 762   } else if (StaticPrefs::privacy_trackingprotection_enabled() ||
 763              (isPrivate &&
 764               StaticPrefs::privacy_trackingprotection_pbmode_enabled())) {
 765     level = StaticPrefs::layout_css_font_visibility_trackingprotection();
 766   } else {
 767     level = StaticPrefs::layout_css_font_visibility_standard();
 768   }
 769
 770   // For private browsing contexts, apply the private-mode limit.
 771   if (isPrivate) {
 772     int32_t priv = StaticPrefs::layout_css_font_visibility_private();
 773     level = std::max(std::min(level, priv), int32_t(FontVisibility::Base));
 774   }
 775
 776   // Clamp result to the valid range of levels.
 777   level = std::max(std::min(level, int32_t(FontVisibility::User)),
 778                    int32_t(FontVisibility::Base));
 779
 780   mFontVisibility = FontVisibility(level);
 781   return mFontVisibility != oldValue;
 782 }
 783
 784 void nsPresContext::ReportBlockedFontFamilyName(const nsCString& aFamily,
 785                                                 FontVisibility aVisibility) {
 786   if (!mBlockedFonts.EnsureInserted(aFamily)) {
 787     return;
 788   }
 789   nsAutoString msg;
 790   msg.AppendPrintf(
 791       "Request for font \"%s\" blocked at visibility level %d (requires %d)\n",
 792       aFamily.get(), int(GetFontVisibility()), int(aVisibility));
 793   nsContentUtils::ReportToConsoleNonLocalized(msg, nsIScriptError::warningFlag,
 794                                               "Security"_ns, mDocument);
 795 }
 796
 797 void nsPresContext::ReportBlockedFontFamily(const fontlist::Family& aFamily) {
 798   auto* fontList = gfxPlatformFontList::PlatformFontList()->SharedFontList();
 799   const nsCString& name = aFamily.DisplayName().AsString(fontList);
 800   ReportBlockedFontFamilyName(name, aFamily.Visibility());
 801 }
 802
 803 void nsPresContext::ReportBlockedFontFamily(const gfxFontFamily& aFamily) {
 804   ReportBlockedFontFamilyName(aFamily.Name(), aFamily.Visibility());
 805 }
 806
 807 void nsPresContext::InitFontCache() {
 808   if (!mFontCache) {
 809     mFontCache = new nsFontCache();
 810     mFontCache->Init(this);
 811   }
 812 }
 813
 814 void nsPresContext::UpdateFontCacheUserFonts(gfxUserFontSet* aUserFontSet) {
 815   if (mFontCache) {
 816     mFontCache->UpdateUserFonts(aUserFontSet);
 817   }
 818 }
 819
 820 already_AddRefed<nsFontMetrics> nsPresContext::GetMetricsFor(
 821     const nsFont& aFont, const nsFontMetrics::Params& aParams) {
 822   InitFontCache();
 823   return mFontCache->GetMetricsFor(aFont, aParams);
 824 }
 825
 826 nsresult nsPresContext::FlushFontCache(void) {
 827   if (mFontCache) {
 828     mFontCache->Flush();
 829   }
 830   return NS_OK;
 831 }
 832
 833 nsresult nsPresContext::FontMetricsDeleted(const nsFontMetrics* aFontMetrics) {
 834   if (mFontCache) {
 835     mFontCache->FontMetricsDeleted(aFontMetrics);
 836   }
 837   return NS_OK;
 838 }
 839
 840 // Note: We don't hold a reference on the shell; it has a reference to
 841 // us
 842 void nsPresContext::AttachPresShell(mozilla::PresShell* aPresShell) {
 843   MOZ_ASSERT(!mPresShell);
 844   mPresShell = aPresShell;
 845
 846   mRestyleManager = MakeUnique<mozilla::RestyleManager>(this);
 847
 848   // Since CounterStyleManager is also the name of a method of
 849   // nsPresContext, it is necessary to prefix the class with the mozilla
 850   // namespace here.
 851   mCounterStyleManager = new mozilla::CounterStyleManager(this);
 852
 853   dom::Document* doc = mPresShell->GetDocument();
 854   MOZ_ASSERT(doc);
 855   // Have to update PresContext's mDocument before calling any other methods.
 856   mDocument = doc;
 857
 858   LookAndFeel::HandleGlobalThemeChange();
 859
 860   // Initialize our state from the user preferences, now that we
 861   // have a presshell, and hence a document.
 862   GetUserPreferences();
 863
 864   EnsureTheme();
 865
 866   nsIURI* docURI = doc->GetDocumentURI();
 867
 868   if (IsDynamic() && docURI) {
 869     if (!docURI->SchemeIs("chrome") && !docURI->SchemeIs("resource"))
 870       mImageAnimationMode = mImageAnimationModePref;
 871     else
 872       mImageAnimationMode = imgIContainer::kNormalAnimMode;
 873   }
 874
 875   UpdateCharSet(doc->GetDocumentCharacterSet());
 876 }
 877
 878 Maybe<ColorScheme> nsPresContext::GetOverriddenOrEmbedderColorScheme() const {
 879   if (Medium() == nsGkAtoms::print) {
 880     return Some(ColorScheme::Light);
 881   }
 882
 883   switch (mOverriddenOrEmbedderColorScheme) {
 884     case dom::PrefersColorSchemeOverride::Dark:
 885       return Some(ColorScheme::Dark);
 886     case dom::PrefersColorSchemeOverride::Light:
 887       return Some(ColorScheme::Light);
 888     case dom::PrefersColorSchemeOverride::None:
 889     case dom::PrefersColorSchemeOverride::EndGuard_:
 890       break;
 891   }
 892
 893   return Nothing();
 894 }
 895
 896 void nsPresContext::SetColorSchemeOverride(
 897     PrefersColorSchemeOverride aOverride) {
 898   auto oldScheme = mDocument->PreferredColorScheme();
 899
 900   mOverriddenOrEmbedderColorScheme = aOverride;
 901
 902   if (mDocument->PreferredColorScheme() != oldScheme) {
 903     MediaFeatureValuesChanged(
 904         MediaFeatureChange::ForPreferredColorSchemeChange(),
 905         MediaFeatureChangePropagation::JustThisDocument);
 906   }
 907 }
 908
 909 void nsPresContext::RecomputeBrowsingContextDependentData() {
 910   MOZ_ASSERT(mDocument);
 911   dom::Document* doc = mDocument;
 912   // Resource documents inherit all this state from their display document.
 913   while (dom::Document* outer = doc->GetDisplayDocument()) {
 914     doc = outer;
 915   }
 916   auto* browsingContext = doc->GetBrowsingContext();
 917   if (!browsingContext) {
 918     // This can legitimately happen for e.g. SVG images. Those just get scaled
 919     // as a result of the zoom on the embedder document so it doesn't really
 920     // matter... Medium also doesn't affect those.
 921     return;
 922   }
 923   auto systemZoom = LookAndFeel::SystemZoomSettings();
 924   SetFullZoom(browsingContext->FullZoom() * systemZoom.mFullZoom);
 925   SetTextZoom(browsingContext->TextZoom() * systemZoom.mTextZoom);
 926   SetOverrideDPPX(browsingContext->OverrideDPPX());
 927
 928   auto* top = browsingContext->Top();
 929   SetColorSchemeOverride([&] {
 930     auto overriden = top->PrefersColorSchemeOverride();
 931     if (overriden != PrefersColorSchemeOverride::None) {
 932       return overriden;
 933     }
 934     if (!StaticPrefs::
 935             layout_css_iframe_embedder_prefers_color_scheme_content_enabled()) {
 936       return top->GetEmbedderColorSchemes().mPreferred;
 937     }
 938     return browsingContext->GetEmbedderColorSchemes().mPreferred;
 939   }());
 940
 941   SetInRDMPane(top->GetInRDMPane());
 942
 943   if (doc == mDocument) {
 944     // Medium doesn't apply to resource documents, etc.
 945     RefPtr<nsAtom> mediumToEmulate;
 946     if (MOZ_UNLIKELY(!top->GetMediumOverride().IsEmpty())) {
 947       nsAutoString lower;
 948       nsContentUtils::ASCIIToLower(top->GetMediumOverride(), lower);
 949       mediumToEmulate = NS_Atomize(lower);
 950     }
 951     EmulateMedium(mediumToEmulate);
 952   }
 953
 954   mDocument->EnumerateExternalResources([](dom::Document& aSubResource) {
 955     if (nsPresContext* subResourcePc = aSubResource.GetPresContext()) {
 956       subResourcePc->RecomputeBrowsingContextDependentData();
 957     }
 958     return CallState::Continue;
 959   });
 960 }
 961
 962 void nsPresContext::DetachPresShell() {
 963   // The counter style manager's destructor needs to deallocate with the
 964   // presshell arena. Disconnect it before nulling out the shell.
 965   //
 966   // XXXbholley: Given recent refactorings, it probably makes more sense to
 967   // just null our mPresShell at the bottom of this function. I'm leaving it
 968   // this way to preserve the old ordering, but I doubt anything would break.
 969   if (mCounterStyleManager) {
 970     mCounterStyleManager->Disconnect();
 971     mCounterStyleManager = nullptr;
 972   }
 973
 974   mPresShell = nullptr;
 975
 976   CancelManagedPostRefreshObservers();
 977
 978   if (mAnimationEventDispatcher) {
 979     mAnimationEventDispatcher->Disconnect();
 980     mAnimationEventDispatcher = nullptr;
 981   }
 982   if (mEffectCompositor) {
 983     mEffectCompositor->Disconnect();
 984     mEffectCompositor = nullptr;
 985   }
 986   if (mTransitionManager) {
 987     mTransitionManager->Disconnect();
 988     mTransitionManager = nullptr;
 989   }
 990   if (mAnimationManager) {
 991     mAnimationManager->Disconnect();
 992     mAnimationManager = nullptr;
 993   }
 994   if (mTimelineManager) {
 995     mTimelineManager->Disconnect();
 996     mTimelineManager = nullptr;
 997   }
 998   if (mRestyleManager) {
 999     mRestyleManager->Disconnect();
1000     mRestyleManager = nullptr;
1001   }
1002   if (mRefreshDriver && mRefreshDriver->GetPresContext() == this) {
1003     mRefreshDriver->Disconnect();
1004     // Can't null out the refresh driver here.
1005   }
1006 }
1007
1008 struct QueryContainerState {
1009   nsSize mSize;
1010   WritingMode mWm;
1011
1012   nscoord GetInlineSize() const { return LogicalSize(mWm, mSize).ISize(mWm); }
1013
1014   bool Changed(const QueryContainerState& aNewState, StyleContainerType aType) {
1015     switch (aType) {
1016       case StyleContainerType::Normal:
1017         break;
1018       case StyleContainerType::Size:
1019         return mSize != aNewState.mSize;
1020       case StyleContainerType::InlineSize:
1021         return GetInlineSize() != aNewState.GetInlineSize();
1022     }
1023     return false;
1024   }
1025 };
1026 NS_DECLARE_FRAME_PROPERTY_DELETABLE(ContainerState, QueryContainerState);
1027
1028 void nsPresContext::RegisterContainerQueryFrame(nsIFrame* aFrame) {
1029   mContainerQueryFrames.Add(aFrame);
1030 }
1031
1032 void nsPresContext::UnregisterContainerQueryFrame(nsIFrame* aFrame) {
1033   mContainerQueryFrames.Remove(aFrame);
1034 }
1035
1036 void nsPresContext::FinishedContainerQueryUpdate() {
1037   mUpdatedContainerQueryContents.Clear();
1038 }
1039
1040 bool nsPresContext::UpdateContainerQueryStyles() {
1041   if (mContainerQueryFrames.IsEmpty()) {
1042     return false;
1043   }
1044
1045   AUTO_PROFILER_MARKER_TEXT("UpdateContainerQueryStyles", LAYOUT, {}, ""_ns);
1046
1047   PresShell()->DoFlushLayout(/* aInterruptible = */ false);
1048
1049   AutoTArray<nsIFrame*, 8> framesToUpdate;
1050
1051   bool anyChanged = false;
1052   for (nsIFrame* frame : mContainerQueryFrames.IterFromShallowest()) {
1053     MOZ_ASSERT(frame->IsPrimaryFrame());
1054
1055     auto type = frame->StyleDisplay()->mContainerType;
1056     MOZ_ASSERT(type != StyleContainerType::Normal,
1057                "Non-container frames shouldn't be in this type");
1058
1059     const QueryContainerState newState{frame->GetSize(),
1060                                        frame->GetWritingMode()};
1061     QueryContainerState* oldState = frame->GetProperty(ContainerState());
1062
1063     const bool changed = !oldState || oldState->Changed(newState, type);
1064
1065     // Make sure to update the state regardless. It's cheap and it keeps tracks
1066     // of both axes correctly even if only one axis is contained.
1067     if (oldState) {
1068       *oldState = newState;
1069     } else {
1070       frame->SetProperty(ContainerState(), new QueryContainerState(newState));
1071     }
1072
1073     if (!changed) {
1074       continue;
1075     }
1076
1077     const bool updatingAncestor = [&] {
1078       for (nsIFrame* f : framesToUpdate) {
1079         if (nsLayoutUtils::IsProperAncestorFrame(f, frame)) {
1080           return true;
1081         }
1082       }
1083       return false;
1084     }();
1085
1086     if (updatingAncestor) {
1087       // We're going to update an ancestor container of this frame already,
1088       // avoid updating this one too until all our ancestor containers are
1089       // updated.
1090       continue;
1091     }
1092
1093     // To prevent unstable layout, only update once per-element per-flush.
1094     if (NS_WARN_IF(!mUpdatedContainerQueryContents.EnsureInserted(
1095             frame->GetContent()))) {
1096       continue;
1097     }
1098
1099     framesToUpdate.AppendElement(frame);
1100
1101     // TODO(emilio): More fine-grained invalidation rather than invalidating the
1102     // whole subtree, probably!
1103     RestyleManager()->PostRestyleEvent(frame->GetContent()->AsElement(),
1104                                        RestyleHint::RestyleSubtree(),
1105                                        nsChangeHint(0));
1106     anyChanged = true;
1107   }
1108   return anyChanged;
1109 }
1110
1111 void nsPresContext::DocumentCharSetChanged(NotNull<const Encoding*> aCharSet) {
1112   UpdateCharSet(aCharSet);
1113   FlushFontCache();
1114
1115   // If a document contains one or more <script> elements, frame construction
1116   // might happen earlier than the UpdateCharSet(), so we need to restyle
1117   // descendants to make their style data up-to-date.
1118   //
1119   // FIXME(emilio): Revisit whether this is true after bug 1438911.
1120   RebuildAllStyleData(NS_STYLE_HINT_REFLOW, RestyleHint::RecascadeSubtree());
1121 }
1122
1123 void nsPresContext::UpdateCharSet(NotNull<const Encoding*> aCharSet) {
1124   switch (GET_BIDI_OPTION_TEXTTYPE(GetBidi())) {
1125     case IBMBIDI_TEXTTYPE_LOGICAL:
1126       SetVisualMode(false);
1127       break;
1128
1129     case IBMBIDI_TEXTTYPE_VISUAL:
1130       SetVisualMode(true);
1131       break;
1132
1133     case IBMBIDI_TEXTTYPE_CHARSET:
1134     default:
1135       SetVisualMode(IsVisualCharset(aCharSet));
1136   }
1137 }
1138
1139 nsPresContext* nsPresContext::GetParentPresContext() const {
1140   mozilla::PresShell* presShell = GetPresShell();
1141   if (presShell) {
1142     nsViewManager* viewManager = presShell->GetViewManager();
1143     if (viewManager) {
1144       nsView* view = viewManager->GetRootView();
1145       if (view) {
1146         view = view->GetParent();  // anonymous inner view
1147         if (view) {
1148           view = view->GetParent();  // subdocumentframe's view
1149           if (view) {
1150             nsIFrame* f = view->GetFrame();
1151             if (f) {
1152               return f->PresContext();
1153             }
1154           }
1155         }
1156       }
1157     }
1158   }
1159   return nullptr;
1160 }
1161
1162 nsPresContext* nsPresContext::GetInProcessRootContentDocumentPresContext() {
1163   if (IsChrome()) return nullptr;
1164   nsPresContext* pc = this;
1165   for (;;) {
1166     nsPresContext* parent = pc->GetParentPresContext();
1167     if (!parent || parent->IsChrome()) return pc;
1168     pc = parent;
1169   }
1170 }
1171
1172 nsIWidget* nsPresContext::GetNearestWidget(nsPoint* aOffset) {
1173   NS_ENSURE_TRUE(mPresShell, nullptr);
1174   nsViewManager* vm = mPresShell->GetViewManager();
1175   NS_ENSURE_TRUE(vm, nullptr);
1176   nsView* rootView = vm->GetRootView();
1177   NS_ENSURE_TRUE(rootView, nullptr);
1178   return rootView->GetNearestWidget(aOffset);
1179 }
1180
1181 nsIWidget* nsPresContext::GetRootWidget() const {
1182   NS_ENSURE_TRUE(mPresShell, nullptr);
1183   nsViewManager* vm = mPresShell->GetViewManager();
1184   if (!vm) {
1185     return nullptr;
1186   }
1187   return vm->GetRootWidget();
1188 }
1189
1190 // We may want to replace this with something faster, maybe caching the root
1191 // prescontext
1192 nsRootPresContext* nsPresContext::GetRootPresContext() const {
1193   nsPresContext* pc = const_cast<nsPresContext*>(this);
1194   for (;;) {
1195     nsPresContext* parent = pc->GetParentPresContext();
1196     if (!parent) break;
1197     pc = parent;
1198   }
1199   return pc->IsRoot() ? static_cast<nsRootPresContext*>(pc) : nullptr;
1200 }
1201
1202 // Helper function for setting Anim Mode on image
1203 static void SetImgAnimModeOnImgReq(imgIRequest* aImgReq, uint16_t aMode) {
1204   if (aImgReq) {
1205     nsCOMPtr<imgIContainer> imgCon;
1206     aImgReq->GetImage(getter_AddRefs(imgCon));
1207     if (imgCon) {
1208       imgCon->SetAnimationMode(aMode);
1209     }
1210   }
1211 }
1212
1213 // IMPORTANT: Assumption is that all images for a Presentation
1214 // have the same Animation Mode (pavlov said this was OK)
1215 //
1216 // Walks content and set the animation mode
1217 // this is a way to turn on/off image animations
1218 void nsPresContext::SetImgAnimations(nsIContent* aParent, uint16_t aMode) {
1219   nsCOMPtr<nsIImageLoadingContent> imgContent(do_QueryInterface(aParent));
1220   if (imgContent) {
1221     nsCOMPtr<imgIRequest> imgReq;
1222     imgContent->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
1223                            getter_AddRefs(imgReq));
1224     SetImgAnimModeOnImgReq(imgReq, aMode);
1225   }
1226
1227   for (nsIContent* childContent = aParent->GetFirstChild(); childContent;
1228        childContent = childContent->GetNextSibling()) {
1229     SetImgAnimations(childContent, aMode);
1230   }
1231 }
1232
1233 void nsPresContext::SetSMILAnimations(dom::Document* aDoc, uint16_t aNewMode,
1234                                       uint16_t aOldMode) {
1235   if (aDoc->HasAnimationController()) {
1236     SMILAnimationController* controller = aDoc->GetAnimationController();
1237     switch (aNewMode) {
1238       case imgIContainer::kNormalAnimMode:
1239       case imgIContainer::kLoopOnceAnimMode:
1240         if (aOldMode == imgIContainer::kDontAnimMode)
1241           controller->Resume(SMILTimeContainer::PAUSE_USERPREF);
1242         break;
1243
1244       case imgIContainer::kDontAnimMode:
1245         if (aOldMode != imgIContainer::kDontAnimMode)
1246           controller->Pause(SMILTimeContainer::PAUSE_USERPREF);
1247         break;
1248     }
1249   }
1250 }
1251
1252 void nsPresContext::SetImageAnimationMode(uint16_t aMode) {
1253   NS_ASSERTION(aMode == imgIContainer::kNormalAnimMode ||
1254                    aMode == imgIContainer::kDontAnimMode ||
1255                    aMode == imgIContainer::kLoopOnceAnimMode,
1256                "Wrong Animation Mode is being set!");
1257
1258   // Image animation mode cannot be changed when rendering to a printer.
1259   if (!IsDynamic()) return;
1260
1261   // Now walk the content tree and set the animation mode
1262   // on all the images.
1263   if (mPresShell) {
1264     dom::Document* doc = mPresShell->GetDocument();
1265     if (doc) {
1266       doc->StyleImageLoader()->SetAnimationMode(aMode);
1267
1268       Element* rootElement = doc->GetRootElement();
1269       if (rootElement) {
1270         SetImgAnimations(rootElement, aMode);
1271       }
1272       SetSMILAnimations(doc, aMode, mImageAnimationMode);
1273     }
1274   }
1275
1276   mImageAnimationMode = aMode;
1277 }
1278
1279 void nsPresContext::UpdateEffectiveTextZoom() {
1280   float newZoom = mSystemFontScale * mTextZoom;
1281   float minZoom = StaticPrefs::zoom_minPercent() / 100.0f;
1282   float maxZoom = StaticPrefs::zoom_maxPercent() / 100.0f;
1283
1284   if (newZoom < minZoom) {
1285     newZoom = minZoom;
1286   } else if (newZoom > maxZoom) {
1287     newZoom = maxZoom;
1288   }
1289
1290   mEffectiveTextZoom = newZoom;
1291
1292   // Media queries could have changed, since we changed the meaning
1293   // of 'em' units in them.
1294   MediaFeatureValuesChanged(
1295       {RestyleHint::RecascadeSubtree(), NS_STYLE_HINT_REFLOW,
1296        MediaFeatureChangeReason::ZoomChange},
1297       MediaFeatureChangePropagation::JustThisDocument);
1298 }
1299
1300 void nsPresContext::SetInRDMPane(bool aInRDMPane) {
1301   if (mInRDMPane == aInRDMPane) {
1302     return;
1303   }
1304   mInRDMPane = aInRDMPane;
1305   RecomputeTheme();
1306 }
1307
1308 float nsPresContext::GetDeviceFullZoom() {
1309   return mDeviceContext->GetFullZoom();
1310 }
1311
1312 void nsPresContext::SetFullZoom(float aZoom) {
1313   if (!mPresShell || mFullZoom == aZoom) {
1314     return;
1315   }
1316
1317   // Re-fetch the view manager's window dimensions in case there's a deferred
1318   // resize which hasn't affected our mVisibleArea yet
1319   nscoord oldWidthAppUnits, oldHeightAppUnits;
1320   mPresShell->GetViewManager()->GetWindowDimensions(&oldWidthAppUnits,
1321                                                     &oldHeightAppUnits);
1322   float oldWidthDevPixels = oldWidthAppUnits / float(mCurAppUnitsPerDevPixel);
1323   float oldHeightDevPixels = oldHeightAppUnits / float(mCurAppUnitsPerDevPixel);
1324   mDeviceContext->SetFullZoom(aZoom);
1325
1326   mFullZoom = aZoom;
1327
1328   AppUnitsPerDevPixelChanged();
1329
1330   mPresShell->GetViewManager()->SetWindowDimensions(
1331       NSToCoordRound(oldWidthDevPixels * AppUnitsPerDevPixel()),
1332       NSToCoordRound(oldHeightDevPixels * AppUnitsPerDevPixel()));
1333 }
1334
1335 void nsPresContext::SetOverrideDPPX(float aDPPX) {
1336   // SetOverrideDPPX is called during navigations, including history
1337   // traversals.  In that case, it's typically called with our current value,
1338   // and we don't need to actually do anything.
1339   if (aDPPX == GetOverrideDPPX()) {
1340     return;
1341   }
1342
1343   mMediaEmulationData.mDPPX = aDPPX;
1344   MediaFeatureValuesChanged({MediaFeatureChangeReason::ResolutionChange},
1345                             MediaFeatureChangePropagation::JustThisDocument);
1346 }
1347
1348 gfxSize nsPresContext::ScreenSizeInchesForFontInflation(bool* aChanged) {
1349   if (aChanged) {
1350     *aChanged = false;
1351   }
1352
1353   nsDeviceContext* dx = DeviceContext();
1354   nsRect clientRect;
1355   dx->GetClientRect(clientRect);  // FIXME: GetClientRect looks expensive
1356   float unitsPerInch = dx->AppUnitsPerPhysicalInch();
1357   gfxSize deviceSizeInches(float(clientRect.width) / unitsPerInch,
1358                            float(clientRect.height) / unitsPerInch);
1359
1360   if (mLastFontInflationScreenSize == gfxSize(-1.0, -1.0)) {
1361     mLastFontInflationScreenSize = deviceSizeInches;
1362   }
1363
1364   if (deviceSizeInches != mLastFontInflationScreenSize && aChanged) {
1365     *aChanged = true;
1366     mLastFontInflationScreenSize = deviceSizeInches;
1367   }
1368
1369   return deviceSizeInches;
1370 }
1371
1372 static bool CheckOverflow(const ComputedStyle* aComputedStyle,
1373                           ScrollStyles* aStyles) {
1374   // If they're not styled yet, we'll get around to it when constructing frames
1375   // for the element.
1376   if (!aComputedStyle) {
1377     return false;
1378   }
1379   const nsStyleDisplay* display = aComputedStyle->StyleDisplay();
1380
1381   // If they will generate no box, just don't.
1382   if (display->mDisplay == StyleDisplay::None ||
1383       display->mDisplay == StyleDisplay::Contents) {
1384     return false;
1385   }
1386
1387   // NOTE(emilio): This check needs to match the one in
1388   // Document::IsPotentiallyScrollable.
1389   if (display->OverflowIsVisibleInBothAxis()) {
1390     return false;
1391   }
1392
1393   *aStyles =
1394       ScrollStyles(*display, ScrollStyles::MapOverflowToValidScrollStyle);
1395   return true;
1396 }
1397
1398 // https://drafts.csswg.org/css-overflow/#overflow-propagation
1399 //
1400 // NOTE(emilio): We may need to use out-of-date styles for this, since this is
1401 // called from nsCSSFrameConstructor::ContentRemoved. We could refactor this a
1402 // bit to avoid doing that, and also fix correctness issues (we don't invalidate
1403 // properly when we insert a body element and there is a previous one, for
1404 // example).
1405 static Element* GetPropagatedScrollStylesForViewport(
1406     nsPresContext* aPresContext, ScrollStyles* aStyles) {
1407   Document* document = aPresContext->Document();
1408   Element* docElement = document->GetRootElement();
1409   // docElement might be null if we're doing this after removing it.
1410   if (!docElement) {
1411     return nullptr;
1412   }
1413
1414   // Check the style on the document root element
1415   const auto* rootStyle = Servo_Element_GetMaybeOutOfDateStyle(docElement);
1416   if (CheckOverflow(rootStyle, aStyles)) {
1417     // tell caller we stole the overflow style from the root element
1418     return docElement;
1419   }
1420
1421   if (rootStyle && rootStyle->StyleDisplay()->IsContainAny()) {
1422     return nullptr;
1423   }
1424
1425   // Don't look in the BODY for non-HTML documents or HTML documents
1426   // with non-HTML roots.
1427   // XXX this should be earlier; we shouldn't even look at the document root
1428   // for non-HTML documents. Fix this once we support explicit CSS styling
1429   // of the viewport
1430   if (!document->IsHTMLOrXHTML() || !docElement->IsHTMLElement()) {
1431     return nullptr;
1432   }
1433
1434   Element* bodyElement = document->AsHTMLDocument()->GetBodyElement();
1435   if (!bodyElement) {
1436     return nullptr;
1437   }
1438
1439   MOZ_ASSERT(bodyElement->IsHTMLElement(nsGkAtoms::body),
1440              "GetBodyElement returned something bogus");
1441
1442   const auto* bodyStyle = Servo_Element_GetMaybeOutOfDateStyle(bodyElement);
1443   if (bodyStyle && bodyStyle->StyleDisplay()->IsContainAny()) {
1444     return nullptr;
1445   }
1446
1447   if (CheckOverflow(bodyStyle, aStyles)) {
1448     // tell caller we stole the overflow style from the body element
1449     return bodyElement;
1450   }
1451
1452   return nullptr;
1453 }
1454
1455 Element* nsPresContext::UpdateViewportScrollStylesOverride() {
1456   ScrollStyles oldViewportScrollStyles = mViewportScrollStyles;
1457
1458   // Start off with our default styles, and then update them as needed.
1459   mViewportScrollStyles =
1460       ScrollStyles(StyleOverflow::Auto, StyleOverflow::Auto);
1461   mViewportScrollOverrideElement = nullptr;
1462   // Don't propagate the scrollbar state in printing or print preview.
1463   if (!IsPaginated()) {
1464     mViewportScrollOverrideElement =
1465         GetPropagatedScrollStylesForViewport(this, &mViewportScrollStyles);
1466   }
1467
1468   dom::Document* document = Document();
1469   if (Element* fsElement = document->GetUnretargetedFullscreenElement()) {
1470     // If the document is in fullscreen, but the fullscreen element is
1471     // not the root element, we should explicitly suppress the scrollbar
1472     // here. Note that, we still need to return the original element
1473     // the styles are from, so that the state of those elements is not
1474     // affected across fullscreen change.
1475     if (fsElement != document->GetRootElement() &&
1476         fsElement != mViewportScrollOverrideElement) {
1477       mViewportScrollStyles =
1478           ScrollStyles(StyleOverflow::Hidden, StyleOverflow::Hidden);
1479     }
1480   }
1481
1482   if (mViewportScrollStyles != oldViewportScrollStyles) {
1483     if (mPresShell) {
1484       if (nsIFrame* frame = mPresShell->GetRootFrame()) {
1485         frame->SchedulePaint();
1486       }
1487     }
1488   }
1489
1490   return mViewportScrollOverrideElement;
1491 }
1492
1493 bool nsPresContext::ElementWouldPropagateScrollStyles(const Element& aElement) {
1494   if (aElement.GetParent() && !aElement.IsHTMLElement(nsGkAtoms::body)) {
1495     // We certainly won't be propagating from this element.
1496     return false;
1497   }
1498
1499   // Go ahead and just call GetPropagatedScrollStylesForViewport, but update
1500   // a dummy ScrollStyles we don't care about.  It'll do a bit of extra work,
1501   // but saves us having to have more complicated code or more code duplication;
1502   // in practice we will make this call quite rarely, because we checked for all
1503   // the common cases above.
1504   ScrollStyles dummy(StyleOverflow::Auto, StyleOverflow::Auto);
1505   return GetPropagatedScrollStylesForViewport(this, &dummy) == &aElement;
1506 }
1507
1508 nsISupports* nsPresContext::GetContainerWeak() const {
1509   return mDocument->GetDocShell();
1510 }
1511
1512 ColorScheme nsPresContext::DefaultBackgroundColorScheme() const {
1513   dom::Document* doc = Document();
1514   // Use a dark background for top-level about:blank that is inaccessible to
1515   // content JS.
1516   {
1517     BrowsingContext* bc = doc->GetBrowsingContext();
1518     if (bc && bc->IsTop() && !bc->HasOpener() && doc->GetDocumentURI() &&
1519         NS_IsAboutBlank(doc->GetDocumentURI())) {
1520       return doc->PreferredColorScheme(Document::IgnoreRFP::Yes);
1521     }
1522   }
1523   // Prefer the root color-scheme (since generally the default canvas
1524   // background comes from the root element's background-color), and fall back
1525   // to the default color-scheme if not available.
1526   if (auto* frame = FrameConstructor()->GetRootElementStyleFrame()) {
1527     return LookAndFeel::ColorSchemeForFrame(frame);
1528   }
1529   return doc->DefaultColorScheme();
1530 }
1531
1532 nscolor nsPresContext::DefaultBackgroundColor() const {
1533   if (!GetBackgroundColorDraw()) {
1534     return NS_RGB(255, 255, 255);
1535   }
1536   return PrefSheetPrefs()
1537       .ColorsFor(DefaultBackgroundColorScheme())
1538       .mDefaultBackground;
1539 }
1540
1541 nsDocShell* nsPresContext::GetDocShell() const {
1542   return nsDocShell::Cast(mDocument->GetDocShell());
1543 }
1544
1545 bool nsPresContext::BidiEnabled() const { return Document()->GetBidiEnabled(); }
1546
1547 void nsPresContext::SetBidiEnabled() const { Document()->SetBidiEnabled(); }
1548
1549 void nsPresContext::SetBidi(uint32_t aSource) {
1550   // Don't do all this stuff unless the options have changed.
1551   if (aSource == GetBidi()) {
1552     return;
1553   }
1554
1555   Document()->SetBidiOptions(aSource);
1556   if (IBMBIDI_TEXTDIRECTION_RTL == GET_BIDI_OPTION_DIRECTION(aSource) ||
1557       IBMBIDI_NUMERAL_HINDI == GET_BIDI_OPTION_NUMERAL(aSource)) {
1558     SetBidiEnabled();
1559   }
1560   if (IBMBIDI_TEXTTYPE_VISUAL == GET_BIDI_OPTION_TEXTTYPE(aSource)) {
1561     SetVisualMode(true);
1562   } else if (IBMBIDI_TEXTTYPE_LOGICAL == GET_BIDI_OPTION_TEXTTYPE(aSource)) {
1563     SetVisualMode(false);
1564   } else {
1565     SetVisualMode(IsVisualCharset(Document()->GetDocumentCharacterSet()));
1566   }
1567 }
1568
1569 uint32_t nsPresContext::GetBidi() const { return Document()->GetBidiOptions(); }
1570
1571 void nsPresContext::RecordInteractionTime(InteractionType aType,
1572                                           const TimeStamp& aTimeStamp) {
1573   if (!mInteractionTimeEnabled || aTimeStamp.IsNull()) {
1574     return;
1575   }
1576
1577   // Array of references to the member variable of each time stamp
1578   // for the different interaction types, keyed by InteractionType.
1579   TimeStamp nsPresContext::*interactionTimes[] = {
1580       &nsPresContext::mFirstClickTime, &nsPresContext::mFirstKeyTime,
1581       &nsPresContext::mFirstMouseMoveTime, &nsPresContext::mFirstScrollTime};
1582
1583   // Array of histogram IDs for the different interaction types,
1584   // keyed by InteractionType.
1585   Telemetry::HistogramID histogramIds[] = {
1586       Telemetry::TIME_TO_FIRST_CLICK_MS, Telemetry::TIME_TO_FIRST_KEY_INPUT_MS,
1587       Telemetry::TIME_TO_FIRST_MOUSE_MOVE_MS,
1588       Telemetry::TIME_TO_FIRST_SCROLL_MS};
1589
1590   TimeStamp& interactionTime =
1591       this->*(interactionTimes[static_cast<uint32_t>(aType)]);
1592   if (!interactionTime.IsNull()) {
1593     // We have already recorded an interaction time.
1594     return;
1595   }
1596
1597   // Record the interaction time if it occurs after the first paint
1598   // of the top level content document.
1599   nsPresContext* inProcessRootPresContext =
1600       GetInProcessRootContentDocumentPresContext();
1601
1602   if (!inProcessRootPresContext ||
1603       !inProcessRootPresContext->IsRootContentDocumentCrossProcess()) {
1604     // There is no top content pres context, or we are in a cross process
1605     // document so we don't care about the interaction time. Record a value
1606     // anyways to avoid trying to find the top content pres context in future
1607     // interactions.
1608     interactionTime = TimeStamp::Now();
1609     return;
1610   }
1611
1612   if (inProcessRootPresContext->mFirstNonBlankPaintTime.IsNull() ||
1613       inProcessRootPresContext->mFirstNonBlankPaintTime > aTimeStamp) {
1614     // Top content pres context has not had a non-blank paint yet
1615     // or the event timestamp is before the first non-blank paint,
1616     // so don't record interaction time.
1617     return;
1618   }
1619
1620   // Check if we are recording the first of any of the interaction types.
1621   bool isFirstInteraction = true;
1622   for (TimeStamp nsPresContext::*memberPtr : interactionTimes) {
1623     TimeStamp& timeStamp = this->*(memberPtr);
1624     if (!timeStamp.IsNull()) {
1625       isFirstInteraction = false;
1626       break;
1627     }
1628   }
1629
1630   interactionTime = TimeStamp::Now();
1631   // Only the top level content pres context reports first interaction
1632   // time to telemetry (if it hasn't already done so).
1633   if (this == inProcessRootPresContext) {
1634     if (Telemetry::CanRecordExtended()) {
1635       double millis =
1636           (interactionTime - mFirstNonBlankPaintTime).ToMilliseconds();
1637       Telemetry::Accumulate(histogramIds[static_cast<uint32_t>(aType)], millis);
1638
1639       if (isFirstInteraction) {
1640         Telemetry::Accumulate(Telemetry::TIME_TO_FIRST_INTERACTION_MS, millis);
1641       }
1642     }
1643   } else {
1644     inProcessRootPresContext->RecordInteractionTime(aType, aTimeStamp);
1645   }
1646 }
1647
1648 nsITheme* nsPresContext::Theme() const {
1649   MOZ_ASSERT(mTheme);
1650   return mTheme;
1651 }
1652
1653 void nsPresContext::EnsureTheme() {
1654   MOZ_ASSERT(!mTheme);
1655   if (Document()->ShouldAvoidNativeTheme()) {
1656     if (mInRDMPane) {
1657       mTheme = do_GetRDMThemeDoNotUseDirectly();
1658     } else {
1659       mTheme = do_GetBasicNativeThemeDoNotUseDirectly();
1660     }
1661   } else {
1662     mTheme = do_GetNativeThemeDoNotUseDirectly();
1663   }
1664   MOZ_RELEASE_ASSERT(mTheme);
1665 }
1666
1667 void nsPresContext::RecomputeTheme() {
1668   if (!mTheme) {
1669     return;
1670   }
1671   nsCOMPtr<nsITheme> oldTheme = std::move(mTheme);
1672   EnsureTheme();
1673   if (oldTheme == mTheme) {
1674     return;
1675   }
1676   // Theme affects layout information (as it affects whether we create
1677   // scrollbar buttons for example) and also style (affects the
1678   // scrollbar-inline-size env var).
1679   RebuildAllStyleData(nsChangeHint_ReconstructFrame,
1680                       RestyleHint::RecascadeSubtree());
1681   // This is a bit of a lie, but this affects the overlay-scrollbars
1682   // media query and it's the code-path that gets taken for regular system
1683   // metrics changes via ThemeChanged().
1684   MediaFeatureValuesChanged({MediaFeatureChangeReason::SystemMetricsChange},
1685                             MediaFeatureChangePropagation::JustThisDocument);
1686 }
1687
1688 bool nsPresContext::UseOverlayScrollbars() const {
1689   return LookAndFeel::GetInt(LookAndFeel::IntID::UseOverlayScrollbars) ||
1690          mInRDMPane;
1691 }
1692
1693 void nsPresContext::ThemeChanged(widget::ThemeChangeKind aKind) {
1694   PROFILER_MARKER_UNTYPED("ThemeChanged", LAYOUT, MarkerStack::Capture());
1695
1696   mPendingThemeChangeKind |= unsigned(aKind);
1697
1698   if (!mPendingThemeChanged) {
1699     nsCOMPtr<nsIRunnable> ev =
1700         new WeakRunnableMethod("nsPresContext::ThemeChangedInternal", this,
1701                                &nsPresContext::ThemeChangedInternal);
1702     RefreshDriver()->AddEarlyRunner(ev);
1703     mPendingThemeChanged = true;
1704   }
1705   MOZ_ASSERT(LookAndFeel::HasPendingGlobalThemeChange());
1706 }
1707
1708 void nsPresContext::ThemeChangedInternal() {
1709   MOZ_ASSERT(mPendingThemeChanged);
1710
1711   mPendingThemeChanged = false;
1712
1713   const auto kind = widget::ThemeChangeKind(mPendingThemeChangeKind);
1714   mPendingThemeChangeKind = 0;
1715
1716   LookAndFeel::HandleGlobalThemeChange();
1717
1718   // Full zoom might have changed as a result of the text scale factor.
1719   RecomputeBrowsingContextDependentData();
1720
1721   // Changes to system metrics and other look and feel values can change media
1722   // queries on them.
1723   //
1724   // Changes in theme can change system colors (whose changes are properly
1725   // reflected in computed style data), system fonts (whose changes are
1726   // some reflected (like sizes and such) and some not), and -moz-appearance
1727   // (whose changes are not), so we need to recascade for the first, and reflow
1728   // for the rest.
1729   auto restyleHint = (kind & widget::ThemeChangeKind::Style)
1730                          ? RestyleHint::RecascadeSubtree()
1731                          : RestyleHint{0};
1732   auto changeHint = (kind & widget::ThemeChangeKind::Layout)
1733                         ? NS_STYLE_HINT_REFLOW
1734                         : nsChangeHint(0);
1735   MediaFeatureValuesChanged(
1736       {restyleHint, changeHint, MediaFeatureChangeReason::SystemMetricsChange},
1737       MediaFeatureChangePropagation::All);
1738
1739   if (Document()->IsInChromeDocShell()) {
1740     if (RefPtr<nsPIDOMWindowInner> win = Document()->GetInnerWindow()) {
1741       nsContentUtils::DispatchEventOnlyToChrome(
1742           Document(), win, u"nativethemechange"_ns, CanBubble::eYes,
1743           Cancelable::eYes, nullptr);
1744     }
1745   }
1746 }
1747
1748 void nsPresContext::UIResolutionChanged() {
1749   if (!mPendingUIResolutionChanged) {
1750     nsCOMPtr<nsIRunnable> ev =
1751         NewRunnableMethod("nsPresContext::UIResolutionChangedInternal", this,
1752                           &nsPresContext::UIResolutionChangedInternal);
1753     nsresult rv = Document()->Dispatch(TaskCategory::Other, ev.forget());
1754     if (NS_SUCCEEDED(rv)) {
1755       mPendingUIResolutionChanged = true;
1756     }
1757   }
1758 }
1759
1760 void nsPresContext::UIResolutionChangedSync() {
1761   if (!mPendingUIResolutionChanged) {
1762     mPendingUIResolutionChanged = true;
1763     UIResolutionChangedInternal();
1764   }
1765 }
1766
1767 static void NotifyTabUIResolutionChanged(nsIRemoteTab* aTab, void* aArg) {
1768   aTab->NotifyResolutionChanged();
1769 }
1770
1771 static void NotifyChildrenUIResolutionChanged(nsPIDOMWindowOuter* aWindow) {
1772   nsCOMPtr<Document> doc = aWindow->GetExtantDoc();
1773   RefPtr<nsPIWindowRoot> topLevelWin = nsContentUtils::GetWindowRoot(doc);
1774   if (!topLevelWin) {
1775     return;
1776   }
1777   topLevelWin->EnumerateBrowsers(NotifyTabUIResolutionChanged, nullptr);
1778 }
1779
1780 void nsPresContext::UIResolutionChangedInternal() {
1781   mPendingUIResolutionChanged = false;
1782
1783   mDeviceContext->CheckDPIChange();
1784   if (mCurAppUnitsPerDevPixel != mDeviceContext->AppUnitsPerDevPixel()) {
1785     AppUnitsPerDevPixelChanged();
1786   }
1787
1788   if (mPresShell) {
1789     mPresShell->RefreshZoomConstraintsForScreenSizeChange();
1790     if (RefPtr<MobileViewportManager> mvm =
1791             mPresShell->GetMobileViewportManager()) {
1792       mvm->UpdateSizesBeforeReflow();
1793     }
1794   }
1795
1796   // Recursively notify all remote leaf descendants of the change.
1797   if (nsPIDOMWindowOuter* window = mDocument->GetWindow()) {
1798     NotifyChildrenUIResolutionChanged(window);
1799   }
1800
1801   auto recurse = [](dom::Document& aSubDoc) {
1802     if (nsPresContext* pc = aSubDoc.GetPresContext()) {
1803       pc->UIResolutionChangedInternal();
1804     }
1805     return CallState::Continue;
1806   };
1807   mDocument->EnumerateSubDocuments(recurse);
1808 }
1809
1810 void nsPresContext::EmulateMedium(nsAtom* aMediaType) {
1811   MOZ_ASSERT(!aMediaType || aMediaType->IsAsciiLowercase());
1812
1813   RefPtr<const nsAtom> oldMedium = Medium();
1814   auto oldScheme = mDocument->PreferredColorScheme();
1815
1816   mMediaEmulationData.mMedium = aMediaType;
1817
1818   if (Medium() == oldMedium) {
1819     return;
1820   }
1821
1822   MediaFeatureChange change(MediaFeatureChangeReason::MediumChange);
1823   if (oldScheme != mDocument->PreferredColorScheme()) {
1824     change |= MediaFeatureChange::ForPreferredColorSchemeChange();
1825   }
1826   MediaFeatureValuesChanged(change,
1827                             MediaFeatureChangePropagation::JustThisDocument);
1828 }
1829
1830 void nsPresContext::ContentLanguageChanged() {
1831   PostRebuildAllStyleDataEvent(nsChangeHint(0),
1832                                RestyleHint::RecascadeSubtree());
1833 }
1834
1835 void nsPresContext::RegisterManagedPostRefreshObserver(
1836     ManagedPostRefreshObserver* aObserver) {
1837   if (MOZ_UNLIKELY(!mPresShell)) {
1838     // If we're detached from our pres shell already, refuse to keep observer
1839     // around, as that'd create a cycle.
1840     RefPtr<ManagedPostRefreshObserver> obs = aObserver;
1841     obs->Cancel();
1842     return;
1843   }
1844
1845   RefreshDriver()->AddPostRefreshObserver(
1846       static_cast<nsAPostRefreshObserver*>(aObserver));
1847   mManagedPostRefreshObservers.AppendElement(aObserver);
1848 }
1849
1850 void nsPresContext::UnregisterManagedPostRefreshObserver(
1851     ManagedPostRefreshObserver* aObserver) {
1852   RefreshDriver()->RemovePostRefreshObserver(
1853       static_cast<nsAPostRefreshObserver*>(aObserver));
1854   DebugOnly<bool> removed =
1855       mManagedPostRefreshObservers.RemoveElement(aObserver);
1856   MOZ_ASSERT(removed,
1857              "ManagedPostRefreshObserver should be owned by PresContext");
1858 }
1859
1860 void nsPresContext::CancelManagedPostRefreshObservers() {
1861   auto observers = std::move(mManagedPostRefreshObservers);
1862   nsRefreshDriver* driver = RefreshDriver();
1863   for (const auto& observer : observers) {
1864     observer->Cancel();
1865     driver->RemovePostRefreshObserver(
1866         static_cast<nsAPostRefreshObserver*>(observer));
1867   }
1868 }
1869
1870 void nsPresContext::RebuildAllStyleData(nsChangeHint aExtraHint,
1871                                         const RestyleHint& aRestyleHint) {
1872   if (!mPresShell) {
1873     // We must have been torn down. Nothing to do here.
1874     return;
1875   }
1876
1877   // TODO(emilio): It's unclear to me why would these three calls below be
1878   // needed. In particular, RebuildAllStyleData doesn't rebuild rules or
1879   // specified style information and such (note the comment in
1880   // RestyleManager::RebuildAllStyleData re. the funny semantics), so I
1881   // don't know why should we rebuild the user font set / counter styles /
1882   // etc...
1883   mDocument->MarkUserFontSetDirty();
1884   MarkCounterStylesDirty();
1885   MarkFontFeatureValuesDirty();
1886   MarkFontPaletteValuesDirty();
1887   PostRebuildAllStyleDataEvent(aExtraHint, aRestyleHint);
1888 }
1889
1890 void nsPresContext::PostRebuildAllStyleDataEvent(
1891     nsChangeHint aExtraHint, const RestyleHint& aRestyleHint) {
1892   if (!mPresShell) {
1893     // We must have been torn down. Nothing to do here.
1894     return;
1895   }
1896   RestyleManager()->RebuildAllStyleData(aExtraHint, aRestyleHint);
1897 }
1898
1899 void nsPresContext::MediaFeatureValuesChanged(
1900     const MediaFeatureChange& aChange,
1901     MediaFeatureChangePropagation aPropagation) {
1902   if (mPresShell) {
1903     mPresShell->EnsureStyleFlush();
1904   }
1905
1906   if (!mPendingMediaFeatureValuesChange) {
1907     mPendingMediaFeatureValuesChange = MakeUnique<MediaFeatureChange>(aChange);
1908   } else {
1909     *mPendingMediaFeatureValuesChange |= aChange;
1910   }
1911
1912   if (aPropagation & MediaFeatureChangePropagation::Images) {
1913     // Propagate the media feature value change down to any SVG images the
1914     // document is using.
1915     mDocument->ImageTracker()->MediaFeatureValuesChangedAllDocuments(aChange);
1916   }
1917
1918   if (aPropagation & MediaFeatureChangePropagation::SubDocuments) {
1919     // And then into any subdocuments.
1920     auto recurse = [&aChange, aPropagation](dom::Document& aSubDoc) {
1921       if (nsPresContext* pc = aSubDoc.GetPresContext()) {
1922         pc->MediaFeatureValuesChanged(aChange, aPropagation);
1923       }
1924       return CallState::Continue;
1925     };
1926     mDocument->EnumerateSubDocuments(recurse);
1927   }
1928
1929   // We notify the media feature values changed for the responsive content of
1930   // HTMLImageElements synchronously, so their image sources are always
1931   // up-to-date when running the image load tasks in the microtasks.
1932   mDocument->NotifyMediaFeatureValuesChanged();
1933 }
1934
1935 bool nsPresContext::FlushPendingMediaFeatureValuesChanged() {
1936   if (!mPendingMediaFeatureValuesChange) {
1937     return false;
1938   }
1939
1940   MediaFeatureChange change = *mPendingMediaFeatureValuesChange;
1941   mPendingMediaFeatureValuesChange.reset();
1942
1943   // MediumFeaturesChanged updates the applied rules, so it always gets called.
1944   if (mPresShell) {
1945     change.mRestyleHint |=
1946         mPresShell->StyleSet()->MediumFeaturesChanged(change.mReason);
1947   }
1948
1949   const bool changedStyle = change.mRestyleHint || change.mChangeHint;
1950   if (changedStyle) {
1951     RebuildAllStyleData(change.mChangeHint, change.mRestyleHint);
1952   }
1953
1954   if (mDocument->IsBeingUsedAsImage()) {
1955     MOZ_ASSERT(mDocument->MediaQueryLists().isEmpty());
1956     return changedStyle;
1957   }
1958
1959   // https://drafts.csswg.org/cssom-view/#evaluate-media-queries-and-report-changes
1960   //
1961   // Media query list listeners should be notified from a queued task
1962   // (in HTML5 terms), although we also want to notify them on certain
1963   // flushes.  (We're already running off an event.)
1964   //
1965   // TODO: This should be better integrated into the "update the rendering"
1966   // steps: https://html.spec.whatwg.org/#update-the-rendering
1967   //
1968   // Note that we do this after the new style from media queries in
1969   // style sheets has been computed.
1970
1971   if (mDocument->MediaQueryLists().isEmpty()) {
1972     return changedStyle;
1973   }
1974
1975   // We build a list of all the notifications we're going to send
1976   // before we send any of them.
1977   nsTArray<RefPtr<mozilla::dom::MediaQueryList>> listsToNotify;
1978   for (MediaQueryList* mql = mDocument->MediaQueryLists().getFirst(); mql;
1979        mql = static_cast<LinkedListElement<MediaQueryList>*>(mql)->getNext()) {
1980     if (mql->MediaFeatureValuesChanged()) {
1981       listsToNotify.AppendElement(mql);
1982     }
1983   }
1984
1985   if (!listsToNotify.IsEmpty()) {
1986     nsContentUtils::AddScriptRunner(NS_NewRunnableFunction(
1987         "nsPresContext::FlushPendingMediaFeatureValuesChanged",
1988         [list = std::move(listsToNotify)] {
1989           for (const auto& mql : list) {
1990             nsAutoMicroTask mt;
1991             mql->FireChangeEvent();
1992           }
1993         }));
1994   }
1995
1996   return changedStyle;
1997 }
1998
1999 void nsPresContext::SizeModeChanged(nsSizeMode aSizeMode) {
2000   if (nsPIDOMWindowOuter* window = mDocument->GetWindow()) {
2001     nsContentUtils::CallOnAllRemoteChildren(
2002         window, [&aSizeMode](BrowserParent* aBrowserParent) -> CallState {
2003           aBrowserParent->SizeModeChanged(aSizeMode);
2004           return CallState::Continue;
2005         });
2006   }
2007   MediaFeatureValuesChanged({MediaFeatureChangeReason::SizeModeChange},
2008                             MediaFeatureChangePropagation::SubDocuments);
2009 }
2010
2011 nsCompatibility nsPresContext::CompatibilityMode() const {
2012   return Document()->GetCompatibilityMode();
2013 }
2014
2015 void nsPresContext::SetPaginatedScrolling(bool aPaginated) {
2016   if (mType == eContext_PrintPreview || mType == eContext_PageLayout) {
2017     mCanPaginatedScroll = aPaginated;
2018   }
2019 }
2020
2021 void nsPresContext::SetPrintSettings(nsIPrintSettings* aPrintSettings) {
2022   if (mMedium != nsGkAtoms::print) {
2023     return;
2024   }
2025
2026   mPrintSettings = aPrintSettings;
2027   mDefaultPageMargin = nsMargin();
2028   if (!mPrintSettings) {
2029     return;
2030   }
2031
2032   // Set the presentation context to the value in the print settings.
2033   mDrawColorBackground = mPrintSettings->GetPrintBGColors();
2034   mDrawImageBackground = mPrintSettings->GetPrintBGImages();
2035
2036   nsIntMargin marginTwips = mPrintSettings->GetMarginInTwips();
2037   if (!mPrintSettings->GetIgnoreUnwriteableMargins()) {
2038     nsIntMargin unwriteableTwips =
2039         mPrintSettings->GetUnwriteableMarginInTwips();
2040     NS_ASSERTION(unwriteableTwips.top >= 0 && unwriteableTwips.right >= 0 &&
2041                      unwriteableTwips.bottom >= 0 && unwriteableTwips.left >= 0,
2042                  "Unwriteable twips should be non-negative");
2043     marginTwips.EnsureAtLeast(unwriteableTwips);
2044   }
2045   mDefaultPageMargin = nsPresContext::CSSTwipsToAppUnits(marginTwips);
2046 }
2047
2048 bool nsPresContext::EnsureVisible() {
2049   BrowsingContext* browsingContext =
2050       mDocument ? mDocument->GetBrowsingContext() : nullptr;
2051   if (!browsingContext || browsingContext->IsInBFCache()) {
2052     return false;
2053   }
2054
2055   nsCOMPtr<nsIDocShell> docShell(GetDocShell());
2056   if (!docShell) {
2057     return false;
2058   }
2059   nsCOMPtr<nsIContentViewer> cv;
2060   docShell->GetContentViewer(getter_AddRefs(cv));
2061   // Make sure this is the content viewer we belong with
2062   if (!cv || cv->GetPresContext() != this) {
2063     return false;
2064   }
2065   // OK, this is us.  We want to call Show() on the content viewer.
2066   nsresult result = cv->Show();
2067   return NS_SUCCEEDED(result);
2068 }
2069
2070 #ifdef MOZ_REFLOW_PERF
2071 void nsPresContext::CountReflows(const char* aName, nsIFrame* aFrame) {
2072   if (mPresShell) {
2073     mPresShell->CountReflows(aName, aFrame);
2074   }
2075 }
2076 #endif
2077
2078 gfxUserFontSet* nsPresContext::GetUserFontSet() {
2079   return mDocument->GetUserFontSet();
2080 }
2081
2082 void nsPresContext::UserFontSetUpdated(gfxUserFontEntry* aUpdatedFont) {
2083   if (!mPresShell) {
2084     return;
2085   }
2086
2087   // Note: this method is called without a font when rules in the userfont set
2088   // are updated.
2089   //
2090   // We can avoid a full restyle if font-metric-dependent units are not in use,
2091   // since we know there's no style resolution that would depend on this font
2092   // and trigger its load.
2093   //
2094   // TODO(emilio): We could be more granular if we knew which families have
2095   // potentially changed.
2096   if (!aUpdatedFont) {
2097     auto hint = StyleSet()->UsesFontMetrics() ? RestyleHint::RecascadeSubtree()
2098                                               : RestyleHint{0};
2099     PostRebuildAllStyleDataEvent(NS_STYLE_HINT_REFLOW, hint);
2100     return;
2101   }
2102
2103   // Iterate over the frame tree looking for frames associated with the
2104   // downloadable font family in question. If a frame's nsStyleFont has
2105   // the name, check the font group associated with the metrics to see if
2106   // it contains that specific font (i.e. the one chosen within the family
2107   // given the weight, width, and slant from the nsStyleFont). If it does,
2108   // mark that frame dirty and skip inspecting its descendants.
2109   if (nsIFrame* root = mPresShell->GetRootFrame()) {
2110     nsFontFaceUtils::MarkDirtyForFontChange(root, aUpdatedFont);
2111   }
2112 }
2113
2114 class CounterStyleCleaner final : public nsAPostRefreshObserver {
2115  public:
2116   CounterStyleCleaner(nsRefreshDriver* aRefreshDriver,
2117                       CounterStyleManager* aCounterStyleManager)
2118       : mRefreshDriver(aRefreshDriver),
2119         mCounterStyleManager(aCounterStyleManager) {}
2120   virtual ~CounterStyleCleaner() = default;
2121
2122   void DidRefresh() final {
2123     mRefreshDriver->RemovePostRefreshObserver(this);
2124     mCounterStyleManager->CleanRetiredStyles();
2125     delete this;
2126   }
2127
2128  private:
2129   RefPtr<nsRefreshDriver> mRefreshDriver;
2130   RefPtr<CounterStyleManager> mCounterStyleManager;
2131 };
2132
2133 void nsPresContext::FlushCounterStyles() {
2134   if (!mPresShell) {
2135     return;  // we've been torn down
2136   }
2137   if (mCounterStyleManager->IsInitial()) {
2138     // Still in its initial state, no need to clean.
2139     return;
2140   }
2141
2142   if (mCounterStylesDirty) {
2143     bool changed = mCounterStyleManager->NotifyRuleChanged();
2144     if (changed) {
2145       PresShell()->NotifyCounterStylesAreDirty();
2146       PostRebuildAllStyleDataEvent(NS_STYLE_HINT_REFLOW, RestyleHint{0});
2147       RefreshDriver()->AddPostRefreshObserver(
2148           new CounterStyleCleaner(RefreshDriver(), mCounterStyleManager));
2149     }
2150     mCounterStylesDirty = false;
2151   }
2152 }
2153
2154 void nsPresContext::MarkCounterStylesDirty() {
2155   if (mCounterStyleManager->IsInitial()) {
2156     // Still in its initial state, no need to touch anything.
2157     return;
2158   }
2159
2160   mCounterStylesDirty = true;
2161 }
2162
2163 void nsPresContext::NotifyMissingFonts() {
2164   if (mMissingFonts) {
2165     mMissingFonts->Flush();
2166   }
2167 }
2168
2169 void nsPresContext::EnsureSafeToHandOutCSSRules() {
2170   if (!mPresShell->StyleSet()->EnsureUniqueInnerOnCSSSheets()) {
2171     // Nothing to do.
2172     return;
2173   }
2174
2175   RebuildAllStyleData(nsChangeHint(0), RestyleHint::RestyleSubtree());
2176 }
2177
2178 void nsPresContext::FireDOMPaintEvent(
2179     nsTArray<nsRect>* aList, TransactionId aTransactionId,
2180     mozilla::TimeStamp aTimeStamp /* = mozilla::TimeStamp() */) {
2181   nsPIDOMWindowInner* ourWindow = mDocument->GetInnerWindow();
2182   if (!ourWindow) return;
2183
2184   nsCOMPtr<EventTarget> dispatchTarget = do_QueryInterface(ourWindow);
2185   nsCOMPtr<EventTarget> eventTarget = dispatchTarget;
2186   if (!IsChrome() && !mSendAfterPaintToContent) {
2187     // Don't tell the window about this event, it should not know that
2188     // something happened in a subdocument. Tell only the chrome event handler.
2189     // (Events sent to the window get propagated to the chrome event handler
2190     // automatically.)
2191     dispatchTarget = ourWindow->GetParentTarget();
2192     if (!dispatchTarget) {
2193       return;
2194     }
2195   }
2196
2197   if (aTimeStamp.IsNull()) {
2198     aTimeStamp = mozilla::TimeStamp::Now();
2199   }
2200   DOMHighResTimeStamp timeStamp = 0;
2201   if (ourWindow) {
2202     mozilla::dom::Performance* perf = ourWindow->GetPerformance();
2203     if (perf) {
2204       timeStamp = perf->GetDOMTiming()->TimeStampToDOMHighRes(aTimeStamp);
2205     }
2206   }
2207
2208   // Events sent to the window get propagated to the chrome event handler
2209   // automatically.
2210   //
2211   // This will empty our list in case dispatching the event causes more damage
2212   // (hopefully it won't, or we're likely to get an infinite loop! At least
2213   // it won't be blocking app execution though).
2214   RefPtr<NotifyPaintEvent> event =
2215       NS_NewDOMNotifyPaintEvent(eventTarget, this, nullptr, eAfterPaint, aList,
2216                                 uint64_t(aTransactionId), timeStamp);
2217
2218   // Even if we're not telling the window about the event (so eventTarget is
2219   // the chrome event handler, not the window), the window is still
2220   // logically the event target.
2221   event->SetTarget(eventTarget);
2222   event->SetTrusted(true);
2223   EventDispatcher::DispatchDOMEvent(dispatchTarget, nullptr,
2224                                     static_cast<Event*>(event), this, nullptr);
2225 }
2226
2227 static bool MayHavePaintEventListener(nsPIDOMWindowInner* aInnerWindow) {
2228   if (!aInnerWindow) return false;
2229   if (aInnerWindow->HasPaintEventListeners()) return true;
2230
2231   EventTarget* parentTarget = aInnerWindow->GetParentTarget();
2232   if (!parentTarget) return false;
2233
2234   EventListenerManager* manager = nullptr;
2235   if ((manager = parentTarget->GetExistingListenerManager()) &&
2236       manager->MayHavePaintEventListener()) {
2237     return true;
2238   }
2239
2240   nsCOMPtr<nsINode> node;
2241   if (parentTarget != aInnerWindow->GetChromeEventHandler()) {
2242     nsCOMPtr<nsIInProcessContentFrameMessageManager> mm =
2243         do_QueryInterface(parentTarget);
2244     if (mm) {
2245       node = mm->GetOwnerContent();
2246     }
2247   }
2248
2249   if (!node) {
2250     node = nsINode::FromEventTarget(parentTarget);
2251   }
2252   if (node) {
2253     return MayHavePaintEventListener(node->OwnerDoc()->GetInnerWindow());
2254   }
2255
2256   if (nsCOMPtr<nsPIDOMWindowInner> window =
2257           nsPIDOMWindowInner::FromEventTarget(parentTarget)) {
2258     return MayHavePaintEventListener(window);
2259   }
2260
2261   if (nsCOMPtr<nsPIWindowRoot> root =
2262           nsPIWindowRoot::FromEventTarget(parentTarget)) {
2263     EventTarget* browserChildGlobal;
2264     return root && (browserChildGlobal = root->GetParentTarget()) &&
2265            (manager = browserChildGlobal->GetExistingListenerManager()) &&
2266            manager->MayHavePaintEventListener();
2267   }
2268
2269   return false;
2270 }
2271
2272 bool nsPresContext::MayHavePaintEventListener() {
2273   return ::MayHavePaintEventListener(mDocument->GetInnerWindow());
2274 }
2275
2276 void nsPresContext::NotifyInvalidation(TransactionId aTransactionId,
2277                                        const nsIntRect& aRect) {
2278   // Prevent values from overflow after DevPixelsToAppUnits().
2279   //
2280   // DevPixelsTopAppUnits() will multiple a factor (60) to the value,
2281   // it may make the result value over the edge (overflow) of max or
2282   // min value of int32_t. Compute the max sized dev pixel rect that
2283   // we can support and intersect with it.
2284   nsIntRect clampedRect = nsIntRect::MaxIntRect();
2285   clampedRect.ScaleInverseRoundIn(AppUnitsPerDevPixel());
2286
2287   clampedRect = clampedRect.Intersect(aRect);
2288
2289   nsRect rect(DevPixelsToAppUnits(clampedRect.x),
2290               DevPixelsToAppUnits(clampedRect.y),
2291               DevPixelsToAppUnits(clampedRect.width),
2292               DevPixelsToAppUnits(clampedRect.height));
2293   NotifyInvalidation(aTransactionId, rect);
2294 }
2295
2296 nsPresContext::TransactionInvalidations* nsPresContext::GetInvalidations(
2297     TransactionId aTransactionId) {
2298   for (TransactionInvalidations& t : mTransactions) {
2299     if (t.mTransactionId == aTransactionId) {
2300       return &t;
2301     }
2302   }
2303   return nullptr;
2304 }
2305
2306 void nsPresContext::NotifyInvalidation(TransactionId aTransactionId,
2307                                        const nsRect& aRect) {
2308   MOZ_ASSERT(GetContainerWeak(), "Invalidation in detached pres context");
2309
2310   // If there is no paint event listener, then we don't need to fire
2311   // the asynchronous event. We don't even need to record invalidation.
2312   // MayHavePaintEventListener is pretty cheap and we could make it
2313   // even cheaper by providing a more efficient
2314   // nsPIDOMWindow::GetListenerManager.
2315
2316   nsPresContext* pc;
2317   for (pc = this; pc; pc = pc->GetParentPresContext()) {
2318     TransactionInvalidations* transaction =
2319         pc->GetInvalidations(aTransactionId);
2320     if (transaction) {
2321       break;
2322     } else {
2323       transaction = pc->mTransactions.AppendElement();
2324       transaction->mTransactionId = aTransactionId;
2325     }
2326   }
2327
2328   TransactionInvalidations* transaction = GetInvalidations(aTransactionId);
2329   MOZ_ASSERT(transaction);
2330   transaction->mInvalidations.AppendElement(aRect);
2331 }
2332
2333 class DelayedFireDOMPaintEvent : public Runnable {
2334  public:
2335   DelayedFireDOMPaintEvent(
2336       nsPresContext* aPresContext, nsTArray<nsRect>&& aList,
2337       TransactionId aTransactionId,
2338       const mozilla::TimeStamp& aTimeStamp = mozilla::TimeStamp())
2339       : mozilla::Runnable("DelayedFireDOMPaintEvent"),
2340         mPresContext(aPresContext),
2341         mTransactionId(aTransactionId),
2342         mTimeStamp(aTimeStamp),
2343         mList(std::move(aList)) {
2344     MOZ_ASSERT(mPresContext->GetContainerWeak(),
2345                "DOMPaintEvent requested for a detached pres context");
2346   }
2347   NS_IMETHOD Run() override {
2348     // The pres context might have been detached during the delay -
2349     // that's fine, just don't fire the event.
2350     if (mPresContext->GetContainerWeak()) {
2351       mPresContext->FireDOMPaintEvent(&mList, mTransactionId, mTimeStamp);
2352     }
2353     return NS_OK;
2354   }
2355
2356   RefPtr<nsPresContext> mPresContext;
2357   TransactionId mTransactionId;
2358   const mozilla::TimeStamp mTimeStamp;
2359   nsTArray<nsRect> mList;
2360 };
2361
2362 void nsPresContext::NotifyRevokingDidPaint(TransactionId aTransactionId) {
2363   if ((IsRoot() || !PresShell()->IsVisible()) && mTransactions.IsEmpty()) {
2364     return;
2365   }
2366
2367   TransactionInvalidations* transaction = nullptr;
2368   for (auto& t : mTransactions) {
2369     if (t.mTransactionId == aTransactionId) {
2370       transaction = &t;
2371       break;
2372     }
2373   }
2374   // If there are no transaction invalidations (which imply callers waiting
2375   // on the event) for this revoked id, then we don't need to fire a
2376   // MozAfterPaint.
2377   if (!transaction) {
2378     return;
2379   }
2380
2381   // If there are queued transactions with an earlier id, we can't send
2382   // our event now since it will arrive out of order. Set the waiting for
2383   // previous transaction flag to true, and we'll send the event when
2384   // the others are completed.
2385   // If this is the only transaction, then we can send it immediately.
2386   if (mTransactions.Length() == 1) {
2387     nsCOMPtr<nsIRunnable> ev = new DelayedFireDOMPaintEvent(
2388         this, std::move(transaction->mInvalidations),
2389         transaction->mTransactionId, mozilla::TimeStamp());
2390     nsContentUtils::AddScriptRunner(ev);
2391     mTransactions.RemoveElementAt(0);
2392   } else {
2393     transaction->mIsWaitingForPreviousTransaction = true;
2394   }
2395
2396   auto recurse = [&aTransactionId](dom::Document& aSubDoc) {
2397     if (nsPresContext* pc = aSubDoc.GetPresContext()) {
2398       pc->NotifyRevokingDidPaint(aTransactionId);
2399     }
2400     return CallState::Continue;
2401   };
2402   mDocument->EnumerateSubDocuments(recurse);
2403 }
2404
2405 void nsPresContext::NotifyDidPaintForSubtree(
2406     TransactionId aTransactionId, const mozilla::TimeStamp& aTimeStamp) {
2407   if (mFirstContentfulPaintTransactionId && !mHadContentfulPaintComposite) {
2408     if (aTransactionId >= *mFirstContentfulPaintTransactionId) {
2409       mHadContentfulPaintComposite = true;
2410       RefPtr<nsDOMNavigationTiming> timing = mDocument->GetNavigationTiming();
2411       if (timing && !IsPrintingOrPrintPreview()) {
2412         timing->NotifyContentfulCompositeForRootContentDocument(aTimeStamp);
2413       }
2414     }
2415   }
2416
2417   if (IsRoot() && mTransactions.IsEmpty()) {
2418     return;
2419   }
2420
2421   if (!PresShell()->IsVisible() && mTransactions.IsEmpty()) {
2422     return;
2423   }
2424
2425   // Non-root prescontexts fire MozAfterPaint to all their descendants
2426   // unconditionally, even if no invalidations have been collected. This is
2427   // because we don't want to eat the cost of collecting invalidations for
2428   // every subdocument (which would require putting every subdocument in its
2429   // own layer).
2430
2431   bool sent = false;
2432   uint32_t i = 0;
2433   while (i < mTransactions.Length()) {
2434     if (mTransactions[i].mTransactionId <= aTransactionId) {
2435       if (!mTransactions[i].mInvalidations.IsEmpty()) {
2436         nsCOMPtr<nsIRunnable> ev = new DelayedFireDOMPaintEvent(
2437             this, std::move(mTransactions[i].mInvalidations),
2438             mTransactions[i].mTransactionId, aTimeStamp);
2439         NS_DispatchToCurrentThreadQueue(ev.forget(),
2440                                         EventQueuePriority::MediumHigh);
2441         sent = true;
2442       }
2443       mTransactions.RemoveElementAt(i);
2444     } else {
2445       // If there are transaction which is waiting for this transaction,
2446       // we should fire a MozAfterPaint immediately.
2447       if (sent && mTransactions[i].mIsWaitingForPreviousTransaction) {
2448         nsCOMPtr<nsIRunnable> ev = new DelayedFireDOMPaintEvent(
2449             this, std::move(mTransactions[i].mInvalidations),
2450             mTransactions[i].mTransactionId, aTimeStamp);
2451         NS_DispatchToCurrentThreadQueue(ev.forget(),
2452                                         EventQueuePriority::MediumHigh);
2453         sent = true;
2454         mTransactions.RemoveElementAt(i);
2455         continue;
2456       }
2457       i++;
2458     }
2459   }
2460
2461   if (!sent) {
2462     nsTArray<nsRect> dummy;
2463     nsCOMPtr<nsIRunnable> ev = new DelayedFireDOMPaintEvent(
2464         this, std::move(dummy), aTransactionId, aTimeStamp);
2465     NS_DispatchToCurrentThreadQueue(ev.forget(),
2466                                     EventQueuePriority::MediumHigh);
2467   }
2468
2469   auto recurse = [&aTransactionId, &aTimeStamp](dom::Document& aSubDoc) {
2470     if (nsPresContext* pc = aSubDoc.GetPresContext()) {
2471       pc->NotifyDidPaintForSubtree(aTransactionId, aTimeStamp);
2472     }
2473     return CallState::Continue;
2474   };
2475   mDocument->EnumerateSubDocuments(recurse);
2476 }
2477
2478 already_AddRefed<nsITimer> nsPresContext::CreateTimer(
2479     nsTimerCallbackFunc aCallback, const char* aName, uint32_t aDelay) {
2480   nsCOMPtr<nsITimer> timer;
2481   NS_NewTimerWithFuncCallback(getter_AddRefs(timer), aCallback, this, aDelay,
2482                               nsITimer::TYPE_ONE_SHOT, aName,
2483                               Document()->EventTargetFor(TaskCategory::Other));
2484   return timer.forget();
2485 }
2486
2487 static bool sGotInterruptEnv = false;
2488 enum InterruptMode { ModeRandom, ModeCounter, ModeEvent };
2489 // Controlled by the GECKO_REFLOW_INTERRUPT_MODE env var; allowed values are
2490 // "random" (except on Windows) or "counter".  If neither is used, the mode is
2491 // ModeEvent.
2492 static InterruptMode sInterruptMode = ModeEvent;
2493 #ifndef XP_WIN
2494 // Used for the "random" mode.  Controlled by the GECKO_REFLOW_INTERRUPT_SEED
2495 // env var.
2496 static uint32_t sInterruptSeed = 1;
2497 #endif
2498 // Used for the "counter" mode.  This is the number of unskipped interrupt
2499 // checks that have to happen before we interrupt.  Controlled by the
2500 // GECKO_REFLOW_INTERRUPT_FREQUENCY env var.
2501 static uint32_t sInterruptMaxCounter = 10;
2502 // Used for the "counter" mode.  This counts up to sInterruptMaxCounter and is
2503 // then reset to 0.
2504 static uint32_t sInterruptCounter;
2505 // Number of interrupt checks to skip before really trying to interrupt.
2506 // Controlled by the GECKO_REFLOW_INTERRUPT_CHECKS_TO_SKIP env var.
2507 static uint32_t sInterruptChecksToSkip = 200;
2508 // Number of milliseconds that a reflow should be allowed to run for before we
2509 // actually allow interruption.  Controlled by the
2510 // GECKO_REFLOW_MIN_NOINTERRUPT_DURATION env var.  Can't be initialized here,
2511 // because TimeDuration/TimeStamp is not safe to use in static constructors..
2512 static TimeDuration sInterruptTimeout;
2513
2514 static void GetInterruptEnv() {
2515   char* ev = PR_GetEnv("GECKO_REFLOW_INTERRUPT_MODE");
2516   if (ev) {
2517 #ifndef XP_WIN
2518     if (nsCRT::strcasecmp(ev, "random") == 0) {
2519       ev = PR_GetEnv("GECKO_REFLOW_INTERRUPT_SEED");
2520       if (ev) {
2521         sInterruptSeed = atoi(ev);
2522       }
2523       srandom(sInterruptSeed);
2524       sInterruptMode = ModeRandom;
2525     } else
2526 #endif
2527         if (PL_strcasecmp(ev, "counter") == 0) {
2528       ev = PR_GetEnv("GECKO_REFLOW_INTERRUPT_FREQUENCY");
2529       if (ev) {
2530         sInterruptMaxCounter = atoi(ev);
2531       }
2532       sInterruptCounter = 0;
2533       sInterruptMode = ModeCounter;
2534     }
2535   }
2536   ev = PR_GetEnv("GECKO_REFLOW_INTERRUPT_CHECKS_TO_SKIP");
2537   if (ev) {
2538     sInterruptChecksToSkip = atoi(ev);
2539   }
2540
2541   ev = PR_GetEnv("GECKO_REFLOW_MIN_NOINTERRUPT_DURATION");
2542   int duration_ms = ev ? atoi(ev) : 100;
2543   sInterruptTimeout = TimeDuration::FromMilliseconds(duration_ms);
2544 }
2545
2546 bool nsPresContext::HavePendingInputEvent() {
2547   switch (sInterruptMode) {
2548 #ifndef XP_WIN
2549     case ModeRandom:
2550       return (random() & 1);
2551 #endif
2552     case ModeCounter:
2553       if (sInterruptCounter < sInterruptMaxCounter) {
2554         ++sInterruptCounter;
2555         return false;
2556       }
2557       sInterruptCounter = 0;
2558       return true;
2559     default:
2560     case ModeEvent: {
2561       nsIFrame* f = PresShell()->GetRootFrame();
2562       if (f) {
2563         nsIWidget* w = f->GetNearestWidget();
2564         if (w) {
2565           return w->HasPendingInputEvent();
2566         }
2567       }
2568       return false;
2569     }
2570   }
2571 }
2572
2573 bool nsPresContext::HasPendingRestyleOrReflow() {
2574   mozilla::PresShell* presShell = PresShell();
2575   return presShell->NeedStyleFlush() || presShell->HasPendingReflow();
2576 }
2577
2578 void nsPresContext::ReflowStarted(bool aInterruptible) {
2579 #ifdef NOISY_INTERRUPTIBLE_REFLOW
2580   if (!aInterruptible) {
2581     printf("STARTING NONINTERRUPTIBLE REFLOW\n");
2582   }
2583 #endif
2584   // We don't support interrupting in paginated contexts, since page
2585   // sequences only handle initial reflow
2586   mInterruptsEnabled = aInterruptible && !IsPaginated() &&
2587                        StaticPrefs::layout_interruptible_reflow_enabled();
2588
2589   // Don't set mHasPendingInterrupt based on HavePendingInputEvent() here.  If
2590   // we ever change that, then we need to update the code in
2591   // PresShell::DoReflow to only add the just-reflown root to dirty roots if
2592   // it's actually dirty.  Otherwise we can end up adding a root that has no
2593   // interruptible descendants, just because we detected an interrupt at reflow
2594   // start.
2595   mHasPendingInterrupt = false;
2596
2597   mInterruptChecksToSkip = sInterruptChecksToSkip;
2598
2599   if (mInterruptsEnabled) {
2600     mReflowStartTime = TimeStamp::Now();
2601   }
2602 }
2603
2604 bool nsPresContext::CheckForInterrupt(nsIFrame* aFrame) {
2605   if (mHasPendingInterrupt) {
2606     mPresShell->FrameNeedsToContinueReflow(aFrame);
2607     return true;
2608   }
2609
2610   if (!sGotInterruptEnv) {
2611     sGotInterruptEnv = true;
2612     GetInterruptEnv();
2613   }
2614
2615   if (!mInterruptsEnabled) {
2616     return false;
2617   }
2618
2619   if (mInterruptChecksToSkip > 0) {
2620     --mInterruptChecksToSkip;
2621     return false;
2622   }
2623   mInterruptChecksToSkip = sInterruptChecksToSkip;
2624
2625   // Don't interrupt if it's been less than sInterruptTimeout since we started
2626   // the reflow.
2627   mHasPendingInterrupt =
2628       TimeStamp::Now() - mReflowStartTime > sInterruptTimeout &&
2629       HavePendingInputEvent() && !IsChrome();
2630
2631   if (mPendingInterruptFromTest) {
2632     mPendingInterruptFromTest = false;
2633     mHasPendingInterrupt = true;
2634   }
2635
2636   if (mHasPendingInterrupt) {
2637 #ifdef NOISY_INTERRUPTIBLE_REFLOW
2638     printf("*** DETECTED pending interrupt (time=%lld)\n", PR_Now());
2639 #endif /* NOISY_INTERRUPTIBLE_REFLOW */
2640     mPresShell->FrameNeedsToContinueReflow(aFrame);
2641   }
2642   return mHasPendingInterrupt;
2643 }
2644
2645 nsIFrame* nsPresContext::GetPrimaryFrameFor(nsIContent* aContent) {
2646   MOZ_ASSERT(aContent, "Don't do that");
2647   if (GetPresShell() &&
2648       GetPresShell()->GetDocument() == aContent->GetComposedDoc()) {
2649     return aContent->GetPrimaryFrame();
2650   }
2651   return nullptr;
2652 }
2653
2654 size_t nsPresContext::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
2655   // Measurement may be added later if DMD finds it is worthwhile.
2656   return 0;
2657 }
2658
2659 bool nsPresContext::IsRootContentDocumentInProcess() const {
2660   if (mDocument->IsResourceDoc()) {
2661     return false;
2662   }
2663   if (IsChrome()) {
2664     return false;
2665   }
2666   // We may not have a root frame, so use views.
2667   nsView* view = PresShell()->GetViewManager()->GetRootView();
2668   if (!view) {
2669     return false;
2670   }
2671   view = view->GetParent();  // anonymous inner view
2672   if (!view) {
2673     return true;
2674   }
2675   view = view->GetParent();  // subdocumentframe's view
2676   if (!view) {
2677     return true;
2678   }
2679
2680   nsIFrame* f = view->GetFrame();
2681   return (f && f->PresContext()->IsChrome());
2682 }
2683
2684 bool nsPresContext::IsRootContentDocumentCrossProcess() const {
2685   if (mDocument->IsResourceDoc()) {
2686     return false;
2687   }
2688
2689   if (BrowsingContext* browsingContext = mDocument->GetBrowsingContext()) {
2690     if (browsingContext->GetEmbeddedInContentDocument()) {
2691       return false;
2692     }
2693   }
2694   return mDocument->IsTopLevelContentDocument();
2695 }
2696
2697 void nsPresContext::NotifyNonBlankPaint() {
2698   MOZ_ASSERT(!mHadNonBlankPaint);
2699   mHadNonBlankPaint = true;
2700   if (IsRootContentDocumentCrossProcess()) {
2701     RefPtr<nsDOMNavigationTiming> timing = mDocument->GetNavigationTiming();
2702     if (timing && !IsPrintingOrPrintPreview()) {
2703       timing->NotifyNonBlankPaintForRootContentDocument();
2704     }
2705
2706     mFirstNonBlankPaintTime = TimeStamp::Now();
2707   }
2708   if (IsChrome() && IsRoot()) {
2709     if (nsCOMPtr<nsIWidget> rootWidget = GetRootWidget()) {
2710       rootWidget->DidGetNonBlankPaint();
2711     }
2712   }
2713 }
2714
2715 void nsPresContext::NotifyContentfulPaint() {
2716   if (mHadContentfulPaint) {
2717     return;
2718   }
2719   nsRootPresContext* rootPresContext = GetRootPresContext();
2720   if (!rootPresContext) {
2721     return;
2722   }
2723   if (!mHadNonTickContentfulPaint) {
2724 #ifdef MOZ_WIDGET_ANDROID
2725     (new AsyncEventDispatcher(mDocument, u"MozFirstContentfulPaint"_ns,
2726                               CanBubble::eYes, ChromeOnlyDispatch::eYes))
2727         ->PostDOMEvent();
2728 #endif
2729   }
2730   if (!rootPresContext->RefreshDriver()->IsInRefresh()) {
2731     if (!mHadNonTickContentfulPaint) {
2732       rootPresContext->RefreshDriver()
2733           ->AddForceNotifyContentfulPaintPresContext(this);
2734       mHadNonTickContentfulPaint = true;
2735     }
2736     return;
2737   }
2738   mHadContentfulPaint = true;
2739   mFirstContentfulPaintTransactionId =
2740       Some(rootPresContext->mRefreshDriver->LastTransactionId().Next());
2741   if (nsPIDOMWindowInner* innerWindow = mDocument->GetInnerWindow()) {
2742     if (Performance* perf = innerWindow->GetPerformance()) {
2743       TimeStamp nowTime = rootPresContext->RefreshDriver()->MostRecentRefresh(
2744           /* aEnsureTimerStarted */ false);
2745       MOZ_ASSERT(!nowTime.IsNull(),
2746                  "Most recent refresh timestamp should exist since we are in "
2747                  "a refresh driver tick");
2748       MOZ_ASSERT(rootPresContext->RefreshDriver()->IsInRefresh(),
2749                  "We should only notify contentful paint during refresh "
2750                  "driver ticks");
2751       RefPtr<PerformancePaintTiming> paintTiming = new PerformancePaintTiming(
2752           perf, u"first-contentful-paint"_ns, nowTime);
2753       perf->SetFCPTimingEntry(paintTiming);
2754
2755       if (profiler_thread_is_being_profiled_for_markers()) {
2756         RefPtr<nsDOMNavigationTiming> timing = mDocument->GetNavigationTiming();
2757         if (timing) {
2758           TimeStamp navigationStart = timing->GetNavigationStartTimeStamp();
2759           TimeDuration elapsed = nowTime - navigationStart;
2760           nsIURI* docURI = Document()->GetDocumentURI();
2761           nsPrintfCString marker(
2762               "Contentful paint after %dms for URL %s",
2763               int(elapsed.ToMilliseconds()),
2764               nsContentUtils::TruncatedURLForDisplay(docURI).get());
2765           PROFILER_MARKER_TEXT(
2766               "FirstContentfulPaint", DOM,
2767               MarkerOptions(MarkerTiming::Interval(navigationStart, nowTime),
2768                             MarkerInnerWindowId(innerWindow->WindowID())),
2769               marker);
2770         }
2771       }
2772     }
2773   }
2774 }
2775
2776 void nsPresContext::NotifyPaintStatusReset() {
2777   mHadNonBlankPaint = false;
2778   mHadContentfulPaint = false;
2779 #if defined(MOZ_WIDGET_ANDROID)
2780   (new AsyncEventDispatcher(mDocument, u"MozPaintStatusReset"_ns,
2781                             CanBubble::eYes, ChromeOnlyDispatch::eYes))
2782       ->PostDOMEvent();
2783 #endif
2784   mHadNonTickContentfulPaint = false;
2785 }
2786
2787 void nsPresContext::NotifyDOMContentFlushed() {
2788   NS_ENSURE_TRUE_VOID(mPresShell);
2789   if (IsRootContentDocumentCrossProcess()) {
2790     RefPtr<nsDOMNavigationTiming> timing = mDocument->GetNavigationTiming();
2791     if (timing) {
2792       timing->NotifyDOMContentFlushedForRootContentDocument();
2793     }
2794   }
2795 }
2796
2797 nscoord nsPresContext::GfxUnitsToAppUnits(gfxFloat aGfxUnits) const {
2798   return mDeviceContext->GfxUnitsToAppUnits(aGfxUnits);
2799 }
2800
2801 gfxFloat nsPresContext::AppUnitsToGfxUnits(nscoord aAppUnits) const {
2802   return mDeviceContext->AppUnitsToGfxUnits(aAppUnits);
2803 }
2804
2805 nscoord nsPresContext::PhysicalMillimetersToAppUnits(float aMM) const {
2806   float inches = aMM / MM_PER_INCH_FLOAT;
2807   return NSToCoordFloorClamped(
2808       inches * float(DeviceContext()->AppUnitsPerPhysicalInch()));
2809 }
2810
2811 bool nsPresContext::IsDeviceSizePageSize() {
2812   nsIDocShell* docShell = GetDocShell();
2813   return docShell && docShell->GetDeviceSizeIsPageSize();
2814 }
2815
2816 uint64_t nsPresContext::GetRestyleGeneration() const {
2817   if (!mRestyleManager) {
2818     return 0;
2819   }
2820   return mRestyleManager->GetRestyleGeneration();
2821 }
2822
2823 uint64_t nsPresContext::GetUndisplayedRestyleGeneration() const {
2824   if (!mRestyleManager) {
2825     return 0;
2826   }
2827   return mRestyleManager->GetUndisplayedRestyleGeneration();
2828 }
2829
2830 mozilla::intl::Bidi& nsPresContext::BidiEngine() {
2831   MOZ_ASSERT(NS_IsMainThread());
2832
2833   if (!mBidiEngine) {
2834     mBidiEngine = MakeUnique<mozilla::intl::Bidi>();
2835   }
2836   return *mBidiEngine;
2837 }
2838
2839 void nsPresContext::FlushFontFeatureValues() {
2840   if (!mPresShell) {
2841     return;  // we've been torn down
2842   }
2843
2844   if (!mFontFeatureValuesDirty) {
2845     return;
2846   }
2847
2848   ServoStyleSet* styleSet = mPresShell->StyleSet();
2849   mFontFeatureValuesLookup = styleSet->BuildFontFeatureValueSet();
2850   mFontFeatureValuesDirty = false;
2851 }
2852
2853 void nsPresContext::FlushFontPaletteValues() {
2854   if (!mPresShell) {
2855     return;  // we've been torn down
2856   }
2857
2858   if (!mFontPaletteValuesDirty) {
2859     return;
2860   }
2861
2862   ServoStyleSet* styleSet = mPresShell->StyleSet();
2863   mFontPaletteValueSet = styleSet->BuildFontPaletteValueSet();
2864   mFontPaletteValuesDirty = false;
2865
2866   // Even if we're not reflowing anything, a change to the palette means we
2867   // need to repaint in order to show the new colors.
2868   InvalidatePaintedLayers();
2869 }
2870
2871 void nsPresContext::SetVisibleArea(const nsRect& r) {
2872   if (!r.IsEqualEdges(mVisibleArea)) {
2873     mVisibleArea = r;
2874     mSizeForViewportUnits = mVisibleArea.Size();
2875     if (IsRootContentDocumentCrossProcess()) {
2876       AdjustSizeForViewportUnits();
2877     }
2878     // Visible area does not affect media queries when paginated.
2879     if (!IsRootPaginatedDocument()) {
2880       MediaFeatureValuesChanged(
2881           {mozilla::MediaFeatureChangeReason::ViewportChange},
2882           MediaFeatureChangePropagation::JustThisDocument);
2883     }
2884   }
2885 }
2886
2887 void nsPresContext::SetDynamicToolbarMaxHeight(ScreenIntCoord aHeight) {
2888   MOZ_ASSERT(IsRootContentDocumentCrossProcess());
2889
2890   if (mDynamicToolbarMaxHeight == aHeight) {
2891     return;
2892   }
2893   mDynamicToolbarMaxHeight = aHeight;
2894   mDynamicToolbarHeight = aHeight;
2895
2896   AdjustSizeForViewportUnits();
2897
2898   if (RefPtr<mozilla::PresShell> presShell = mPresShell) {
2899     // Changing the max height of the dynamic toolbar changes the ICB size, we
2900     // need to kick a reflow with the current window dimensions since the max
2901     // height change doesn't change the window dimensions but
2902     // PresShell::ResizeReflow ends up subtracting the new dynamic toolbar
2903     // height from the window dimensions and kick a reflow with the proper ICB
2904     // size.
2905     presShell->ForceResizeReflowWithCurrentDimensions();
2906   }
2907 }
2908
2909 void nsPresContext::AdjustSizeForViewportUnits() {
2910   MOZ_ASSERT(IsRootContentDocumentCrossProcess());
2911   if (mVisibleArea.height == NS_UNCONSTRAINEDSIZE) {
2912     // Ignore `NS_UNCONSTRAINEDSIZE` since it's a temporary state during a
2913     // reflow. We will end up calling this function again with a proper size in
2914     // the same reflow.
2915     return;
2916   }
2917
2918   if (MOZ_UNLIKELY(mVisibleArea.height +
2919                        NSIntPixelsToAppUnits(mDynamicToolbarMaxHeight,
2920                                              mCurAppUnitsPerDevPixel) >
2921                    nscoord_MAX)) {
2922     MOZ_ASSERT_UNREACHABLE("The dynamic toolbar max height is probably wrong");
2923     return;
2924   }
2925
2926   mSizeForViewportUnits.height =
2927       mVisibleArea.height +
2928       NSIntPixelsToAppUnits(mDynamicToolbarMaxHeight, mCurAppUnitsPerDevPixel);
2929 }
2930
2931 void nsPresContext::UpdateDynamicToolbarOffset(ScreenIntCoord aOffset) {
2932   MOZ_ASSERT(IsRootContentDocumentCrossProcess());
2933   if (!mPresShell) {
2934     return;
2935   }
2936
2937   if (!HasDynamicToolbar()) {
2938     return;
2939   }
2940
2941   MOZ_ASSERT(-mDynamicToolbarMaxHeight <= aOffset && aOffset <= 0);
2942   if (mDynamicToolbarHeight == mDynamicToolbarMaxHeight + aOffset) {
2943     return;
2944   }
2945
2946   // Forcibly flush position:fixed elements in the case where the dynamic
2947   // toolbar is going to be completely hidden or starts to be visible so that
2948   // %-based style values will be recomputed with the visual viewport size which
2949   // is including the area covered by the dynamic toolbar.
2950   if (mDynamicToolbarHeight == 0 || aOffset == -mDynamicToolbarMaxHeight) {
2951     mPresShell->MarkFixedFramesForReflow(IntrinsicDirty::None);
2952     mPresShell->AddResizeEventFlushObserverIfNeeded();
2953   }
2954
2955   mDynamicToolbarHeight = mDynamicToolbarMaxHeight + aOffset;
2956
2957   if (RefPtr<MobileViewportManager> mvm =
2958           mPresShell->GetMobileViewportManager()) {
2959     mvm->UpdateVisualViewportSizeByDynamicToolbar(-aOffset);
2960   }
2961
2962   mPresShell->StyleSet()->InvalidateForViewportUnits(
2963       ServoStyleSet::OnlyDynamic::Yes);
2964 }
2965
2966 DynamicToolbarState nsPresContext::GetDynamicToolbarState() const {
2967   if (!IsRootContentDocumentCrossProcess() || !HasDynamicToolbar()) {
2968     return DynamicToolbarState::None;
2969   }
2970
2971   if (mDynamicToolbarMaxHeight == mDynamicToolbarHeight) {
2972     return DynamicToolbarState::Expanded;
2973   } else if (mDynamicToolbarHeight == 0) {
2974     return DynamicToolbarState::Collapsed;
2975   }
2976   return DynamicToolbarState::InTransition;
2977 }
2978
2979 void nsPresContext::SetSafeAreaInsets(const ScreenIntMargin& aSafeAreaInsets) {
2980   if (mSafeAreaInsets == aSafeAreaInsets) {
2981     return;
2982   }
2983   mSafeAreaInsets = aSafeAreaInsets;
2984
2985   PostRebuildAllStyleDataEvent(nsChangeHint(0),
2986                                RestyleHint::RecascadeSubtree());
2987 }
2988
2989 #ifdef DEBUG
2990
2991 void nsPresContext::ValidatePresShellAndDocumentReleation() const {
2992   NS_ASSERTION(!mPresShell || !mPresShell->GetDocument() ||
2993                    mPresShell->GetDocument() == mDocument,
2994                "nsPresContext doesn't have the same document as nsPresShell!");
2995 }
2996
2997 #endif  // #ifdef DEBUG
2998
2999 nsRootPresContext::nsRootPresContext(dom::Document* aDocument,
3000                                      nsPresContextType aType)
3001     : nsPresContext(aDocument, aType) {}
3002
3003 void nsRootPresContext::AddWillPaintObserver(nsIRunnable* aRunnable) {
3004   if (!mWillPaintFallbackEvent.IsPending()) {
3005     mWillPaintFallbackEvent = new RunWillPaintObservers(this);
3006     Document()->Dispatch(TaskCategory::Other,
3007                          do_AddRef(mWillPaintFallbackEvent));
3008   }
3009   mWillPaintObservers.AppendElement(aRunnable);
3010 }
3011
3012 /**
3013  * Run all runnables that need to get called before the next paint.
3014  */
3015 void nsRootPresContext::FlushWillPaintObservers() {
3016   mWillPaintFallbackEvent = nullptr;
3017   nsTArray<nsCOMPtr<nsIRunnable>> observers = std::move(mWillPaintObservers);
3018   for (uint32_t i = 0; i < observers.Length(); ++i) {
3019     observers[i]->Run();
3020   }
3021 }
3022
3023 size_t nsRootPresContext::SizeOfExcludingThis(
3024     MallocSizeOf aMallocSizeOf) const {
3025   return nsPresContext::SizeOfExcludingThis(aMallocSizeOf);
3026
3027   // Measurement of the following members may be added later if DMD finds it is
3028   // worthwhile:
3029   // - mWillPaintObservers
3030   // - mWillPaintFallbackEvent
3031 }