/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/* a presentation of a document, part 2 */

#include "PresShell.h"

#include <algorithm>

#include "AnchorPositioningUtils.h"
#include "AutoProfilerStyleMarker.h"
#include "ChildIterator.h"
#include "MobileViewportManager.h"
#include "OverflowChangedTracker.h"
#include "PLDHashTable.h"
#include "PositionedEventTargeting.h"
#include "PresShellWidgetListener.h"
#include "ScrollSnap.h"
#include "StickyScrollContainer.h"
#include "Units.h"
#include "VisualViewport.h"
#include "XULTreeElement.h"
#include "ZoomConstraintsClient.h"
#include "gfxContext.h"
#include "gfxPlatform.h"
#include "gfxUserFontSet.h"
#include "gfxUtils.h"
#include "js/GCAPI.h"
#include "mozilla/AccessibleCaretEventHub.h"
#include "mozilla/AnimationEventDispatcher.h"
#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/CaretAssociationHint.h"
#include "mozilla/ConnectedAncestorTracker.h"
#include "mozilla/ContentIterator.h"
#include "mozilla/DisplayPortUtils.h"
#include "mozilla/EditorBase.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/EventDispatcher.h"
#include "mozilla/EventForwards.h"
#include "mozilla/EventStateManager.h"
#include "mozilla/GeckoMVMContext.h"
#include "mozilla/GlobalStyleSheetCache.h"
#include "mozilla/IMEStateManager.h"
#include "mozilla/InputTaskManager.h"
#include "mozilla/IntegerRange.h"
#include "mozilla/Likely.h"
#include "mozilla/Logging.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/MouseEvents.h"
#include "mozilla/PerfStats.h"
#include "mozilla/PointerLockManager.h"
#include "mozilla/Preferences.h"
#include "mozilla/PresShellInlines.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/ProfilerMarkers.h"
#include "mozilla/RangeUtils.h"
#include "mozilla/RefPtr.h"
#include "mozilla/ReflowInput.h"
#include "mozilla/RestyleManager.h"
#include "mozilla/SMILAnimationController.h"
#include "mozilla/SVGFragmentIdentifier.h"
#include "mozilla/SVGObserverUtils.h"
#include "mozilla/ScopeExit.h"
#include "mozilla/ScrollContainerFrame.h"
#include "mozilla/ScrollTypes.h"
#include "mozilla/ServoBindings.h"
#include "mozilla/ServoStyleSet.h"
#include "mozilla/Sprintf.h"
#include "mozilla/StartupTimeline.h"
#include "mozilla/StaticAnalysisFunctions.h"
#include "mozilla/StaticPrefs_apz.h"
#include "mozilla/StaticPrefs_dom.h"
#include "mozilla/StaticPrefs_font.h"
#include "mozilla/StaticPrefs_image.h"
#include "mozilla/StaticPrefs_layout.h"
#include "mozilla/StaticPrefs_test.h"
#include "mozilla/StaticPrefs_toolkit.h"
#include "mozilla/StyleSheet.h"
#include "mozilla/StyleSheetInlines.h"
#include "mozilla/Telemetry.h"
#include "mozilla/TextComposition.h"
#include "mozilla/TextEvents.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/TouchEvents.h"
#include "mozilla/Try.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/ViewportFrame.h"
#include "mozilla/ViewportUtils.h"
#include "mozilla/css/ImageLoader.h"
#include "mozilla/dom/AncestorIterator.h"
#include "mozilla/dom/AnimationTimelinesController.h"
#include "mozilla/dom/BrowserBridgeChild.h"
#include "mozilla/dom/BrowserChild.h"
#include "mozilla/dom/BrowsingContext.h"
#include "mozilla/dom/CanonicalBrowsingContext.h"
#include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/ContentList.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/DOMIntersectionObserver.h"
#include "mozilla/dom/Document.h"
#include "mozilla/dom/DocumentInlines.h"
#include "mozilla/dom/DocumentTimeline.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/ElementBinding.h"
#include "mozilla/dom/ElementInlines.h"
#include "mozilla/dom/FontFaceSet.h"
#include "mozilla/dom/FragmentDirective.h"
#include "mozilla/dom/HTMLAreaElement.h"
#include "mozilla/dom/HighlightRegistry.h"
#include "mozilla/dom/LargestContentfulPaint.h"
#include "mozilla/dom/MouseEventBinding.h"
#include "mozilla/dom/Performance.h"
#include "mozilla/dom/PerformanceMainThread.h"
#include "mozilla/dom/PointerEventBinding.h"
#include "mozilla/dom/PointerEventHandler.h"
#include "mozilla/dom/PopupBlocker.h"
#include "mozilla/dom/SVGAnimationElement.h"
#include "mozilla/dom/ScriptSettings.h"
#include "mozilla/dom/Selection.h"
#include "mozilla/dom/ShadowIncludingTreeIterator.h"
#include "mozilla/dom/Touch.h"
#include "mozilla/dom/TouchEvent.h"
#include "mozilla/dom/UserActivation.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/Types.h"
#include "mozilla/glean/GfxMetrics.h"
#include "mozilla/glean/LayoutMetrics.h"
#include "mozilla/glue/Debug.h"
#include "mozilla/layers/APZPublicUtils.h"
#include "mozilla/layers/CompositorBridgeChild.h"
#include "mozilla/layers/FocusTarget.h"
#include "mozilla/layers/InputAPZContext.h"
#include "mozilla/layers/ScrollingInteractionContext.h"
#include "mozilla/layers/WebRenderLayerManager.h"
#include "mozilla/layers/WebRenderUserData.h"
#include "mozilla/layout/ScrollAnchorContainer.h"
#include "nsAnimationManager.h"
#include "nsAutoLayoutPhase.h"
#include "nsCOMArray.h"
#include "nsCOMPtr.h"
#include "nsCRTGlue.h"
#include "nsCSSFrameConstructor.h"
#include "nsCSSRendering.h"
#include "nsCanvasFrame.h"
#include "nsCaret.h"
#include "nsClassHashtable.h"
#include "nsContainerFrame.h"
#include "nsDOMNavigationTiming.h"
#include "nsDisplayList.h"
#include "nsDocShell.h"  // for reflow observation
#include "nsError.h"
#include "nsFlexContainerFrame.h"
#include "nsFocusManager.h"
#include "nsFrameSelection.h"
#include "nsGkAtoms.h"
#include "nsGlobalWindowOuter.h"
#include "nsHashKeys.h"
#include "nsIBaseWindow.h"
#include "nsIContent.h"
#include "nsIContentInlines.h"
#include "nsIDOMXULMenuListElement.h"
#include "nsIDOMXULMultSelectCntrlEl.h"
#include "nsIDOMXULSelectCntrlItemEl.h"
#include "nsIDocShellTreeItem.h"
#include "nsIDocShellTreeOwner.h"
#include "nsIDragSession.h"
#include "nsIFrame.h"
#include "nsIFrameInlines.h"
#include "nsILayoutHistoryState.h"
#include "nsILineIterator.h"  // for ScrollContentIntoView
#include "nsIMutationObserver.h"
#include "nsIObserverService.h"
#include "nsIReflowCallback.h"
#include "nsIScreen.h"
#include "nsIScreenManager.h"
#include "nsITimer.h"
#include "nsIURI.h"
#include "nsImageFrame.h"
#include "nsLayoutUtils.h"
#include "nsListControlFrame.h"
#include "nsMenuPopupFrame.h"
#include "nsNameSpaceManager.h"  // for Pref-related rule management (bugs 22963,20760,31816)
#include "nsNetUtil.h"
#include "nsPIDOMWindow.h"
#include "nsPageSequenceFrame.h"
#include "nsPlaceholderFrame.h"
#include "nsPresContext.h"
#include "nsQueryObject.h"
#include "nsRange.h"
#include "nsReadableUtils.h"
#include "nsRefreshDriver.h"
#include "nsRegion.h"
#include "nsStyleChangeList.h"
#include "nsStyleSheetService.h"
#include "nsSubDocumentFrame.h"
#include "nsTArray.h"
#include "nsThreadUtils.h"
#include "nsTransitionManager.h"
#include "nsTreeBodyFrame.h"
#include "nsTreeColumns.h"
#include "nsViewportInfo.h"
#include "nsWindowSizes.h"
#include "nsXPCOM.h"
#include "nsXULElement.h"
#include "prenv.h"
#include "prinrval.h"

#ifdef XP_WIN
#  include "winuser.h"
#endif

#ifdef MOZ_REFLOW_PERF
#  include "nsFontMetrics.h"
#endif

#ifdef ACCESSIBILITY
#  include "mozilla/a11y/DocAccessible.h"
#  ifdef DEBUG
#    include "mozilla/a11y/Logging.h"
#  endif
#endif

// define the scalfactor of drag and drop images
// relative to the max screen height/width
#define RELATIVE_SCALEFACTOR 0.0925f

using namespace mozilla;
using namespace mozilla::css;
using namespace mozilla::dom;
using namespace mozilla::gfx;
using namespace mozilla::layers;
using namespace mozilla::gfx;
using namespace mozilla::layout;
using PaintFrameFlags = nsLayoutUtils::PaintFrameFlags;
typedef ScrollableLayerGuid::ViewID ViewID;

constinit PresShell::CapturingContentInfo PresShell::sCapturingContentInfo;

// RangePaintInfo is used to paint ranges to offscreen buffers
struct RangePaintInfo {
  nsDisplayListBuilder mBuilder;
  nsDisplayList mList;

  // offset of builder's reference frame to the root frame
  nsPoint mRootOffset;

  // Resolution at which the items are normally painted. So if we're painting
  // these items in a range separately from the "full display list", we may want
  // to paint them at this resolution.
  float mResolution = 1.0;

  explicit RangePaintInfo(nsIFrame* aFrame)
      : mBuilder(aFrame, nsDisplayListBuilderMode::Painting, false),
        mList(&mBuilder) {
    MOZ_COUNT_CTOR(RangePaintInfo);
    mBuilder.BeginFrame();
  }

  ~RangePaintInfo() {
    mList.DeleteAll(&mBuilder);
    mBuilder.EndFrame();
    MOZ_COUNT_DTOR(RangePaintInfo);
  }
};

#undef NOISY

#ifdef MOZ_REFLOW_PERF
class ReflowCountMgr;

static const char kGrandTotalsStr[] = "Grand Totals";

// Counting Class
class ReflowCounter {
 public:
  explicit ReflowCounter(ReflowCountMgr* aMgr = nullptr);
  ~ReflowCounter() = default;

  void ClearTotals();
  void DisplayTotals(const char* aStr);
  void DisplayDiffTotals(const char* aStr);
  void DisplayHTMLTotals(const char* aStr);

  void Add() { mTotal++; }
  void Add(uint32_t aTotal) { mTotal += aTotal; }

  void CalcDiffInTotals();
  void SetTotalsCache();

  void SetMgr(ReflowCountMgr* aMgr) { mMgr = aMgr; }

  uint32_t GetTotal() { return mTotal; }

 protected:
  void DisplayTotals(uint32_t aTotal, const char* aTitle);
  void DisplayHTMLTotals(uint32_t aTotal, const char* aTitle);

  uint32_t mTotal;
  uint32_t mCacheTotal;

  ReflowCountMgr* mMgr;  // weak reference (don't delete)
};

// Counting Class
class IndiReflowCounter {
 public:
  explicit IndiReflowCounter(ReflowCountMgr* aMgr = nullptr)
      : mFrame(nullptr),
        mCount(0),
        mMgr(aMgr),
        mCounter(aMgr),
        mHasBeenOutput(false) {}
  virtual ~IndiReflowCounter() = default;

  nsAutoString mName;
  nsIFrame* mFrame;  // weak reference (don't delete)
  int32_t mCount;

  ReflowCountMgr* mMgr;  // weak reference (don't delete)

  ReflowCounter mCounter;
  bool mHasBeenOutput;
};

//--------------------
// Manager Class
//--------------------
class ReflowCountMgr {
 public:
  ReflowCountMgr();
  virtual ~ReflowCountMgr();

  void ClearTotals();
  void ClearGrandTotals();
  void DisplayTotals(const char* aStr);
  void DisplayHTMLTotals(const char* aStr);
  void DisplayDiffsInTotals();

  void Add(const char* aName, nsIFrame* aFrame);
  ReflowCounter* LookUp(const char* aName);

  void PaintCount(const char* aName, gfxContext* aRenderingContext,
                  nsPresContext* aPresContext, nsIFrame* aFrame,
                  const nsPoint& aOffset, uint32_t aColor);

  FILE* GetOutFile() { return mFD; }

  void SetPresContext(nsPresContext* aPresContext) {
    mPresContext = aPresContext;  // weak reference
  }
  void SetPresShell(PresShell* aPresShell) {
    mPresShell = aPresShell;  // weak reference
  }

  void SetDumpFrameCounts(bool aVal) { mDumpFrameCounts = aVal; }
  void SetDumpFrameByFrameCounts(bool aVal) { mDumpFrameByFrameCounts = aVal; }
  void SetPaintFrameCounts(bool aVal) { mPaintFrameByFrameCounts = aVal; }

  bool IsPaintingFrameCounts() { return mPaintFrameByFrameCounts; }

 protected:
  void DisplayTotals(uint32_t aTotal, uint32_t* aDupArray, char* aTitle);
  void DisplayHTMLTotals(uint32_t aTotal, uint32_t* aDupArray, char* aTitle);

  void DoGrandTotals();
  void DoIndiTotalsTree();

  // HTML Output Methods
  void DoGrandHTMLTotals();

  nsClassHashtable<nsCharPtrHashKey, ReflowCounter> mCounts;
  nsClassHashtable<nsCharPtrHashKey, IndiReflowCounter> mIndiFrameCounts;
  FILE* mFD;

  bool mDumpFrameCounts;
  bool mDumpFrameByFrameCounts;
  bool mPaintFrameByFrameCounts;

  bool mCycledOnce;

  // Root Frame for Individual Tracking
  nsPresContext* mPresContext;
  PresShell* mPresShell;

  // ReflowCountMgr gReflowCountMgr;
};
#endif
//========================================================================

// comment out to hide caret
#define SHOW_CARET

// The upper bound on the amount of time to spend reflowing, in
// microseconds.  When this bound is exceeded and reflow commands are
// still queued up, a reflow event is posted.  The idea is for reflow
// to not hog the processor beyond the time specifed in
// gMaxRCProcessingTime.  This data member is initialized from the
// layout.reflow.timeslice pref.
#define NS_MAX_REFLOW_TIME 1000000
static int32_t gMaxRCProcessingTime = -1;

struct nsCallbackEventRequest {
  nsIReflowCallback* callback;
  nsCallbackEventRequest* next;
};

// ----------------------------------------------------------------------------

class nsAutoCauseReflowNotifier {
 public:
  MOZ_CAN_RUN_SCRIPT explicit nsAutoCauseReflowNotifier(PresShell* aPresShell)
      : mPresShell(aPresShell) {
    mPresShell->WillCauseReflow();
  }
  MOZ_CAN_RUN_SCRIPT ~nsAutoCauseReflowNotifier() {
    // This check should not be needed. Currently the only place that seem
    // to need it is the code that deals with bug 337586.
    if (!mPresShell->mHaveShutDown) {
      RefPtr<PresShell> presShell(mPresShell);
      presShell->DidCauseReflow();
    } else {
      nsContentUtils::RemoveScriptBlocker();
    }
  }

  PresShell* mPresShell;
};

class MOZ_STACK_CLASS nsPresShellEventCB : public EventDispatchingCallback {
 public:
  explicit nsPresShellEventCB(PresShell* aPresShell) : mPresShell(aPresShell) {}

  MOZ_CAN_RUN_SCRIPT
  virtual void HandleEvent(EventChainPostVisitor& aVisitor) override {
    if (aVisitor.mPresContext && aVisitor.mEvent->mClass != eBasicEventClass) {
      if (aVisitor.mEvent->mMessage == eMouseDown ||
          aVisitor.mEvent->mMessage == eMouseUp) {
        // Mouse-up and mouse-down events call nsIFrame::HandlePress/Release
        // which call GetContentOffsetsFromPoint which requires up-to-date
        // layout. Bring layout up-to-date now so that GetCurrentEventFrame()
        // below will return a real frame and we don't have to worry about
        // destroying it by flushing later.
        MOZ_KnownLive(mPresShell)->FlushPendingNotifications(FlushType::Layout);
      } else if (aVisitor.mEvent->mMessage == eWheel &&
                 aVisitor.mEventStatus != nsEventStatus_eConsumeNoDefault) {
        nsIFrame* frame = mPresShell->GetCurrentEventFrame();
        if (frame) {
          // chrome (including addons) should be able to know if content
          // handles both D3E "wheel" event and legacy mouse scroll events.
          // We should dispatch legacy mouse events before dispatching the
          // "wheel" event into system group.
          RefPtr<EventStateManager> esm =
              aVisitor.mPresContext->EventStateManager();
          esm->DispatchLegacyMouseScrollEvents(
              frame, aVisitor.mEvent->AsWheelEvent(), &aVisitor.mEventStatus);
        }
      }
      nsIFrame* frame = mPresShell->GetCurrentEventFrame();
      if (!frame && (aVisitor.mEvent->mMessage == eMouseUp ||
                     aVisitor.mEvent->mMessage == eTouchEnd)) {
        // Redirect BUTTON_UP and TOUCH_END events to the root frame to ensure
        // that capturing is released.
        frame = mPresShell->GetRootFrame();
      }
      if (frame) {
        frame->HandleEvent(aVisitor.mPresContext, aVisitor.mEvent->AsGUIEvent(),
                           &aVisitor.mEventStatus);
      }
    }
  }

  RefPtr<PresShell> mPresShell;
};

class nsBeforeFirstPaintDispatcher : public Runnable {
 public:
  explicit nsBeforeFirstPaintDispatcher(Document* aDocument)
      : mozilla::Runnable("nsBeforeFirstPaintDispatcher"),
        mDocument(aDocument) {}

  // Fires the "before-first-paint" event so that interested parties (right now,
  // the mobile browser) are aware of it.
  NS_IMETHOD Run() override {
    nsCOMPtr<nsIObserverService> observerService =
        mozilla::services::GetObserverService();
    if (observerService) {
      observerService->NotifyObservers(ToSupports(mDocument),
                                       "before-first-paint", nullptr);
    }
    return NS_OK;
  }

 private:
  RefPtr<Document> mDocument;
};

// This is a helper class to track whether the targeted frame is destroyed after
// dispatching pointer events. In that case, we need the original targeted
// content so that we can dispatch the mouse events to it.
class MOZ_RAII AutoPointerEventTargetUpdater final {
 public:
  AutoPointerEventTargetUpdater(PresShell* aShell, WidgetEvent* aEvent,
                                nsIFrame* aFrame, nsIContent* aTargetContent,
                                nsIContent** aOutTargetContent) {
    MOZ_ASSERT(aEvent);
    if (!aOutTargetContent || aEvent->mClass != ePointerEventClass) {
      // Make the destructor happy.
      mOutTargetContent = nullptr;
      return;
    }
    MOZ_ASSERT(aShell);
    MOZ_ASSERT_IF(aFrame && aFrame->GetContent(),
                  aShell->GetDocument() == aFrame->GetContent()->OwnerDoc());

    mShell = aShell;
    mWeakFrame = aFrame;
    mOutTargetContent = aOutTargetContent;
    mFromTouch = aEvent->AsPointerEvent()->mFromTouchEvent;
    // Touch event target may have no frame, e.g., removed from the DOM
    MOZ_ASSERT_IF(!mFromTouch, aFrame);
    // The frame may be a text frame, but the event target should be an element
    // node.  Therefore, refer aTargetContent first, then, if we have only a
    // frame, we should use inclusive ancestor of the content.
    mOriginalPointerEventTarget = [&]() -> nsIContent* {
      nsIContent* const target =
          aTargetContent ? aTargetContent
                         : (aFrame ? aFrame->GetContent() : nullptr);
      if (MOZ_UNLIKELY(!target)) {
        return nullptr;
      }
      if (target->IsElement() ||
          !IsForbiddenDispatchingToNonElementContent(aEvent->mMessage)) {
        return target;
      }
      return target->GetInclusiveFlattenedTreeAncestorElement();
    }();
    if (mOriginalPointerEventTarget &&
        mOriginalPointerEventTarget->IsInComposedDoc()) {
      mPointerEventTargetTracker.emplace(*mOriginalPointerEventTarget);
    }
  }

  ~AutoPointerEventTargetUpdater() {
    if (!mOutTargetContent || !mShell || mWeakFrame.IsAlive()) {
      return;
    }
    if (mFromTouch) {
      // If the source event is a touch event, the touch event target should
      // always be same target as preceding ePointerDown.  Therefore, we should
      // always set it back to the original event target.
      mOriginalPointerEventTarget.swap(*mOutTargetContent);
    } else {
      // If the source event is not a touch event (must be a mouse event in
      // this case), the event should be fired on the closest inclusive ancestor
      // of the pointer event target which is still connected.  The mutations
      // are tracked by PresShell::ContentRemoved.  Therefore, we should set it.
      if (!mPointerEventTargetTracker ||
          !mPointerEventTargetTracker->ContentWasRemoved()) {
        mOriginalPointerEventTarget.swap(*mOutTargetContent);
      } else {
        nsCOMPtr<nsIContent> connectedAncestor =
            mPointerEventTargetTracker->GetConnectedContent();
        connectedAncestor.swap(*mOutTargetContent);
      }
    }
  }

 private:
  RefPtr<PresShell> mShell;
  nsCOMPtr<nsIContent> mOriginalPointerEventTarget;
  AutoWeakFrame mWeakFrame;
  Maybe<AutoConnectedAncestorTracker> mPointerEventTargetTracker;
  nsIContent** mOutTargetContent;
  bool mFromTouch = false;
};

bool PresShell::sDisableNonTestMouseEvents = false;

LazyLogModule PresShell::gLog("PresShell");

TimeStamp PresShell::EventHandler::sLastInputCreated;
TimeStamp PresShell::EventHandler::sLastInputProcessed;
StaticRefPtr<Element> PresShell::EventHandler::sLastKeyDownEventTargetElement;

bool PresShell::sProcessInteractable = false;

Modifiers PresShell::sCurrentModifiers = MODIFIER_NONE;

void PresShell::AddAutoWeakFrame(AutoWeakFrame* aWeakFrame) {
  if (aWeakFrame->GetFrame()) {
    aWeakFrame->GetFrame()->AddStateBits(NS_FRAME_EXTERNAL_REFERENCE);
  }
  aWeakFrame->SetPreviousWeakFrame(mAutoWeakFrames);
  mAutoWeakFrames = aWeakFrame;
}

void PresShell::AddWeakFrame(WeakFrame* aWeakFrame) {
  if (aWeakFrame->GetFrame()) {
    aWeakFrame->GetFrame()->AddStateBits(NS_FRAME_EXTERNAL_REFERENCE);
  }
  MOZ_ASSERT(!mWeakFrames.Contains(aWeakFrame));
  mWeakFrames.Insert(aWeakFrame);
}

void PresShell::AddConnectedAncestorTracker(
    AutoConnectedAncestorTracker& aTracker) {
  aTracker.mPreviousTracker = mLastConnectedAncestorTracker;
  mLastConnectedAncestorTracker = &aTracker;
}

void PresShell::RemoveAutoWeakFrame(AutoWeakFrame* aWeakFrame) {
  if (mAutoWeakFrames == aWeakFrame) {
    mAutoWeakFrames = aWeakFrame->GetPreviousWeakFrame();
    return;
  }
  AutoWeakFrame* nextWeak = mAutoWeakFrames;
  while (nextWeak && nextWeak->GetPreviousWeakFrame() != aWeakFrame) {
    nextWeak = nextWeak->GetPreviousWeakFrame();
  }
  if (nextWeak) {
    nextWeak->SetPreviousWeakFrame(aWeakFrame->GetPreviousWeakFrame());
  }
}

void PresShell::RemoveWeakFrame(WeakFrame* aWeakFrame) {
  MOZ_ASSERT(mWeakFrames.Contains(aWeakFrame));
  mWeakFrames.Remove(aWeakFrame);
}

void PresShell::RemoveConnectedAncestorTracker(
    const AutoConnectedAncestorTracker& aTracker) {
  if (mLastConnectedAncestorTracker == &aTracker) {
    mLastConnectedAncestorTracker = aTracker.mPreviousTracker;
    return;
  }
  AutoConnectedAncestorTracker* nextTracker = mLastConnectedAncestorTracker;
  while (nextTracker && nextTracker->mPreviousTracker != &aTracker) {
    nextTracker = nextTracker->mPreviousTracker;
  }
  if (nextTracker) {
    nextTracker->mPreviousTracker = aTracker.mPreviousTracker;
  }
}

already_AddRefed<nsFrameSelection> PresShell::FrameSelection() {
  RefPtr<nsFrameSelection> ret = mSelection;
  return ret.forget();
}

//----------------------------------------------------------------------

static uint32_t sNextPresShellId = 0;

/* static */
bool PresShell::AccessibleCaretEnabled(nsIDocShell* aDocShell) {
  // If the pref forces it on, then enable it.
  if (StaticPrefs::layout_accessiblecaret_enabled()) {
    return true;
  }
  // If the touch pref is on, and touch events are enabled (this depends
  // on the specific device running), then enable it.
  if (StaticPrefs::layout_accessiblecaret_enabled_on_touch() &&
      dom::TouchEvent::PrefEnabled(aDocShell)) {
    return true;
  }
  // Otherwise, disabled.
  return false;
}

PresShell::PresShell(Document* aDocument)
    : mDocument(aDocument),
      mLastSelectionForToString(nullptr),
#ifdef ACCESSIBILITY
      mDocAccessible(nullptr),
#endif  // ACCESSIBILITY
      mLastResolutionChangeOrigin(ResolutionChangeOrigin::Apz),
      mPaintCount(0),
      mAPZFocusSequenceNumber(0),
      mActiveSuppressDisplayport(0),
      mPresShellId(++sNextPresShellId),
      mFontSizeInflationEmPerLine(0),
      mFontSizeInflationMinTwips(0),
      mFontSizeInflationLineThreshold(0),
      mSelectionFlags(nsISelectionDisplay::DISPLAY_TEXT |
                      nsISelectionDisplay::DISPLAY_IMAGES),
      mChangeNestCount(0),
      mRenderingStateFlags(RenderingStateFlags::None),
      mCaretEnabled(false),
      mNeedLayoutFlush(true),
      mNeedStyleFlush(true),
      mNeedThrottledAnimationFlush(true),
      mVisualViewportSizeSet(false),
      mDidInitialize(false),
      mIsDestroying(false),
      mIsReflowing(false),
      mIsObservingDocument(false),
      mForbiddenToFlush(false),
      mIsDocumentGone(false),
      mHaveShutDown(false),
      mPaintingSuppressed(false),
      mShouldUnsuppressPainting(false),
      mIgnoreFrameDestruction(false),
      mIsActive(true),
      mFrozen(false),
      mIsFirstPaint(true),
      mWasLastReflowInterrupted(false),
      mResizeEventPending(false),
      mVisualViewportResizeEventPending(false),
      mFontSizeInflationForceEnabled(false),
      mFontSizeInflationEnabled(false),
      mIsNeverPainting(false),
      mResolutionUpdated(false),
      mResolutionUpdatedByApz(false),
      mUnderHiddenEmbedderElement(false),
      mDocumentLoading(false),
      mNoDelayedMouseEvents(false),
      mNoDelayedKeyEvents(false),
      mNoDelayedSingleTap(false),
      mApproximateFrameVisibilityVisited(false),
      mIsLastChromeOnlyEscapeKeyConsumed(false),
      mHasReceivedPaintMessage(false),
      mIsLastKeyDownCanceled(false),
      mHasHandledUserInput(false),
      mForceDispatchKeyPressEventsForNonPrintableKeys(false),
      mForceUseLegacyKeyCodeAndCharCodeValues(false),
      mInitializedWithKeyPressEventDispatchingBlacklist(false),
      mHasTriedFastUnsuppress(false),
      mProcessingReflowCommands(false),
      mPendingDidDoReflow(false),
      mHasSeenAnchorPos(false),
      mHasShownFullscreenWarningForCurrentEscapeKeyLongPress(false),
      mEscapeKeyDownCountForFullscreenKeyboardLockWarning(0) {
  MOZ_LOG(gLog, LogLevel::Debug, ("PresShell::PresShell this=%p", this));
  MOZ_ASSERT(aDocument);

#ifdef MOZ_REFLOW_PERF
  mReflowCountMgr = MakeUnique<ReflowCountMgr>();
  mReflowCountMgr->SetPresContext(mPresContext);
  mReflowCountMgr->SetPresShell(this);
#endif
  mLastOSWake = mLoadBegin = TimeStamp::Now();
}

NS_INTERFACE_TABLE_HEAD(PresShell)
  NS_INTERFACE_TABLE_BEGIN
    // In most cases, PresShell should be treated as concrete class, but need to
    // QI for weak reference.  Therefore, the case needed by do_QueryReferent()
    // should be tested first.
    NS_INTERFACE_TABLE_ENTRY(PresShell, PresShell)
    NS_INTERFACE_TABLE_ENTRY(PresShell, nsIDocumentObserver)
    NS_INTERFACE_TABLE_ENTRY(PresShell, nsISelectionController)
    NS_INTERFACE_TABLE_ENTRY(PresShell, nsISelectionDisplay)
    NS_INTERFACE_TABLE_ENTRY(PresShell, nsIObserver)
    NS_INTERFACE_TABLE_ENTRY(PresShell, nsISupportsWeakReference)
    NS_INTERFACE_TABLE_ENTRY(PresShell, nsIMutationObserver)
    NS_INTERFACE_TABLE_ENTRY_AMBIGUOUS(PresShell, nsISupports, nsIObserver)
  NS_INTERFACE_TABLE_END
  NS_INTERFACE_TABLE_TO_MAP_SEGUE
NS_INTERFACE_MAP_END

NS_IMPL_ADDREF(PresShell)
NS_IMPL_RELEASE(PresShell)

PresShell::~PresShell() {
  MOZ_RELEASE_ASSERT(!mForbiddenToFlush,
                     "Flag should only be set temporarily, while doing things "
                     "that shouldn't cause destruction");
  MOZ_LOG(gLog, LogLevel::Debug, ("PresShell::~PresShell this=%p", this));

  if (!mHaveShutDown) {
    MOZ_ASSERT_UNREACHABLE("Someone did not call PresShell::Destroy()");
    Destroy();
  }

  NS_ASSERTION(mCurrentEventTargetStack.IsEmpty(),
               "Huh, event content left on the stack in pres shell dtor!");
  NS_ASSERTION(mFirstCallbackEventRequest == nullptr &&
                   mLastCallbackEventRequest == nullptr,
               "post-reflow queues not empty.  This means we're leaking");

  MOZ_ASSERT(!mAllocatedPointers || mAllocatedPointers->IsEmpty(),
             "Some pres arena objects were not freed");

  mFrameConstructor = nullptr;
}

/**
 * Initialize the presentation shell.
 * Note this can't be merged into our constructor because caret initialization
 * calls AddRef() on us.
 */
void PresShell::Init(nsPresContext* aPresContext) {
  MOZ_ASSERT(mDocument);
  MOZ_ASSERT(aPresContext);
  MOZ_ASSERT(!mWidgetListener, "Already initialized");

  mWidgetListener = MakeUnique<PresShellWidgetListener>(this);

  // mDocument is now set.  It might have a display document whose "need layout/
  // style" flush flags are not set, but ours will be set.  To keep these
  // consistent, call the flag setting functions to propagate those flags up
  // to the display document.
  SetNeedLayoutFlush();
  SetNeedStyleFlush();

  // Create our frame constructor.
  mFrameConstructor = MakeUnique<nsCSSFrameConstructor>(mDocument, this);

  // Bind the context to the presentation shell.
  // FYI: We cannot initialize mPresContext in the constructor because we
  //      cannot call AttachPresShell() in it and once we initialize
  //      mPresContext, other objects may refer refresh driver or restyle
  //      manager via mPresContext and that causes hitting MOZ_ASSERT in some
  //      places.  Therefore, we should initialize mPresContext here with
  //      const_cast hack since we want to guarantee that mPresContext lives
  //      as long as the PresShell.
  const_cast<RefPtr<nsPresContext>&>(mPresContext) = aPresContext;
  mPresContext->AttachPresShell(this);

  mPresContext->InitFontCache();

  // FIXME(emilio, bug 1544185): Some Android code somehow depends on the shell
  // being eagerly registered as a style flush observer. This shouldn't be
  // needed otherwise.
  EnsureStyleFlush();

  const bool accessibleCaretEnabled =
      AccessibleCaretEnabled(mDocument->GetDocShell());
  if (accessibleCaretEnabled) {
    // Need to happen before nsFrameSelection has been set up.
    mAccessibleCaretEventHub = MakeRefPtr<AccessibleCaretEventHub>(this);
    mAccessibleCaretEventHub->Init();
  }

  mSelection = MakeRefPtr<nsFrameSelection>(this, accessibleCaretEnabled);

  // Important: this has to happen after the selection has been set up
#ifdef SHOW_CARET
  // make the caret
  mCaret = MakeRefPtr<nsCaret>();
  mCaret->Init(this);
  mOriginalCaret = mCaret;

  // SetCaretEnabled(true);       // make it show in browser windows
#endif
  // set up selection to be displayed in document
  // Don't enable selection for print media
  nsPresContext::nsPresContextType type = mPresContext->Type();
  if (type != nsPresContext::eContext_PrintPreview &&
      type != nsPresContext::eContext_Print) {
    SetDisplaySelection(nsISelectionController::SELECTION_DISABLED);
  }

  if (gMaxRCProcessingTime == -1) {
    gMaxRCProcessingTime =
        Preferences::GetInt("layout.reflow.timeslice", NS_MAX_REFLOW_TIME);
  }

  if (nsStyleSheetService* ss = nsStyleSheetService::GetInstance()) {
    ss->RegisterPresShell(this);
  }

  {
    nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
    if (os) {
      os->AddObserver(this, "memory-pressure", false);
      os->AddObserver(this, NS_WIDGET_WAKE_OBSERVER_TOPIC, false);
      if (XRE_IsParentProcess() && !sProcessInteractable) {
        os->AddObserver(this, "sessionstore-one-or-no-tab-restored", false);
      }
      os->AddObserver(this, "font-info-updated", false);
      os->AddObserver(this, "internal-look-and-feel-changed", false);
    }
  }

#ifdef MOZ_REFLOW_PERF
  if (mReflowCountMgr) {
    bool paintFrameCounts =
        Preferences::GetBool("layout.reflow.showframecounts");

    bool dumpFrameCounts =
        Preferences::GetBool("layout.reflow.dumpframecounts");

    bool dumpFrameByFrameCounts =
        Preferences::GetBool("layout.reflow.dumpframebyframecounts");

    mReflowCountMgr->SetDumpFrameCounts(dumpFrameCounts);
    mReflowCountMgr->SetDumpFrameByFrameCounts(dumpFrameByFrameCounts);
    mReflowCountMgr->SetPaintFrameCounts(paintFrameCounts);
  }
#endif

  mDocument->TimelinesController().UpdateLastRefreshDriverTime();

  // Get our activeness from the docShell.
  ActivenessMaybeChanged();

  // Setup our font inflation preferences.
  mFontSizeInflationEmPerLine = StaticPrefs::font_size_inflation_emPerLine();
  mFontSizeInflationMinTwips = StaticPrefs::font_size_inflation_minTwips();
  mFontSizeInflationLineThreshold =
      StaticPrefs::font_size_inflation_lineThreshold();
  mFontSizeInflationForceEnabled =
      StaticPrefs::font_size_inflation_forceEnabled();
  // We'll compute the font size inflation state in Initialize(), when we know
  // the document type.

  mTouchManager.Init(this, mDocument);

  if (mPresContext->IsRootContentDocumentCrossProcess()) {
    mZoomConstraintsClient = MakeRefPtr<ZoomConstraintsClient>();
    mZoomConstraintsClient->Init(this, mDocument);

    // We call this to create mMobileViewportManager, if it is needed.
    MaybeRecreateMobileViewportManager(false);
  }

  if (nsCOMPtr<nsIDocShell> docShell = mPresContext->GetDocShell()) {
    if (BrowsingContext* bc = docShell->GetBrowsingContext()) {
      mUnderHiddenEmbedderElement = bc->IsUnderHiddenEmbedderElement();
    }
  }
}

enum TextPerfLogType { eLog_reflow, eLog_loaddone, eLog_totals };

static void LogTextPerfStats(gfxTextPerfMetrics* aTextPerf,
                             PresShell* aPresShell,
                             const gfxTextPerfMetrics::TextCounts& aCounts,
                             float aTime, TextPerfLogType aLogType,
                             const char* aURL) {
  LogModule* tpLog = gfxPlatform::GetLog(eGfxLog_textperf);

  // ignore XUL contexts unless at debug level
  mozilla::LogLevel logLevel = LogLevel::Warning;
  if (aCounts.numContentTextRuns == 0) {
    logLevel = LogLevel::Debug;
  }

  if (!MOZ_LOG_TEST(tpLog, logLevel)) {
    return;
  }

  char prefix[256];

  switch (aLogType) {
    case eLog_reflow:
      SprintfLiteral(prefix, "(textperf-reflow) %p time-ms: %7.0f", aPresShell,
                     aTime);
      break;
    case eLog_loaddone:
      SprintfLiteral(prefix, "(textperf-loaddone) %p time-ms: %7.0f",
                     aPresShell, aTime);
      break;
    default:
      MOZ_ASSERT(aLogType == eLog_totals, "unknown textperf log type");
      SprintfLiteral(prefix, "(textperf-totals) %p", aPresShell);
  }

  double hitRatio = 0.0;
  uint32_t lookups = aCounts.wordCacheHit + aCounts.wordCacheMiss;
  if (lookups) {
    hitRatio = double(aCounts.wordCacheHit) / double(lookups);
  }

  if (aLogType == eLog_loaddone) {
    MOZ_LOG(
        tpLog, logLevel,
        ("%s reflow: %d chars: %d "
         "[%s] "
         "content-textruns: %d chrome-textruns: %d "
         "max-textrun-len: %d "
         "word-cache-lookups: %d word-cache-hit-ratio: %4.3f "
         "word-cache-space: %d word-cache-long: %d "
         "pref-fallbacks: %d system-fallbacks: %d "
         "textruns-const: %d textruns-destr: %d "
         "generic-lookups: %d "
         "cumulative-textruns-destr: %d\n",
         prefix, aTextPerf->reflowCount, aCounts.numChars, (aURL ? aURL : ""),
         aCounts.numContentTextRuns, aCounts.numChromeTextRuns,
         aCounts.maxTextRunLen, lookups, hitRatio, aCounts.wordCacheSpaceRules,
         aCounts.wordCacheLong, aCounts.fallbackPrefs, aCounts.fallbackSystem,
         aCounts.textrunConst, aCounts.textrunDestr, aCounts.genericLookups,
         aTextPerf->cumulative.textrunDestr));
  } else {
    MOZ_LOG(
        tpLog, logLevel,
        ("%s reflow: %d chars: %d "
         "content-textruns: %d chrome-textruns: %d "
         "max-textrun-len: %d "
         "word-cache-lookups: %d word-cache-hit-ratio: %4.3f "
         "word-cache-space: %d word-cache-long: %d "
         "pref-fallbacks: %d system-fallbacks: %d "
         "textruns-const: %d textruns-destr: %d "
         "generic-lookups: %d "
         "cumulative-textruns-destr: %d\n",
         prefix, aTextPerf->reflowCount, aCounts.numChars,
         aCounts.numContentTextRuns, aCounts.numChromeTextRuns,
         aCounts.maxTextRunLen, lookups, hitRatio, aCounts.wordCacheSpaceRules,
         aCounts.wordCacheLong, aCounts.fallbackPrefs, aCounts.fallbackSystem,
         aCounts.textrunConst, aCounts.textrunDestr, aCounts.genericLookups,
         aTextPerf->cumulative.textrunDestr));
  }
}

bool PresShell::InRDMPane() {
  if (Document* doc = GetDocument()) {
    if (BrowsingContext* bc = doc->GetBrowsingContext()) {
      return bc->InRDMPane();
    }
  }
  return false;
}

#if defined(MOZ_WIDGET_ANDROID)
void PresShell::MaybeNotifyShowDynamicToolbar() {
  const DynamicToolbarState dynToolbarState = GetDynamicToolbarState();
  if ((dynToolbarState == DynamicToolbarState::Collapsed ||
       dynToolbarState == DynamicToolbarState::InTransition)) {
    MOZ_ASSERT(mPresContext &&
               mPresContext->IsRootContentDocumentCrossProcess());
    if (BrowserChild* browserChild = BrowserChild::GetFrom(this)) {
      browserChild->SendShowDynamicToolbar();
    }
  }
}
#endif  // defined(MOZ_WIDGET_ANDROID)

void PresShell::Destroy() {
  // Do not add code before this line please!
  if (mHaveShutDown) {
    return;
  }

  NS_ASSERTION(!nsContentUtils::IsSafeToRunScript(),
               "destroy called on presshell while scripts not blocked");

  nsIURI* uri = mDocument->GetDocumentURI();
  AUTO_PROFILER_LABEL_DYNAMIC_NSCSTRING_RELEVANT_FOR_JS(
      "Layout tree destruction", LAYOUT_Destroy,
      uri ? uri->GetSpecOrDefault() : "N/A"_ns);

  // Try to determine if the page is the user had a meaningful opportunity to
  // zoom this page. This is not 100% accurate but should be "good enough" for
  // telemetry purposes.
  auto isUserZoomablePage = [&]() -> bool {
    if (mIsFirstPaint) {
      // Page was never painted, so it wasn't zoomable by the user. We get a
      // handful of these "transient" presShells.
      return false;
    }
    if (!mPresContext->IsRootContentDocumentCrossProcess()) {
      // Not a root content document, so APZ doesn't support zooming it.
      return false;
    }
    if (InRDMPane()) {
      // Responsive design mode is a special case that we want to ignore here.
      return false;
    }
    if (mDocument && mDocument->IsInitialDocument()) {
      // Ignore initial about:blank page loads
      return false;
    }
    if (XRE_IsContentProcess() &&
        IsExtensionRemoteType(ContentChild::GetSingleton()->GetRemoteType())) {
      // Also omit presShells from the extension process because they sometimes
      // can't be zoomed by the user.
      return false;
    }
    // Otherwise assume the page is user-zoomable.
    return true;
  };
  if (isUserZoomablePage()) {
    glean::apz_zoom::activity
        .EnumGet(static_cast<glean::apz_zoom::ActivityLabel>(
            IsResolutionUpdatedByApz()))
        .Add();
  }

  // dump out cumulative text perf metrics
  gfxTextPerfMetrics* tp;
  if (mPresContext && (tp = mPresContext->GetTextPerfMetrics())) {
    tp->Accumulate();
    if (tp->cumulative.numChars > 0) {
      LogTextPerfStats(tp, this, tp->cumulative, 0.0, eLog_totals, nullptr);
    }
  }
  if (mPresContext) {
    if (gfxUserFontSet* fs = mPresContext->GetUserFontSet()) {
      uint32_t fontCount;
      uint64_t fontSize;
      fs->GetLoadStatistics(fontCount, fontSize);
      glean::webfont::per_page.Add(fontCount);
      glean::webfont::size_per_page.Accumulate(uint32_t(fontSize / 1024));
    } else {
      glean::webfont::per_page.Add(0);
      glean::webfont::size_per_page.Accumulate(0);
    }
  }

#ifdef MOZ_REFLOW_PERF
  DumpReflows();
  mReflowCountMgr = nullptr;
#endif

  if (mZoomConstraintsClient) {
    mZoomConstraintsClient->Destroy();
    mZoomConstraintsClient = nullptr;
  }
  if (mMobileViewportManager) {
    mMobileViewportManager->Destroy();
    mMobileViewportManager = nullptr;
    mMVMContext = nullptr;
  }

  MaybeReleaseCapturingContent();

  EventHandler::OnPresShellDestroy(mDocument);

  if (mContentToScrollTo) {
    mContentToScrollTo->RemoveProperty(nsGkAtoms::scrolling);
    mContentToScrollTo = nullptr;
  }

  if (mPresContext) {
    // We need to notify the destroying the nsPresContext to ESM for
    // suppressing to use from ESM.
    mPresContext->EventStateManager()->NotifyDestroyPresContext(mPresContext);
  }

  if (nsStyleSheetService* ss = nsStyleSheetService::GetInstance()) {
    ss->UnregisterPresShell(this);
  }

  {
    nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
    if (os) {
      os->RemoveObserver(this, "memory-pressure");
      os->RemoveObserver(this, NS_WIDGET_WAKE_OBSERVER_TOPIC);
      if (XRE_IsParentProcess()) {
        os->RemoveObserver(this, "sessionstore-one-or-no-tab-restored");
      }
      os->RemoveObserver(this, "font-info-updated");
      os->RemoveObserver(this, "internal-look-and-feel-changed");
    }
  }

  // If our paint suppression timer is still active, kill it.
  CancelPaintSuppressionTimer();

  mSynthMouseMoveEvent.Revoke();

  mUpdateApproximateFrameVisibilityEvent.Revoke();

  ClearApproximatelyVisibleFramesList(Some(OnNonvisible::DiscardImages));

  if (mOriginalCaret) {
    mOriginalCaret->Terminate();
  }
  if (mCaret && mCaret != mOriginalCaret) {
    mCaret->Terminate();
  }
  mCaret = mOriginalCaret = nullptr;

  mFocusedFrameSelection = nullptr;

  if (mSelection) {
    RefPtr<nsFrameSelection> frameSelection = mSelection;
    frameSelection->DisconnectFromPresShell();
  }

  mIsDestroying = true;

#ifdef ACCESSIBILITY
  if (mDocAccessible) {
#  ifdef DEBUG
    if (a11y::logging::IsEnabled(a11y::logging::eDocDestroy))
      a11y::logging::DocDestroy("presshell destroyed", mDocument);
#  endif

    mDocAccessible->Shutdown();
    mDocAccessible = nullptr;
  }
#endif  // ACCESSIBILITY

  // We can't release all the event content in
  // mCurrentEventContentStack here since there might be code on the
  // stack that will release the event content too. Double release
  // bad!

  // The frames will be torn down, so remove them from the current
  // event frame stack (since they'd be dangling references if we'd
  // leave them in) and null out the mCurrentEventFrame pointer as
  // well.

  mCurrentEventTarget.ClearFrame();

  for (EventTargetInfo& eventTargetInfo : mCurrentEventTargetStack) {
    eventTargetInfo.ClearFrame();
  }

  mFramesToDirty.Clear();
  mPendingScrollAnchorSelection.Clear();
  mPendingScrollAnchorAdjustment.Clear();
  mPendingScrollResnap.Clear();

  // This shell must be removed from the document before the frame
  // hierarchy is torn down to avoid finding deleted frames through
  // this presshell while the frames are being torn down
  if (mDocument) {
    NS_ASSERTION(mDocument->GetPresShell() == this, "Wrong shell?");
    mDocument->ClearServoRestyleRoot();
    mDocument->DeletePresShell();
  }

  if (mPresContext) {
    mPresContext->AnimationEventDispatcher()->ClearEventQueue();
  }

  // Revoke any pending events.  We need to do this and cancel pending reflows
  // before we destroy the frame constructor, since apparently frame destruction
  // sometimes spins the event queue when plug-ins are involved(!).
  // XXXmats is this still needed now that plugins are gone?
  CancelAllPendingReflows();
  CancelPostedReflowCallbacks();

  // Destroy the frame constructor. This will destroy the frame hierarchy
  mFrameConstructor->WillDestroyFrameTree();

  NS_WARNING_ASSERTION(!mAutoWeakFrames && mWeakFrames.IsEmpty(),
                       "Weak frames alive after destroying FrameManager");
  while (mAutoWeakFrames) {
    mAutoWeakFrames->Clear(this);
  }
  const nsTArray<WeakFrame*> weakFrames = ToArray(mWeakFrames);
  for (WeakFrame* weakFrame : weakFrames) {
    weakFrame->Clear(this);
  }

  // Clear the embedding frame only after tearing down the frame tree, since we
  // rely on reaching the display root frame from frame destruction.
  if (nsSubDocumentFrame* f = GetInProcessEmbedderFrame()) {
    f->RemoveEmbeddingPresShell(this);
  }
  mEmbedderFrame = nullptr;

  // Terminate AccessibleCaretEventHub after tearing down the frame tree so that
  // we don't need to remove caret element's frame in
  // AccessibleCaret::RemoveCaretElement().
  if (mAccessibleCaretEventHub) {
    mAccessibleCaretEventHub->Terminate();
    mAccessibleCaretEventHub = nullptr;
  }

  mWidgetListener = nullptr;

  if (mPresContext) {
    // We hold a reference to the pres context, and it holds a weak link back
    // to us. To avoid the pres context having a dangling reference, set its
    // pres shell to nullptr
    mPresContext->DetachPresShell();
  }

  mHaveShutDown = true;

  mTouchManager.Destroy();
}

void PresShell::StartObservingRefreshDriver() {
  nsRefreshDriver* rd = mPresContext->RefreshDriver();
  if (mResizeEventPending || mVisualViewportResizeEventPending) {
    rd->ScheduleRenderingPhase(mozilla::RenderingPhase::ResizeSteps);
  }
  if (mNeedLayoutFlush || mNeedStyleFlush) {
    rd->ScheduleRenderingPhase(mozilla::RenderingPhase::Layout);
  }
}

nsRefreshDriver* PresShell::GetRefreshDriver() const {
  return mPresContext ? mPresContext->RefreshDriver() : nullptr;
}

// NOTE(emilio): It'd be ideal if instead of this explicit tracking we could
// rely on mDocument->GetEmbedderElement()->GetPrimaryFrame() + relevant
// null-checks. However, given how things are set up now, the embedder element
// in BrowsingContext / Window get cleared before tearing down the pres shell,
// and RDL relies on getting ahold of it to get the display root.
void PresShell::SetInProcessEmbedderFrame(nsSubDocumentFrame* aFrame) {
  mEmbedderFrame = aFrame;
}

void PresShell::SetAuthorStyleDisabled(bool aStyleDisabled) {
  if (aStyleDisabled != StyleSet()->GetAuthorStyleDisabled()) {
    StyleSet()->SetAuthorStyleDisabled(aStyleDisabled);
    mDocument->ApplicableStylesChanged();

    nsCOMPtr<nsIObserverService> observerService =
        mozilla::services::GetObserverService();
    if (observerService) {
      observerService->NotifyObservers(
          ToSupports(mDocument), "author-style-disabled-changed", nullptr);
    }
  }
}

bool PresShell::GetAuthorStyleDisabled() const {
  return StyleSet()->GetAuthorStyleDisabled();
}

void PresShell::AddUserSheet(StyleSheet* aSheet) {
  // Make sure this does what nsDocumentViewer::CreateStyleSet does wrt
  // ordering. We want this new sheet to come after all the existing stylesheet
  // service sheets (which are at the start), but before other user sheets; see
  // nsIStyleSheetService.idl for the ordering.

  nsStyleSheetService* sheetService = nsStyleSheetService::GetInstance();
  nsTArray<RefPtr<StyleSheet>>& userSheets = *sheetService->UserStyleSheets();

  // Search for the place to insert the new user sheet. Since all of the
  // stylesheet service provided user sheets should be at the start of the style
  // set's list, and aSheet should be at the end of userSheets. Given that, we
  // can find the right place to insert the new sheet based on the length of
  // userSheets.
  MOZ_ASSERT(aSheet);
  MOZ_ASSERT(userSheets.LastElement() == aSheet);

  size_t index = userSheets.Length() - 1;

  // Assert that all of userSheets (except for the last, new element) matches up
  // with what's in the style set.
  for (size_t i = 0; i < index; ++i) {
    MOZ_ASSERT(StyleSet()->SheetAt(StyleOrigin::User, i) == userSheets[i]);
  }

  if (index == static_cast<size_t>(StyleSet()->SheetCount(StyleOrigin::User))) {
    StyleSet()->AppendStyleSheet(*aSheet);
  } else {
    StyleSheet* ref = StyleSet()->SheetAt(StyleOrigin::User, index);
    StyleSet()->InsertStyleSheetBefore(*aSheet, *ref);
  }

  mDocument->ApplicableStylesChanged();
}

void PresShell::AddAgentSheet(StyleSheet* aSheet) {
  // Make sure this does what nsDocumentViewer::CreateStyleSet does
  // wrt ordering.
  StyleSet()->AppendStyleSheet(*aSheet);
  mDocument->ApplicableStylesChanged();
}

void PresShell::AddAuthorSheet(StyleSheet* aSheet) {
  // Document specific "additional" Author sheets should be stronger than the
  // ones added with the StyleSheetService.
  StyleSheet* firstAuthorSheet = mDocument->GetFirstAdditionalAuthorSheet();
  if (firstAuthorSheet) {
    StyleSet()->InsertStyleSheetBefore(*aSheet, *firstAuthorSheet);
  } else {
    StyleSet()->AppendStyleSheet(*aSheet);
  }

  mDocument->ApplicableStylesChanged();
}

bool PresShell::NeedsFocusFixUp() const {
  if (NS_WARN_IF(!mDocument)) {
    return false;
  }

  nsIContent* currentFocus = mDocument->GetUnretargetedFocusedContent(
      Document::IncludeChromeOnly::Yes);
  if (!currentFocus) {
    return false;
  }

  // If focus target is an area element with one or more shapes that are
  // focusable areas.
  if (auto* area = HTMLAreaElement::FromNode(currentFocus)) {
    if (nsFocusManager::IsAreaElementFocusable(*area)) {
      return false;
    }
  }

  nsIFrame* f = currentFocus->GetPrimaryFrame();
  if (f && f->IsFocusable()) {
    return false;
  }

  if (currentFocus == mDocument->GetBody() ||
      currentFocus == mDocument->GetRootElement()) {
    return false;
  }

  return true;
}

bool PresShell::FixUpFocus() {
  if (!NeedsFocusFixUp()) {
    return false;
  }
  RefPtr fm = nsFocusManager::GetFocusManager();
  nsCOMPtr<nsPIDOMWindowOuter> window = mDocument->GetWindow();
  if (NS_WARN_IF(!window)) {
    return false;
  }
  if (auto* element = fm->GetFocusedElement()) {
    // Ensure that focus navigation still starts from this element.
    element->OwnerDoc()->SetPreviouslyFocusedContent(element);
  }
  fm->ClearFocus(window);
  return true;
}

void PresShell::SelectionWillTakeFocus() {
  if (mSelection) {
    FrameSelectionWillTakeFocus(*mSelection,
                                CanMoveLastSelectionForToString::No);
  }
}

void PresShell::SelectionWillLoseFocus() {
  // Do nothing, the main selection is the default focused selection.
}

// Selection repainting code relies on selection offsets being properly
// adjusted (see bug 1626291), so we need to wait until the DOM is finished
// notifying.
static void RepaintNormalSelectionWhenSafe(nsFrameSelection& aFrameSelection) {
  if (nsContentUtils::IsSafeToRunScript()) {
    aFrameSelection.RepaintSelection(SelectionType::eNormal);
    return;
  }

  // Note that importantly we don't defer changing the DisplaySelection. That'd
  // be potentially racy with other code that may change it.
  nsContentUtils::AddScriptRunner(NS_NewRunnableFunction(
      "RepaintNormalSelectionWhenSafe",
      [sel = RefPtr<nsFrameSelection>(&aFrameSelection)] {
        sel->RepaintSelection(SelectionType::eNormal);
      }));
}

void PresShell::FrameSelectionWillLoseFocus(nsFrameSelection& aFrameSelection) {
  if (mFocusedFrameSelection != &aFrameSelection) {
    return;
  }

  // Do nothing, the main selection is the default focused selection.
  if (&aFrameSelection == mSelection) {
    return;
  }

  RefPtr<nsFrameSelection> old = std::move(mFocusedFrameSelection);
  MOZ_ASSERT(!mFocusedFrameSelection);

  if (old->GetDisplaySelection() != nsISelectionController::SELECTION_HIDDEN) {
    old->SetDisplaySelection(nsISelectionController::SELECTION_HIDDEN);
    RepaintNormalSelectionWhenSafe(*old);
  }

  if (mSelection) {
    FrameSelectionWillTakeFocus(*mSelection,
                                CanMoveLastSelectionForToString::No);
  }
}

void PresShell::FrameSelectionWillTakeFocus(
    nsFrameSelection& aFrameSelection,
    CanMoveLastSelectionForToString aCanMoveLastSelectionForToString) {
  if (StaticPrefs::dom_selection_mimic_chrome_tostring_enabled()) {
    if (aCanMoveLastSelectionForToString ==
        CanMoveLastSelectionForToString::Yes) {
      UpdateLastSelectionForToString(&aFrameSelection);
    }
  }
  if (mFocusedFrameSelection == &aFrameSelection) {
#ifdef XP_MACOSX
    // FIXME: Mac needs to update the global selection cache, even if the
    // document's focused selection doesn't change, and this is currently done
    // from RepaintSelection. Maybe we should move part of the global selection
    // handling here, or something of that sort, unclear.
    RepaintNormalSelectionWhenSafe(aFrameSelection);
#endif
    return;
  }

  RefPtr<nsFrameSelection> old = std::move(mFocusedFrameSelection);
  mFocusedFrameSelection = &aFrameSelection;

  if (old &&
      old->GetDisplaySelection() != nsISelectionController::SELECTION_HIDDEN) {
    old->SetDisplaySelection(nsISelectionController::SELECTION_HIDDEN);
    RepaintNormalSelectionWhenSafe(*old);
  }

  if (aFrameSelection.GetDisplaySelection() !=
      nsISelectionController::SELECTION_ON) {
    aFrameSelection.SetDisplaySelection(nsISelectionController::SELECTION_ON);
    RepaintNormalSelectionWhenSafe(aFrameSelection);
  }
}

void PresShell::UpdateLastSelectionForToString(
    const nsFrameSelection* aFrameSelection) {
  if (mLastSelectionForToString != aFrameSelection) {
    mLastSelectionForToString = aFrameSelection;
  }
}

NS_IMETHODIMP
PresShell::SetDisplaySelection(int16_t aToggle) {
  mSelection->SetDisplaySelection(aToggle);
  return NS_OK;
}

NS_IMETHODIMP
PresShell::GetDisplaySelection(int16_t* aToggle) {
  *aToggle = mSelection->GetDisplaySelection();
  return NS_OK;
}

NS_IMETHODIMP
PresShell::GetSelectionFromScript(RawSelectionType aRawSelectionType,
                                  Selection** aSelection) {
  if (!aSelection || !mSelection) {
    return NS_ERROR_NULL_POINTER;
  }

  RefPtr<Selection> selection =
      mSelection->GetSelection(ToSelectionType(aRawSelectionType));

  if (!selection) {
    return NS_ERROR_INVALID_ARG;
  }

  selection.forget(aSelection);
  return NS_OK;
}

Selection* PresShell::GetSelection(RawSelectionType aRawSelectionType) {
  if (!mSelection) {
    return nullptr;
  }

  return mSelection->GetSelection(ToSelectionType(aRawSelectionType));
}

Selection* PresShell::GetCurrentSelection(SelectionType aSelectionType) {
  if (!mSelection) {
    return nullptr;
  }

  return mSelection->GetSelection(aSelectionType);
}

nsFrameSelection* PresShell::GetLastFocusedFrameSelection() {
  return mFocusedFrameSelection ? mFocusedFrameSelection : mSelection;
}

NS_IMETHODIMP
PresShell::ScrollSelectionIntoView(RawSelectionType aRawSelectionType,
                                   SelectionRegion aRegion,
                                   ControllerScrollFlags aFlags) {
  if (!mSelection) {
    return NS_ERROR_NULL_POINTER;
  }

  RefPtr<nsFrameSelection> frameSelection = mSelection;
  return frameSelection->ScrollSelectionIntoView(
      ToSelectionType(aRawSelectionType), aRegion, aFlags);
}

NS_IMETHODIMP
PresShell::RepaintSelection(RawSelectionType aRawSelectionType) {
  if (!mSelection) {
    return NS_ERROR_NULL_POINTER;
  }

  if (MOZ_UNLIKELY(mIsDestroying)) {
    return NS_OK;
  }

  RefPtr<nsFrameSelection> frameSelection = mSelection;
  return frameSelection->RepaintSelection(ToSelectionType(aRawSelectionType));
}

void PresShell::RepaintPseudoElementStyledSelections() {
  if (MOZ_UNLIKELY(mIsDestroying)) {
    return;
  }

  if (RefPtr<nsFrameSelection> frameSelection = mSelection) {
    frameSelection->RepaintSelection(SelectionType::eNormal);
    frameSelection->RepaintSelection(SelectionType::eTargetText);
  }

  mDocument->HighlightRegistry().RepaintAllHighlightSelections();
}

// Make shell be a document observer
void PresShell::BeginObservingDocument() {
  if (mDocument && !mIsDestroying) {
    mIsObservingDocument = true;
    if (mIsDocumentGone) {
      NS_WARNING(
          "Adding a presshell that was disconnected from the document "
          "as a document observer?  Sounds wrong...");
      mIsDocumentGone = false;
    }
  }
}

// Make shell stop being a document observer
void PresShell::EndObservingDocument() {
  // XXXbz do we need to tell the frame constructor that the document
  // is gone, perhaps?  Except for printing it's NOT gone, sometimes.
  mIsDocumentGone = true;
  mIsObservingDocument = false;
}

void PresShell::InitPaintSuppressionTimer() {
  // Default to PAINTLOCK_EVENT_DELAY if we can't get the pref value.
  Document* doc = mDocument->GetDisplayDocument()
                      ? mDocument->GetDisplayDocument()
                      : mDocument.get();
  const bool inProcess = !doc->GetBrowsingContext() ||
                         doc->GetBrowsingContext()->Top()->IsInProcess();
  int32_t delay = inProcess
                      ? StaticPrefs::nglayout_initialpaint_delay()
                      : StaticPrefs::nglayout_initialpaint_delay_in_oopif();
  mPaintSuppressionTimer->InitWithNamedFuncCallback(
      [](nsITimer* aTimer, void* aPresShell) {
        RefPtr<PresShell> self = static_cast<PresShell*>(aPresShell);
        self->UnsuppressPainting();
      },
      this, delay, nsITimer::TYPE_ONE_SHOT,
      "PresShell::sPaintSuppressionCallback"_ns);
}

nsresult PresShell::Initialize() {
  if (mIsDestroying) {
    return NS_OK;
  }

  if (!mDocument) {
    // Nothing to do
    return NS_OK;
  }

  MOZ_LOG(gLog, LogLevel::Debug, ("PresShell::Initialize this=%p", this));

  NS_ASSERTION(!mDidInitialize, "Why are we being called?");

  RefPtr<PresShell> kungFuDeathGrip(this);

  RecomputeFontSizeInflationEnabled();
  MOZ_DIAGNOSTIC_ASSERT(!mIsDestroying);

  // Ensure the pres context doesn't think it has changed, since we haven't even
  // started layout. This avoids spurious restyles / reflows afterwards.
  //
  // Note that this is very intentionally before setting mDidInitialize so it
  // doesn't notify the document, or run media query change events.
  mPresContext->FlushPendingMediaFeatureValuesChanged();
  MOZ_DIAGNOSTIC_ASSERT(!mIsDestroying);

  mDidInitialize = true;

  // Get the root frame from the frame constructor.
  // XXXbz it would be nice to move this somewhere else... like frame manager
  // Init(), say.  But we need to make sure our views are all set up by the
  // time we do this!
  MOZ_ASSERT(!mFrameConstructor->GetRootFrame(),
             "How did that happen, exactly?");
  ViewportFrame* rootFrame;
  {
    nsAutoScriptBlocker scriptBlocker;
    rootFrame = mFrameConstructor->ConstructRootFrame();
    mFrameConstructor->SetRootFrame(rootFrame);
  }

  NS_ENSURE_STATE(!mHaveShutDown);

  if (!rootFrame) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  if (Element* root = mDocument->GetRootElement()) {
    {
      nsAutoCauseReflowNotifier reflowNotifier(this);
      // Have the style sheet processor construct frame for the root
      // content object down
      mFrameConstructor->ContentInserted(
          root, nsCSSFrameConstructor::InsertionKind::Sync);
    }
    // Something in mFrameConstructor->ContentInserted may have caused
    // Destroy() to get called, bug 337586.  Or, nsAutoCauseReflowNotifier
    // (which sets up a script blocker) going out of scope may have killed us
    // too
    NS_ENSURE_STATE(!mHaveShutDown);
  }

  mDocument->MaybeScheduleRendering();

  NS_ASSERTION(rootFrame, "How did that happen?");

  // Note: when the frame was created above it had the NS_FRAME_IS_DIRTY bit
  // set, but XBL processing could have caused a reflow which clears it.
  if (MOZ_LIKELY(rootFrame->HasAnyStateBits(NS_FRAME_IS_DIRTY))) {
    // Unset the DIRTY bits so that FrameNeedsReflow() will work right.
    rootFrame->RemoveStateBits(NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN);
    NS_ASSERTION(!mDirtyRoots.Contains(rootFrame),
                 "Why is the root in mDirtyRoots already?");
    FrameNeedsReflow(rootFrame, IntrinsicDirty::None, NS_FRAME_IS_DIRTY);
    NS_ASSERTION(mDirtyRoots.Contains(rootFrame),
                 "Should be in mDirtyRoots now");
    NS_ASSERTION(mNeedStyleFlush || mNeedLayoutFlush,
                 "Why no reflow scheduled?");
  }

  // Restore our root scroll position now if we're getting here after EndLoad
  // got called, since this is our one chance to do it.  Note that we need not
  // have reflowed for this to work; when the scrollframe is finally reflowed
  // it'll pick up the position we store in it here.
  if (!mDocumentLoading) {
    RestoreRootScrollPosition();
  }

  // For printing, we just immediately unsuppress.
  if (!mPresContext->IsPaginated()) {
    // Kick off a one-shot timer based off our pref value.  When this timer
    // fires, if painting is still locked down, then we will go ahead and
    // trigger a full invalidate and allow painting to proceed normally.
    mPaintingSuppressed = true;
    // Don't suppress painting if the document isn't loading. However,
    // the initial about:blank appears not to be loading, but we still
    // want to suppress painting.
    nsIDocShell* docShell = mDocument->GetDocShell();
    if ((docShell &&
         !nsDocShell::Cast(docShell)
              ->HasStartedLoadingOtherThanInitialBlankURI() &&
         mDocument->IsInitialDocument()) ||
        mDocument->GetReadyStateEnum() != Document::READYSTATE_COMPLETE) {
      mPaintSuppressionTimer = NS_NewTimer();
    }
    if (!mPaintSuppressionTimer) {
      mPaintingSuppressed = false;
    } else {
      // Initialize the timer.
      mPaintSuppressionTimer->SetTarget(GetMainThreadSerialEventTarget());
      InitPaintSuppressionTimer();
      if (mHasTriedFastUnsuppress) {
        // Someone tried to unsuppress painting before Initialize was called so
        // unsuppress painting rather soon.
        mHasTriedFastUnsuppress = false;
        TryUnsuppressPaintingSoon();
        MOZ_ASSERT(mHasTriedFastUnsuppress);
      }
    }
  }

  // If we get here and painting is not suppressed, we still want to run the
  // unsuppression logic, so set mShouldUnsuppressPainting to true.
  if (!mPaintingSuppressed) {
    mShouldUnsuppressPainting = true;
  }

  return NS_OK;  // XXX this needs to be real. MMP
}

void PresShell::TryUnsuppressPaintingSoon() {
  if (mHasTriedFastUnsuppress) {
    return;
  }
  mHasTriedFastUnsuppress = true;

  if (!mDidInitialize || !IsPaintingSuppressed() || !XRE_IsContentProcess()) {
    return;
  }

  if (!mDocument->IsInitialDocument() &&
      mDocument->DidHitCompleteSheetCache() &&
      mPresContext->IsRootContentDocumentCrossProcess()) {
    // Try to unsuppress faster on a top level page if it uses stylesheet
    // cache, since that hints that many resources can be painted sooner than
    // in a cold page load case.
    NS_DispatchToCurrentThreadQueue(
        NS_NewRunnableFunction("PresShell::TryUnsuppressPaintingSoon",
                               [self = RefPtr{this}]() -> void {
                                 if (self->IsPaintingSuppressed()) {
                                   PROFILER_MARKER_UNTYPED(
                                       "Fast paint unsuppression", GRAPHICS);
                                   self->UnsuppressPainting();
                                 }
                               }),
        EventQueuePriority::Control);
  }
}

void PresShell::RefreshZoomConstraintsForScreenSizeChange() {
  if (mZoomConstraintsClient) {
    mZoomConstraintsClient->ScreenSizeChanged();
  }
}

nsSize PresShell::MaybePendingLayoutViewportSize() const {
  if (mPendingLayoutViewportSize) {
    return *mPendingLayoutViewportSize;
  }
  return mPresContext ? mPresContext->GetVisibleArea().Size() : nsSize();
}

bool PresShell::ShouldDelayResize() const {
  if (!IsVisible()) {
    return true;
  }
  nsRefreshDriver* rd = GetRefreshDriver();
  return rd && rd->IsResizeSuppressed();
}

void PresShell::FlushDelayedResize() {
  if (!mPendingLayoutViewportSize) {
    return;
  }
  auto size = mPendingLayoutViewportSize.extract();
  if (!mPresContext || size == mPresContext->GetVisibleArea().Size()) {
    return;
  }
  ResizeReflow(size);
}

void PresShell::SetLayoutViewportSize(const nsSize& aSize, bool aDelay) {
  mPendingLayoutViewportSize = Some(aSize);
  if (aDelay || ShouldDelayResize()) {
    SetNeedStyleFlush();
    SetNeedLayoutFlush();
    return;
  }
  FlushDelayedResize();
}

void PresShell::ForceResizeReflowWithCurrentDimensions() {
  ResizeReflow(MaybePendingLayoutViewportSize());
}

void PresShell::ResizeReflow(const nsSize& aSize,
                             ResizeReflowOptions aOptions) {
  if (mZoomConstraintsClient) {
    // If we have a ZoomConstraintsClient and the available screen area
    // changed, then we might need to disable double-tap-to-zoom, so notify
    // the ZCC to update itself.
    mZoomConstraintsClient->ScreenSizeChanged();
  }
  if (UsesMobileViewportSizing()) {
    // If we are using mobile viewport sizing, request a reflow from the MVM.
    // It can recompute the final CSS viewport and trigger a call to
    // ResizeReflowIgnoreOverride if it changed. We don't force adjusting
    // of resolution, because that is only necessary when we are destroying
    // the MVM.
    MOZ_ASSERT(mMobileViewportManager);
    mMobileViewportManager->RequestReflow(false);
    return;
  }
  ResizeReflowIgnoreOverride(aSize, aOptions);
}

bool PresShell::SimpleResizeReflow(const nsSize& aSize) {
  MOZ_ASSERT(aSize.width != NS_UNCONSTRAINEDSIZE);
  MOZ_ASSERT(aSize.height != NS_UNCONSTRAINEDSIZE);
  nsSize oldSize = mPresContext->GetVisibleArea().Size();
  mPresContext->SetVisibleArea(nsRect(nsPoint(), aSize));
  nsIFrame* rootFrame = GetRootFrame();
  if (!rootFrame) {
    return false;
  }
  WritingMode wm = rootFrame->GetWritingMode();
  bool isBSizeChanging = wm.IsVertical() ? oldSize.width != aSize.width
                                         : oldSize.height != aSize.height;
  if (isBSizeChanging) {
    nsLayoutUtils::MarkIntrinsicISizesDirtyIfDependentOnBSize(rootFrame);
    rootFrame->SetHasBSizeChange(true);
  }
  FrameNeedsReflow(rootFrame, IntrinsicDirty::None,
                   NS_FRAME_HAS_DIRTY_CHILDREN);

  if (mMobileViewportManager) {
    mMobileViewportManager->UpdateSizesBeforeReflow();
  }
  return true;
}

bool PresShell::CanHandleUserInputEvents(WidgetGUIEvent* aGUIEvent) {
  if (XRE_IsParentProcess()) {
    return true;
  }

  if (aGUIEvent->mFlags.mIsSynthesizedForTests &&
      !StaticPrefs::dom_input_events_security_isUserInputHandlingDelayTest()) {
    return true;
  }

  if (!aGUIEvent->IsUserAction()) {
    return true;
  }

  if (nsPresContext* rootPresContext = mPresContext->GetRootPresContext()) {
    return rootPresContext->UserInputEventsAllowed();
  }

  return true;
}

void PresShell::PostScrollEvent(Runnable* aEvent) {
  MOZ_ASSERT(aEvent);
  mPendingScrollEvents.AppendElement(aEvent);

  // If we (or any descendant docs) have any content visibility: auto elements,
  // we also need to run its proximity to the viewport on scroll. Same for
  // intersection observers.
  //
  // We don't need to mark ourselves as needing a layout flush. We don't need to
  // get flushed, we just need the viewport relevancy / content-visibility: auto
  // viewport proximity phases to run.
  mPresContext->RefreshDriver()->ScheduleRenderingPhases(
      {RenderingPhase::ScrollSteps, RenderingPhase::Layout,
       RenderingPhase::UpdateIntersectionObservations});
}

void PresShell::ScheduleResizeEventIfNeeded(ResizeEventKind aKind) {
  if (mIsDestroying) {
    return;
  }
  if (MOZ_UNLIKELY(mDocument->GetBFCacheEntry())) {
    return;
  }
  if (aKind == ResizeEventKind::Regular) {
    mResizeEventPending = true;
  } else {
    MOZ_ASSERT(aKind == ResizeEventKind::Visual);
    mVisualViewportResizeEventPending = true;
  }
  mPresContext->RefreshDriver()->ScheduleRenderingPhase(
      RenderingPhase::ResizeSteps);
}

bool PresShell::ResizeReflowIgnoreOverride(const nsSize& aSize,
                                           ResizeReflowOptions aOptions) {
  MOZ_ASSERT(!mIsReflowing, "Shouldn't be in reflow here!");

  // Historically we never fired resize events if there was no root frame by the
  // time this function got called.
  const bool initialized = mDidInitialize;
  RefPtr<PresShell> kungFuDeathGrip(this);

  auto postResizeEventIfNeeded = [this, initialized]() {
    if (initialized) {
      ScheduleResizeEventIfNeeded(ResizeEventKind::Regular);
    }
  };

  // If there are orthogonal flows that were dependent on the ICB size, mark
  // them as dirty to ensure they will be reflowed.
  for (auto* frame : mOrthogonalFlows) {
    FrameNeedsReflow(frame, IntrinsicDirty::None, NS_FRAME_HAS_DIRTY_CHILDREN);
  }
  mOrthogonalFlows.Clear();

  if (!(aOptions & ResizeReflowOptions::BSizeLimit)) {
    nsSize oldSize = mPresContext->GetVisibleArea().Size();
    if (oldSize == aSize) {
      return false;
    }

    bool changed = SimpleResizeReflow(aSize);
    postResizeEventIfNeeded();
    return changed;
  }

  // Make sure that style is flushed before setting the pres context
  // VisibleArea.
  //
  // Otherwise we may end up with bogus viewport units resolved against the
  // unconstrained bsize, or restyling the whole document resolving viewport
  // units against targetWidth, which may end up doing wasteful work.
  mDocument->FlushPendingNotifications(FlushType::Frames);

  nsIFrame* rootFrame = GetRootFrame();
  if (mIsDestroying || !rootFrame) {
    // If we don't have a root frame yet, that means we haven't had our initial
    // reflow... If that's the case, and aWidth or aHeight is unconstrained,
    // ignore them altogether.
    if (aSize.height == NS_UNCONSTRAINEDSIZE ||
        aSize.width == NS_UNCONSTRAINEDSIZE) {
      // We can't do the work needed for SizeToContent without a root
      // frame, and we want to return before setting the visible area.
      return false;
    }

    mPresContext->SetVisibleArea(nsRect(nsPoint(), aSize));
    // There isn't anything useful we can do if the initial reflow hasn't
    // happened.
    return true;
  }

  WritingMode wm = rootFrame->GetWritingMode();
  MOZ_ASSERT(
      (wm.IsVertical() ? aSize.height : aSize.width) != NS_UNCONSTRAINEDSIZE,
      "unconstrained isize not allowed");

  nsSize targetSize = aSize;
  if (wm.IsVertical()) {
    targetSize.width = NS_UNCONSTRAINEDSIZE;
  } else {
    targetSize.height = NS_UNCONSTRAINEDSIZE;
  }

  mPresContext->SetVisibleArea(nsRect(nsPoint(), targetSize));
  // XXX Do a full invalidate at the beginning so that invalidates along
  // the way don't have region accumulation issues?

  // For height:auto BSizes (i.e. layout-controlled), descendant
  // intrinsic sizes can't depend on them. So the only other case is
  // viewport-controlled BSizes which we handle here.
  nsLayoutUtils::MarkIntrinsicISizesDirtyIfDependentOnBSize(rootFrame);
  rootFrame->SetHasBSizeChange(true);
  FrameNeedsReflow(rootFrame, IntrinsicDirty::None,
                   NS_FRAME_HAS_DIRTY_CHILDREN);

  {
    nsAutoCauseReflowNotifier crNotifier(this);
    WillDoReflow();

    // Kick off a top-down reflow
    AUTO_LAYOUT_PHASE_ENTRY_POINT(GetPresContext(), Reflow);

    mDirtyRoots.Remove(rootFrame);
    DoReflow(rootFrame, true, nullptr);

    const bool reflowAgain =
        wm.IsVertical() ? mPresContext->GetVisibleArea().width > aSize.width
                        : mPresContext->GetVisibleArea().height > aSize.height;

    if (reflowAgain) {
      mPresContext->SetVisibleArea(nsRect(nsPoint(), aSize));
      rootFrame->SetHasBSizeChange(true);
      DoReflow(rootFrame, true, nullptr);
    }
  }

  // Now, we may have been destroyed by the destructor of
  // `nsAutoCauseReflowNotifier`.

  mPendingDidDoReflow = true;
  DidDoReflow(true);

  // the reflow above should've set our bsize if it was NS_UNCONSTRAINEDSIZE,
  // and the isize shouldn't be NS_UNCONSTRAINEDSIZE anyway.
  MOZ_DIAGNOSTIC_ASSERT(
      mPresContext->GetVisibleArea().width != NS_UNCONSTRAINEDSIZE,
      "width should not be NS_UNCONSTRAINEDSIZE after reflow");
  MOZ_DIAGNOSTIC_ASSERT(
      mPresContext->GetVisibleArea().height != NS_UNCONSTRAINEDSIZE,
      "height should not be NS_UNCONSTRAINEDSIZE after reflow");

  postResizeEventIfNeeded();
  return true;
}

// https://drafts.csswg.org/cssom-view/#document-run-the-resize-steps
void PresShell::RunResizeSteps() {
  if (!mResizeEventPending && !mVisualViewportResizeEventPending) {
    return;
  }
  if (mIsDocumentGone) {
    return;
  }

  RefPtr window = nsGlobalWindowInner::Cast(mDocument->GetInnerWindow());
  if (!window) {
    return;
  }

  if (mResizeEventPending) {
    // Clear it before firing, just in case the event triggers another resize
    // event. Such event will fire next tick.
    mResizeEventPending = false;
    WidgetEvent event(true, mozilla::eResize);
    nsEventStatus status = nsEventStatus_eIgnore;

    if (RefPtr<nsPIDOMWindowOuter> outer = window->GetOuterWindow()) {
      // MOZ_KnownLive due to bug 1506441
      EventDispatcher::Dispatch(MOZ_KnownLive(nsGlobalWindowOuter::Cast(outer)),
                                mPresContext, &event, nullptr, &status);
    }
  }

  if (mVisualViewportResizeEventPending) {
    mVisualViewportResizeEventPending = false;
    RefPtr vv = window->VisualViewport();
    vv->FireResizeEvent();
  }
}

// https://drafts.csswg.org/cssom-view/#document-run-the-scroll-steps
// But note: https://github.com/w3c/csswg-drafts/issues/11164
void PresShell::RunScrollSteps() {
  // Scroll events are one-shot, so after running them we can drop them.
  // However, dispatching a scroll event can potentially cause more scroll
  // events to be posted, so we move the initial set into a temporary array
  // first. (Newly posted scroll events will be dispatched on the next tick.)
  auto events = std::move(mPendingScrollEvents);
  for (auto& event : events) {
    event->Run();
  }
}

static nsIContent* GetNativeAnonymousSubtreeRoot(nsIContent* aContent) {
  if (!aContent) {
    return nullptr;
  }
  return aContent->GetClosestNativeAnonymousSubtreeRoot();
}

void PresShell::NativeAnonymousContentWillBeRemoved(nsIContent* aAnonContent) {
  MOZ_ASSERT(aAnonContent->IsRootOfNativeAnonymousSubtree());
  mPresContext->EventStateManager()->NativeAnonymousContentRemoved(
      aAnonContent);
#ifdef ACCESSIBILITY
  if (nsAccessibilityService* accService = GetAccService()) {
    accService->ContentRemoved(this, aAnonContent);
  }
#endif
  if (mDocument->DevToolsAnonymousAndShadowEventsEnabled()) {
    aAnonContent->QueueDevtoolsAnonymousEvent(/* aIsRemove = */ true);
  }
  if (nsIContent* root =
          GetNativeAnonymousSubtreeRoot(mCurrentEventTarget.mContent)) {
    if (aAnonContent == root) {
      mCurrentEventTarget.UpdateFrameAndContent(
          nullptr, aAnonContent->GetFlattenedTreeParent());
    }
  }

  for (EventTargetInfo& eventTargetInfo : mCurrentEventTargetStack) {
    nsIContent* anon = GetNativeAnonymousSubtreeRoot(eventTargetInfo.mContent);
    if (aAnonContent == anon) {
      eventTargetInfo.UpdateFrameAndContent(
          nullptr, aAnonContent->GetFlattenedTreeParent());
    }
  }
}

void PresShell::SetIgnoreFrameDestruction(bool aIgnore) {
  if (mDocument) {
    // We need to tell the ImageLoader to drop all its references to frames
    // because they're about to go away and it won't get notifications of that.
    mDocument->EnsureStyleImageLoader().ClearFrames(mPresContext);
  }
  mIgnoreFrameDestruction = aIgnore;
}

void PresShell::NotifyDestroyingFrame(nsIFrame* aFrame) {
  // We must remove these from FrameLayerBuilder::DisplayItemData::mFrameList
  // here, otherwise the DisplayItemData destructor will use the destroyed frame
  // when it tries to remove it from the (array) value of this property.
  aFrame->RemoveDisplayItemDataForDeletion();

  if (!mIgnoreFrameDestruction) {
    if (aFrame->HasImageRequest()) {
      mDocument->EnsureStyleImageLoader().DropRequestsForFrame(aFrame);
    }

    mFrameConstructor->NotifyDestroyingFrame(aFrame);

    mDirtyRoots.Remove(aFrame);

    // Remove frame properties
    aFrame->RemoveAllProperties();

    const auto ComputeTargetContent =
        [&aFrame](const EventTargetInfo& aEventTargetInfo) -> nsIContent* {
      if (!IsForbiddenDispatchingToNonElementContent(
              aEventTargetInfo.mEventMessage)) {
        return aFrame->GetContent();
      }
      return aFrame->GetContent()
                 ? aFrame->GetContent()
                       ->GetInclusiveFlattenedTreeAncestorElement()
                 : nullptr;
    };

    if (aFrame == mCurrentEventTarget.mFrame) {
      mCurrentEventTarget.UpdateFrameAndContent(
          nullptr, ComputeTargetContent(mCurrentEventTarget));
    }

    for (EventTargetInfo& eventTargetInfo : mCurrentEventTargetStack) {
      if (aFrame == eventTargetInfo.mFrame) {
        // One of our stack frames was deleted.  Get its content so that when we
        // pop it we can still get its new frame from its content
        eventTargetInfo.UpdateFrameAndContent(
            nullptr, ComputeTargetContent(eventTargetInfo));
      }
    }

    mFramesToDirty.Remove(aFrame);
    mOrthogonalFlows.Remove(aFrame);

    if (ScrollContainerFrame* scrollContainerFrame = do_QueryFrame(aFrame)) {
      mPendingScrollAnchorSelection.Remove(scrollContainerFrame);
      mPendingScrollAnchorAdjustment.Remove(scrollContainerFrame);
      mPendingScrollResnap.Remove(scrollContainerFrame);
    }
  }
}

already_AddRefed<nsCaret> PresShell::GetActiveCaret() const {
  RefPtr<nsCaret> caret = mCaret;
  return caret.forget();
}

already_AddRefed<nsCaret> PresShell::GetOriginalCaret() const {
  RefPtr<nsCaret> caret = mOriginalCaret;
  return caret.forget();
}

already_AddRefed<AccessibleCaretEventHub>
PresShell::GetAccessibleCaretEventHub() const {
  RefPtr<AccessibleCaretEventHub> eventHub = mAccessibleCaretEventHub;
  return eventHub.forget();
}

void PresShell::SetActiveCaret(nsCaret* aNewCaret) {
  if (mCaret == aNewCaret) {
    return;
  }
  if (mCaret) {
    mCaret->SchedulePaint();
  }
  mCaret = aNewCaret;
  if (aNewCaret) {
    aNewCaret->SchedulePaint();
  }
}

void PresShell::RestoreOriginalCaret() { SetActiveCaret(mOriginalCaret); }

NS_IMETHODIMP PresShell::SetCaretEnabled(bool aInEnable) {
  bool oldEnabled = mCaretEnabled;

  mCaretEnabled = aInEnable;

  if (mCaretEnabled != oldEnabled) {
    MOZ_ASSERT(mOriginalCaret);
    if (mOriginalCaret) {
      mOriginalCaret->SetVisible(mCaretEnabled);
    }
  }

  return NS_OK;
}

NS_IMETHODIMP PresShell::SetCaretReadOnly(bool aReadOnly) {
  if (mOriginalCaret) {
    mOriginalCaret->SetCaretReadOnly(aReadOnly);
  }
  return NS_OK;
}

NS_IMETHODIMP PresShell::GetCaretEnabled(bool* aOutEnabled) {
  NS_ENSURE_ARG_POINTER(aOutEnabled);
  *aOutEnabled = mCaretEnabled;
  return NS_OK;
}

NS_IMETHODIMP PresShell::SetCaretVisibilityDuringSelection(bool aVisibility) {
  if (mOriginalCaret) {
    mOriginalCaret->SetVisibilityDuringSelection(aVisibility);
  }
  return NS_OK;
}

NS_IMETHODIMP PresShell::GetCaretVisible(bool* aOutIsVisible) {
  *aOutIsVisible = false;
  if (mOriginalCaret) {
    *aOutIsVisible = mOriginalCaret->IsVisible();
  }
  return NS_OK;
}

NS_IMETHODIMP PresShell::SetSelectionFlags(int16_t aFlags) {
  mSelectionFlags = aFlags;
  return NS_OK;
}

NS_IMETHODIMP PresShell::GetSelectionFlags(int16_t* aFlags) {
  if (!aFlags) {
    return NS_ERROR_INVALID_ARG;
  }

  *aFlags = mSelectionFlags;
  return NS_OK;
}

// implementation of nsISelectionController

NS_IMETHODIMP
PresShell::PhysicalMove(int16_t aDirection, int16_t aAmount, bool aExtend) {
  RefPtr<nsFrameSelection> frameSelection = mSelection;
  return frameSelection->PhysicalMove(aDirection, aAmount, aExtend);
}

NS_IMETHODIMP
PresShell::CharacterMove(bool aForward, bool aExtend) {
  RefPtr<nsFrameSelection> frameSelection = mSelection;
  return frameSelection->CharacterMove(aForward, aExtend);
}

NS_IMETHODIMP
PresShell::WordMove(bool aForward, bool aExtend) {
  RefPtr<nsFrameSelection> frameSelection = mSelection;
  nsresult result = frameSelection->WordMove(aForward, aExtend);
  // if we can't go down/up any more we must then move caret completely to
  // end/beginning respectively.
  if (NS_FAILED(result)) {
    result = CompleteMove(aForward, aExtend);
  }
  return result;
}

NS_IMETHODIMP
PresShell::LineMove(bool aForward, bool aExtend) {
  RefPtr<nsFrameSelection> frameSelection = mSelection;
  nsresult result = frameSelection->LineMove(aForward, aExtend);
  // if we can't go down/up any more we must then move caret completely to
  // end/beginning respectively.
  if (NS_FAILED(result)) {
    result = CompleteMove(aForward, aExtend);
  }
  return result;
}

NS_IMETHODIMP
PresShell::IntraLineMove(bool aForward, bool aExtend) {
  RefPtr<nsFrameSelection> frameSelection = mSelection;
  return frameSelection->IntraLineMove(aForward, aExtend);
}

NS_IMETHODIMP
PresShell::ParagraphMove(bool aForward, bool aExtend) {
  RefPtr<nsFrameSelection> frameSelection = mSelection;
  return frameSelection->ParagraphMove(aForward, aExtend);
}

NS_IMETHODIMP
PresShell::PageMove(bool aForward, bool aExtend) {
  nsIFrame* frame = nullptr;
  if (!aExtend) {
    frame = GetScrollContainerFrameToScroll(VerticalScrollDirection);
    // If there is no scrollable frame, get the frame to move caret instead.
  }
  if (!frame || frame->PresContext() != mPresContext) {
    frame = mSelection->GetFrameToPageSelect();
    if (!frame) {
      return NS_OK;
    }
  }
  // We may scroll parent scrollable element of current selection limiter.
  // In such case, we don't want to scroll selection into view unless
  // selection is changed.
  RefPtr<nsFrameSelection> frameSelection = mSelection;
  return frameSelection->PageMove(
      aForward, aExtend, frame, nsFrameSelection::SelectionIntoView::IfChanged);
}

NS_IMETHODIMP
PresShell::ScrollPage(bool aForward) {
  ScrollContainerFrame* scrollContainerFrame =
      GetScrollContainerFrameToScroll(VerticalScrollDirection);
  ScrollMode scrollMode = apz::GetScrollModeForOrigin(ScrollOrigin::Pages);
  if (scrollContainerFrame) {
    scrollContainerFrame->ScrollBy(nsIntPoint(0, aForward ? 1 : -1),
                                   ScrollUnit::PAGES, scrollMode, nullptr,
                                   mozilla::ScrollOrigin::NotSpecified,
                                   ScrollContainerFrame::NOT_MOMENTUM,
                                   ScrollSnapFlags::IntendedDirection |
                                       ScrollSnapFlags::IntendedEndPosition);
  }
  return NS_OK;
}

NS_IMETHODIMP
PresShell::ScrollLine(bool aForward) {
  ScrollContainerFrame* scrollContainerFrame =
      GetScrollContainerFrameToScroll(VerticalScrollDirection);
  ScrollMode scrollMode = apz::GetScrollModeForOrigin(ScrollOrigin::Lines);
  if (scrollContainerFrame) {
    nsRect scrollPort = scrollContainerFrame->GetScrollPortRect();
    nsSize lineSize = scrollContainerFrame->GetLineScrollAmount();
    int32_t lineCount = StaticPrefs::toolkit_scrollbox_verticalScrollDistance();
    if (lineCount * lineSize.height > scrollPort.Height()) {
      return ScrollPage(aForward);
    }
    scrollContainerFrame->ScrollBy(
        nsIntPoint(0, aForward ? lineCount : -lineCount), ScrollUnit::LINES,
        scrollMode, nullptr, mozilla::ScrollOrigin::NotSpecified,
        ScrollContainerFrame::NOT_MOMENTUM, ScrollSnapFlags::IntendedDirection);
  }
  return NS_OK;
}

NS_IMETHODIMP
PresShell::ScrollCharacter(bool aRight) {
  ScrollContainerFrame* scrollContainerFrame =
      GetScrollContainerFrameToScroll(HorizontalScrollDirection);
  ScrollMode scrollMode = apz::GetScrollModeForOrigin(ScrollOrigin::Lines);
  if (scrollContainerFrame) {
    int32_t h = StaticPrefs::toolkit_scrollbox_horizontalScrollDistance();
    scrollContainerFrame->ScrollBy(
        nsIntPoint(aRight ? h : -h, 0), ScrollUnit::LINES, scrollMode, nullptr,
        mozilla::ScrollOrigin::NotSpecified, ScrollContainerFrame::NOT_MOMENTUM,
        ScrollSnapFlags::IntendedDirection);
  }
  return NS_OK;
}

NS_IMETHODIMP
PresShell::CompleteScroll(bool aForward) {
  ScrollContainerFrame* scrollContainerFrame =
      GetScrollContainerFrameToScroll(VerticalScrollDirection);
  ScrollMode scrollMode = apz::GetScrollModeForOrigin(ScrollOrigin::Other);
  if (scrollContainerFrame) {
    scrollContainerFrame->ScrollBy(nsIntPoint(0, aForward ? 1 : -1),
                                   ScrollUnit::WHOLE, scrollMode, nullptr,
                                   mozilla::ScrollOrigin::NotSpecified,
                                   ScrollContainerFrame::NOT_MOMENTUM,
                                   ScrollSnapFlags::IntendedEndPosition);
  }
  return NS_OK;
}

NS_IMETHODIMP
PresShell::CompleteMove(bool aForward, bool aExtend) {
  // Beware! This may flush notifications via synchronous
  // ScrollSelectionIntoView.
  const RefPtr<nsFrameSelection> frameSelection = mSelection;
  const RefPtr<Element> limiter = frameSelection->GetAncestorLimiter();
  const auto pos = [&]() -> Maybe<nsIFrame::CaretPosition> {
    nsIFrame* frame = limiter ? limiter->GetPrimaryFrame()
                              : FrameConstructor()->GetRootElementFrame();
    if (!frame) [[unlikely]] {
      return Nothing{};
    }
    return Some(frame->GetExtremeCaretPosition(!aForward));
  }();
  if (pos.isNothing()) [[unlikely]] {
    return NS_ERROR_FAILURE;
  }

  const nsFrameSelection::FocusMode focusMode =
      aExtend ? nsFrameSelection::FocusMode::kExtendSelection
              : nsFrameSelection::FocusMode::kCollapseToNewPoint;
  frameSelection->HandleClick(
      MOZ_KnownLive(pos->mResultContent) /* bug 1636889 */, pos->mContentOffset,
      pos->mContentOffset, focusMode,
      aForward ? CaretAssociationHint::After : CaretAssociationHint::Before);
  if (IsDestroying()) [[unlikely]] {
    return NS_OK;
  }
  if (limiter && GetDocument() == limiter->GetComposedDoc()) {
    // HandleClick resets ancestorLimiter, so set it again.
    frameSelection->SetAncestorLimiter(limiter);
  }

  // After ScrollSelectionIntoView(), the pending notifications might be
  // flushed and PresShell/PresContext/Frames may be dead. See bug 418470.
  return ScrollSelectionIntoView(SelectionType::eNormal,
                                 nsISelectionController::SELECTION_FOCUS_REGION,
                                 SelectionScrollMode::SyncFlush);
}

// end implementations nsISelectionController

ScrollContainerFrame* PresShell::GetRootScrollContainerFrame() const {
  if (!mFrameConstructor) {
    return nullptr;
  }
  nsIFrame* rootFrame = mFrameConstructor->GetRootFrame();
  if (!rootFrame) {
    return nullptr;
  }
  nsIFrame* theFrame = rootFrame->PrincipalChildList().FirstChild();
  if (!theFrame || !theFrame->IsScrollContainerFrame()) {
    return nullptr;
  }
  return static_cast<ScrollContainerFrame*>(theFrame);
}

nsPageSequenceFrame* PresShell::GetPageSequenceFrame() const {
  return mFrameConstructor->GetPageSequenceFrame();
}

nsCanvasFrame* PresShell::GetCanvasFrame() const {
  return mFrameConstructor->GetCanvasFrame();
}

void PresShell::RestoreRootScrollPosition() {
  if (ScrollContainerFrame* sf = GetRootScrollContainerFrame()) {
    sf->ScrollToRestoredPosition();
  }
}

void PresShell::MaybeReleaseCapturingContent() {
  RefPtr<nsFrameSelection> frameSelection = FrameSelection();
  if (frameSelection) {
    frameSelection->SetDragState(false);
  }
  if (sCapturingContentInfo.mContent &&
      sCapturingContentInfo.mContent->OwnerDoc() == mDocument) {
    PresShell::ReleaseCapturingContent();
  }
}

void PresShell::BeginLoad(Document* aDocument) {
  mDocumentLoading = true;

  SuppressDisplayport(true);

  gfxTextPerfMetrics* tp = nullptr;
  if (mPresContext) {
    tp = mPresContext->GetTextPerfMetrics();
  }

  bool shouldLog = MOZ_LOG_TEST(gLog, LogLevel::Debug);
  if (shouldLog || tp) {
    mLoadBegin = TimeStamp::Now();
  }

  if (shouldLog) {
    nsIURI* uri = mDocument->GetDocumentURI();
    MOZ_LOG(gLog, LogLevel::Debug,
            ("(presshell) %p load begin [%s]\n", this,
             uri ? uri->GetSpecOrDefault().get() : ""));
  }
}

void PresShell::EndLoad(Document* aDocument) {
  MOZ_ASSERT(aDocument == mDocument, "Wrong document");

  SuppressDisplayport(false);
  RestoreRootScrollPosition();

  mDocumentLoading = false;
}

void PresShell::LoadComplete() {
  gfxTextPerfMetrics* tp = nullptr;
  if (mPresContext) {
    tp = mPresContext->GetTextPerfMetrics();
  }

  // log load
  bool shouldLog = MOZ_LOG_TEST(gLog, LogLevel::Debug);
  if (shouldLog || tp) {
    TimeDuration loadTime = TimeStamp::Now() - mLoadBegin;
    nsIURI* uri = mDocument->GetDocumentURI();
    nsAutoCString spec;
    if (uri) {
      spec = uri->GetSpecOrDefault();
    }
    if (shouldLog) {
      MOZ_LOG(gLog, LogLevel::Debug,
              ("(presshell) %p load done time-ms: %9.2f [%s]\n", this,
               loadTime.ToMilliseconds(), spec.get()));
    }
    if (tp) {
      tp->Accumulate();
      if (tp->cumulative.numChars > 0) {
        LogTextPerfStats(tp, this, tp->cumulative, loadTime.ToMilliseconds(),
                         eLog_loaddone, spec.get());
      }
    }
  }
}

#ifdef DEBUG
void PresShell::VerifyHasDirtyRootAncestor(nsIFrame* aFrame) {
  // XXXbz due to bug 372769, can't actually assert anything here...
  // XXX Since bug 372769 is now fixed, the assertion is being enabled in bug
  //     1758104.
#  if 0
  // XXXbz shouldn't need this part; remove it once FrameNeedsReflow
  // handles the root frame correctly.
  if (!aFrame->GetParent()) {
    return;
  }

  // Make sure that there is a reflow root ancestor of |aFrame| that's
  // in mDirtyRoots already.
  while (aFrame && aFrame->HasAnyStateBits(NS_FRAME_HAS_DIRTY_CHILDREN)) {
    if ((aFrame->HasAnyStateBits(NS_FRAME_REFLOW_ROOT |
                                 NS_FRAME_DYNAMIC_REFLOW_ROOT) ||
         !aFrame->GetParent()) &&
        mDirtyRoots.Contains(aFrame)) {
      return;
    }

    aFrame = aFrame->GetParent();
  }

  MOZ_ASSERT_UNREACHABLE(
      "Frame has dirty bits set but isn't scheduled to be "
      "reflowed?");
#  endif
}
#endif

void PresShell::PostPendingScrollAnchorSelection(
    mozilla::layout::ScrollAnchorContainer* aContainer) {
  mPendingScrollAnchorSelection.Insert(aContainer->ScrollContainer());
}

void PresShell::FlushPendingScrollAnchorSelections() {
  for (ScrollContainerFrame* scroll : mPendingScrollAnchorSelection) {
    scroll->Anchor()->SelectAnchor();
  }
  mPendingScrollAnchorSelection.Clear();
}

void PresShell::PostPendingScrollAnchorAdjustment(
    ScrollAnchorContainer* aContainer) {
  mPendingScrollAnchorAdjustment.Insert(aContainer->ScrollContainer());
}

void PresShell::FlushPendingScrollAnchorAdjustments() {
  for (ScrollContainerFrame* scroll : mPendingScrollAnchorAdjustment) {
    scroll->Anchor()->ApplyAdjustments();
  }
  mPendingScrollAnchorAdjustment.Clear();
}

void PresShell::PostPendingScrollResnap(
    ScrollContainerFrame* aScrollContainerFrame) {
  mPendingScrollResnap.Insert(aScrollContainerFrame);
}

void PresShell::FlushPendingScrollResnap() {
  for (ScrollContainerFrame* scrollContainerFrame : mPendingScrollResnap) {
    scrollContainerFrame->TryResnap();
  }
  mPendingScrollResnap.Clear();
}

void PresShell::FrameNeedsReflow(nsIFrame* aFrame,
                                 IntrinsicDirty aIntrinsicDirty,
                                 nsFrameState aBitToAdd,
                                 ReflowRootHandling aRootHandling) {
  MOZ_ASSERT(aBitToAdd == NS_FRAME_IS_DIRTY ||
                 aBitToAdd == NS_FRAME_HAS_DIRTY_CHILDREN || !aBitToAdd,
             "Unexpected bits being added");

  // FIXME bug 478135
  NS_ASSERTION(
      aIntrinsicDirty != IntrinsicDirty::FrameAncestorsAndDescendants ||
          aBitToAdd != NS_FRAME_HAS_DIRTY_CHILDREN,
      "bits don't correspond to style change reason");

  // FIXME bug 457400
  NS_ASSERTION(!mIsReflowing, "can't mark frame dirty during reflow");

  // If we've not yet done the initial reflow, then don't bother
  // enqueuing a reflow command yet.
  if (!mDidInitialize) {
    return;
  }

  // If we're already destroying, don't bother with this either.
  if (mIsDestroying) {
    return;
  }

  AutoTArray<nsIFrame*, 4> subtrees;
  subtrees.AppendElement(aFrame);

  do {
    nsIFrame* subtreeRoot = subtrees.PopLastElement();

    // Grab |wasDirty| now so we can go ahead and update the bits on
    // subtreeRoot.
    bool wasDirty = subtreeRoot->IsSubtreeDirty();
    subtreeRoot->AddStateBits(aBitToAdd);

    // Determine whether we need to keep looking for the next ancestor
    // reflow root if subtreeRoot itself is a reflow root.
    bool targetNeedsReflowFromParent;
    switch (aRootHandling) {
      case ReflowRootHandling::PositionOrSizeChange:
        targetNeedsReflowFromParent = true;
        break;
      case ReflowRootHandling::NoPositionOrSizeChange:
        targetNeedsReflowFromParent = false;
        break;
      case ReflowRootHandling::InferFromBitToAdd:
        targetNeedsReflowFromParent = (aBitToAdd == NS_FRAME_IS_DIRTY);
        break;
    }

    auto FrameIsReflowRoot = [](const nsIFrame* aFrame) {
      return aFrame->HasAnyStateBits(NS_FRAME_REFLOW_ROOT |
                                     NS_FRAME_DYNAMIC_REFLOW_ROOT);
    };

    auto CanStopClearingAncestorIntrinsics = [&](const nsIFrame* aFrame) {
      return FrameIsReflowRoot(aFrame) && aFrame != subtreeRoot;
    };

    auto IsReflowBoundary = [&](const nsIFrame* aFrame) {
      return FrameIsReflowRoot(aFrame) &&
             (aFrame != subtreeRoot || !targetNeedsReflowFromParent);
    };

    // Mark the intrinsic widths as dirty on the frame, all of its ancestors,
    // and all of its descendants, if needed:

    if (aIntrinsicDirty != IntrinsicDirty::None) {
      // Mark argument and all ancestors dirty. (Unless we hit a reflow root
      // that should contain the reflow.
      for (nsIFrame* a = subtreeRoot;
           a && !CanStopClearingAncestorIntrinsics(a); a = a->GetParent()) {
        a->MarkIntrinsicISizesDirty();
        if (a->IsAbsolutelyPositioned()) {
          // If we get here, 'a' is abspos, so its subtree's intrinsic sizing
          // has no effect on its ancestors' intrinsic sizing. So, don't loop
          // upwards any further.
          break;
        }
      }
    }

    const bool frameAncestorAndDescendantISizesDirty =
        (aIntrinsicDirty == IntrinsicDirty::FrameAncestorsAndDescendants);
    const bool dirty = (aBitToAdd == NS_FRAME_IS_DIRTY);
    if (frameAncestorAndDescendantISizesDirty || dirty) {
      // Mark all descendants dirty (using an nsTArray stack rather than
      // recursion).
      // Note that ReflowInput::InitResizeFlags has some similar
      // code; see comments there for how and why it differs.
      AutoTArray<nsIFrame*, 32> stack;
      stack.AppendElement(subtreeRoot);

      do {
        nsIFrame* f = stack.PopLastElement();

        if (frameAncestorAndDescendantISizesDirty && f->IsPlaceholderFrame()) {
          // Call `GetOutOfFlowFrame` directly because we can get here from
          // frame destruction and the placeholder might be already torn down.
          if (nsIFrame* oof =
                  static_cast<nsPlaceholderFrame*>(f)->GetOutOfFlowFrame()) {
            if (!nsLayoutUtils::IsProperAncestorFrame(subtreeRoot, oof)) {
              // We have another distinct subtree we need to mark.
              subtrees.AppendElement(oof);
            }
          }
        }

        for (const auto& childList : f->ChildLists()) {
          for (nsIFrame* kid : childList.mList) {
            if (frameAncestorAndDescendantISizesDirty) {
              kid->MarkIntrinsicISizesDirty();
            }
            if (dirty) {
              kid->AddStateBits(NS_FRAME_IS_DIRTY);
            }
            stack.AppendElement(kid);
          }
        }
      } while (stack.Length() != 0);
    }

    // Skip setting dirty bits up the tree if we weren't given a bit to add.
    if (!aBitToAdd) {
      continue;
    }

    // Set NS_FRAME_HAS_DIRTY_CHILDREN bits (via nsIFrame::ChildIsDirty)
    // up the tree until we reach either a frame that's already dirty or
    // a reflow root.
    nsIFrame* f = subtreeRoot;
    for (;;) {
      if (IsReflowBoundary(f) || !f->GetParent()) {
        // we've hit a reflow root or the root frame
        if (!wasDirty) {
          mDirtyRoots.Add(f);
          SetNeedLayoutFlush();
        }
#ifdef DEBUG
        else {
          VerifyHasDirtyRootAncestor(f);
        }
#endif

        break;
      }

      nsIFrame* child = f;
      f = f->GetParent();
      wasDirty = f->IsSubtreeDirty();
      f->ChildIsDirty(child);
      NS_ASSERTION(f->HasAnyStateBits(NS_FRAME_HAS_DIRTY_CHILDREN),
                   "ChildIsDirty didn't do its job");
      if (wasDirty) {
        // This frame was already marked dirty.
#ifdef DEBUG
        VerifyHasDirtyRootAncestor(f);
#endif
        break;
      }
    }
  } while (subtrees.Length() != 0);

  EnsureLayoutFlush();
}

void PresShell::FrameNeedsToContinueReflow(nsIFrame* aFrame) {
  NS_ASSERTION(mIsReflowing, "Must be in reflow when marking path dirty.");
  MOZ_ASSERT(mCurrentReflowRoot, "Must have a current reflow root here");
  NS_ASSERTION(
      aFrame == mCurrentReflowRoot ||
          nsLayoutUtils::IsProperAncestorFrame(mCurrentReflowRoot, aFrame),
      "Frame passed in is not the descendant of mCurrentReflowRoot");
  NS_ASSERTION(aFrame->HasAnyStateBits(NS_FRAME_IN_REFLOW),
               "Frame passed in not in reflow?");

  mFramesToDirty.Insert(aFrame);
}

already_AddRefed<nsIContent> PresShell::GetContentForScrolling() const {
  if (nsCOMPtr<nsIContent> focused = GetFocusedContentInOurWindow()) {
    return focused.forget();
  }
  return GetSelectedContentForScrolling();
}

already_AddRefed<nsIContent> PresShell::GetSelectedContentForScrolling() const {
  nsCOMPtr<nsIContent> selectedContent;
  if (mSelection) {
    Selection& domSelection = mSelection->NormalSelection();
    selectedContent = nsIContent::FromNodeOrNull(domSelection.GetFocusNode());
  }
  return selectedContent.forget();
}

ScrollContainerFrame* PresShell::GetScrollContainerFrameToScrollForContent(
    nsIContent* aContent, ScrollDirections aDirections) {
  ScrollContainerFrame* scrollContainerFrame = nullptr;
  if (aContent) {
    nsIFrame* startFrame = aContent->GetPrimaryFrame();
    if (startFrame) {
      scrollContainerFrame = startFrame->GetScrollTargetFrame();
      if (scrollContainerFrame) {
        startFrame = scrollContainerFrame->GetScrolledFrame();
      }
      scrollContainerFrame =
          nsLayoutUtils::GetNearestScrollableFrameForDirection(startFrame,
                                                               aDirections);
    }
  }
  if (!scrollContainerFrame) {
    scrollContainerFrame = GetRootScrollContainerFrame();
    if (!scrollContainerFrame || !scrollContainerFrame->GetScrolledFrame()) {
      return nullptr;
    }
    scrollContainerFrame = nsLayoutUtils::GetNearestScrollableFrameForDirection(
        scrollContainerFrame->GetScrolledFrame(), aDirections);
  }
  return scrollContainerFrame;
}

ScrollContainerFrame* PresShell::GetScrollContainerFrameToScroll(
    ScrollDirections aDirections) {
  nsCOMPtr<nsIContent> content = GetContentForScrolling();
  return GetScrollContainerFrameToScrollForContent(content.get(), aDirections);
}

void PresShell::CancelAllPendingReflows() { mDirtyRoots.Clear(); }

static bool DestroyFramesAndStyleDataFor(
    Element* aElement, nsPresContext& aPresContext,
    RestyleManager::IncludeRoot aIncludeRoot) {
  bool didReconstruct =
      aPresContext.FrameConstructor()->DestroyFramesFor(aElement);
  RestyleManager::ClearServoDataFromSubtree(aElement, aIncludeRoot);
  return didReconstruct;
}

void PresShell::SlotAssignmentWillChange(Element& aElement,
                                         HTMLSlotElement* aOldSlot,
                                         HTMLSlotElement* aNewSlot) {
  MOZ_ASSERT(aOldSlot != aNewSlot);

  if (MOZ_UNLIKELY(!mDidInitialize)) {
    return;
  }

  // If the old slot is about to become empty and show fallback, let layout know
  // that it needs to do work.
  if (aOldSlot && aOldSlot->AssignedNodes().Length() == 1 &&
      aOldSlot->HasChildren()) {
    DestroyFramesForAndRestyle(aOldSlot);
  }

  // Ensure the new element starts off clean.
  DestroyFramesAndStyleDataFor(&aElement, *mPresContext,
                               RestyleManager::IncludeRoot::Yes);

  if (aNewSlot) {
    // If the new slot will stop showing fallback content, we need to reframe it
    // altogether.
    if (aNewSlot->AssignedNodes().IsEmpty() && aNewSlot->HasChildren()) {
      DestroyFramesForAndRestyle(aNewSlot);
      // Otherwise we just care about the element, but we need to ensure that
      // something takes care of traversing to the relevant slot, if needed.
    } else if (aNewSlot->HasServoData() &&
               !Servo_Element_IsDisplayNone(aNewSlot)) {
      // Set the reframe bits...
      aNewSlot->NoteDescendantsNeedFramesForServo();
      aElement.SetFlags(NODE_NEEDS_FRAME);
      // Now the style dirty bits. Note that we can't just do
      // aElement.NoteDirtyForServo(), because the new slot is not setup yet.
      aNewSlot->SetHasDirtyDescendantsForServo();
      aNewSlot->NoteDirtySubtreeForServo();
    }
  }
}

#ifdef DEBUG
static void AssertNoFramesOrStyleDataInDescendants(Element& aElement) {
  for (nsINode* node : ShadowIncludingTreeIterator(aElement)) {
    nsIContent* c = nsIContent::FromNode(node);
    if (c == &aElement) {
      continue;
    }
    // FIXME(emilio): The <area> check is needed because of bug 135040.
    MOZ_ASSERT(!c->GetPrimaryFrame() || c->IsHTMLElement(nsGkAtoms::area));
    MOZ_ASSERT(!c->IsElement() || !c->AsElement()->HasServoData());
  }
}
#endif

void PresShell::DestroyFramesForAndRestyle(Element* aElement) {
#ifdef DEBUG
  auto postCondition = MakeScopeExit([&]() {
    MOZ_ASSERT(!aElement->GetPrimaryFrame());
    AssertNoFramesOrStyleDataInDescendants(*aElement);
  });
#endif

  MOZ_ASSERT(aElement);
  if (!aElement->HasServoData()) {
    // Nothing to do here, the element already is out of the flat tree or is not
    // styled.
    return;
  }

  // Mark ourselves as not safe to flush while we're doing frame destruction.
  nsAutoScriptBlocker scriptBlocker;
  ++mChangeNestCount;

  const bool didReconstruct = FrameConstructor()->DestroyFramesFor(aElement);
  // Clear the style data from all the flattened tree descendants, but _not_
  // from us, since otherwise we wouldn't see the reframe.
  RestyleManager::ClearServoDataFromSubtree(aElement,
                                            RestyleManager::IncludeRoot::No);
  auto changeHint =
      didReconstruct ? nsChangeHint(0) : nsChangeHint_ReconstructFrame;
  mPresContext->RestyleManager()->PostRestyleEvent(
      aElement, RestyleHint::RestyleSubtree(), changeHint);

  --mChangeNestCount;
}

void PresShell::ShadowRootWillBeAttached(Element& aElement) {
#ifdef DEBUG
  auto postCondition = MakeScopeExit(
      [&]() { AssertNoFramesOrStyleDataInDescendants(aElement); });
#endif

  if (!aElement.HasServoData()) {
    // Nothing to do here, the element already is out of the flat tree or is not
    // styled.
    return;
  }

  if (!aElement.HasChildren()) {
    // The element has no children, just avoid the work.
    return;
  }

  // Mark ourselves as not safe to flush while we're doing frame destruction.
  nsAutoScriptBlocker scriptBlocker;
  ++mChangeNestCount;

  // NOTE(emilio): We use FlattenedChildIterator intentionally here (rather than
  // StyleChildrenIterator), since we don't want to remove ::before / ::after
  // content.
  FlattenedChildIterator iter(&aElement);
  nsCSSFrameConstructor* fc = FrameConstructor();
  for (nsIContent* c = iter.GetNextChild(); c; c = iter.GetNextChild()) {
    fc->DestroyFramesFor(c);
    if (c->IsElement()) {
      RestyleManager::ClearServoDataFromSubtree(c->AsElement());
    }
  }

#ifdef ACCESSIBILITY
  if (nsAccessibilityService* accService = GetAccService()) {
    accService->ScheduleAccessibilitySubtreeUpdate(this, &aElement);
  }
#endif

  --mChangeNestCount;
}

void PresShell::PostRecreateFramesFor(Element* aElement) {
  if (MOZ_UNLIKELY(!mDidInitialize)) {
    // Nothing to do here. In fact, if we proceed and aElement is the root, we
    // will crash.
    return;
  }

  mPresContext->RestyleManager()->PostRestyleEvent(
      aElement, RestyleHint{0}, nsChangeHint_ReconstructFrame);
}

void PresShell::RestyleForAnimation(Element* aElement, RestyleHint aHint) {
  // Now that we no longer have separate non-animation and animation
  // restyles, this method having a distinct identity is less important,
  // but it still seems useful to offer as a "more public" API and as a
  // checkpoint for these restyles to go through.
  mPresContext->RestyleManager()->PostRestyleEvent(aElement, aHint,
                                                   nsChangeHint(0));
}

void PresShell::SetForwardingContainer(const WeakPtr<nsDocShell>& aContainer) {
  mForwardingContainer = aContainer;
}

void PresShell::ClearFrameRefs(nsIFrame* aFrame) {
  mPresContext->EventStateManager()->ClearFrameRefs(aFrame);

  AutoWeakFrame* weakFrame = mAutoWeakFrames;
  while (weakFrame) {
    AutoWeakFrame* prev = weakFrame->GetPreviousWeakFrame();
    if (weakFrame->GetFrame() == aFrame) {
      // This removes weakFrame from mAutoWeakFrames.
      weakFrame->Clear(this);
    }
    weakFrame = prev;
  }

  AutoTArray<WeakFrame*, 4> toRemove;
  for (WeakFrame* weakFrame : mWeakFrames) {
    if (weakFrame->GetFrame() == aFrame) {
      toRemove.AppendElement(weakFrame);
    }
  }
  for (WeakFrame* weakFrame : toRemove) {
    weakFrame->Clear(this);
  }
}

UniquePtr<gfxContext> PresShell::CreateReferenceRenderingContext() {
  if (mPresContext->IsScreen()) {
    return gfxContext::CreateOrNull(
        gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget().get());
  }

  // We assume the devCtx has positive width and height for this call.
  // However, width and height, may be outside of the reasonable range
  // so rc may still be null.
  nsDeviceContext* devCtx = mPresContext->DeviceContext();
  return devCtx->CreateReferenceRenderingContext();
}

// https://html.spec.whatwg.org/#scroll-to-the-fragment-identifier
nsresult PresShell::GoToAnchor(const nsAString& aAnchorName,
                               const nsRange* aFirstTextDirective, bool aScroll,
                               ScrollFlags aAdditionalScrollFlags) {
  if (!mDocument) {
    return NS_ERROR_FAILURE;
  }

  if (mDocument->GetSVGRootElement()) {
    // We need to execute this even if there is an empty anchor name
    // so that any existing SVG fragment identifier effect is removed
    if (SVGFragmentIdentifier::ProcessFragmentIdentifier(mDocument,
                                                         aAnchorName)) {
      return NS_OK;
    }
  }

  // Hold a reference to the ESM in case event dispatch tears us down.
  RefPtr<EventStateManager> esm = mPresContext->EventStateManager();

  // https://wicg.github.io/scroll-to-text-fragment/#invoking-text-directives
  // From "Monkeypatching HTML § 7.4.6.3 Scrolling to a fragment:"
  // 3.4. If target is a range, then:
  // 3.4.1 Set target to be the first common ancestor of target's start node and
  //       end node.
  // 3.4.2 While target is non-null and is not an element, set target to
  //       target's parent.
  // ------
  // Common closest ancestor is not suitable here, as it can scroll to positions
  // where no text directive is visible. Instead, scroll to the start container
  // of the text directive.
  // see https://bugzil.la/1906895 and
  // https://github.com/WICG/scroll-to-text-fragment/issues/259
  Element* textFragmentTargetElement = [&aFirstTextDirective]() -> Element* {
    nsINode* node = aFirstTextDirective
                        ? aFirstTextDirective->GetStartContainer()
                        : nullptr;
    while (node && !node->IsElement()) {
      node = node->GetParent();
    }
    return Element::FromNodeOrNull(node);
  }();
  const bool thereIsATextFragment = !!textFragmentTargetElement;

  // 1. If there is no indicated part of the document, set the Document's target
  //    element to null.
  //
  // FIXME(emilio): Per spec empty fragment string should take the same
  // code-path as "top"!
  if (aAnchorName.IsEmpty() && !thereIsATextFragment) {
    NS_ASSERTION(!aScroll, "can't scroll to empty anchor name");
    esm->SetContentState(nullptr, ElementState::URLTARGET);
    return NS_OK;
  }

  // 2. If the indicated part of the document is the top of the document,
  // then:
  // (handled below when `target` is null, and anchor is `top`)

  // 3.1. Let target be element that is the indicated part of the document.
  //
  // https://html.spec.whatwg.org/#target-element
  // https://html.spec.whatwg.org/#find-a-potential-indicated-element
  RefPtr<Element> target = textFragmentTargetElement;
  if (!target) {
    target = nsContentUtils::GetTargetElement(mDocument, aAnchorName);
  }

  // 1. If there is no indicated part of the document, set the Document's
  //    target element to null.
  // 2.1. Set the Document's target element to null.
  // 3.2. Set the Document's target element to target.
  esm->SetContentState(target, ElementState::URLTARGET);

  if (target) {
    // 3.4 Run the ancestor revealing algorithm on target.
    ErrorResult rv;
    target->AncestorRevealingAlgorithm(rv);
    if (MOZ_UNLIKELY(rv.Failed())) {
      return rv.StealNSResult();
    }

    if (aScroll) {
      // https://wicg.github.io/scroll-to-text-fragment/#invoking-text-directives
      // From "Monkeypatching HTML § 7.4.6.3 Scrolling to a fragment:"
      // 3.9 Let blockPosition be "center" if scrollTarget is a range, "start"
      //     otherwise.
      // Implementation note: Use `ScrollSelectionIntoView` for text fragment,
      // since the text fragment is stored as a `eTargetText` selection.
      //
      // 3.4. Scroll target into view, with behavior set to "auto", block set to
      //      "auto", and inline set to "auto".
      // https://github.com/w3c/csswg-drafts/issues/9576
      // FIXME(emilio): Not all callers pass ScrollSmoothAuto (but we use auto
      // smooth scroll for `top` regardless below, so maybe they should!).
      ScrollingInteractionContext scrollToAnchorContext(true);
      if (thereIsATextFragment) {
        MOZ_TRY(ScrollSelectionIntoView(
            SelectionType::eTargetText,
            nsISelectionController::SELECTION_ANCHOR_REGION,
            AxisScrollParams(WhereToScroll::Center, WhenToScroll::Always),
            AxisScrollParams(WhereToScroll::Center, WhenToScroll::Always),
            ScrollFlags::AnchorScrollFlags | aAdditionalScrollFlags,
            SelectionScrollMode::SyncFlush));
      } else {
        MOZ_TRY(ScrollContentIntoView(
            target, AxisScrollParams(WhereToScroll::Auto, WhenToScroll::Always),
            AxisScrollParams(WhereToScroll::Auto),
            ScrollFlags::AnchorScrollFlags | aAdditionalScrollFlags));
      }
      if (ScrollContainerFrame* rootScroll = GetRootScrollContainerFrame()) {
        mLastAnchorScrolledTo = target;
        mLastAnchorScrollPositionY = rootScroll->GetScrollPosition().y;
        mLastAnchorScrollType = thereIsATextFragment
                                    ? AnchorScrollType::TextDirective
                                    : AnchorScrollType::Anchor;
      }
    }

    {
      // 3.6. Move the sequential focus navigation starting point to target.
      //
      // Move the caret to the anchor. That way tabbing will start from the new
      // location.
      //
      // TODO(emilio): Do we want to do this even if aScroll is false?
      //
      // NOTE: Intentionally out of order for now with the focus steps, see
      // https://github.com/whatwg/html/issues/7759
      RefPtr<nsRange> jumpToRange = nsRange::Create(mDocument);
      nsCOMPtr<nsIContent> nodeToSelect = target.get();
      while (nodeToSelect->GetFirstChild()) {
        nodeToSelect = nodeToSelect->GetFirstChild();
      }
      jumpToRange->SelectNodeContents(*nodeToSelect, IgnoreErrors());
      RefPtr sel = &mSelection->NormalSelection();
      MOZ_ASSERT(sel);
      sel->RemoveAllRanges(IgnoreErrors());
      sel->AddRangeAndSelectFramesAndNotifyListeners(*jumpToRange,
                                                     IgnoreErrors());
      if (!StaticPrefs::layout_selectanchor()) {
        // Use a caret (collapsed selection) at the start of the anchor.
        sel->CollapseToStart(IgnoreErrors());
      }
    }

    // 3.5. Run the focusing steps for target, with the Document's viewport as
    // the fallback target.
    //
    // Note that ScrollContentIntoView flushes, so we don't need to do that
    // again here. We also don't need to scroll again either.
    //
    // We intentionally focus the target only when aScroll is true, we need to
    // sort out if the spec needs to differentiate these cases. When aScroll is
    // false we still clear the focus unconditionally, that's legacy behavior,
    // maybe we shouldn't do it.
    //
    // TODO(emilio): Do we really want to clear the focus even if aScroll is
    // false?
    const bool shouldFocusTarget = [&] {
      if (!aScroll || thereIsATextFragment) {
        return false;
      }
      nsIFrame* targetFrame = target->GetPrimaryFrame();
      return targetFrame && targetFrame->IsFocusable();
    }();

    if (shouldFocusTarget) {
      FocusOptions options;
      options.mPreventScroll = true;
      target->Focus(options, CallerType::NonSystem, IgnoreErrors());
    } else if (RefPtr<nsIFocusManager> fm = nsFocusManager::GetFocusManager()) {
      if (nsPIDOMWindowOuter* win = mDocument->GetWindow()) {
        // Now focus the document itself if focus is on an element within it.
        nsCOMPtr<mozIDOMWindowProxy> focusedWindow;
        fm->GetFocusedWindow(getter_AddRefs(focusedWindow));
        if (SameCOMIdentity(win, focusedWindow)) {
          fm->ClearFocus(focusedWindow);
        }
      }
    }
    // The focusing stuff above could have set the previously-focused
    // content due to blurring the focused element.
    // However, we want focus navigation to start from the the selection
    // (which is now target), so we clear that here.
    mDocument->SetPreviouslyFocusedContent(nullptr);

    // If the target is an animation element, activate the animation
    if (auto* animationElement = SVGAnimationElement::FromNode(target.get())) {
      animationElement->ActivateByHyperlink();
    }

#ifdef ACCESSIBILITY
    if (nsAccessibilityService* accService = GetAccService()) {
      nsIContent* a11yTarget = target;
      if (thereIsATextFragment) {
        // A text fragment starts in a text leaf node. `target` is the element
        // parent, but there may be many other children of that element before
        // the start of the text fragment. Explicitly use the start leaf node
        // here to get a11y clients as close as possible to the fragment (on
        // platforms which support this).
        a11yTarget = nsIContent::FromNodeOrNull(
            aFirstTextDirective->GetStartContainer());
        if (!a11yTarget) {
          a11yTarget = target;
        }
      }
      accService->NotifyOfAnchorJumpTo(a11yTarget);
    }
#endif
  } else if (nsContentUtils::EqualsIgnoreASCIICase(aAnchorName, u"top"_ns)) {
    // 2.2. Scroll to the beginning of the document for the Document.
    ScrollContainerFrame* sf = GetRootScrollContainerFrame();
    // Check |aScroll| after setting |rv| so we set |rv| to the same
    // thing whether or not |aScroll| is true.
    if (aScroll && sf) {
      ScrollMode scrollMode = sf->ScrollModeForScrollBehavior();
      // Scroll to the top of the page
      sf->ScrollTo(nsPoint(0, 0), scrollMode);
    }
  } else {
    return NS_ERROR_FAILURE;
  }

  return NS_OK;
}

nsresult PresShell::ScrollToAnchor() {
  NS_ASSERTION(mDidInitialize, "should have done initial reflow by now");
  if (mLastAnchorScrollType == AnchorScrollType::Anchor) {
    nsCOMPtr<nsIContent> lastAnchor = std::move(mLastAnchorScrolledTo);
    if (!lastAnchor) {
      return NS_OK;
    }

    ScrollContainerFrame* rootScroll = GetRootScrollContainerFrame();
    if (!rootScroll ||
        mLastAnchorScrollPositionY != rootScroll->GetScrollPosition().y) {
      return NS_OK;
    }
    return ScrollContentIntoView(
        lastAnchor, AxisScrollParams(WhereToScroll::Auto, WhenToScroll::Always),
        AxisScrollParams(WhereToScroll::Auto), ScrollFlags::AnchorScrollFlags);
  }

  return ScrollSelectionIntoView(
      SelectionType::eTargetText,
      nsISelectionController::SELECTION_ANCHOR_REGION,
      AxisScrollParams(WhereToScroll::Center, WhenToScroll::Always),
      AxisScrollParams(WhereToScroll::Center, WhenToScroll::Always),
      ScrollFlags::AnchorScrollFlags, SelectionScrollMode::SyncFlush);
}

/*
 * Helper (per-continuation) for ScrollContentIntoView.
 *
 * @param aContainerFrame [in] the frame which aRect is relative to
 * @param aFrame [in] Frame whose bounds should be unioned
 * @param aUseWholeLineHeightForInlines [in] if true, then for inline frames
 * we should include the top of the line in the added rectangle
 * @param aRect [inout] rect into which its bounds should be unioned
 * @param aHaveRect [inout] whether aRect contains data yet
 * @param aPrevBlock [inout] the block aLines is a line iterator for
 * @param aLines [inout] the line iterator we're using
 * @param aCurLine [inout] the line to start looking from in this iterator
 */
static void AccumulateFrameBounds(nsIFrame* aContainerFrame, nsIFrame* aFrame,
                                  bool aUseWholeLineHeightForInlines,
                                  nsRect& aRect, bool& aHaveRect,
                                  nsIFrame*& aPrevBlock,
                                  nsILineIterator*& aLines, int32_t& aCurLine) {
  nsIFrame* frame = aFrame;
  nsRect frameBounds = nsRect(nsPoint(0, 0), aFrame->GetSize());

  // If this is an inline frame and either the bounds height is 0 (quirks
  // layout model) or aUseWholeLineHeightForInlines is set, we need to
  // change the top of the bounds to include the whole line.
  if (frameBounds.height == 0 || aUseWholeLineHeightForInlines) {
    nsIFrame* prevFrame = aFrame;
    nsIFrame* f = aFrame;

    while (f && f->IsLineParticipant() && !f->IsTransformed() &&
           !f->IsAbsPosContainingBlock()) {
      prevFrame = f;
      f = prevFrame->GetParent();
    }

    if (f != aFrame && f && f->IsBlockFrame()) {
      // find the line containing aFrame and increase the top of |offset|.
      if (f != aPrevBlock) {
        aLines = f->GetLineIterator();
        aPrevBlock = f;
        aCurLine = 0;
      }
      if (aLines) {
        int32_t index = aLines->FindLineContaining(prevFrame, aCurLine);
        if (index >= 0) {
          auto line = aLines->GetLine(index).unwrap();
          frameBounds += frame->GetOffsetTo(f);
          frame = f;
          if (line.mLineBounds.y < frameBounds.y) {
            frameBounds.height = frameBounds.YMost() - line.mLineBounds.y;
            frameBounds.y = line.mLineBounds.y;
          }
        }
      }
    }
  }

  nsRect transformedBounds = nsLayoutUtils::TransformFrameRectToAncestor(
      frame, frameBounds, aContainerFrame);

  if (aHaveRect) {
    // We can't use nsRect::UnionRect since it drops empty rects on
    // the floor, and we need to include them.  (Thus we need
    // aHaveRect to know when to drop the initial value on the floor.)
    aRect = aRect.UnionEdges(transformedBounds);
  } else {
    aHaveRect = true;
    aRect = transformedBounds;
  }
}

static bool ComputeNeedToScroll(WhenToScroll aWhenToScroll, nscoord aLineSize,
                                nscoord aRectMin, nscoord aRectMax,
                                nscoord aViewMin, nscoord aViewMax) {
  // See how the rect should be positioned in a given axis.
  switch (aWhenToScroll) {
    case WhenToScroll::Always:
      // The caller wants the frame as visible as possible
      return true;
    case WhenToScroll::IfNotVisible:
      if (aLineSize > (aRectMax - aRectMin)) {
        // If the line size is greater than the size of the rect
        // to scroll into view, do not use the line size to determine
        // if we need to scroll.
        aLineSize = 0;
      }

      // Scroll only if no part of the frame is visible in this view.
      return aRectMax - aLineSize <= aViewMin ||
             aRectMin + aLineSize >= aViewMax;
    case WhenToScroll::IfNotFullyVisible:
      // Scroll only if part of the frame is hidden and more can fit in view
      return !(aRectMin >= aViewMin && aRectMax <= aViewMax) &&
             std::min(aViewMax, aRectMax) - std::max(aRectMin, aViewMin) <
                 aViewMax - aViewMin;
  }
  return false;
}

static nscoord ComputeWhereToScroll(WhereToScroll aWhereToScroll,
                                    nscoord aOriginalCoord, nscoord aRectMin,
                                    nscoord aRectMax, nscoord aViewSize,
                                    nscoord aScrollMin, nscoord aScrollMax) {
  nscoord resultCoord = aOriginalCoord;
  if (!aWhereToScroll.mPercentage) {
    // Scroll the minimum amount necessary to show as much as possible of the
    // frame. If the frame is too large, don't hide any initially visible part
    // of it.
    nscoord min = std::min(aRectMin, aRectMax - aViewSize);
    nscoord max = std::max(aRectMin, aRectMax - aViewSize);
    resultCoord = std::clamp(aOriginalCoord, min, max);
  } else {
    float percent = aWhereToScroll.mPercentage.value() / 100.0f;
    nscoord frameAlignCoord =
        NSToCoordRound(aRectMin + (aRectMax - aRectMin) * percent);
    resultCoord = NSToCoordRound(frameAlignCoord - aViewSize * percent);
  }
  // Clamp scroll offset to the viable range.
  return std::clamp(resultCoord, aScrollMin, aScrollMax);
}

static WhereToScroll GetApplicableWhereToScroll(
    const ScrollContainerFrame* aScrollContainerFrame,
    const nsIFrame* aScrollableFrame, const nsIFrame* aTarget,
    ScrollDirection aScrollDirection, WhereToScroll aOriginal,
    WhereToScroll aAutoDefault) {
  MOZ_ASSERT(do_QueryFrame(aScrollContainerFrame) == aScrollableFrame);

  if (!aOriginal.mIsAuto) {
    return aOriginal;
  }

  if (aTarget == aScrollableFrame) {
    return aAutoDefault;
  }

  StyleScrollSnapAlignKeyword align =
      aScrollDirection == ScrollDirection::eHorizontal
          ? aScrollContainerFrame->GetScrollSnapAlignFor(aTarget).first
          : aScrollContainerFrame->GetScrollSnapAlignFor(aTarget).second;

  switch (align) {
    case StyleScrollSnapAlignKeyword::None:
      return aAutoDefault;
    case StyleScrollSnapAlignKeyword::Start:
      return WhereToScroll::Start;
    case StyleScrollSnapAlignKeyword::Center:
      return WhereToScroll::Center;
    case StyleScrollSnapAlignKeyword::End:
      return WhereToScroll::End;
  }
  return aAutoDefault;
}

static ScrollMode GetScrollModeForScrollIntoView(
    const ScrollContainerFrame* aScrollContainerFrame,
    ScrollFlags aScrollFlags) {
  // Default to an instant scroll, but if the scroll behavior given is "auto"
  // or "smooth", use that as the specified behavior. If the user has disabled
  // smooth scrolls, a given mode of "auto" or "smooth" should not result in
  // a smooth scroll.
  ScrollBehavior behavior = ScrollBehavior::Instant;
  if (aScrollFlags & ScrollFlags::ScrollSmooth) {
    behavior = ScrollBehavior::Smooth;
  } else if (aScrollFlags & ScrollFlags::ScrollSmoothAuto) {
    behavior = ScrollBehavior::Auto;
  }
  return aScrollContainerFrame->ScrollModeForScrollBehavior(behavior);
}

struct ScrollPointRange {
  nscoord mCoord;
  nscoord mMin;
  nscoord mMax;
};

static ScrollPointRange ComputeWhereToScrollAndRange(
    WhereToScroll aWhereToScroll, nscoord aOriginalCoord, nscoord aRectMin,
    nscoord aRectMax, nscoord aViewSize, nscoord aScrollMin,
    nscoord aScrollMax) {
  const auto coord =
      ComputeWhereToScroll(aWhereToScroll, aOriginalCoord, aRectMin, aRectMax,
                           aViewSize, aScrollMin, aScrollMax);

  const auto min = std::min(coord, aRectMax - aViewSize);
  const auto max = std::max(coord, aRectMin) - min;
  return ScrollPointRange{coord, min, max};
}

/**
 * This function takes a scroll container frame, a rect in the coordinate system
 * of the scrolled frame, and a desired percentage-based scroll
 * position and attempts to scroll the rect to that position in the
 * visual viewport.
 *
 * This needs to work even if aRect has a width or height of zero.
 */
static Maybe<nsPoint> ScrollToShowRect(
    ScrollContainerFrame* aScrollContainerFrame,
    const nsIFrame* aScrollableFrame, const nsIFrame* aTarget,
    const nsRect& aRect, const Sides aScrollPaddingSkipSides,
    const nsMargin& aMargin, AxisScrollParams aVertical,
    AxisScrollParams aHorizontal, ScrollFlags aScrollFlags,
    WhereToScroll aVerticalAutoDefault, WhereToScroll aHorizontalAutoDefault) {
  nsPoint scrollPt = aScrollContainerFrame->GetVisualViewportOffset();
  const nsPoint originalScrollPt = scrollPt;
  const nsRect visibleRect(scrollPt,
                           aScrollContainerFrame->GetVisualViewportSize());

  const nsMargin padding = [&] {
    nsMargin p = aScrollContainerFrame->GetScrollPadding();
    p.ApplySkipSides(aScrollPaddingSkipSides);
    return p + aMargin;
  }();

  const nsRect rectToScrollIntoView = [&] {
    nsRect r(aRect);
    r.Inflate(padding);
    return r.Intersect(aScrollContainerFrame->GetScrolledRect());
  }();

  nsSize lineSize;
  // Don't call GetLineScrollAmount unless we actually need it. Not only
  // does this save time, but it's not safe to call GetLineScrollAmount
  // during reflow (because it depends on font size inflation and doesn't
  // use the in-reflow-safe font-size inflation path). If we did call it,
  // it would assert and possible give the wrong result.
  if (aVertical.mWhenToScroll == WhenToScroll::IfNotVisible ||
      aHorizontal.mWhenToScroll == WhenToScroll::IfNotVisible) {
    lineSize = aScrollContainerFrame->GetLineScrollAmount();
  }
  ScrollStyles ss = aScrollContainerFrame->GetScrollStyles();
  nsRect scrollRange(scrollPt, nsSize(0, 0));
  const auto scrollConstraint = aScrollContainerFrame->GetVisualScrollRange();
  if ((aScrollFlags & ScrollFlags::ScrollOverflowHidden) ||
      ss.mVertical != StyleOverflow::Hidden) {
    if (ComputeNeedToScroll(aVertical.mWhenToScroll, lineSize.height, aRect.y,
                            aRect.YMost(), visibleRect.y + padding.top,
                            visibleRect.YMost() - padding.bottom)) {
      WhereToScroll whereToScroll = GetApplicableWhereToScroll(
          aScrollContainerFrame, aScrollableFrame, aTarget,
          ScrollDirection::eVertical, aVertical.mWhereToScroll,
          aVerticalAutoDefault);

      const auto result = ComputeWhereToScrollAndRange(
          whereToScroll, scrollPt.y, rectToScrollIntoView.y,
          rectToScrollIntoView.YMost(), visibleRect.height, scrollConstraint.y,
          scrollConstraint.YMost());
      scrollPt.y = result.mCoord;
      scrollRange.y = result.mMin;
      scrollRange.height = result.mMax;
    }
  }

  if ((aScrollFlags & ScrollFlags::ScrollOverflowHidden) ||
      ss.mHorizontal != StyleOverflow::Hidden) {
    if (ComputeNeedToScroll(aHorizontal.mWhenToScroll, lineSize.width, aRect.x,
                            aRect.XMost(), visibleRect.x + padding.left,
                            visibleRect.XMost() - padding.right)) {
      WhereToScroll whereToScroll = GetApplicableWhereToScroll(
          aScrollContainerFrame, aScrollableFrame, aTarget,
          ScrollDirection::eHorizontal, aHorizontal.mWhereToScroll,
          aHorizontalAutoDefault);

      const auto result = ComputeWhereToScrollAndRange(
          whereToScroll, scrollPt.x, rectToScrollIntoView.x,
          rectToScrollIntoView.XMost(), visibleRect.width, scrollConstraint.x,
          scrollConstraint.XMost());
      scrollPt.x = result.mCoord;
      scrollRange.x = result.mMin;
      scrollRange.width = result.mMax;
    }
  }

  // If we don't need to scroll, then don't try since it might cancel
  // a current smooth scroll operation.
  if (scrollPt == originalScrollPt) {
    return Nothing();
  }

  ScrollMode scrollMode =
      GetScrollModeForScrollIntoView(aScrollContainerFrame, aScrollFlags);
  nsIFrame* frame = do_QueryFrame(aScrollContainerFrame);
  AutoWeakFrame weakFrame(frame);
  aScrollContainerFrame->ScrollTo(scrollPt, scrollMode, &scrollRange,
                                  ScrollSnapFlags::IntendedEndPosition,
                                  aScrollFlags & ScrollFlags::TriggeredByScript
                                      ? ScrollTriggeredByScript::Yes
                                      : ScrollTriggeredByScript::No);
  return Some(scrollPt);
}

nsresult PresShell::ScrollContentIntoView(nsIContent* aContent,
                                          AxisScrollParams aVertical,
                                          AxisScrollParams aHorizontal,
                                          ScrollFlags aScrollFlags) {
  NS_ENSURE_TRUE(aContent, NS_ERROR_NULL_POINTER);
  RefPtr<Document> composedDoc = aContent->GetComposedDoc();
  NS_ENSURE_STATE(composedDoc);

  NS_ASSERTION(mDidInitialize, "should have done initial reflow by now");

  if (mContentToScrollTo) {
    mContentToScrollTo->RemoveProperty(nsGkAtoms::scrolling);
  }
  mContentToScrollTo = aContent;
  ScrollIntoViewData* data = new ScrollIntoViewData();
  data->mContentScrollVAxis = aVertical;
  data->mContentScrollHAxis = aHorizontal;
  data->mContentToScrollToFlags = aScrollFlags;
  if (NS_FAILED(mContentToScrollTo->SetProperty(
          nsGkAtoms::scrolling, data,
          nsINode::DeleteProperty<PresShell::ScrollIntoViewData>))) {
    mContentToScrollTo = nullptr;
  }

  // If the target frame has an ancestor of a `content-visibility: auto`
  // element ensure that it is laid out, so that the boundary rectangle is
  // correct.
  // Additionally, ensure that all ancestor elements with 'content-visibility:
  // auto' are set to 'visible'. so that they are laid out as visible before
  // scrolling, improving the accuracy of the scroll position, especially when
  // the scroll target is within the overflow area. And here invoking
  // 'SetTemporarilyVisibleForScrolledIntoViewDescendant' would make the
  // intersection observer knows that it should generate entries for these
  // c-v:auto ancestors, so that the content relevancy could be checked again
  // after scrolling. https://drafts.csswg.org/css-contain-2/#cv-notes
  bool reflowedForHiddenContent = false;
  if (mContentToScrollTo) {
    if (nsIFrame* frame = mContentToScrollTo->GetPrimaryFrame()) {
      bool hasContentVisibilityAutoAncestor = false;
      auto* ancestor = frame->GetClosestContentVisibilityAncestor(
          nsIFrame::IncludeContentVisibility::Auto);
      while (ancestor) {
        if (auto* element = Element::FromNodeOrNull(ancestor->GetContent())) {
          hasContentVisibilityAutoAncestor = true;
          element->SetTemporarilyVisibleForScrolledIntoViewDescendant(true);
          element->SetVisibleForContentVisibility(true);
        }
        ancestor = ancestor->GetClosestContentVisibilityAncestor(
            nsIFrame::IncludeContentVisibility::Auto);
      }
      if (hasContentVisibilityAutoAncestor) {
        UpdateHiddenContentInForcedLayout(frame);
        // TODO: There might be the other already scheduled relevancy updates,
        // other than caused be scrollIntoView.
        UpdateContentRelevancyImmediately(ContentRelevancyReason::Visible);
        reflowedForHiddenContent = ReflowForHiddenContentIfNeeded();
      }
    }
  }

  if (!reflowedForHiddenContent) {
    // Flush layout and attempt to scroll in the process.
    if (PresShell* presShell = composedDoc->GetPresShell()) {
      presShell->SetNeedLayoutFlush();
    }
    composedDoc->FlushPendingNotifications(FlushType::InterruptibleLayout);
  }

  // If mContentToScrollTo is non-null, that means we interrupted the reflow
  // (or suppressed it altogether because we're suppressing interruptible
  // flushes right now) and won't necessarily get the position correct, but do
  // a best-effort scroll here.  The other option would be to do this inside
  // FlushPendingNotifications, but I'm not sure the repeated scrolling that
  // could trigger if reflows keep getting interrupted would be more desirable
  // than a single best-effort scroll followed by one final scroll on the first
  // completed reflow.
  if (mContentToScrollTo) {
    DoScrollContentIntoView();
  }
  return NS_OK;
}

static nsMargin GetScrollMargin(const nsIFrame* aFrame) {
  MOZ_ASSERT(aFrame);
  // If we're focusing something that can't be targeted by content, allow
  // content to customize the margin.
  //
  // TODO: This is also a bit of an issue for delegated focus, see
  // https://github.com/whatwg/html/issues/7033.
  if (aFrame->GetContent() && aFrame->GetContent()->ChromeOnlyAccess()) {
    // XXX Should we use nsIContent::FindFirstNonChromeOnlyAccessContent()
    // instead of nsINode::GetClosestNativeAnonymousSubtreeRootParentOrHost()?
    if (const nsIContent* userContent =
            aFrame->GetContent()
                ->GetClosestNativeAnonymousSubtreeRootParentOrHost()) {
      if (const nsIFrame* frame = userContent->GetPrimaryFrame()) {
        return frame->StyleMargin()->GetScrollMargin();
      }
    }
  }
  return aFrame->StyleMargin()->GetScrollMargin();
}

void PresShell::DoScrollContentIntoView() {
  NS_ASSERTION(mDidInitialize, "should have done initial reflow by now");

  nsIFrame* frame = mContentToScrollTo->GetPrimaryFrame();

  if (!frame || frame->IsHiddenByContentVisibilityOnAnyAncestor(
                    nsIFrame::IncludeContentVisibility::Hidden)) {
    mContentToScrollTo->RemoveProperty(nsGkAtoms::scrolling);
    mContentToScrollTo = nullptr;
    return;
  }

  if (frame->HasAnyStateBits(NS_FRAME_FIRST_REFLOW)) {
    // The reflow flush before this scroll got interrupted, and this frame's
    // coords and size are all zero, and it has no content showing anyway.
    // Don't bother scrolling to it.  We'll try again when we finish up layout.
    return;
  }

  auto* data = static_cast<ScrollIntoViewData*>(
      mContentToScrollTo->GetProperty(nsGkAtoms::scrolling));
  if (MOZ_UNLIKELY(!data)) {
    mContentToScrollTo = nullptr;
    return;
  }

  ScrollFrameIntoView(frame, Nothing(), data->mContentScrollVAxis,
                      data->mContentScrollHAxis, data->mContentToScrollToFlags);
}

static bool NeedToVisuallyScroll(const nsSize& aLayoutViewportSize,
                                 const nsRect& aPositionFixedRect) {
  // position:fixed elements are fixed to the layout viewport, thus the
  // coordinate system is (0, 0) origin.
  // (and the maximum visible position is the layout viewport size, elements
  // outside of the size will never be laid out)
  const nsRect layoutViewport = nsRect(nsPoint(), aLayoutViewportSize);

  // `BaseRect::Intersects(const Sub& aRect)` does return false if `aRect` is
  // empty, but we do want to visually scroll to empty position:fixed elements
  // if the elements are inside the layout viewport.
  if (aPositionFixedRect.IsEmpty()) {
    if (aPositionFixedRect.x > layoutViewport.XMost() ||
        aPositionFixedRect.XMost() < layoutViewport.x ||
        aPositionFixedRect.y > layoutViewport.YMost() ||
        aPositionFixedRect.YMost() < layoutViewport.y) {
      return false;
    }
    return true;
  }

  if (!layoutViewport.Intersects(aPositionFixedRect)) {
    return false;
  }
  return true;
}

void PresShell::ScrollFrameIntoVisualViewport(
    Maybe<nsPoint>& aDestination, const nsRect& aPositionFixedRect,
    const nsIFrame* aPositionFixedFrame, AxisScrollParams aVertical,
    AxisScrollParams aHorizontal, ScrollFlags aScrollFlags) {
  PresShell* root = GetRootPresShell();
  if (!root) {
    return;
  }

  if (!root->GetPresContext()->IsRootContentDocumentCrossProcess()) {
    return;
  }

  ScrollContainerFrame* rootScrollContainer =
      root->GetRootScrollContainerFrame();
  if (!rootScrollContainer) {
    return;
  }

  if (!aDestination) {
    MOZ_ASSERT(aPositionFixedFrame);
    // If we have in the top level content document but we didn't reach to
    // the root scroll container in the frame tree walking up loop in
    // ScrollFrameIntoView, it means the target element is inside a
    // position:fixed subtree.
    if (!StaticPrefs::layout_scroll_fixed_content_into_view_visually()) {
      return;
    }

    const nsSize visualViewportSize =
        rootScrollContainer->GetVisualViewportSize();

    const nsSize layoutViewportSize = root->GetLayoutViewportSize();
    const nsRect layoutViewport = nsRect(nsPoint(), layoutViewportSize);
    // `positon:fixed` element are attached/fixed to the ViewportFrame, which is
    // the parent of the root scroll container frame, thus what we need here is
    // the visible area of the position:fixed element inside the root scroll
    // container frame.
    // For example, if the top left position of the fixed element is (-100,
    // -100), it's outside of the scrollable range either in the layout viewport
    // or the visual viewport. Likewise, if the right bottom position of the
    // fixed element is (110vw, 110vh), it's also outside of the scrollable
    // range.
    // If the position:fixed element is totally outside of the layout viewport,
    // it will never be in the viewport.
    if (!NeedToVisuallyScroll(layoutViewportSize, aPositionFixedRect)) {
      return;
    }

    // If the position:fixed element is already in the visual viewport, no
    // visual scroll is needed. Convert to layout coordinates first since the
    // visual viewport may have been panned from the origin.
    nsRect clampedPositionFixedRect =
        aPositionFixedRect.MoveInsideAndClamp(layoutViewport);
    nsPoint layoutOffset = rootScrollContainer->GetScrollPosition();
    clampedPositionFixedRect.MoveBy(layoutOffset);
    const nsRect visualViewport(GetVisualViewportOffset(), visualViewportSize);
    // Use Contains(point) twice rather than Contains(rect) because the latter
    // returns true for empty rects regardless of position.
    if (visualViewport.Contains(clampedPositionFixedRect.TopLeft()) &&
        visualViewport.Contains(clampedPositionFixedRect.BottomRight())) {
      return;
    }
    // Offset the position:fixed element position by the layout scroll
    // position because the position:fixed origin (0, 0) is the layout scroll
    // position. Otherwise if we've already scrolled, this scrollIntoView
    // operation will jump back to near (0, 0) position.
    const auto scrollRange = rootScrollContainer->GetVisualScrollRange();

    const nsRect visibleRect(layoutOffset, visualViewportSize);
    nscoord x = ComputeWhereToScroll(
        aScrollFlags & ScrollFlags::ForZoomToFocusedInput
            ? WhereToScroll::Nearest
            : aHorizontal.mWhereToScroll,
        layoutOffset.x, aPositionFixedRect.x, aPositionFixedRect.XMost(),
        visibleRect.width, scrollRange.x, scrollRange.XMost());
    nscoord y = ComputeWhereToScroll(
        aScrollFlags & ScrollFlags::ForZoomToFocusedInput
            ? WhereToScroll::Nearest
            : aVertical.mWhereToScroll,
        layoutOffset.y, aPositionFixedRect.y, aPositionFixedRect.YMost(),
        visibleRect.height, scrollRange.y, scrollRange.YMost());

    layoutOffset.x += x;
    layoutOffset.y += y;
    aDestination = Some(layoutOffset);
  }

  // NOTE: It seems chrome doesn't respect the root element's
  // scroll-behavior for visual scrolling.
  ScrollMode scrollMode =
      GetScrollModeForScrollIntoView(rootScrollContainer, aScrollFlags);
  root->ScrollToVisual(*aDestination, ScrollOffsetUpdateType::MainThread,
                       scrollMode);
}

bool PresShell::ScrollFrameIntoView(
    nsIFrame* aTargetFrame, const Maybe<nsRect>& aKnownRectRelativeToTarget,
    AxisScrollParams aVertical, AxisScrollParams aHorizontal,
    ScrollFlags aScrollFlags) {
  // If the AxesAreLogical flag is set, the aVertical and aHorizontal params
  // actually refer to block and inline axes respectively, so we resolve them
  // to physical axes/directions here.
  // XXX Maybe we should convert more of the following code to logical axes,
  // if it's convenient for more callers to work that way?

  // The default of WhereToScroll for physical vertical/horizontal axes:
  // block-start (top) and inline-nearest respectively, matching the spec for
  // horizontal writing modes. These are overridden below when AxesAreLogical is
  // set.
  WhereToScroll verticalAutoDefault = WhereToScroll::Start;
  WhereToScroll horizontalAutoDefault = WhereToScroll::Nearest;

  if (aScrollFlags & ScrollFlags::AxesAreLogical) {
    // The aVertical parameter actually refers to the element's block axis,
    // and aHorizontal to its inline axis. Potentially reverse/swap them,
    // according to its writing mode and directionality.
    WritingMode wm = aTargetFrame->GetWritingMode();
    if (wm.IsVerticalRL()) {
      // Reverse the block-axis percentage.
      if (aVertical.mWhereToScroll.mPercentage) {
        aVertical.mWhereToScroll.mPercentage =
            Some(100 - aVertical.mWhereToScroll.mPercentage.value());
      }
    }
    if (wm.IsInlineReversed()) {
      // Reverse the inline-axis percentage.
      if (aHorizontal.mWhereToScroll.mPercentage) {
        aHorizontal.mWhereToScroll.mPercentage =
            Some(100 - aHorizontal.mWhereToScroll.mPercentage.value());
      }
    }
    if (wm.IsVertical()) {
      std::swap(aVertical, aHorizontal);

      // After the swap, physical vertical = inline and physical horizontal =
      // block for vertical writing modes. Compute auto defaults accordingly.
      verticalAutoDefault = WhereToScroll::Nearest;
      horizontalAutoDefault = wm.IsVerticalRL()
                                  ? WhereToScroll{WhereToScroll::End}
                                  : WhereToScroll{WhereToScroll::Start};
    }
    // Remove the AxesAreLogical flag, to make it clear that methods we call
    // always get physical axes from here on.
    aScrollFlags &= ~ScrollFlags::AxesAreLogical;
  }

  // The scroll margin only applies to the whole bounds of the element, so don't
  // apply it if we get an arbitrary rect / point to scroll to.
  const nsMargin scrollMargin =
      aKnownRectRelativeToTarget ? nsMargin() : GetScrollMargin(aTargetFrame);

  Sides skipPaddingSides;
  const auto MaybeSkipPaddingSides = [&](nsIFrame* aFrame) {
    if (!aFrame->IsStickyPositioned()) {
      return;
    }
    const nsPoint pos = aFrame->GetPosition();
    const nsPoint normalPos = aFrame->GetNormalPosition();
    if (pos == normalPos) {
      return;  // Frame is not stuck.
    }
    // If we're targetting a sticky element, make sure not to apply
    // scroll-padding on the direction we're stuck.
    const auto* stylePosition = aFrame->StylePosition();
    const auto anchorResolutionParams =
        AnchorPosOffsetResolutionParams::UseCBFrameSize(
            AnchorPosResolutionParams::From(aFrame));
    for (auto side : AllPhysicalSides()) {
      if (stylePosition->GetAnchorResolvedInset(side, anchorResolutionParams)
              ->IsAuto()) {
        continue;
      }
      // See if this axis is stuck.
      const bool yAxis = side == eSideTop || side == eSideBottom;
      const bool stuck = yAxis ? pos.y != normalPos.y : pos.x != normalPos.x;
      if (!stuck) {
        continue;
      }
      skipPaddingSides |= SideToSideBit(side);
    }
  };

  nsIFrame* container = aTargetFrame;

  const nsIFrame* positionFixedFrame = nullptr;
  auto isPositionFixed = [&](const nsIFrame* aFrame) -> bool {
    return aFrame->StyleDisplay()->mPosition == StylePositionProperty::Fixed &&
           nsLayoutUtils::IsReallyFixedPos(aFrame);
  };
  // This function needs to work even if rect has a width or height of 0.
  nsRect rect = [&] {
    if (aKnownRectRelativeToTarget) {
      return *aKnownRectRelativeToTarget;
    }
    MaybeSkipPaddingSides(aTargetFrame);
    while (nsIFrame* parent = container->GetParent()) {
      if (isPositionFixed(container)) {
        positionFixedFrame = container;
      }
      container = parent;
      if (container->IsScrollContainerOrSubclass()) {
        // We really just need a non-fragmented frame so that we can accumulate
        // the bounds of all our continuations relative to it. We shouldn't jump
        // out of our nearest scrollable frame, and that's an ok reference
        // frame, so try to use that, or the root frame if there's nothing to
        // scroll in this document.
        break;
      }
      MaybeSkipPaddingSides(container);
    }
    MOZ_DIAGNOSTIC_ASSERT(container);

    nsRect targetFrameBounds;
    {
      bool haveRect = false;
      const bool useWholeLineHeightForInlines =
          aVertical.mWhenToScroll != WhenToScroll::IfNotFullyVisible;
      AutoAssertNoDomMutations
          guard;  // Ensure use of nsILineIterators is safe.
      nsIFrame* prevBlock = nullptr;
      // Reuse the same line iterator across calls to AccumulateFrameBounds.
      // We set it every time we detect a new block (stored in prevBlock).
      nsILineIterator* lines = nullptr;
      // The last line we found a continuation on in |lines|.  We assume that
      // later continuations cannot come on earlier lines.
      int32_t curLine = 0;
      nsIFrame* frame = aTargetFrame;
      do {
        AccumulateFrameBounds(container, frame, useWholeLineHeightForInlines,
                              targetFrameBounds, haveRect, prevBlock, lines,
                              curLine);
      } while ((frame = frame->GetNextContinuation()));
    }

    return targetFrameBounds;
  }();
  bool didScroll = false;
  const nsIFrame* target = aTargetFrame;
  Maybe<nsPoint> rootScrollDestination;
  // Walk up the frame hierarchy scrolling the rect into view and
  // keeping rect relative to container
  do {
    if (isPositionFixed(container)) {
      positionFixedFrame = container;
    }

    if (ScrollContainerFrame* sf = do_QueryFrame(container)) {
      nsPoint oldPosition = sf->GetScrollPosition();
      nsRect targetRect = rect - sf->GetScrolledFrame()->GetPosition();

      {
        AutoWeakFrame wf(container);
        Maybe<nsPoint> destination = ScrollToShowRect(
            sf, container, target, targetRect, skipPaddingSides, scrollMargin,
            aVertical, aHorizontal, aScrollFlags, verticalAutoDefault,
            horizontalAutoDefault);
        if (!wf.IsAlive()) {
          return didScroll;
        }

        if (sf->IsRootScrollFrameOfDocument() &&
            sf->PresContext()->IsRootContentDocumentCrossProcess()) {
          rootScrollDestination = destination;
        }
      }

      nsPoint newPosition = sf->LastScrollDestination();
      // If the scroll position increased, that means our content moved up,
      // so our rect's offset should decrease
      rect += oldPosition - newPosition;

      if (oldPosition != newPosition) {
        didScroll = true;
      }

      // only scroll one container when this flag is set
      if (aScrollFlags & ScrollFlags::ScrollFirstAncestorOnly) {
        break;
      }

      // This scroll container will be the next target element in the nearest
      // ancestor scroll container.
      target = container;
      // We found a sticky scroll container, we shouldn't skip that side
      // anymore.
      skipPaddingSides = {};
    }

    MaybeSkipPaddingSides(container);

    nsIFrame* parent = container->GetParent();
    NS_ASSERTION(parent || !container->IsTransformed(),
                 "viewport shouldnt be transformed");
    if (parent && container->IsTransformed()) {
      rect =
          nsLayoutUtils::TransformFrameRectToAncestor(container, rect, parent);
    } else {
      rect += container->GetPosition();
    }
    if (!parent && !(aScrollFlags & ScrollFlags::ScrollNoParentFrames)) {
      nsPoint extraOffset(0, 0);
      int32_t APD = container->PresContext()->AppUnitsPerDevPixel();
      parent = nsLayoutUtils::GetCrossDocParentFrameInProcess(container,
                                                              &extraOffset);
      if (parent) {
        int32_t parentAPD = parent->PresContext()->AppUnitsPerDevPixel();
        rect = rect.ScaleToOtherAppUnitsRoundOut(APD, parentAPD);
        rect += extraOffset;
      } else {
        nsCOMPtr<nsIDocShell> docShell =
            container->PresContext()->GetDocShell();
        if (BrowserChild* browserChild = BrowserChild::GetFrom(docShell)) {
          // Defer to the parent document if this is an out-of-process iframe.
          (void)browserChild->SendScrollRectIntoView(
              rect, aVertical, aHorizontal, aScrollFlags, APD);
        }
      }
    }
    container = parent;
  } while (container);

  // If this is inside the top level content document process (and a direct
  // descendant of it), also call ScrollToVisual() since we want to
  // scroll the rect into view visually, and that may require scrolling
  // the visual viewport in scenarios where there is not enough layout
  // scroll range.
  if (!rootScrollDestination && !positionFixedFrame) {
    return didScroll;
  }

  ScrollFrameIntoVisualViewport(rootScrollDestination, rect, positionFixedFrame,
                                aVertical, aHorizontal, aScrollFlags);

  return didScroll;
}

void PresShell::SchedulePaint() {
  if (MOZ_UNLIKELY(mIsDestroying)) {
    return;
  }
  if (nsPresContext* presContext = GetPresContext()) {
    presContext->RefreshDriver()->SchedulePaint();
  }
}

void PresShell::ClearMouseCapture() {
  ReleaseCapturingContent();
  AllowMouseCapture(false);
}

void PresShell::ClearMouseCapture(nsIFrame* aFrame) {
  MOZ_ASSERT(aFrame);

  nsIContent* capturingContent = GetCapturingContent();
  if (!capturingContent) {
    return;
  }

  nsIFrame* capturingFrame = capturingContent->GetPrimaryFrame();
  const bool shouldClear =
      !capturingFrame ||
      nsLayoutUtils::IsAncestorFrameCrossDocInProcess(aFrame, capturingFrame);
  if (shouldClear) {
    ClearMouseCapture();
  }
}

nsresult PresShell::CaptureHistoryState(nsILayoutHistoryState** aState) {
  MOZ_ASSERT(nullptr != aState, "null state pointer");

  // We actually have to mess with the docshell here, since we want to
  // store the state back in it.
  // XXXbz this isn't really right, since this is being called in the
  // content viewer's Hide() method...  by that point the docshell's
  // state could be wrong.  We should sort out a better ownership
  // model for the layout history state.
  nsCOMPtr<nsIDocShell> docShell(mPresContext->GetDocShell());
  if (!docShell) {
    return NS_ERROR_FAILURE;
  }

  nsCOMPtr<nsILayoutHistoryState> historyState;
  docShell->GetLayoutHistoryState(getter_AddRefs(historyState));
  if (!historyState) {
    // Create the document state object
    historyState = NS_NewLayoutHistoryState();
    docShell->SetLayoutHistoryState(historyState);
  }

  *aState = historyState;
  NS_IF_ADDREF(*aState);

  // Capture frame state for the entire frame hierarchy
  nsIFrame* rootFrame = mFrameConstructor->GetRootFrame();
  if (!rootFrame) {
    return NS_OK;
  }

  mFrameConstructor->CaptureFrameState(rootFrame, historyState);

  return NS_OK;
}

void PresShell::ScheduleBeforeFirstPaint() {
  if (!mDocument->IsResourceDoc()) {
    // Notify observers that a new page is about to be drawn. Execute this
    // as soon as it is safe to run JS, which is guaranteed to be before we
    // go back to the event loop and actually draw the page.
    MOZ_LOG(gLog, LogLevel::Debug,
            ("PresShell::ScheduleBeforeFirstPaint this=%p", this));

    nsContentUtils::AddScriptRunner(
        MakeAndAddRef<nsBeforeFirstPaintDispatcher>(mDocument));
  }
}

void PresShell::UnsuppressAndInvalidate() {
  // Note: We ignore the EnsureVisible check for resource documents, because
  // they won't have a docshell, so they'll always fail EnsureVisible.
  if ((!mDocument->IsResourceDoc() && !mPresContext->EnsureVisible()) ||
      mHaveShutDown) {
    // No point; we're about to be torn down anyway.
    return;
  }

  ScheduleBeforeFirstPaint();

  mDocument->MaybeScheduleRenderingPhases({RenderingPhase::Reveal});

  PROFILER_MARKER_UNTYPED("UnsuppressAndInvalidate", GRAPHICS);

  mPaintingSuppressed = false;
  if (nsIFrame* rootFrame = mFrameConstructor->GetRootFrame()) {
    // let's assume that outline on a root frame is not supported
    rootFrame->InvalidateFrame();
  }

  if (mPresContext->IsRootContentDocumentCrossProcess()) {
    if (auto* bc = BrowserChild::GetFrom(mDocument->GetDocShell())) {
      if (mDocument->IsInitialDocument()) {
        bc->SendDidUnsuppressPaintingNormalPriority();
      } else {
        bc->SendDidUnsuppressPainting();
      }
    }
  }

  // now that painting is unsuppressed, focus may be set on the document
  if (nsPIDOMWindowOuter* win = mDocument->GetWindow()) {
    win->SetReadyForFocus();
  }

  if (!mHaveShutDown) {
    SynthesizeMouseMove(false);
    ScheduleApproximateFrameVisibilityUpdateNow();
  }
}

void PresShell::CancelPaintSuppressionTimer() {
  if (mPaintSuppressionTimer) {
    mPaintSuppressionTimer->Cancel();
    mPaintSuppressionTimer = nullptr;
  }
}

void PresShell::UnsuppressPainting() {
  CancelPaintSuppressionTimer();

  if (mIsDocumentGone || !mPaintingSuppressed) {
    return;
  }

  // If we have reflows pending, just wait until we process
  // the reflows and get all the frames where we want them
  // before actually unlocking the painting.  Otherwise
  // go ahead and unlock now.
  if (!mDirtyRoots.IsEmpty()) {
    mShouldUnsuppressPainting = true;
  } else {
    UnsuppressAndInvalidate();
  }
}

// Post a request to handle an arbitrary callback after reflow has finished.
nsresult PresShell::PostReflowCallback(nsIReflowCallback* aCallback) {
  void* result = AllocateByObjectID(eArenaObjectID_nsCallbackEventRequest,
                                    sizeof(nsCallbackEventRequest));
  nsCallbackEventRequest* request = (nsCallbackEventRequest*)result;

  request->callback = aCallback;
  request->next = nullptr;

  if (mLastCallbackEventRequest) {
    mLastCallbackEventRequest = mLastCallbackEventRequest->next = request;
  } else {
    mFirstCallbackEventRequest = request;
    mLastCallbackEventRequest = request;
  }

  return NS_OK;
}

void PresShell::CancelReflowCallback(nsIReflowCallback* aCallback) {
  nsCallbackEventRequest* before = nullptr;
  nsCallbackEventRequest* node = mFirstCallbackEventRequest;
  while (node) {
    nsIReflowCallback* callback = node->callback;

    if (callback == aCallback) {
      nsCallbackEventRequest* toFree = node;
      if (node == mFirstCallbackEventRequest) {
        node = node->next;
        mFirstCallbackEventRequest = node;
        NS_ASSERTION(before == nullptr, "impossible");
      } else {
        node = node->next;
        before->next = node;
      }

      if (toFree == mLastCallbackEventRequest) {
        mLastCallbackEventRequest = before;
      }

      FreeByObjectID(eArenaObjectID_nsCallbackEventRequest, toFree);
    } else {
      before = node;
      node = node->next;
    }
  }
}

void PresShell::CancelPostedReflowCallbacks() {
  while (mFirstCallbackEventRequest) {
    nsCallbackEventRequest* node = mFirstCallbackEventRequest;
    mFirstCallbackEventRequest = node->next;
    if (!mFirstCallbackEventRequest) {
      mLastCallbackEventRequest = nullptr;
    }
    nsIReflowCallback* callback = node->callback;
    FreeByObjectID(eArenaObjectID_nsCallbackEventRequest, node);
    if (callback) {
      callback->ReflowCallbackCanceled();
    }
  }
}

void PresShell::HandlePostedReflowCallbacks(bool aInterruptible) {
  while (true) {
    // Call all our callbacks, tell us if we need to flush again.
    bool shouldFlush = false;
    while (mFirstCallbackEventRequest) {
      nsCallbackEventRequest* node = mFirstCallbackEventRequest;
      mFirstCallbackEventRequest = node->next;
      if (!mFirstCallbackEventRequest) {
        mLastCallbackEventRequest = nullptr;
      }
      nsIReflowCallback* callback = node->callback;
      FreeByObjectID(eArenaObjectID_nsCallbackEventRequest, node);
      if (callback && callback->ReflowFinished()) {
        shouldFlush = true;
      }
    }

    if (!shouldFlush || mIsDestroying) {
      return;
    }

    // The flush might cause us to have more callbacks.
    const auto flushType =
        aInterruptible ? FlushType::InterruptibleLayout : FlushType::Layout;
    FlushPendingNotifications(flushType);
  }
}

bool PresShell::IsSafeToFlush() const {
  // Not safe if we are getting torn down, reflowing, or in the middle of frame
  // construction.
  if (mIsReflowing || mChangeNestCount || mIsDestroying) {
    return false;
  }
  // Not safe either if we're painting.
  // TODO(emilio): What could call us while painting now?
  return !mIsPainting;
}

void PresShell::NotifyFontFaceSetOnRefresh() {
  if (FontFaceSet* set = mDocument->GetFonts()) {
    set->DidRefresh();
  }
}

void PresShell::DoFlushPendingNotifications(FlushType aType) {
  // by default, flush animations if aType >= FlushType::Style
  mozilla::ChangesToFlush flush(aType, aType >= FlushType::Style,
                                aType >= FlushType::Layout);
  FlushPendingNotifications(flush);
}

#ifdef DEBUG
static void AssertFrameSubtreeIsSane(const nsIFrame& aRoot) {
  if (const nsIContent* content = aRoot.GetContent()) {
    MOZ_ASSERT(content->GetFlattenedTreeParentNodeForStyle(),
               "Node not in the flattened tree still has a frame?");
  }

  for (const auto& childList : aRoot.ChildLists()) {
    for (const nsIFrame* child : childList.mList) {
      AssertFrameSubtreeIsSane(*child);
    }
  }
}
#endif

static inline void AssertFrameTreeIsSane(const PresShell& aPresShell) {
#ifdef DEBUG
  if (const nsIFrame* root = aPresShell.GetRootFrame()) {
    AssertFrameSubtreeIsSane(*root);
  }
#endif
}

void PresShell::DoFlushPendingNotifications(mozilla::ChangesToFlush aFlush) {
  // FIXME(emilio, bug 1530177): Turn into a release assert when bug 1530188 and
  // bug 1530190 are fixed.
  MOZ_DIAGNOSTIC_ASSERT(!mForbiddenToFlush, "This is bad!");

  // Per our API contract, hold a strong ref to ourselves until we return.
  RefPtr<PresShell> kungFuDeathGrip = this;

  /**
   * VERY IMPORTANT: If you add some sort of new flushing to this
   * method, make sure to add the relevant SetNeedLayoutFlush or
   * SetNeedStyleFlush calls on the shell.
   */
  FlushType flushType = aFlush.mFlushType;

  if (aFlush.mUpdateRelevancy) {
    // If needed, first update the relevancy of any content of elements with
    // `content-visibility: auto` so that the values returned from e.g. script
    // queries are up-to-date.
    UpdateRelevancyOfContentVisibilityAutoFrames();
  }

  MOZ_ASSERT(NeedFlush(flushType), "Why did we get called?");

  AUTO_PROFILER_MARKER_TEXT(
      "DoFlushPendingNotifications", LAYOUT,
      MarkerOptions(MarkerStack::Capture(), MarkerInnerWindowIdFromDocShell(
                                                mPresContext->GetDocShell())),
      nsDependentCString(kFlushTypeNames[flushType]));
  AUTO_PROFILER_LABEL_DYNAMIC_CSTR_NONSENSITIVE(
      "PresShell::DoFlushPendingNotifications", LAYOUT,
      kFlushTypeNames[flushType]);

#ifdef ACCESSIBILITY
#  ifdef DEBUG
  if (nsAccessibilityService* accService = GetAccService()) {
    NS_ASSERTION(!accService->IsProcessingRefreshDriverNotification(),
                 "Flush during accessible tree update!");
  }
#  endif
#endif

  NS_ASSERTION(flushType >= FlushType::Style, "Why did we get called?");

  bool isSafeToFlush = IsSafeToFlush();

  // If layout could possibly trigger scripts, then it's only safe to flush if
  // it's safe to run script.
  bool hasHadScriptObject;
  if (mDocument->GetScriptHandlingObject(hasHadScriptObject) ||
      hasHadScriptObject) {
    isSafeToFlush = isSafeToFlush && nsContentUtils::IsSafeToRunScript();
  }

  // Don't flush if the doc is already in the bfcache.
  if (MOZ_UNLIKELY(mDocument->GetPresShell() != this)) {
    MOZ_DIAGNOSTIC_ASSERT(!mDocument->GetPresShell(),
                          "Where did this shell come from?");
    isSafeToFlush = false;
  }

  MOZ_DIAGNOSTIC_ASSERT(!mIsDestroying || !isSafeToFlush);
  MOZ_DIAGNOSTIC_ASSERT(mIsDestroying || mWidgetListener);
  MOZ_DIAGNOSTIC_ASSERT(mIsDestroying || mDocument->HasShellOrBFCacheEntry());

  if (!isSafeToFlush) {
    return;
  }

  // We need to make sure external resource documents are flushed too (for
  // example, svg filters that reference a filter in an external document
  // need the frames in the external document to be constructed for the
  // filter to work). We only need external resources to be flushed when the
  // main document is flushing >= FlushType::Frames, so we flush external
  // resources here instead of Document::FlushPendingNotifications.
  mDocument->FlushExternalResources(flushType);

  // Force flushing of any pending content notifications that might have
  // queued up while our event was pending.  That will ensure that we don't
  // construct frames for content right now that's still waiting to be
  // notified on,
  mDocument->FlushPendingNotifications(FlushType::ContentAndNotify);

  mDocument->UpdateSVGUseElementShadowTrees();

  // Process pending restyles, since any flush of the presshell wants
  // up-to-date style data.
  if (MOZ_LIKELY(!mIsDestroying)) {
    FlushDelayedResize();
    mPresContext->FlushPendingMediaFeatureValuesChanged();
  }

  if (MOZ_LIKELY(!mIsDestroying)) {
    // Now that we have flushed media queries, update the rules before looking
    // up @font-face / @counter-style / @font-feature-values rules.
    StyleSet()->UpdateStylistIfNeeded();

    // Flush any pending update of the user font set, since that could
    // cause style changes (for updating ex/ch units, and to cause a
    // reflow).
    mDocument->FlushUserFontSet();

    mPresContext->FlushCounterStyles();

    mPresContext->FlushFontFeatureValues();

    mPresContext->FlushFontPaletteValues();

    // Flush any requested SMIL samples.
    if (mDocument->HasAnimationController()) {
      mDocument->GetAnimationController()->FlushResampleRequests();
    }
  }

  // The FlushResampleRequests() above might have flushed style changes.
  if (MOZ_LIKELY(!mIsDestroying)) {
    if (aFlush.mFlushAnimations) {
      mPresContext->EffectCompositor()->PostRestyleForThrottledAnimations();
      mNeedThrottledAnimationFlush = false;
    }

    nsAutoScriptBlocker scriptBlocker;
    Maybe<uint64_t> innerWindowID;
    if (auto* window = mDocument->GetInnerWindow()) {
      innerWindowID = Some(window->WindowID());
    }
    AutoProfilerStyleMarker tracingStyleFlush(std::move(mStyleCause),
                                              innerWindowID);
    PerfStats::AutoMetricRecording<PerfStats::Metric::Styling> autoRecording;

    mPresContext->RestyleManager()->ProcessPendingRestyles();
    mNeedStyleFlush = false;
  }

  AssertFrameTreeIsSane(*this);

  if (flushType >= (SuppressInterruptibleReflows()
                        ? FlushType::Layout
                        : FlushType::InterruptibleLayout) &&
      !mIsDestroying) {
    if (DoFlushLayout(/* aInterruptible = */ flushType < FlushType::Layout)) {
      if (mContentToScrollTo) {
        DoScrollContentIntoView();
        if (mContentToScrollTo) {
          mContentToScrollTo->RemoveProperty(nsGkAtoms::scrolling);
          mContentToScrollTo = nullptr;
        }
      }
    }
    // FIXME(emilio): Maybe we should assert here but it's not 100% sure it'd
    // hold right now, UnsuppressAndInvalidate and so on can run script...
    if (MOZ_LIKELY(mDirtyRoots.IsEmpty())) {
      mNeedLayoutFlush = false;
    }
  }

  FlushPendingScrollResnap();
}

MOZ_CAN_RUN_SCRIPT_BOUNDARY void PresShell::CharacterDataChanged(
    nsIContent* aContent, const CharacterDataChangeInfo& aInfo) {
  MOZ_ASSERT(!nsContentUtils::IsSafeToRunScript());
  MOZ_ASSERT(!mIsDocumentGone, "Unexpected CharacterDataChanged");
  MOZ_ASSERT(aContent->OwnerDoc() == mDocument, "Unexpected document");

#ifdef ACCESSIBILITY
  if (mDocAccessible) {
    mDocAccessible->MaybeHandleChangeToHiddenNameOrDescription(aContent);
  }
#endif

  nsAutoCauseReflowNotifier crNotifier(this);

  mPresContext->RestyleManager()->CharacterDataChanged(aContent, aInfo);
  mFrameConstructor->CharacterDataChanged(aContent, aInfo);
}

MOZ_CAN_RUN_SCRIPT_BOUNDARY void PresShell::ElementStateChanged(
    Document* aDocument, Element* aElement, ElementState aStateMask) {
  MOZ_ASSERT(!nsContentUtils::IsSafeToRunScript());
  MOZ_ASSERT(!mIsDocumentGone, "Unexpected ContentStateChanged");
  MOZ_ASSERT(aDocument == mDocument, "Unexpected aDocument");

#ifdef ACCESSIBILITY
  if (mDocAccessible) {
    mDocAccessible->ElementStateChanged(aDocument, aElement, aStateMask);
  }
#endif

  if (mDidInitialize) {
    nsAutoCauseReflowNotifier crNotifier(this);
    mPresContext->RestyleManager()->ElementStateChanged(aElement, aStateMask);
  }
}

MOZ_CAN_RUN_SCRIPT_BOUNDARY void PresShell::CustomStatesWillChange(
    Element& aElement) {
  if (MOZ_UNLIKELY(!mDidInitialize)) {
    return;
  }

  mPresContext->RestyleManager()->CustomStatesWillChange(aElement);
}

MOZ_CAN_RUN_SCRIPT_BOUNDARY void PresShell::CustomStateChanged(
    Element& aElement, nsAtom* aState) {
  MOZ_ASSERT(!mIsDocumentGone, "Unexpected CustomStateChanged");
  MOZ_ASSERT(aState, "Unexpected empty state");

  if (mDidInitialize) {
    nsAutoCauseReflowNotifier crNotifier(this);
    mPresContext->RestyleManager()->CustomStateChanged(aElement, aState);
  }
}

void PresShell::DocumentStatesChanged(DocumentState aStateMask) {
  MOZ_ASSERT(!mIsDocumentGone, "Unexpected DocumentStatesChanged");
  MOZ_ASSERT(mDocument);
  MOZ_ASSERT(!aStateMask.IsEmpty());

  if (mDidInitialize) {
    StyleSet()->InvalidateStyleForDocumentStateChanges(aStateMask);
  }

  if (aStateMask.HasState(DocumentState::WINDOW_INACTIVE)) {
    if (nsIFrame* root = mFrameConstructor->GetRootFrame()) {
      root->SchedulePaint();
    }
  }
}

MOZ_CAN_RUN_SCRIPT_BOUNDARY void PresShell::AttributeWillChange(
    Element* aElement, int32_t aNameSpaceID, nsAtom* aAttribute,
    AttrModType aModType) {
  MOZ_ASSERT(!nsContentUtils::IsSafeToRunScript());
  MOZ_ASSERT(!mIsDocumentGone, "Unexpected AttributeWillChange");
  MOZ_ASSERT(aElement->OwnerDoc() == mDocument, "Unexpected document");

#ifdef ACCESSIBILITY
  if (mDocAccessible) {
    mDocAccessible->AttributeWillChange(aElement, aNameSpaceID, aAttribute,
                                        aModType);
  }
#endif

  // XXXwaterson it might be more elegant to wait until after the
  // initial reflow to begin observing the document. That would
  // squelch any other inappropriate notifications as well.
  if (mDidInitialize) {
    nsAutoCauseReflowNotifier crNotifier(this);
    mPresContext->RestyleManager()->AttributeWillChange(aElement, aNameSpaceID,
                                                        aAttribute, aModType);
  }
}

MOZ_CAN_RUN_SCRIPT_BOUNDARY void PresShell::AttributeChanged(
    Element* aElement, int32_t aNameSpaceID, nsAtom* aAttribute,
    AttrModType aModType, const nsAttrValue* aOldValue) {
  MOZ_ASSERT(!nsContentUtils::IsSafeToRunScript());
  MOZ_ASSERT(!mIsDocumentGone, "Unexpected AttributeChanged");
  MOZ_ASSERT(aElement->OwnerDoc() == mDocument, "Unexpected document");

#ifdef ACCESSIBILITY
  if (mDocAccessible) {
    mDocAccessible->AttributeChanged(aElement, aNameSpaceID, aAttribute,
                                     aModType, aOldValue);
  }
#endif

  // XXXwaterson it might be more elegant to wait until after the
  // initial reflow to begin observing the document. That would
  // squelch any other inappropriate notifications as well.
  if (mDidInitialize) {
    nsAutoCauseReflowNotifier crNotifier(this);
    mPresContext->RestyleManager()->AttributeChanged(
        aElement, aNameSpaceID, aAttribute, aModType, aOldValue);
  }
}

static void MaybeDestroyFramesAndStyles(nsIContent* aContent,
                                        nsPresContext& aPresContext) {
  if (!aContent->IsElement()) {
    return;
  }

  Element* element = aContent->AsElement();
  if (!element->HasServoData()) {
    return;
  }

  Element* parent =
      Element::FromNodeOrNull(element->GetFlattenedTreeParentNode());
  if (!parent || !parent->HasServoData() ||
      Servo_Element_IsDisplayNone(parent)) {
    DestroyFramesAndStyleDataFor(element, aPresContext,
                                 RestyleManager::IncludeRoot::Yes);
  }
}

MOZ_CAN_RUN_SCRIPT_BOUNDARY void PresShell::ContentAppended(
    nsIContent* aFirstNewContent, const ContentAppendInfo& aInfo) {
  MOZ_ASSERT(!nsContentUtils::IsSafeToRunScript());
  MOZ_ASSERT(!mIsDocumentGone, "Unexpected ContentAppended");
  MOZ_ASSERT(aFirstNewContent->OwnerDoc() == mDocument, "Unexpected document");

  // We never call ContentAppended with a document as the container, so we can
  // assert that we have an nsIContent parent.
  MOZ_ASSERT(aFirstNewContent->GetParent());
  MOZ_ASSERT(aFirstNewContent->GetParent()->IsElement() ||
             aFirstNewContent->GetParent()->IsShadowRoot());

  if (!mDidInitialize) {
    return;
  }

#ifdef ACCESSIBILITY
  if (mDocAccessible) {
    mDocAccessible->MaybeHandleChangeToHiddenNameOrDescription(
        aFirstNewContent);
  }
#endif

  mPresContext->EventStateManager()->ContentAppended(aFirstNewContent, aInfo);

  if (aInfo.mOldParent) {
    MaybeDestroyFramesAndStyles(aFirstNewContent, *mPresContext);
  }

  nsAutoCauseReflowNotifier crNotifier(this);

  // Call this here so it only happens for real content mutations and
  // not cases when the frame constructor calls its own methods to force
  // frame reconstruction.
  mPresContext->RestyleManager()->ContentAppended(aFirstNewContent);

  mFrameConstructor->ContentAppended(
      aFirstNewContent, nsCSSFrameConstructor::InsertionKind::Async);
}

MOZ_CAN_RUN_SCRIPT_BOUNDARY void PresShell::ContentInserted(
    nsIContent* aChild, const ContentInsertInfo& aInfo) {
  MOZ_ASSERT(!nsContentUtils::IsSafeToRunScript());
  MOZ_ASSERT(!mIsDocumentGone, "Unexpected ContentInserted");
  MOZ_ASSERT(aChild->OwnerDoc() == mDocument, "Unexpected document");

  if (!mDidInitialize) {
    return;
  }

  mPresContext->EventStateManager()->ContentInserted(aChild, aInfo);

#ifdef ACCESSIBILITY
  if (mDocAccessible) {
    mDocAccessible->MaybeHandleChangeToHiddenNameOrDescription(aChild);
  }
#endif

  if (aInfo.mOldParent) {
    MaybeDestroyFramesAndStyles(aChild, *mPresContext);
  }

  nsAutoCauseReflowNotifier crNotifier(this);

  // Call this here so it only happens for real content mutations and
  // not cases when the frame constructor calls its own methods to force
  // frame reconstruction.
  mPresContext->RestyleManager()->ContentInserted(aChild);

  mFrameConstructor->ContentInserted(
      aChild, nsCSSFrameConstructor::InsertionKind::Async);
}

MOZ_CAN_RUN_SCRIPT_BOUNDARY void PresShell::ContentWillBeRemoved(
    nsIContent* aChild, const ContentRemoveInfo& aInfo) {
  MOZ_ASSERT(!nsContentUtils::IsSafeToRunScript());
  MOZ_ASSERT(!mIsDocumentGone, "Unexpected ContentRemoved");
  MOZ_ASSERT(aChild->OwnerDoc() == mDocument, "Unexpected document");
  // Notify the ESM that the content has been removed, so that
  // it can clean up any state related to the content.

  mPresContext->EventStateManager()->ContentRemoved(mDocument, aChild, aInfo);

#ifdef ACCESSIBILITY
  if (mDocAccessible) {
    mDocAccessible->ContentRemoved(aChild);
  }
#endif

  nsAutoCauseReflowNotifier crNotifier(this);

  for (AutoConnectedAncestorTracker* tracker = mLastConnectedAncestorTracker;
       tracker; tracker = tracker->mPreviousTracker) {
    if (tracker->ConnectedNode().IsInclusiveFlatTreeDescendantOf(aChild)) {
      tracker->mConnectedAncestor = aChild->GetFlattenedTreeParentElement();
    }
  }

  if (aInfo.mNewParent && aChild->IsElement()) {
    if (aInfo.mNewParent->IsElement() &&
        aInfo.mNewParent->AsElement()->HasServoData() &&
        !Servo_Element_IsDisplayNone(aInfo.mNewParent->AsElement())) {
      DestroyFramesForAndRestyle(aChild->AsElement());
      return;
    }
  }

  mFrameConstructor->ContentWillBeRemoved(
      aChild, nsCSSFrameConstructor::RemovalKind::Dom);

  // NOTE(emilio): It's important that this goes after the frame constructor
  // stuff, otherwise the frame constructor can't see elements which are
  // display: contents / display: none, because we'd have cleared all the style
  // data from there.
  mPresContext->RestyleManager()->ContentWillBeRemoved(aChild);
}

void PresShell::NotifyCounterStylesAreDirty() {
  // TODO: Looks like that nsFrameConstructor::NotifyCounterStylesAreDirty()
  //       does not run script.  If so, we don't need to block script with
  //       nsAutoCauseReflowNotifier here.  Instead, there should be methods
  //       and stack only class which manages only mChangeNestCount for
  //       avoiding unnecessary `MOZ_CAN_RUN_SCRIPT` marking.
  nsAutoCauseReflowNotifier reflowNotifier(this);
  mFrameConstructor->NotifyCounterStylesAreDirty();
}

bool PresShell::FrameIsAncestorOfDirtyRoot(nsIFrame* aFrame) const {
  return mDirtyRoots.FrameIsAncestorOfAnyElement(aFrame);
}

void PresShell::ReconstructFrames() {
  MOZ_ASSERT(!mFrameConstructor->GetRootFrame() || mDidInitialize,
             "Must not have root frame before initial reflow");
  if (!mDidInitialize || mIsDestroying) {
    // Nothing to do here
    return;
  }

  if (Element* root = mDocument->GetRootElement()) {
    PostRecreateFramesFor(root);
  }

  mDocument->FlushPendingNotifications(FlushType::Frames);
}

nsresult PresShell::RenderDocument(const nsRect& aRect,
                                   RenderDocumentFlags aFlags,
                                   nscolor aBackgroundColor,
                                   gfxContext* aThebesContext) {
  NS_ENSURE_TRUE(!(aFlags & RenderDocumentFlags::IsUntrusted),
                 NS_ERROR_NOT_IMPLEMENTED);

  nsRootPresContext* rootPresContext = mPresContext->GetRootPresContext();
  if (rootPresContext) {
    rootPresContext->FlushWillPaintObservers();
    if (mIsDestroying) {
      return NS_OK;
    }
  }

  nsAutoScriptBlocker blockScripts;

  // Set up the rectangle as the path in aThebesContext
  gfxRect r(0, 0, nsPresContext::AppUnitsToFloatCSSPixels(aRect.width),
            nsPresContext::AppUnitsToFloatCSSPixels(aRect.height));
  aThebesContext->NewPath();
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
  aThebesContext->SnappedRectangle(r);
#else
  aThebesContext->Rectangle(r);
#endif

  nsIFrame* rootFrame = mFrameConstructor->GetRootFrame();
  if (!rootFrame) {
    // Nothing to paint, just fill the rect
    aThebesContext->SetColor(sRGBColor::FromABGR(aBackgroundColor));
    aThebesContext->Fill();
    return NS_OK;
  }

  gfxContextAutoSaveRestore save(aThebesContext);

  MOZ_ASSERT(aThebesContext->CurrentOp() == CompositionOp::OP_OVER);

  aThebesContext->Clip();

  nsDeviceContext* devCtx = mPresContext->DeviceContext();

  gfxPoint offset(-nsPresContext::AppUnitsToFloatCSSPixels(aRect.x),
                  -nsPresContext::AppUnitsToFloatCSSPixels(aRect.y));
  gfxFloat scale =
      gfxFloat(devCtx->AppUnitsPerDevPixel()) / AppUnitsPerCSSPixel();

  // Since canvas APIs use floats to set up their matrices, we may have some
  // slight rounding errors here.  We use NudgeToIntegers() here to adjust
  // matrix components that are integers up to the accuracy of floats to be
  // those integers.
  gfxMatrix newTM = aThebesContext->CurrentMatrixDouble()
                        .PreTranslate(offset)
                        .PreScale(scale, scale)
                        .NudgeToIntegers();
  aThebesContext->SetMatrixDouble(newTM);

  AutoSaveRestoreRenderingState _(this);

  bool wouldFlushRetainedLayers = false;
  PaintFrameFlags flags = PaintFrameFlags::IgnoreSuppression;
  if (aThebesContext->CurrentMatrix().HasNonIntegerTranslation()) {
    flags |= PaintFrameFlags::InTransform;
  }
  if (!(aFlags & RenderDocumentFlags::AsyncDecodeImages)) {
    flags |= PaintFrameFlags::SyncDecodeImages;
  }
  if (aFlags & RenderDocumentFlags::UseHighQualityScaling) {
    flags |= PaintFrameFlags::UseHighQualityScaling;
  }
  if (aFlags & RenderDocumentFlags::UseWidgetLayers) {
    // We only support using widget layers on display root's with widgets.
    nsIWidget* widget = rootFrame->GetOwnWidget();
    if (widget && nsLayoutUtils::GetDisplayRootFrame(rootFrame) == rootFrame) {
      WindowRenderer* renderer = widget->GetWindowRenderer();
      // WebRenderLayerManagers in content processes
      // don't support taking snapshots.
      if (renderer &&
          (!renderer->AsKnowsCompositor() || XRE_IsParentProcess())) {
        flags |= PaintFrameFlags::WidgetLayers;
      }
    }
  }
  if (!(aFlags & RenderDocumentFlags::DrawCaret)) {
    wouldFlushRetainedLayers = true;
    flags |= PaintFrameFlags::HideCaret;
  }
  if (aFlags & RenderDocumentFlags::IgnoreViewportScrolling) {
    wouldFlushRetainedLayers = !IgnoringViewportScrolling();
    mRenderingStateFlags |= RenderingStateFlags::IgnoringViewportScrolling;
  }
  if (aFlags & RenderDocumentFlags::ResetViewportScrolling) {
    wouldFlushRetainedLayers = true;
    flags |= PaintFrameFlags::ResetViewportScrolling;
  }
  if (aFlags & RenderDocumentFlags::DrawWindowNotFlushing) {
    mRenderingStateFlags |= RenderingStateFlags::DrawWindowNotFlushing;
  }
  if (aFlags & RenderDocumentFlags::DocumentRelative) {
    // XXX be smarter about this ... drawWindow might want a rect
    // that's "pretty close" to what our retained layer tree covers.
    // In that case, it wouldn't disturb normal rendering too much,
    // and we should allow it.
    wouldFlushRetainedLayers = true;
    flags |= PaintFrameFlags::DocumentRelative;
  }

  // Don't let drawWindow blow away our retained layer tree
  if ((flags & PaintFrameFlags::WidgetLayers) && wouldFlushRetainedLayers) {
    flags &= ~PaintFrameFlags::WidgetLayers;
  }

  nsLayoutUtils::PaintFrame(aThebesContext, rootFrame, nsRegion(aRect),
                            aBackgroundColor,
                            (aFlags & RenderDocumentFlags::ForPrinting)
                                ? nsDisplayListBuilderMode::PaintForPrinting
                                : nsDisplayListBuilderMode::Painting,
                            flags);

  return NS_OK;
}

/*
 * Clip the display list aList to a range. Returns the clipped
 * rectangle surrounding the range.
 */
nsRect PresShell::ClipListToRange(nsDisplayListBuilder* aBuilder,
                                  nsDisplayList* aList, nsRange* aRange) {
  // iterate though the display items and add up the bounding boxes of each.
  // This will allow the total area of the frames within the range to be
  // determined. To do this, remove an item from the bottom of the list, check
  // whether it should be part of the range, and if so, append it to the top
  // of the temporary list tmpList. If the item is a text frame at the end of
  // the selection range, clip it to the portion of the text frame that is
  // part of the selection. Then, append the wrapper to the top of the list.
  // Otherwise, just delete the item and don't append it.
  nsRect surfaceRect;

  for (nsDisplayItem* i : aList->TakeItems()) {
    if (i->GetType() == DisplayItemType::TYPE_CONTAINER) {
      aList->AppendToTop(i);
      surfaceRect.UnionRect(
          surfaceRect, ClipListToRange(aBuilder, i->GetChildren(), aRange));
      continue;
    }

    // itemToInsert indiciates the item that should be inserted into the
    // temporary list. If null, no item should be inserted.
    nsDisplayItem* itemToInsert = nullptr;
    nsIFrame* frame = i->Frame();
    nsIContent* content = frame->GetContent();
    if (content) {
      bool atStart =
          content == aRange->GetMayCrossShadowBoundaryStartContainer();
      bool atEnd = content == aRange->GetMayCrossShadowBoundaryEndContainer();
      if ((atStart || atEnd) && frame->IsTextFrame()) {
        auto [frameStartOffset, frameEndOffset] = frame->GetOffsets();

        int32_t highlightStart =
            atStart ? std::max(static_cast<int32_t>(
                                   aRange->MayCrossShadowBoundaryStartOffset()),
                               frameStartOffset)
                    : frameStartOffset;
        int32_t highlightEnd =
            atEnd ? std::min(static_cast<int32_t>(
                                 aRange->MayCrossShadowBoundaryEndOffset()),
                             frameEndOffset)
                  : frameEndOffset;
        if (highlightStart < highlightEnd) {
          // determine the location of the start and end edges of the range.
          nsPoint startPoint, endPoint;
          frame->GetPointFromOffset(highlightStart, &startPoint);
          frame->GetPointFromOffset(highlightEnd, &endPoint);

          // The clip rectangle is determined by taking the the start and
          // end points of the range, offset from the reference frame.
          // Because of rtl, the end point may be to the left of (or above,
          // in vertical mode) the start point, so x (or y) is set to the
          // lower of the values.
          nsRect textRect(aBuilder->ToReferenceFrame(frame), frame->GetSize());
          if (frame->GetWritingMode().IsVertical()) {
            nscoord y = std::min(startPoint.y, endPoint.y);
            textRect.y += y;
            textRect.height = std::max(startPoint.y, endPoint.y) - y;
          } else {
            nscoord x = std::min(startPoint.x, endPoint.x);
            textRect.x += x;
            textRect.width = std::max(startPoint.x, endPoint.x) - x;
          }
          surfaceRect.UnionRect(surfaceRect, textRect);

          const ActiveScrolledRoot* asr = i->GetActiveScrolledRoot();

          DisplayItemClip newClip;
          newClip.SetTo(textRect);

          const DisplayItemClipChain* newClipChain =
              aBuilder->AllocateDisplayItemClipChain(newClip, asr, nullptr);

          i->IntersectClip(aBuilder, newClipChain, true);
          itemToInsert = i;
        }
      }
      // Don't try to descend into subdocuments.
      // If this ever changes we'd need to add handling for subdocuments with
      // different zoom levels.
      else if (content->GetComposedDoc() ==
               aRange->GetMayCrossShadowBoundaryStartContainer()
                   ->GetComposedDoc()) {
        // if the node is within the range, append it to the temporary list
        bool before, after;
        nsresult rv =
            RangeUtils::CompareNodeToRange<TreeKind::ShadowIncludingDOM>(
                content, aRange, &before, &after);
        if (NS_SUCCEEDED(rv) && !before && !after) {
          itemToInsert = i;
          bool snap;
          surfaceRect.UnionRect(surfaceRect, i->GetBounds(aBuilder, &snap));
        }
      }
    }

    // insert the item into the list if necessary. If the item has a child
    // list, insert that as well
    nsDisplayList* sublist = i->GetSameCoordinateSystemChildren();
    if (itemToInsert || sublist) {
      aList->AppendToTop(itemToInsert ? itemToInsert : i);
      // if the item is a list, iterate over it as well
      if (sublist) {
        surfaceRect.UnionRect(surfaceRect,
                              ClipListToRange(aBuilder, sublist, aRange));
      }
    } else {
      // otherwise, just delete the item and don't readd it to the list
      i->Destroy(aBuilder);
    }
  }

  return surfaceRect;
}

#ifdef DEBUG
#  include <stdio.h>

static bool gDumpRangePaintList = false;
#endif

UniquePtr<RangePaintInfo> PresShell::CreateRangePaintInfo(
    nsRange* aRange, nsRect& aSurfaceRect, bool aForPrimarySelection) {
  nsIFrame* ancestorFrame = nullptr;
  nsIFrame* rootFrame = GetRootFrame();

  // If the start or end of the range is the document, just use the root
  // frame, otherwise get the common ancestor of the two endpoints of the
  // range.
  nsINode* startContainer = aRange->GetMayCrossShadowBoundaryStartContainer();
  nsINode* endContainer = aRange->GetMayCrossShadowBoundaryEndContainer();
  Document* doc = startContainer->GetComposedDoc();
  if (startContainer == doc || endContainer == doc) {
    ancestorFrame = rootFrame;
  } else {
    nsINode* ancestor =
        nsContentUtils::GetClosestCommonShadowIncludingInclusiveAncestor(
            startContainer, endContainer);
    NS_ASSERTION(!ancestor || ancestor->IsContent(),
                 "common ancestor is not content");

    while (ancestor && ancestor->IsContent()) {
      ancestorFrame = ancestor->AsContent()->GetPrimaryFrame();
      if (ancestorFrame) {
        break;
      }

      ancestor = ancestor->GetParentOrShadowHostNode();
    }

    // use the nearest ancestor frame that includes all continuations as the
    // root for building the display list
    while (ancestorFrame &&
           nsLayoutUtils::GetNextContinuationOrIBSplitSibling(ancestorFrame)) {
      ancestorFrame = ancestorFrame->GetParent();
    }
  }

  if (!ancestorFrame) {
    return nullptr;
  }

  // get a display list containing the range
  auto info = MakeUnique<RangePaintInfo>(ancestorFrame);
  info->mBuilder.SetIncludeAllOutOfFlows();
  if (aForPrimarySelection) {
    info->mBuilder.SetSelectedFramesOnly();
  }
  info->mBuilder.EnterPresShell(ancestorFrame);

  ContentSubtreeIterator subtreeIter;
  nsresult rv = subtreeIter.InitWithAllowCrossShadowBoundary(aRange);
  if (NS_FAILED(rv)) {
    return nullptr;
  }

  auto BuildDisplayListForNode = [&](nsINode* aNode) {
    if (MOZ_UNLIKELY(!aNode->IsContent())) {
      return;
    }
    nsIFrame* frame = aNode->AsContent()->GetPrimaryFrame();
    // XXX deal with frame being null due to display:contents
    for (; frame;
         frame = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(frame)) {
      if (frame->HasAnyStateBits(NS_FRAME_IS_NONDISPLAY)) {
        continue;
      }
      info->mBuilder.SetVisibleRect(frame->InkOverflowRect());
      info->mBuilder.SetDirtyRect(frame->InkOverflowRect());
      frame->BuildDisplayListForStackingContext(&info->mBuilder, &info->mList);
    }
  };
  if (startContainer->NodeType() == nsINode::TEXT_NODE) {
    BuildDisplayListForNode(startContainer);
  }
  for (; !subtreeIter.IsDone(); subtreeIter.Next()) {
    nsCOMPtr<nsINode> node = subtreeIter.GetCurrentNode();
    BuildDisplayListForNode(node);
  }
  if (endContainer != startContainer &&
      endContainer->NodeType() == nsINode::TEXT_NODE) {
    BuildDisplayListForNode(endContainer);
  }

  // If one of the ancestor presShells (including this one) has a resolution
  // set, we may have some APZ zoom applied. That means we may want to rasterize
  // the nodes at that zoom level. Populate `info` with the relevant information
  // so that the caller can decide what to do. Also wrap the display list in
  // appropriate nsDisplayAsyncZoom display items. This code handles the general
  // case with nested async zooms (even though that never actually happens),
  // because it fell out of the implementation for free.
  //
  // TODO: Do we need to do the same for ancestor transforms?
  for (nsPresContext* ctx = GetPresContext(); ctx;
       ctx = ctx->GetParentPresContext()) {
    PresShell* shell = ctx->PresShell();
    float resolution = shell->GetResolution();

    // If we are at the root document in the process, try to see if documents
    // in enclosing processes have a resolution and include that as well.
    if (!ctx->GetParentPresContext()) {
      // xScale is an arbitrary choice. Outside of edge cases involving CSS
      // transforms, xScale == yScale so it doesn't matter.
      resolution *= ViewportUtils::TryInferEnclosingResolution(shell).xScale;
    }

    if (resolution == 1.0) {
      continue;
    }

    info->mResolution *= resolution;
    nsIFrame* rootScrollContainerFrame = shell->GetRootScrollContainerFrame();
    ViewID zoomedId = nsLayoutUtils::FindOrCreateIDFor(
        rootScrollContainerFrame->GetContent());

    nsDisplayList wrapped(&info->mBuilder);
    wrapped.AppendNewToTop<nsDisplayAsyncZoom>(
        &info->mBuilder, rootScrollContainerFrame, &info->mList, nullptr,
        nsDisplayItem::ContainerASRType::Constant, zoomedId);
    info->mList.AppendToTop(&wrapped);
  }

#ifdef DEBUG
  if (gDumpRangePaintList) {
    fprintf(stderr, "CreateRangePaintInfo --- before ClipListToRange:\n");
    nsIFrame::PrintDisplayList(&(info->mBuilder), info->mList);
  }
#endif

  nsRect rangeRect = ClipListToRange(&info->mBuilder, &info->mList, aRange);

  info->mBuilder.LeavePresShell(ancestorFrame, &info->mList);

#ifdef DEBUG
  if (gDumpRangePaintList) {
    fprintf(stderr, "CreateRangePaintInfo --- after ClipListToRange:\n");
    nsIFrame::PrintDisplayList(&(info->mBuilder), info->mList);
  }
#endif

  // determine the offset of the reference frame for the display list
  // to the root frame. This will allow the coordinates used when painting
  // to all be offset from the same point
  info->mRootOffset = ancestorFrame->GetBoundingClientRect().TopLeft();
  rangeRect.MoveBy(info->mRootOffset);
  aSurfaceRect.UnionRect(aSurfaceRect, rangeRect);

  return info;
}

already_AddRefed<SourceSurface> PresShell::PaintRangePaintInfo(
    const nsTArray<UniquePtr<RangePaintInfo>>& aItems, Selection* aSelection,
    const Maybe<CSSIntRegion>& aRegion, nsRect aArea,
    const LayoutDeviceIntPoint aPoint, LayoutDeviceIntRect* aScreenRect,
    RenderImageFlags aFlags) {
  nsPresContext* pc = GetPresContext();
  if (!pc || aArea.width == 0 || aArea.height == 0) {
    return nullptr;
  }

  // use the rectangle to create the surface
  LayoutDeviceIntRect pixelArea = LayoutDeviceIntRect::FromAppUnitsToOutside(
      aArea, pc->AppUnitsPerDevPixel());

  // if the image should not be resized, scale must be 1
  float scale = 1.0;

  const nsRect maxSize = pc->DeviceContext()->GetClientRect();

  // check if the image should be resized
  bool resize = !!(aFlags & RenderImageFlags::AutoScale);

  if (resize) {
    // check if image-resizing-algorithm should be used
    if (aFlags & RenderImageFlags::IsImage) {
      // get max screensize
      int32_t maxWidth = pc->AppUnitsToDevPixels(maxSize.width);
      int32_t maxHeight = pc->AppUnitsToDevPixels(maxSize.height);
      // resize image relative to the screensize
      // get best height/width relative to screensize
      float bestHeight = float(maxHeight) * RELATIVE_SCALEFACTOR;
      float bestWidth = float(maxWidth) * RELATIVE_SCALEFACTOR;
      // calculate scale for bestWidth
      float adjustedScale = bestWidth / float(pixelArea.width);
      // get the worst height (height when width is perfect)
      float worstHeight = float(pixelArea.height) * adjustedScale;
      // get the difference of best and worst height
      float difference = bestHeight - worstHeight;
      // halve the difference and add it to worstHeight to get
      // the best compromise between bestHeight and bestWidth,
      // then calculate the corresponding scale factor
      adjustedScale = (worstHeight + difference / 2) / float(pixelArea.height);
      // prevent upscaling
      scale = std::min(scale, adjustedScale);
    } else {
      // get half of max screensize
      int32_t maxWidth = pc->AppUnitsToDevPixels(maxSize.width >> 1);
      int32_t maxHeight = pc->AppUnitsToDevPixels(maxSize.height >> 1);
      if (pixelArea.width > maxWidth || pixelArea.height > maxHeight) {
        // divide the maximum size by the image size in both directions.
        // Whichever direction produces the smallest result determines how much
        // should be scaled.
        if (pixelArea.width > maxWidth) {
          scale = std::min(scale, float(maxWidth) / pixelArea.width);
        }
        if (pixelArea.height > maxHeight) {
          scale = std::min(scale, float(maxHeight) / pixelArea.height);
        }
      }
    }

    // Pick a resolution scale factor that is the highest we need for any of
    // the items. This means some items may get rendered at a higher-than-needed
    // resolution but at least nothing will be avoidably blurry.
    float resolutionScale = 1.0;
    for (const UniquePtr<RangePaintInfo>& rangeInfo : aItems) {
      resolutionScale = std::max(resolutionScale, rangeInfo->mResolution);
    }
    float unclampedResolution = resolutionScale;
    // Clamp the resolution scale so that `pixelArea` when scaled by `scale` and
    // `resolutionScale` isn't bigger than `maxSize`. This prevents creating
    // giant/unbounded images.
    resolutionScale =
        std::min(resolutionScale, maxSize.width / (scale * pixelArea.width));
    resolutionScale =
        std::min(resolutionScale, maxSize.height / (scale * pixelArea.height));
    // The following assert should only get hit if pixelArea scaled by `scale`
    // alone would already have been bigger than `maxSize`, which should never
    // be the case. For release builds we handle gracefully by reverting
    // resolutionScale to 1.0 to avoid unexpected consequences.
    MOZ_ASSERT(resolutionScale >= 1.0);
    resolutionScale = std::max(1.0f, resolutionScale);

    scale *= resolutionScale;

    // Now we need adjust the output screen position of the surface based on the
    // scaling factor and any APZ zoom that may be in effect. The goal is here
    // to set `aScreenRect`'s top-left corner (in screen-relative LD pixels)
    // such that the scaling effect on the surface appears anchored  at `aPoint`
    // ("anchor" here is like "transform-origin"). When this code is e.g. used
    // to generate a drag image for dragging operations, `aPoint` refers to the
    // position of the mouse cursor (also in screen-relative LD pixels), and the
    // user-visible effect of doing this is that the point at which the user
    // clicked to start the drag remains under the mouse during the drag.

    // In order to do this we first compute the top-left corner of the
    // pixelArea is screen-relative LD pixels.
    LayoutDevicePoint visualPoint = ViewportUtils::ToScreenRelativeVisual(
        LayoutDevicePoint(pixelArea.TopLeft()), pc);
    // And then adjust the output screen position based on that, which we can do
    // since everything here is screen-relative LD pixels. Note that the scale
    // factor we use here is the effective "transform" scale applied to the
    // content we're painting, relative to the scale at which it would normally
    // get painted at as part of page rendering (`unclampedResolution`).
    float scaleRelativeToNormalContent = scale / unclampedResolution;
    aScreenRect->x =
        NSToIntFloor(aPoint.x - float(aPoint.x.value - visualPoint.x.value) *
                                    scaleRelativeToNormalContent);
    aScreenRect->y =
        NSToIntFloor(aPoint.y - float(aPoint.y.value - visualPoint.y.value) *
                                    scaleRelativeToNormalContent);

    pixelArea.width = NSToIntFloor(float(pixelArea.width) * scale);
    pixelArea.height = NSToIntFloor(float(pixelArea.height) * scale);
    if (!pixelArea.width || !pixelArea.height) {
      return nullptr;
    }
  } else {
    // move aScreenRect to the position of the surface in screen coordinates
    LayoutDevicePoint visualPoint = ViewportUtils::ToScreenRelativeVisual(
        LayoutDevicePoint(pixelArea.TopLeft()), pc);
    aScreenRect->MoveTo(RoundedToInt(visualPoint));
  }
  aScreenRect->width = pixelArea.width;
  aScreenRect->height = pixelArea.height;

  RefPtr<DrawTarget> dt =
      gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(
          IntSize(pixelArea.width, pixelArea.height), SurfaceFormat::B8G8R8A8);
  if (!dt || !dt->IsValid()) {
    return nullptr;
  }

  gfxContext ctx(dt);

  if (aRegion) {
    RefPtr<PathBuilder> builder = dt->CreatePathBuilder(FillRule::FILL_WINDING);

    // Convert aRegion from CSS pixels to dev pixels
    nsIntRegion region = aRegion->ToAppUnits(AppUnitsPerCSSPixel())
                             .ToOutsidePixels(pc->AppUnitsPerDevPixel());
    for (auto iter = region.RectIter(); !iter.Done(); iter.Next()) {
      const IntRect& rect = iter.Get();

      builder->MoveTo(rect.TopLeft());
      builder->LineTo(rect.TopRight());
      builder->LineTo(rect.BottomRight());
      builder->LineTo(rect.BottomLeft());
      builder->LineTo(rect.TopLeft());
    }

    RefPtr<Path> path = builder->Finish();
    ctx.Clip(path);
  }

  gfxMatrix initialTM = ctx.CurrentMatrixDouble();

  if (resize) {
    initialTM.PreScale(scale, scale);
  }

  // translate so that points are relative to the surface area
  gfxPoint surfaceOffset = nsLayoutUtils::PointToGfxPoint(
      -aArea.TopLeft(), pc->AppUnitsPerDevPixel());
  initialTM.PreTranslate(surfaceOffset);

  // temporarily hide the selection so that text is drawn normally. If a
  // selection is being rendered, use that, otherwise use the presshell's
  // selection.
  RefPtr<nsFrameSelection> frameSelection;
  if (aSelection) {
    frameSelection = aSelection->GetFrameSelection();
  } else {
    frameSelection = FrameSelection();
  }
  int16_t oldDisplaySelection = frameSelection->GetDisplaySelection();
  frameSelection->SetDisplaySelection(nsISelectionController::SELECTION_HIDDEN);

  // next, paint each range in the selection
  for (const UniquePtr<RangePaintInfo>& rangeInfo : aItems) {
    // the display lists paint relative to the offset from the reference
    // frame, so account for that translation too:
    gfxPoint rootOffset = nsLayoutUtils::PointToGfxPoint(
        rangeInfo->mRootOffset, pc->AppUnitsPerDevPixel());
    ctx.SetMatrixDouble(initialTM.PreTranslate(rootOffset));
    aArea.MoveBy(-rangeInfo->mRootOffset.x, -rangeInfo->mRootOffset.y);
    nsRegion visible(aArea);
    rangeInfo->mList.PaintRoot(&rangeInfo->mBuilder, &ctx,
                               nsDisplayList::PAINT_DEFAULT, Nothing());
    aArea.MoveBy(rangeInfo->mRootOffset.x, rangeInfo->mRootOffset.y);
  }

  // restore the old selection display state
  frameSelection->SetDisplaySelection(oldDisplaySelection);

  return dt->Snapshot();
}

already_AddRefed<SourceSurface> PresShell::RenderNode(
    nsINode* aNode, const Maybe<CSSIntRegion>& aRegion,
    const LayoutDeviceIntPoint aPoint, LayoutDeviceIntRect* aScreenRect,
    RenderImageFlags aFlags) {
  // area will hold the size of the surface needed to draw the node, measured
  // from the root frame.
  nsRect area;
  nsTArray<UniquePtr<RangePaintInfo>> rangeItems;

  // nothing to draw if the node isn't in a document
  if (!aNode->IsInComposedDoc()) {
    return nullptr;
  }

  RefPtr<nsRange> range = nsRange::Create(aNode);
  IgnoredErrorResult rv;
  range->SelectNode(*aNode, rv);
  if (rv.Failed()) {
    return nullptr;
  }

  UniquePtr<RangePaintInfo> info = CreateRangePaintInfo(range, area, false);
  if (info) {
    // XXX(Bug 1631371) Check if this should use a fallible operation as it
    // pretended earlier, or change the return type to void.
    rangeItems.AppendElement(std::move(info));
  }

  Maybe<CSSIntRegion> region = aRegion;
  if (region) {
    // combine the area with the supplied region
    CSSIntRect rrectPixels = region->GetBounds();

    nsRect rrect = ToAppUnits(rrectPixels, AppUnitsPerCSSPixel());
    area.IntersectRect(area, rrect);

    nsPresContext* pc = GetPresContext();
    if (!pc) {
      return nullptr;
    }

    // move the region so that it is offset from the topleft corner of the
    // surface
    region->MoveBy(-nsPresContext::AppUnitsToIntCSSPixels(area.x),
                   -nsPresContext::AppUnitsToIntCSSPixels(area.y));
  }

  return PaintRangePaintInfo(rangeItems, nullptr, region, area, aPoint,
                             aScreenRect, aFlags);
}

already_AddRefed<SourceSurface> PresShell::RenderSelection(
    Selection* aSelection, const LayoutDeviceIntPoint aPoint,
    LayoutDeviceIntRect* aScreenRect, RenderImageFlags aFlags) {
  // area will hold the size of the surface needed to draw the selection,
  // measured from the root frame.
  nsRect area;
  nsTArray<UniquePtr<RangePaintInfo>> rangeItems;

  // iterate over each range and collect them into the rangeItems array.
  // This is done so that the size of selection can be determined so as
  // to allocate a surface area
  const uint32_t rangeCount = aSelection->RangeCount();
  NS_ASSERTION(rangeCount > 0, "RenderSelection called with no selection");
  for (const uint32_t r : IntegerRange(rangeCount)) {
    MOZ_ASSERT(aSelection->RangeCount() == rangeCount);
    RefPtr<nsRange> range = aSelection->GetRangeAt(r);

    UniquePtr<RangePaintInfo> info = CreateRangePaintInfo(range, area, true);
    if (info) {
      // XXX(Bug 1631371) Check if this should use a fallible operation as it
      // pretended earlier.
      rangeItems.AppendElement(std::move(info));
    }
  }

  return PaintRangePaintInfo(rangeItems, aSelection, Nothing(), area, aPoint,
                             aScreenRect, aFlags);
}

static void AddDisplayItemToBottom(nsDisplayListBuilder* aBuilder,
                                   nsDisplayList* aList, nsDisplayItem* aItem) {
  nsDisplayList list(aBuilder);
  list.AppendToTop(aItem);
  list.AppendToTop(aList);
  aList->AppendToTop(&list);
}

void PresShell::AddCanvasBackgroundColorItem(nsDisplayListBuilder* aBuilder,
                                             nsDisplayList* aList,
                                             nsIFrame* aFrame,
                                             const nsRect& aBounds,
                                             nscolor aBackstopColor) {
  if (aBounds.IsEmpty() || !aFrame->IsViewportFrame()) {
    // We don't want to add an item for the canvas background color if the frame
    // (sub)tree we are painting doesn't include any canvas frames.
    return;
  }

  const SingleCanvasBackground& canvasBg = mCanvasBackground.mViewport;
  const nscolor bgcolor = NS_ComposeColors(aBackstopColor, canvasBg.mColor);
  if (NS_GET_A(bgcolor) == 0) {
    return;
  }

  // With async scrolling, we'd like to have two instances of the background
  // color: one that scrolls with the content and one underneath which does not
  // scroll with the content, but which can be shown during checkerboarding and
  // overscroll and the dynamic toolbar movement. We can only do that if the
  // color is opaque.
  //
  // We also need to paint the background if CSS hasn't specified it (since
  // otherwise nsCanvasFrame might not paint it). Note that non-CSS-specified
  // backgrounds shouldn't ever be semi-transparent.
  const bool forceUnscrolledItem =
      nsLayoutUtils::UsesAsyncScrolling(aFrame) && NS_GET_A(bgcolor) == 255;
  if (canvasBg.mCSSSpecified && !forceUnscrolledItem) {
    return;
  }

  MOZ_ASSERT(NS_GET_A(bgcolor) == 255);
  const bool isRootContentDocumentCrossProcess =
      mPresContext->IsRootContentDocumentCrossProcess();
  MOZ_ASSERT_IF(
      !aFrame->GetParent() && isRootContentDocumentCrossProcess &&
          mPresContext->HasDynamicToolbar(),
      aBounds.Size() ==
          nsLayoutUtils::ExpandHeightForDynamicToolbar(
              mPresContext, aFrame->InkOverflowRectRelativeToSelf().Size()));

  nsDisplaySolidColor* item =
      MakeDisplayItem<nsDisplaySolidColor>(aBuilder, aFrame, aBounds, bgcolor);
  if (canvasBg.mCSSSpecified && isRootContentDocumentCrossProcess) {
    item->SetIsCheckerboardBackground();
  }
  AddDisplayItemToBottom(aBuilder, aList, item);
}

bool PresShell::IsTransparentContainerElement() const {
  if (mDocument->IsInitialDocument()) {
    switch (StaticPrefs::layout_css_initial_document_transparency()) {
      case 3:
        return true;
      case 2:
        if (!mDocument->IsTopLevelContentDocument()) {
          return true;
        }
        [[fallthrough]];
      case 1:
        if (mDocument->IsLikelyContentInaccessibleTopLevelAboutBlank()) {
          return true;
        }
        [[fallthrough]];
      default:
        break;
    }
  }

  nsPresContext* pc = GetPresContext();
  if (!pc->IsRootContentDocumentCrossProcess()) {
    if (mDocument->IsInChromeDocShell()) {
      return true;
    }
    // Frames are transparent except if their used embedder color-scheme is
    // mismatched, in which case we use an opaque background to avoid
    // black-on-black or white-on-white text, see
    // https://github.com/w3c/csswg-drafts/issues/4772
    if (BrowsingContext* bc = mDocument->GetBrowsingContext()) {
      switch (bc->GetEmbedderColorSchemes().mUsed) {
        case dom::PrefersColorSchemeOverride::Light:
          return pc->DefaultBackgroundColorScheme() == ColorScheme::Light;
        case dom::PrefersColorSchemeOverride::Dark:
          return pc->DefaultBackgroundColorScheme() == ColorScheme::Dark;
        case dom::PrefersColorSchemeOverride::None:
          break;
      }
    }
    return true;
  }

  nsIDocShell* docShell = pc->GetDocShell();
  if (!docShell) {
    return false;
  }
  nsPIDOMWindowOuter* pwin = docShell->GetWindow();
  if (!pwin) {
    return false;
  }
  if (Element* containerElement = pwin->GetFrameElementInternal()) {
    return containerElement->HasAttr(nsGkAtoms::transparent);
  }
  if (BrowserChild* tab = BrowserChild::GetFrom(docShell)) {
    // Check if presShell is the top PresShell. Only the top can influence the
    // canvas background color.
    return this == tab->GetTopLevelPresShell() && tab->IsTransparent();
  }
  return false;
}

nscolor PresShell::GetDefaultBackgroundColorToDraw() const {
  if (!mPresContext) {
    return NS_RGB(255, 255, 255);
  }
  return mPresContext->DefaultBackgroundColor();
}

void PresShell::UpdateCanvasBackground() {
  mCanvasBackground = ComputeCanvasBackground();
}

static SingleCanvasBackground ComputeSingleCanvasBackground(nsIFrame* aCanvas) {
  MOZ_ASSERT(aCanvas->IsCanvasFrame());
  const nsIFrame* bgFrame = nsCSSRendering::FindBackgroundFrame(aCanvas);
  static constexpr nscolor kTransparent = NS_RGBA(0, 0, 0, 0);
  if (bgFrame->IsThemed()) {
    // Ignore the CSS background-color if `appearance` is used on the root.
    return {kTransparent, false};
  }
  bool drawBackgroundImage = false;
  bool drawBackgroundColor = false;
  nscolor color = nsCSSRendering::DetermineBackgroundColor(
      aCanvas->PresContext(), bgFrame->Style(), aCanvas, drawBackgroundImage,
      drawBackgroundColor);
  if (!drawBackgroundColor) {
    // No need to draw the CSS-specified background (or no CSS-specified
    // background at all).
    return {kTransparent, false};
  }
  return {color, true};
}

PresShell::CanvasBackground PresShell::ComputeCanvasBackground() const {
  // If we have a frame tree and it has style information that
  // specifies the background color of the canvas, update our local
  // cache of that color.
  nsIFrame* canvas = GetCanvasFrame();
  if (!canvas) {
    nscolor color = GetDefaultBackgroundColorToDraw();
    // If the root element of the document (ie html) has style 'display: none'
    // then the document's background color does not get drawn; return the color
    // we actually draw.
    return {{color, false}, {color, false}};
  }

  auto viewportBg = ComputeSingleCanvasBackground(canvas);
  if (!IsTransparentContainerElement()) {
    viewportBg.mColor =
        NS_ComposeColors(GetDefaultBackgroundColorToDraw(), viewportBg.mColor);
  }
  auto pageBg = viewportBg;
  nsCanvasFrame* docElementCb =
      mFrameConstructor->GetDocElementContainingBlock();
  if (canvas != docElementCb) {
    // We're in paged mode / print / print-preview, and just computed the "root"
    // canvas background. Compute the doc element containing block background
    // too.
    MOZ_ASSERT(mPresContext->IsRootPaginatedDocument());
    pageBg = ComputeSingleCanvasBackground(docElementCb);
  }
  return {viewportBg, pageBg};
}

nscolor PresShell::ComputeBackstopColor(nsIFrame* aDisplayRoot) {
  nsIWidget* widget =
      aDisplayRoot ? aDisplayRoot->GetNearestWidget() : GetNearestWidget();
  if (widget &&
      (widget->GetTransparencyMode() != widget::TransparencyMode::Opaque ||
       widget->WidgetPaintsBackground())) {
    // Within a transparent widget, so the backstop color must be
    // totally transparent.
    return NS_RGBA(0, 0, 0, 0);
  }
  // Within an opaque widget (or no widget at all), so the backstop
  // color must be totally opaque. The user's default background
  // as reported by the prescontext is guaranteed to be opaque.
  return GetDefaultBackgroundColorToDraw();
}

struct PaintParams {
  nscolor mBackgroundColor;
};

WindowRenderer* PresShell::GetWindowRenderer() {
  if (nsIWidget* widget = GetOwnWidget()) {
    return widget->GetWindowRenderer();
  }
  return nullptr;
}

nsIWidget* PresShell::GetNearestWidget() const {
  if (auto* widget = GetOwnWidget()) {
    return widget;
  }
  if (auto* embedder = GetInProcessEmbedderFrame()) {
    return embedder->GetNearestWidget();
  }
  return GetRootWidget();
}

nsIWidget* PresShell::GetOwnWidget() const {
  return mWidgetListener ? mWidgetListener->GetWidget() : nullptr;
}

bool PresShell::AsyncPanZoomEnabled() {
  if (nsIWidget* widget = GetOwnWidget()) {
    return widget->AsyncPanZoomEnabled();
  }
  return gfxPlatform::AsyncPanZoomEnabled();
}

nsresult PresShell::SetResolutionAndScaleTo(float aResolution,
                                            ResolutionChangeOrigin aOrigin) {
  if (!(aResolution > 0.0)) {
    return NS_ERROR_ILLEGAL_VALUE;
  }
  if (aResolution == mResolution.valueOr(0.0)) {
    MOZ_ASSERT(mResolution.isSome());
    return NS_OK;
  }

  // GetResolution handles mResolution being nothing by returning 1 so this
  // is checking that the resolution is actually changing.
  bool resolutionUpdated = aResolution != GetResolution();

  mLastResolutionChangeOrigin = aOrigin;

  RenderingState state(this);
  state.mResolution = Some(aResolution);
  SetRenderingState(state);
  if (mMobileViewportManager) {
    mMobileViewportManager->ResolutionUpdated(aOrigin);
  }
  // Changing the resolution changes the visual viewport size which may
  // make the current visual viewport offset out-of-bounds (if the size
  // increased). APZ will reconcile this by sending a clamped visual
  // viewport offset on the next repaint, but to avoid main-thread code
  // observing an out-of-bounds offset until then, reclamp it here.
  if (IsVisualViewportOffsetSet()) {
    SetVisualViewportOffset(GetVisualViewportOffset(),
                            GetLayoutViewportOffset());
  }
  if (aOrigin == ResolutionChangeOrigin::Apz) {
    mResolutionUpdatedByApz = true;
  } else if (resolutionUpdated) {
    mResolutionUpdated = true;
  }

  if (auto* window = nsGlobalWindowInner::Cast(mDocument->GetInnerWindow())) {
    window->VisualViewport()->PostResizeEvent();
  }

  return NS_OK;
}

float PresShell::GetCumulativeResolution() const {
  float resolution = GetResolution();
  nsPresContext* parentCtx = GetPresContext()->GetParentPresContext();
  if (parentCtx) {
    resolution *= parentCtx->PresShell()->GetCumulativeResolution();
  }
  return resolution;
}

void PresShell::SetRestoreResolution(float aResolution,
                                     LayoutDeviceIntSize aDisplaySize) {
  if (mMobileViewportManager) {
    mMobileViewportManager->SetRestoreResolution(aResolution, aDisplaySize);
  }
}

void PresShell::SetRenderingState(const RenderingState& aState) {
  if (GetResolution() != aState.mResolution.valueOr(1.f)) {
    if (nsIFrame* frame = GetRootFrame()) {
      frame->SchedulePaint();
    }
  }

  mRenderingStateFlags = aState.mRenderingStateFlags;
  mResolution = aState.mResolution;
#ifdef ACCESSIBILITY
  if (nsAccessibilityService* accService = GetAccService()) {
    accService->NotifyOfResolutionChange(this, GetResolution());
  }
#endif
}

void PresShell::SynthesizeMouseMove(bool aFromScroll) {
  if (!StaticPrefs::layout_reflow_synthMouseMove()) {
    return;
  }

  if (mPaintingSuppressed || !mIsActive || !mPresContext) {
    return;
  }

  if (!IsRoot()) {
    if (PresShell* rootPresShell = GetRootPresShell()) {
      rootPresShell->SynthesizeMouseMove(aFromScroll);
    }
    return;
  }

  if (mLastMousePointerId.isNothing() && mPointerIds.IsEmpty()) {
    // After a same-tab navigation, the new PresShell hasn't received
    // any mouse events yet so its per-PresShell pointer state is
    // empty. The static last-mouse state in PointerEventHandler may
    // still hold a valid position from before the navigation; if so,
    // claim it for this PresShell so cursor / :hover restyles can
    // take effect without requiring the user to move the mouse first
    // (bug 2038491).
    if (Maybe<uint32_t> claimedPointerId =
            PointerEventHandler::TryClaimOrphanedLastMouseInfo(*this)) {
      mLastMousePointerId = claimedPointerId;
    } else {
      return;
    }
  }

  if (!mSynthMouseMoveEvent.IsPending()) {
    auto ev = MakeRefPtr<nsSynthMouseMoveEvent>(this, aFromScroll);

    GetPresContext()->RefreshDriver()->AddRefreshObserver(
        ev, FlushType::Display, "Synthetic mouse move event");
    mSynthMouseMoveEvent = std::move(ev);
  }
}

static nsMenuPopupFrame* FindPopupFrame(nsPresContext* aRootPresContext,
                                        nsIWidget* aRootWidget,
                                        const LayoutDeviceIntPoint& aPt) {
  return nsLayoutUtils::GetPopupFrameForPoint(
      aRootPresContext, aRootWidget, aPt,
      nsLayoutUtils::GetPopupFrameForPointFlags::OnlyReturnFramesWithWidgets);
}

void PresShell::ProcessSynthMouseMoveEvent(bool aFromScroll) {
  auto forgetMouseMove = MakeScopeExit([&]() {
    // Must be safe to refer `this` without grabbing it with a RefPtr since this
    // method is marked as MOZ_CAN_RUN_SCRIPT, and we don't want to use RefPtr
    // here because of a hot path
    mSynthMouseMoveEvent.Forget();
  });
  // If drag session has started, we shouldn't synthesize mousemove event.
  nsIWidget* widget = GetOwnWidget();
  if (!widget) {
    return;
  }
  nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession(widget);
  if (dragSession) {
    // Don't forget it.  We need to synthesize a mouse move when the drag
    // session ends.
    forgetMouseMove.release();
    return;
  }

  if (!mPresContext) {
    return;
  }

  // allow new event to be posted while handling this one only if the
  // source of the event is a scroll (to prevent infinite reflow loops)
  if (aFromScroll) {
    mSynthMouseMoveEvent.Forget();
    forgetMouseMove.release();
  }

  NS_ASSERTION(IsRoot(), "Only a root pres shell should be here");

  if (StaticPrefs::dom_event_pointer_boundary_dispatch_when_layout_change()) {
    const AutoTArray<uint32_t, 16> pointerIds(mPointerIds.Clone());
    for (const uint32_t pointerId : pointerIds) {
      const PointerInfo* const pointerInfo =
          PointerEventHandler::GetPointerInfo(pointerId);
      if (MOZ_UNLIKELY(!pointerInfo) || !pointerInfo->HasLastState() ||
          // We shouldn't dispatch pointer boundary events when a layout change
          // if the pointer is not a stationary device.
          !pointerInfo->InputSourceSupportsHover()) {
        continue;
      }
      // If the pointer is captured, we don't need to dispatch pointer boundary
      // events since pointer boundary events should be fired before
      // gotpointercapture.
      PointerCaptureInfo* const captureInfo =
          PointerEventHandler::GetPointerCaptureInfo(pointerId);
      if (captureInfo && captureInfo->mOverrideElement) {
        continue;
      }
      ProcessSynthMouseOrPointerMoveEvent(ePointerMove, pointerId,
                                          *pointerInfo);
    }
  }

  if (mLastMousePointerId.isSome()) {
    if (const PointerInfo* const lastMouseInfo =
            PointerEventHandler::GetLastMouseInfo(this)) {
      // We shouldn't dispatch mouse boundary events when a layout change
      // if the mouse event was caused by a pointing device which does not
      // support hover state.
      if (lastMouseInfo->HasLastState() &&
          (lastMouseInfo->InputSourceSupportsHover() ||
           lastMouseInfo->mIsActive)) {
        ProcessSynthMouseOrPointerMoveEvent(eMouseMove, *mLastMousePointerId,
                                            *lastMouseInfo);
      }
    }
  }
}

void PresShell::ProcessSynthMouseOrPointerMoveEvent(
    EventMessage aMoveMessage, uint32_t aPointerId,
    const PointerInfo& aPointerInfo) {
  MOZ_ASSERT(aMoveMessage == eMouseMove || aMoveMessage == ePointerMove);
  NS_ASSERTION(IsRoot(), "Only a root pres shell should be here");

#ifdef DEBUG
  if (aMoveMessage == eMouseMove || aMoveMessage == ePointerMove) {
    MOZ_LOG(aMoveMessage == eMouseMove
                ? PointerEventHandler::MouseLocationLogRef()
                : PointerEventHandler::PointerLocationLogRef(),
            LogLevel::Info,
            ("[ps=%p]synthesizing %s to (%d,%d) (pointerId=%u, source=%s)\n",
             this, ToChar(aMoveMessage), aPointerInfo.mLastRefPointInRootDoc.x,
             aPointerInfo.mLastRefPointInRootDoc.y, aPointerId,
             InputSourceToString(aPointerInfo.mInputSource).get()));
  }
#endif

  int32_t APD = mPresContext->AppUnitsPerDevPixel();

  // mRefPoint will be mMouseLocation relative to the widget of |view|, the
  // widget we will put in the event we dispatch, in widgetAPD appunits
  nsPoint refpoint(0, 0);

  nsIWidget* ownWidget = GetOwnWidget();
  if (!ownWidget) {
    return;
  }
  MOZ_ASSERT(!nsCOMPtr{nsContentUtils::GetDragSession(ownWidget)});

  // We need a widget to put in the event we are going to dispatch so we look
  // for a view that has a widget and the mouse location is over. We first look
  // for floating views, if there isn't one we use the root view. |view| holds
  // that view.
  nsCOMPtr<nsIWidget> widget;
  // We always dispatch the event to the pres shell that contains the view that
  // the mouse is over. pointShell is that.
  RefPtr<PresShell> pointShell;
  // The appunits per devpixel ratio of |widget|.
  int32_t widgetAPD;
  // If we're in a child process and the view points to an OOP iframe, this is
  // its BrowserBridgeChild.
  RefPtr<BrowserBridgeChild> bbc;

  // We either dispatch the event to a popup, or a view.
  nsMenuPopupFrame* popupFrame =
      FindPopupFrame(mPresContext, ownWidget,
                     LayoutDeviceIntPoint::FromAppUnitsToNearest(
                         aPointerInfo.mLastRefPointInRootDoc, APD));
  if (popupFrame) {
    pointShell = popupFrame->PresShell();
    widget = popupFrame->GetWidget();
    widgetAPD = popupFrame->PresContext()->AppUnitsPerDevPixel();
    refpoint = aPointerInfo.mLastRefPointInRootDoc;
    DebugOnly<nsLayoutUtils::TransformResult> result =
        nsLayoutUtils::TransformPoint(
            RelativeTo{GetRootFrame(), ViewportType::Visual},
            RelativeTo{popupFrame, ViewportType::Layout}, refpoint);
    MOZ_ASSERT(result == nsLayoutUtils::TRANSFORM_SUCCEEDED);
  }
  if (!widget) {
    widget = ownWidget;
    widgetAPD = APD;
    pointShell = this;
    refpoint = aPointerInfo.mLastRefPointInRootDoc;
  }
  NS_ASSERTION(widget, "view should have a widget here");
  Maybe<WidgetMouseEvent> mouseMoveEvent;
  Maybe<WidgetPointerEvent> pointerMoveEvent;
  if (aMoveMessage == eMouseMove) {
    mouseMoveEvent.emplace(true, eMouseMove, widget,
                           WidgetMouseEvent::eSynthesized);
    mouseMoveEvent->mButton = MouseButton::ePrimary;
    // We don't want to dispatch preceding pointer event since the caller
    // should've already been dispatched it.  However, if the target is an OOP
    // iframe, we'll set this to true again below.
    mouseMoveEvent->convertToPointer = false;
  } else {
    pointerMoveEvent.emplace(true, ePointerMove, widget);
    pointerMoveEvent->mButton = MouseButton::eNotPressed;
    pointerMoveEvent->mReason = WidgetMouseEvent::eSynthesized;
  }
  WidgetMouseEvent& event =
      mouseMoveEvent ? mouseMoveEvent.ref() : pointerMoveEvent.ref();

  // If the last cursor location was set by a synthesized mouse event for tests,
  // running test should expect a restyle or a DOM mutation under the cursor may
  // cause mouse boundary events in a remote process if the cursor is over a
  // remote content.  Therefore, the events should not be ignored by
  // PresShell::HandleEvent in the remote process.  So we need to mark the
  // synthesized eMouseMove as "synthesized for tests".
  event.mFlags.mIsSynthesizedForTests = aPointerInfo.mIsSynthesizedForTests;

  event.mRefPoint =
      LayoutDeviceIntPoint::FromAppUnitsToNearest(refpoint, widgetAPD);
  event.mButtons = aPointerInfo.mLastButtons;
  event.mInputSource = aPointerInfo.mInputSource;
  event.pointerId = aPointerId;
  event.mModifiers = PresShell::GetCurrentModifiers();

  MOZ_ASSERT(pointShell);
  // Since this gets run in a refresh tick there isn't an InputAPZContext on
  // the stack from the nsIWidget. We need to simulate one with at least
  // the correct target guid, so that the correct callback transform gets
  // applied if this event goes to a child process. The input block id is set
  // to 0 because this is a synthetic event which doesn't really belong to any
  // input block. Same for the APZ response field.
  InputAPZContext apzContext(aPointerInfo.mLastTargetGuid, 0,
                             nsEventStatus_eIgnore);
  AUTO_PROFILER_MARKER_DOCSHELL("DispatchSynthMouseOrPointerMove", GRAPHICS,
                                pointShell->GetPresContext()->GetDocShell());
  nsEventStatus status = nsEventStatus_eIgnore;
  if (auto* eventFrame = popupFrame ? popupFrame : GetRootFrame()) {
    pointShell->HandleEvent(eventFrame, &event, false, &status);
  }
}

/* static */
void PresShell::MarkFramesInListApproximatelyVisible(
    const nsDisplayList& aList) {
  for (nsDisplayItem* item : aList) {
    nsDisplayList* sublist = item->GetChildren();
    if (sublist) {
      MarkFramesInListApproximatelyVisible(*sublist);
      continue;
    }

    nsIFrame* frame = item->Frame();
    MOZ_ASSERT(frame);

    if (!frame->TrackingVisibility()) {
      continue;
    }

    // Use the presshell containing the frame.
    PresShell* presShell = frame->PresShell();
    MOZ_ASSERT(!presShell->AssumeAllFramesVisible());
    if (presShell->mApproximatelyVisibleFrames.EnsureInserted(frame)) {
      // The frame was added to mApproximatelyVisibleFrames, so increment its
      // visible count.
      frame->IncApproximateVisibleCount();
    }
  }
}

/* static */
void PresShell::DecApproximateVisibleCount(
    VisibleFrames& aFrames, const Maybe<OnNonvisible>& aNonvisibleAction
    /* = Nothing() */) {
  for (nsIFrame* frame : aFrames) {
    // Decrement the frame's visible count if we're still tracking its
    // visibility. (We may not be, if the frame disabled visibility tracking
    // after we added it to the visible frames list.)
    if (frame->TrackingVisibility()) {
      frame->DecApproximateVisibleCount(aNonvisibleAction);
    }
  }
}

void PresShell::RebuildApproximateFrameVisibilityDisplayList(
    const nsDisplayList& aList) {
  MOZ_ASSERT(!mApproximateFrameVisibilityVisited, "already visited?");
  mApproximateFrameVisibilityVisited = true;

  // Remove the entries of the mApproximatelyVisibleFrames hashtable and put
  // them in oldApproxVisibleFrames.
  VisibleFrames oldApproximatelyVisibleFrames =
      std::move(mApproximatelyVisibleFrames);

  MarkFramesInListApproximatelyVisible(aList);

  DecApproximateVisibleCount(oldApproximatelyVisibleFrames);
}

void PresShell::ClearApproximateFrameVisibilityVisited() {
  if (!mApproximateFrameVisibilityVisited) {
    ClearApproximatelyVisibleFramesList();
  }
  mApproximateFrameVisibilityVisited = false;
  mDocument->EnumerateSubDocuments([](Document& aSubdoc) {
    if (auto* ps = aSubdoc.GetPresShell()) {
      ps->ClearApproximateFrameVisibilityVisited();
    }
    return CallState::Continue;
  });
}

void PresShell::ClearApproximatelyVisibleFramesList(
    const Maybe<OnNonvisible>& aNonvisibleAction
    /* = Nothing() */) {
  DecApproximateVisibleCount(mApproximatelyVisibleFrames, aNonvisibleAction);
  mApproximatelyVisibleFrames.Clear();
}

// aRect is relative to aFrame
// aPreserve3DRect is set upon entering a preserve3d context and it doesn't
// change, it stays relative to the root frame in the preserve3d context. Any
// frame that is in a preserve3d context ignores aRect but takes aPreserve3DRect
// and transforms it from the root of the preserve3d context to itself
// (nsDisplayTransform::UntransformRect does this by default), and passes the
// result down as aRect (leaving aPreserve3DRect untouched). Additionally, we
// descend into every frame inside the preserve3d context (we skip the rect
// intersection test). Any frame that is not in a preserve3d context just uses
// aRect and doesn't need to know about any of this, even if it's parent frame
// is in the preserve3d context. Any frame that is extend3d (ie has preserve3d
// transform style) but not combines3d (ie its either transformed or backface
// visibility hidden and its parent has preserve3d style) forms the root of a
// preserve3d context. And any frame that is combines3d is in a preserve3d
// context.
void PresShell::MarkFramesInSubtreeApproximatelyVisible(
    nsIFrame* aFrame, const nsRect& aRect, const nsRect& aPreserve3DRect,
    bool aRemoveOnly /* = false */) {
  MOZ_DIAGNOSTIC_ASSERT(aFrame, "aFrame arg should be a valid frame pointer");
  MOZ_ASSERT(aFrame->PresShell() == this, "wrong presshell");

  if (aFrame->TrackingVisibility() && aFrame->StyleVisibility()->IsVisible() &&
      (!aRemoveOnly ||
       aFrame->GetVisibility() == Visibility::ApproximatelyVisible)) {
    MOZ_ASSERT(!AssumeAllFramesVisible());
    if (mApproximatelyVisibleFrames.EnsureInserted(aFrame)) {
      // The frame was added to mApproximatelyVisibleFrames, so increment its
      // visible count.
      aFrame->IncApproximateVisibleCount();
    }
  }

  nsSubDocumentFrame* subdocFrame = do_QueryFrame(aFrame);
  if (subdocFrame) {
    PresShell* presShell = subdocFrame->GetSubdocumentPresShellForPainting(
        nsSubDocumentFrame::IGNORE_PAINT_SUPPRESSION);
    if (presShell && !presShell->AssumeAllFramesVisible()) {
      nsRect rect = aRect;
      nsIFrame* root = presShell->GetRootFrame();
      if (root) {
        rect.MoveBy(aFrame->GetOffsetToCrossDoc(root));
      } else {
        rect.MoveBy(-aFrame->GetContentRectRelativeToSelf().TopLeft());
      }
      rect = rect.ScaleToOtherAppUnitsRoundOut(
          aFrame->PresContext()->AppUnitsPerDevPixel(),
          presShell->GetPresContext()->AppUnitsPerDevPixel());

      presShell->RebuildApproximateFrameVisibility(&rect);
    }
    return;
  }

  nsRect rect = aRect;

  if (ScrollContainerFrame* scrollFrame = do_QueryFrame(aFrame)) {
    bool ignoreDisplayPort = false;
    if (DisplayPortUtils::IsMissingDisplayPortBaseRect(aFrame->GetContent())) {
      // We can properly set the base rect for root scroll frames on top level
      // and root content documents. Otherwise the base rect we compute might
      // be way too big without the limiting that
      // ScrollContainerFrame::DecideScrollableLayer does, so we just ignore the
      // displayport in that case.
      nsPresContext* pc = aFrame->PresContext();
      if (scrollFrame->IsRootScrollFrameOfDocument() &&
          (pc->IsRootContentDocumentCrossProcess() ||
           (pc->IsChrome() && !pc->GetParentPresContext()))) {
        nsRect baseRect(
            nsPoint(), nsLayoutUtils::CalculateCompositionSizeForFrame(aFrame));
        DisplayPortUtils::SetDisplayPortBase(aFrame->GetContent(), baseRect);
      } else {
        ignoreDisplayPort = true;
      }
    }

    nsRect displayPort;
    bool usingDisplayport =
        !ignoreDisplayPort &&
        DisplayPortUtils::GetDisplayPortForVisibilityTesting(
            aFrame->GetContent(), &displayPort);

    scrollFrame->NotifyApproximateFrameVisibilityUpdate(!usingDisplayport);

    if (usingDisplayport) {
      rect = displayPort;
    } else {
      rect = rect.Intersect(scrollFrame->GetScrollPortRect());
    }
    rect = scrollFrame->ExpandRectToNearlyVisible(rect);
  }

  for (const auto& [list, listID] : aFrame->ChildLists()) {
    for (nsIFrame* child : list) {
      // Note: This assert should be trivially satisfied, just by virtue of how
      // nsFrameList and its iterator works (with nullptr being an end-of-list
      // sentinel which should terminate the loop).  But we do somehow get
      // crash reports inside this loop that suggest `child` is null...
      MOZ_DIAGNOSTIC_ASSERT(child, "shouldn't have null values in child lists");

      const bool extend3DContext = child->Extend3DContext();
      const bool combines3DTransformWithAncestors =
          (extend3DContext || child->IsTransformed()) &&
          child->Combines3DTransformWithAncestors();

      nsRect r = rect - child->GetPosition();
      if (!combines3DTransformWithAncestors) {
        if (!r.IntersectRect(r, child->InkOverflowRect())) {
          continue;
        }
      }

      nsRect newPreserve3DRect = aPreserve3DRect;
      if (extend3DContext && !combines3DTransformWithAncestors) {
        newPreserve3DRect = r;
      }

      if (child->IsTransformed()) {
        if (combines3DTransformWithAncestors) {
          r = newPreserve3DRect;
        }
        const nsRect overflow = child->InkOverflowRectRelativeToSelf();
        nsRect out;
        if (nsDisplayTransform::UntransformRect(r, overflow, child, &out)) {
          r = out;
        } else {
          r.SetEmpty();
        }
      }
      MarkFramesInSubtreeApproximatelyVisible(child, r, newPreserve3DRect,
                                              aRemoveOnly);
    }
  }
}

void PresShell::RebuildApproximateFrameVisibility(
    nsRect* aRect, bool aRemoveOnly /* = false */) {
  MOZ_ASSERT(!mApproximateFrameVisibilityVisited, "already visited?");
  mApproximateFrameVisibilityVisited = true;

  nsIFrame* rootFrame = GetRootFrame();
  if (!rootFrame) {
    return;
  }

  // Remove the entries of the mApproximatelyVisibleFrames hashtable and put
  // them in oldApproximatelyVisibleFrames.
  VisibleFrames oldApproximatelyVisibleFrames =
      std::move(mApproximatelyVisibleFrames);

  nsRect vis(nsPoint(0, 0), rootFrame->GetSize());
  if (aRect) {
    vis = *aRect;
  }

  // If we are in-process root but not the top level content, we need to take
  // the intersection with the iframe visible rect.
  if (mPresContext->IsRootContentDocumentInProcess() &&
      !mPresContext->IsRootContentDocumentCrossProcess()) {
    // There are two possibilities that we can't get the iframe's visible
    // rect other than the iframe is out side of ancestors' display ports.
    // a) the BrowserChild is being torn down
    // b) the visible rect hasn't been delivered the BrowserChild
    // In both cases we consider the visible rect is empty.
    Maybe<nsRect> visibleRect;
    if (BrowserChild* browserChild = BrowserChild::GetFrom(this)) {
      visibleRect = browserChild->GetVisibleRect();
    }
    vis = vis.Intersect(visibleRect.valueOr(nsRect()));
  }

  MarkFramesInSubtreeApproximatelyVisible(rootFrame, vis, vis, aRemoveOnly);

  DecApproximateVisibleCount(oldApproximatelyVisibleFrames);
}

void PresShell::UpdateApproximateFrameVisibility() {
  DoUpdateApproximateFrameVisibility(/* aRemoveOnly = */ false);
}

void PresShell::DoUpdateApproximateFrameVisibility(bool aRemoveOnly) {
  MOZ_ASSERT(
      !mPresContext || mPresContext->IsRootContentDocumentInProcess(),
      "Updating approximate frame visibility on a non-root content document?");

  mUpdateApproximateFrameVisibilityEvent.Revoke();

  if (mHaveShutDown || mIsDestroying) {
    return;
  }

  // call update on that frame
  nsIFrame* rootFrame = GetRootFrame();
  if (!rootFrame) {
    ClearApproximatelyVisibleFramesList(Some(OnNonvisible::DiscardImages));
    return;
  }

  RebuildApproximateFrameVisibility(/* aRect = */ nullptr, aRemoveOnly);
  ClearApproximateFrameVisibilityVisited();

#ifdef DEBUG_FRAME_VISIBILITY_DISPLAY_LIST
  // This can be used to debug the frame walker by comparing beforeFrameList
  // and mApproximatelyVisibleFrames in RebuildFrameVisibilityDisplayList to see
  // if they produce the same results (mApproximatelyVisibleFrames holds the
  // frames the display list thinks are visible, beforeFrameList holds the
  // frames the frame walker thinks are visible).
  nsDisplayListBuilder builder(
      rootFrame, nsDisplayListBuilderMode::FRAME_VISIBILITY, false);
  nsRect updateRect(nsPoint(0, 0), rootFrame->GetSize());
  nsIFrame* rootScroll = GetRootScrollFrame();
  if (rootScroll) {
    nsIContent* content = rootScroll->GetContent();
    if (content) {
      (void)nsLayoutUtils::GetDisplayPortForVisibilityTesting(
          content, &updateRect, RelativeTo::ScrollFrame);
    }

    if (IgnoringViewportScrolling()) {
      builder.SetIgnoreScrollFrame(rootScroll);
    }
  }
  builder.IgnorePaintSuppression();
  builder.EnterPresShell(rootFrame);
  nsDisplayList list;
  rootFrame->BuildDisplayListForStackingContext(&builder, updateRect, &list);
  builder.LeavePresShell(rootFrame, &list);

  RebuildApproximateFrameVisibilityDisplayList(list);

  ClearApproximateFrameVisibilityVisited();

  list.DeleteAll(&builder);
#endif
}

bool PresShell::AssumeAllFramesVisible() {
  if (!StaticPrefs::layout_framevisibility_enabled() || !mPresContext ||
      !mDocument) {
    return true;
  }

  // We assume all frames are visible in print, print preview, chrome, and
  // resource docs and don't keep track of them.
  if (mPresContext->Type() == nsPresContext::eContext_PrintPreview ||
      mPresContext->Type() == nsPresContext::eContext_Print ||
      mPresContext->IsChrome() || mDocument->IsResourceDoc()) {
    return true;
  }

  // If we're assuming all frames are visible in the top level content
  // document, we need to in subdocuments as well. Otherwise we can get in a
  // situation where things like animations won't work in subdocuments because
  // their frames appear not to be visible, since we won't schedule an image
  // visibility update if the top level content document is assuming all
  // frames are visible.
  //
  // Note that it's not safe to call IsRootContentDocumentInProcess() if we're
  // currently being destroyed, so we have to check that first.
  if (!mHaveShutDown && !mIsDestroying &&
      !mPresContext->IsRootContentDocumentInProcess()) {
    nsPresContext* presContext =
        mPresContext->GetInProcessRootContentDocumentPresContext();
    if (presContext && presContext->PresShell()->AssumeAllFramesVisible()) {
      return true;
    }
  }

  return false;
}

void PresShell::ScheduleApproximateFrameVisibilityUpdateSoon() {
  if (AssumeAllFramesVisible()) {
    return;
  }

  if (!mPresContext) {
    return;
  }

  nsRefreshDriver* refreshDriver = mPresContext->RefreshDriver();
  if (!refreshDriver) {
    return;
  }

  // Ask the refresh driver to update frame visibility soon.
  refreshDriver->ScheduleFrameVisibilityUpdate();
}

void PresShell::ScheduleApproximateFrameVisibilityUpdateNow() {
  if (AssumeAllFramesVisible()) {
    return;
  }

  if (!mPresContext->IsRootContentDocumentInProcess()) {
    nsPresContext* presContext =
        mPresContext->GetInProcessRootContentDocumentPresContext();
    if (!presContext) {
      return;
    }
    MOZ_ASSERT(presContext->IsRootContentDocumentInProcess(),
               "Didn't get a root prescontext from "
               "GetInProcessRootContentDocumentPresContext?");
    presContext->PresShell()->ScheduleApproximateFrameVisibilityUpdateNow();
    return;
  }

  if (mHaveShutDown || mIsDestroying) {
    return;
  }

  if (mUpdateApproximateFrameVisibilityEvent.IsPending()) {
    return;
  }

  RefPtr<nsRunnableMethod<PresShell>> event =
      NewRunnableMethod("PresShell::UpdateApproximateFrameVisibility", this,
                        &PresShell::UpdateApproximateFrameVisibility);
  nsresult rv = mDocument->Dispatch(do_AddRef(event));

  if (NS_SUCCEEDED(rv)) {
    mUpdateApproximateFrameVisibilityEvent = std::move(event);
  }
}

void PresShell::EnsureFrameInApproximatelyVisibleList(nsIFrame* aFrame) {
  if (!aFrame->TrackingVisibility()) {
    return;
  }

  if (AssumeAllFramesVisible()) {
    aFrame->IncApproximateVisibleCount();
    return;
  }

#ifdef DEBUG
  // Make sure it's in this pres shell.
  nsCOMPtr<nsIContent> content = aFrame->GetContent();
  if (content) {
    PresShell* presShell = content->OwnerDoc()->GetPresShell();
    MOZ_ASSERT(!presShell || presShell == this, "wrong shell");
  }
#endif

  if (mApproximatelyVisibleFrames.EnsureInserted(aFrame)) {
    // We inserted a new entry.
    aFrame->IncApproximateVisibleCount();
  }
}

void PresShell::RemoveFrameFromApproximatelyVisibleList(nsIFrame* aFrame) {
#ifdef DEBUG
  // Make sure it's in this pres shell.
  nsCOMPtr<nsIContent> content = aFrame->GetContent();
  if (content) {
    PresShell* presShell = content->OwnerDoc()->GetPresShell();
    MOZ_ASSERT(!presShell || presShell == this, "wrong shell");
  }
#endif

  if (AssumeAllFramesVisible()) {
    MOZ_ASSERT(mApproximatelyVisibleFrames.Count() == 0,
               "Shouldn't have any frames in the table");
    return;
  }

  if (mApproximatelyVisibleFrames.EnsureRemoved(aFrame) &&
      aFrame->TrackingVisibility()) {
    // aFrame was in the hashtable, and we're still tracking its visibility,
    // so we need to decrement its visible count.
    aFrame->DecApproximateVisibleCount();
  }
}

void PresShell::PaintAndRequestComposite(nsIFrame* aFrame,
                                         WindowRenderer* aRenderer,
                                         PaintFlags aFlags) {
  if (!mIsActive) {
    return;
  }

  NS_ASSERTION(aRenderer, "Must be in paint event");
  if (aRenderer->AsFallback()) {
    // The fallback renderer doesn't do any retaining, so we just need to
    // notify the view and widget that we're invalid, and we'll do a
    // paint+composite from the PaintWindow callback.
    if (nsIWidget* widget = aFrame ? aFrame->GetOwnWidget() : nullptr) {
      auto bounds = widget->GetBounds();
      widget->Invalidate(LayoutDeviceIntRect({}, bounds.Size()));
    }
    return;
  }

  // Otherwise we're a retained WebRenderLayerManager, so we want to call
  // Paint to update with any changes and push those to WR.
  PaintInternalFlags flags = PaintInternalFlags::None;
  if (aFlags & PaintFlags::PaintSyncDecodeImages) {
    flags |= PaintInternalFlags::PaintSyncDecodeImages;
  }
  if (aFlags & PaintFlags::PaintCompositeOffscreen) {
    flags |= PaintInternalFlags::PaintCompositeOffscreen;
  }
  PaintInternal(aFrame, aRenderer, flags);
}

void PresShell::SyncPaintFallback(nsIFrame* aFrame, WindowRenderer* aRenderer) {
  if (!mIsActive) {
    return;
  }

  NS_ASSERTION(aRenderer->AsFallback(),
               "Can't do Sync paint for remote renderers");
  if (!aRenderer->AsFallback()) {
    return;
  }

  PaintInternal(aFrame, aRenderer, PaintInternalFlags::PaintComposite);
  GetPresContext()->NotifyDidPaintForSubtree();
}

void PresShell::PaintInternal(nsIFrame* aFrame, WindowRenderer* aRenderer,
                              PaintInternalFlags aFlags) {
  MOZ_ASSERT_IF(aFrame,
                aFrame->IsViewportFrame() || aFrame->IsMenuPopupFrame());
  nsCString url;
  nsIURI* uri = mDocument->GetDocumentURI();
  Document* contentRoot = GetPrimaryContentDocument();
  if (contentRoot) {
    uri = contentRoot->GetDocumentURI();
  }
  url = uri ? uri->GetSpecOrDefault() : "N/A"_ns;
  AUTO_PROFILER_LABEL_DYNAMIC_NSCSTRING_RELEVANT_FOR_JS(
      "Paint", GRAPHICS, Substring(url, std::min(size_t(128), url.Length())));

  Maybe<js::AutoAssertNoContentJS> nojs;

  // On Android, Flash can call into content JS during painting, so we can't
  // assert there. However, we don't rely on this assertion on Android because
  // we don't paint while JS is running.
#if !defined(MOZ_WIDGET_ANDROID)
  if (!(aFlags & PaintInternalFlags::PaintComposite)) {
    // We need to allow content JS when the flag is set since we may trigger
    // MozAfterPaint events in content in those cases.
    nojs.emplace(dom::danger::GetJSContext());
  }
#endif

  NS_ASSERTION(!mIsDestroying, "painting a destroyed PresShell");
  NS_ASSERTION(aRenderer, "null renderer");

  MOZ_ASSERT(!mApproximateFrameVisibilityVisited, "Should have been cleared");

  if (!mIsActive) {
    return;
  }

  FocusTarget focusTarget;
  if (StaticPrefs::apz_keyboard_enabled_AtStartup()) {
    // Update the focus target for async keyboard scrolling. This will be
    // forwarded to APZ by nsDisplayList::PaintRoot. We need to to do this
    // before we enter the paint phase because dispatching eVoid events can
    // cause layout to happen.
    uint64_t focusSequenceNumber = mAPZFocusSequenceNumber;
    if (nsMenuPopupFrame* popup = do_QueryFrame(aFrame)) {
      focusSequenceNumber = popup->GetAPZFocusSequenceNumber();
    }
    focusTarget = FocusTarget(this, focusSequenceNumber);
  }

  nsPresContext* presContext = GetPresContext();
  AUTO_LAYOUT_PHASE_ENTRY_POINT(presContext, Paint);

  WebRenderLayerManager* layerManager = aRenderer->AsWebRender();

  // Whether or not we should set first paint when painting is suppressed
  // is debatable. For now we'll do it because B2G relied on first paint
  // to configure the viewport and we only want to do that when we have
  // real content to paint. See Bug 798245
  if (mIsFirstPaint && !mPaintingSuppressed) {
    MOZ_LOG(gLog, LogLevel::Debug,
            ("PresShell::Paint, first paint, this=%p", this));

    if (layerManager) {
      layerManager->SetIsFirstPaint();
    }
    mIsFirstPaint = false;
  }

  const bool offscreen =
      bool(aFlags & PaintInternalFlags::PaintCompositeOffscreen);

  if (!aRenderer->BeginTransaction(url)) {
    return;
  }

  // Send an updated focus target with this transaction. Be sure to do this
  // before we paint in the case this is an empty transaction.
  if (layerManager) {
    layerManager->SetFocusTarget(focusTarget);
  }

  if (aFrame) {
    if (!(aFlags & PaintInternalFlags::PaintSyncDecodeImages) &&
        !aFrame->HasAnyStateBits(NS_FRAME_UPDATE_LAYER_TREE)) {
      if (layerManager) {
        layerManager->SetTransactionIdAllocator(presContext->RefreshDriver());
      }

      if (aRenderer->EndEmptyTransaction(
              (aFlags & PaintInternalFlags::PaintComposite)
                  ? WindowRenderer::END_DEFAULT
                  : WindowRenderer::END_NO_COMPOSITE)) {
        return;
      }
    }
    aFrame->RemoveStateBits(NS_FRAME_UPDATE_LAYER_TREE);
  }

  nscolor bgcolor = ComputeBackstopColor(aFrame);
  PaintFrameFlags flags =
      PaintFrameFlags::WidgetLayers | PaintFrameFlags::ExistingTransaction;

  // We force sync-decode for printing / print-preview (printing already does
  // this from nsPageSequenceFrame::PrintNextSheet).
  // We also force sync-decoding via pref for reftests.
  if (aFlags & PaintInternalFlags::PaintSyncDecodeImages ||
      mDocument->IsStaticDocument() ||
      StaticPrefs::image_testing_decode_sync_enabled()) {
    flags |= PaintFrameFlags::SyncDecodeImages;
  }
  if (aFlags & PaintInternalFlags::PaintCompositeOffscreen) {
    flags |= PaintFrameFlags::CompositeOffscreen;
  }
  if (aRenderer->GetBackendType() == layers::LayersBackend::LAYERS_WR) {
    flags |= PaintFrameFlags::ForWebRender;
  }

  if (aFrame) {
    // We can paint directly into the widget using its layer manager.
    SelectionNodeCache cache(*this);
    nsLayoutUtils::PaintFrame(nullptr, aFrame, nsRegion(), bgcolor,
                              nsDisplayListBuilderMode::Painting, flags);
    return;
  }

  bgcolor = NS_ComposeColors(bgcolor, mCanvasBackground.mViewport.mColor);

  if (aRenderer->GetBackendType() == layers::LayersBackend::LAYERS_WR) {
    LayoutDeviceRect bounds = LayoutDeviceRect::FromAppUnits(
        presContext->GetVisibleArea(), presContext->AppUnitsPerDevPixel());
    WebRenderBackgroundData data(wr::ToLayoutRect(bounds),
                                 wr::ToColorF(ToDeviceColor(bgcolor)));
    WrFiltersHolder wrFilters;

    layerManager->SetTransactionIdAllocator(presContext->RefreshDriver());
    layerManager->EndTransactionWithoutLayer(
        nullptr, nullptr, std::move(wrFilters), &data, 0, offscreen);
    return;
  }

  FallbackRenderer* fallback = aRenderer->AsFallback();
  MOZ_ASSERT(fallback);

  if (aFlags & PaintInternalFlags::PaintComposite) {
    nsIntRect bounds = presContext->GetVisibleArea().ToOutsidePixels(
        presContext->AppUnitsPerDevPixel());
    fallback->EndTransactionWithColor(bounds, ToDeviceColor(bgcolor));
  }
}

// static
void PresShell::SetCapturingContent(nsIContent* aContent, CaptureFlags aFlags,
                                    WidgetEvent* aEvent) {
  // If capture was set for pointer lock, don't unlock unless we are coming
  // out of pointer lock explicitly.
  if (!aContent && sCapturingContentInfo.mPointerLock &&
      !(aFlags & CaptureFlags::PointerLock)) {
    return;
  }

  sCapturingContentInfo.mContent = nullptr;
  sCapturingContentInfo.mRemoteTarget = nullptr;

  // only set capturing content if allowed or the
  // CaptureFlags::IgnoreAllowedState or CaptureFlags::PointerLock are used.
  if ((aFlags & CaptureFlags::IgnoreAllowedState) ||
      sCapturingContentInfo.mAllowed || (aFlags & CaptureFlags::PointerLock)) {
    if (aContent) {
      sCapturingContentInfo.mContent = aContent;
    }
    if (aEvent) {
      MOZ_ASSERT(XRE_IsParentProcess());
      MOZ_ASSERT(aEvent->mMessage == eMouseDown);
      MOZ_ASSERT(aEvent->HasBeenPostedToRemoteProcess());
      sCapturingContentInfo.mRemoteTarget =
          BrowserParent::GetLastMouseRemoteTarget();
      MOZ_ASSERT(sCapturingContentInfo.mRemoteTarget);
    }
    // CaptureFlags::PointerLock is the same as
    // CaptureFlags::RetargetToElement & CaptureFlags::IgnoreAllowedState.
    sCapturingContentInfo.mRetargetToElement =
        !!(aFlags & CaptureFlags::RetargetToElement) ||
        !!(aFlags & CaptureFlags::PointerLock);
    sCapturingContentInfo.mPreventDrag =
        !!(aFlags & CaptureFlags::PreventDragStart);
    sCapturingContentInfo.mPointerLock = !!(aFlags & CaptureFlags::PointerLock);
  }
}

nsIContent* PresShell::GetCurrentEventContent() {
  if (mCurrentEventTarget.mContent &&
      mCurrentEventTarget.mContent->GetComposedDoc() != mDocument) {
    mCurrentEventTarget.Clear();
  }
  return mCurrentEventTarget.mContent;
}

nsIFrame* PresShell::GetCurrentEventFrame() {
  if (MOZ_UNLIKELY(mIsDestroying)) {
    return nullptr;
  }

  // GetCurrentEventContent() makes sure the content is still in the
  // same document that this pres shell belongs to. If not, then the
  // frame shouldn't get an event, nor should we even assume its safe
  // to try and find the frame.
  nsIContent* content = GetCurrentEventContent();
  if (!mCurrentEventTarget.mFrame && content) {
    mCurrentEventTarget.mFrame = content->GetPrimaryFrame();
    MOZ_ASSERT_IF(
        mCurrentEventTarget.mFrame,
        mCurrentEventTarget.mFrame->PresContext()->GetPresShell() == this);
  }
  return mCurrentEventTarget.mFrame;
}

nsIContent* PresShell::GetExplicitEventTargetContent(
    const WidgetEvent* aEvent /* = nullptr */) {
  nsIContent* content = GetCurrentEventContent();
  if (!content) {
    if (nsIFrame* currentEventFrame = GetCurrentEventFrame()) {
      content = currentEventFrame->GetExplicitEventTargetContent(aEvent);
      NS_ASSERTION(!content || content->GetComposedDoc() == mDocument,
                   "handing out content from a different doc");
    }
  }
  return content;
}

nsIContent* PresShell::GetEventTargetContent(
    const WidgetEvent* aEvent /* = nullptr */) {
  return nsContentUtils::GetEventTargetContent(
      GetExplicitEventTargetContent(aEvent), aEvent);
}

void PresShell::PushCurrentEventInfo(const EventTargetInfo& aInfo) {
  if (mCurrentEventTarget.IsSet()) {
    // XXX Why do we insert first item instead of append it? This requires to
    // move the previous items...
    mCurrentEventTargetStack.InsertElementAt(0, std::move(mCurrentEventTarget));
  }
  mCurrentEventTarget = aInfo;
}

void PresShell::PushCurrentEventInfo(EventTargetInfo&& aInfo) {
  if (mCurrentEventTarget.IsSet()) {
    mCurrentEventTargetStack.InsertElementAt(0, std::move(mCurrentEventTarget));
  }
  mCurrentEventTarget = std::move(aInfo);
}

void PresShell::PopCurrentEventInfo() {
  mCurrentEventTarget.Clear();

  if (!mCurrentEventTargetStack.IsEmpty()) {
    mCurrentEventTarget = std::move(mCurrentEventTargetStack[0]);
    mCurrentEventTargetStack.RemoveElementAt(0);

    // Don't use it if it has moved to a different document.
    if (mCurrentEventTarget.mContent &&
        mCurrentEventTarget.mContent->GetComposedDoc() != mDocument) {
      mCurrentEventTarget.Clear();
    }
  }
}

// static
bool PresShell::EventHandler::InZombieDocument(nsIContent* aContent) {
  // If a content node points to a null document, or the document is not
  // attached to a window, then it is possibly in a zombie document,
  // about to be replaced by a newly loading document.
  // Such documents cannot handle DOM events.
  // It might actually be in a node not attached to any document,
  // in which case there is not parent presshell to retarget it to.
  Document* doc = aContent->GetComposedDoc();
  return !doc || !doc->GetWindow();
}

already_AddRefed<nsPIDOMWindowOuter> PresShell::GetRootWindow() {
  nsCOMPtr<nsPIDOMWindowOuter> window = mDocument->GetWindow();
  if (window) {
    nsCOMPtr<nsPIDOMWindowOuter> rootWindow = window->GetPrivateRoot();
    NS_ASSERTION(rootWindow, "nsPIDOMWindow::GetPrivateRoot() returns NULL");
    return rootWindow.forget();
  }

  // If we don't have DOM window, we're zombie, we should find the root window
  // with our parent shell.
  RefPtr<PresShell> parentPresShell = GetParentPresShellForEventHandling();
  NS_ENSURE_TRUE(parentPresShell, nullptr);
  return parentPresShell->GetRootWindow();
}

already_AddRefed<nsPIDOMWindowOuter>
PresShell::GetFocusedDOMWindowInOurWindow() {
  nsCOMPtr<nsPIDOMWindowOuter> rootWindow = GetRootWindow();
  NS_ENSURE_TRUE(rootWindow, nullptr);
  nsCOMPtr<nsPIDOMWindowOuter> focusedWindow;
  nsFocusManager::GetFocusedDescendant(rootWindow,
                                       nsFocusManager::eIncludeAllDescendants,
                                       getter_AddRefs(focusedWindow));
  return focusedWindow.forget();
}

already_AddRefed<nsIContent> PresShell::GetFocusedContentInOurWindow() const {
  nsFocusManager* fm = nsFocusManager::GetFocusManager();
  if (fm && mDocument) {
    RefPtr<Element> focusedElement;
    fm->GetFocusedElementForWindow(mDocument->GetWindow(), false, nullptr,
                                   getter_AddRefs(focusedElement));
    return focusedElement.forget();
  }
  return nullptr;
}

already_AddRefed<PresShell> PresShell::GetParentPresShellForEventHandling() {
  if (!mPresContext) {
    return nullptr;
  }

  // Now, find the parent pres shell and send the event there
  RefPtr<nsDocShell> docShell = mPresContext->GetDocShell();
  if (!docShell) {
    docShell = mForwardingContainer.get();
  }

  // Might have gone away, or never been around to start with
  if (!docShell) {
    return nullptr;
  }

  BrowsingContext* bc = docShell->GetBrowsingContext();
  if (!bc) {
    return nullptr;
  }

  RefPtr<BrowsingContext> parentBC;
  if (XRE_IsParentProcess()) {
    parentBC = bc->Canonical()->GetParentCrossChromeBoundary();
  } else {
    parentBC = bc->GetParent();
  }

  RefPtr<nsIDocShell> parentDocShell =
      parentBC ? parentBC->GetDocShell() : nullptr;
  if (!parentDocShell) {
    return nullptr;
  }

  RefPtr<PresShell> parentPresShell = parentDocShell->GetPresShell();
  return parentPresShell.forget();
}

nsresult PresShell::EventHandler::RetargetEventToParent(
    WidgetGUIEvent* aGUIEvent, nsEventStatus* aEventStatus) {
  // Send this events straight up to the parent pres shell.
  // We do this for keystroke events in zombie documents or if either a frame
  // or a root content is not present.
  // That way at least the UI key bindings can work.

  RefPtr<PresShell> parentPresShell = GetParentPresShellForEventHandling();
  NS_ENSURE_TRUE(parentPresShell, NS_ERROR_FAILURE);

  // Fake the event as though it's from the parent pres shell's root frame.
  return parentPresShell->HandleEvent(parentPresShell->GetRootFrame(),
                                      aGUIEvent, true, aEventStatus);
}

void PresShell::DisableNonTestMouseEvents(bool aDisable) {
  sDisableNonTestMouseEvents = aDisable;
}

nsPoint PresShell::GetEventLocation(const WidgetMouseEvent& aEvent) const {
  nsIFrame* rootFrame = GetRootFrame();
  if (!rootFrame) {
    // Matches old TranslateWidgetToView behavior
    return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
  }

  RelativeTo relativeTo{rootFrame};
  if (rootFrame->PresContext()->IsRootContentDocumentCrossProcess()) {
    relativeTo.mViewportType = ViewportType::Visual;
  }
  return nsLayoutUtils::GetEventCoordinatesRelativeTo(&aEvent, relativeTo);
}

void PresShell::RecordPointerLocation(WidgetGUIEvent* aEvent) {
  if (!mPresContext) {
    return;
  }

  if (!IsRoot()) {
    PresShell* rootPresShell = GetRootPresShell();
    if (rootPresShell) {
      rootPresShell->RecordPointerLocation(aEvent);
    }
    return;
  }

  const auto StoreMouseLocation = [&](const WidgetMouseEvent& aMouseEvent) {
    if (aMouseEvent.mMessage == eMouseMove && aMouseEvent.IsSynthesized()) {
      return false;
    }
    PointerEventHandler::RecordMouseState(*this, aMouseEvent);
    mLastMousePointerId = Some(aMouseEvent.pointerId);
    return true;
  };

  const auto ClearMouseLocation = [&](const WidgetMouseEvent& aMouseEvent) {
    PointerEventHandler::ClearMouseState(*this, aMouseEvent);
    mLastMousePointerId.reset();
  };

  const auto ClearMouseLocationIfSetByTouch =
      [&](const WidgetPointerEvent& aPointerEvent) {
        const PointerInfo* lastMouseInfo =
            PointerEventHandler::GetLastMouseInfo(this);
        if (lastMouseInfo && lastMouseInfo->HasLastState() &&
            lastMouseInfo->mInputSource ==
                MouseEvent_Binding::MOZ_SOURCE_TOUCH &&
            aPointerEvent.mInputSource ==
                MouseEvent_Binding::MOZ_SOURCE_TOUCH) {
          ClearMouseLocation(aPointerEvent);
        }
      };

  const auto StorePointerLocation =
      [&](const WidgetMouseEvent& aMouseOrPointerEvent) {
        if (!mPointerIds.Contains(aMouseOrPointerEvent.pointerId)) {
          mPointerIds.AppendElement(aMouseOrPointerEvent.pointerId);
        }
        PointerEventHandler::RecordPointerState(
            GetEventLocation(aMouseOrPointerEvent), aMouseOrPointerEvent);
      };

  const auto ClearPointerLocation =
      [&](const WidgetMouseEvent& aMouseOrPointerEvent) {
        mPointerIds.RemoveElement(aMouseOrPointerEvent.pointerId);
        PointerEventHandler::RecordPointerState(
            nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE),
            aMouseOrPointerEvent);
      };

  const auto StoreLastPointerEventLocation =
      [&](const WidgetMouseEvent& aMouseOrPointerEvent) {
        // TODO: instead, encapsulate mMouseLocation and
        // `mLastOverWindowPointerLocation` in a struct.
        mLastOverWindowPointerLocation = GetEventLocation(aMouseOrPointerEvent);
      };

  switch (aEvent->mMessage) {
    case eMouseMove:
    case eMouseEnterIntoWidget:
    case eMouseDown:
    case eMouseUp:
    case eDragEnter:
    case eDragStart:
    case eDragOver:
    case eDrop: {
      const WidgetMouseEvent& mouseEvent = *aEvent->AsMouseEvent();
      if (StoreMouseLocation(mouseEvent) &&
          (aEvent->mMessage == eMouseEnterIntoWidget ||
           aEvent->mClass == eDragEventClass)) {
        SynthesizeMouseMove(false);
      }
      // In a drag session, we won't dispatch pointer events except
      // ePointerCancel immediately after eDragStart.  However, once the drag
      // session ends, we want to synthesize ePointerMove at the dropped point.
      // Therefore, we should update the last state of the pointer when we start
      // handling a drag event.
      // We also need to store the pointer location for eMouseEnterIntoWidget,
      // so that the pointer boundary event can be generated earlier.
      if (aEvent->mMessage == eMouseEnterIntoWidget ||
          aEvent->mClass == eDragEventClass) {
        StorePointerLocation(mouseEvent);
      }
      break;
    }
    case eDragExit: {
      const WidgetMouseEvent& mouseEvent = *aEvent->AsMouseEvent();
      if (aEvent->mRelatedTarget) {
        // not exit from the widget
        break;
      }
      ClearMouseLocation(mouseEvent);
      ClearPointerLocation(mouseEvent);
      break;
    }
    case eMouseExitFromWidget: {
      const WidgetMouseEvent& mouseEvent = *aEvent->AsMouseEvent();
      // Although we only care about the mouse moving into an area for which
      // this pres shell doesn't receive mouse move events, we don't check which
      // widget the mouse exit was for since this seems to vary by platform.
      // Hopefully this won't matter at all since we'll get the mouse move or
      // enter after the mouse exit when the mouse moves from one of our widgets
      // into another.
      ClearMouseLocation(mouseEvent);
      ClearPointerLocation(mouseEvent);
      break;
    }
    case ePointerMove:
    case ePointerRawUpdate:
    case eMouseRawUpdate: {
      const WidgetMouseEvent& mouseEvent = *aEvent->AsMouseEvent();
      if (!mouseEvent.IsReal()) {
        break;
      }
      StoreLastPointerEventLocation(mouseEvent);
      if (const WidgetPointerEvent* const pointerEvent =
              mouseEvent.AsPointerEvent()) {
        StorePointerLocation(*pointerEvent);
      }
      break;
    }
    case ePointerDown: {
      const WidgetPointerEvent& pointerEvent = *aEvent->AsPointerEvent();
      StoreLastPointerEventLocation(pointerEvent);
      StorePointerLocation(pointerEvent);
      break;
    }
    case ePointerUp: {
      const WidgetPointerEvent& pointerEvent = *aEvent->AsPointerEvent();
      StoreLastPointerEventLocation(pointerEvent);
      // If the pointer supports hover, we need to keep storing the last
      // position to synthesize ePointerMove after layout changes.
      if (pointerEvent.InputSourceSupportsHover()) {
        StorePointerLocation(pointerEvent);
      }
      // If the pointer does not support hover, we won't synthesize ePointerMove
      // for that.  So, we can clear the pointer location.
      else {
        ClearPointerLocation(pointerEvent);
      }
      // If the pointer is for a touch, we need to forget the last state of
      // mMouseLocation if it was set by a touch because the touch is being
      // removed from the active pointers.
      ClearMouseLocationIfSetByTouch(pointerEvent);
      break;
    }
    case ePointerCancel: {
      // If a touch is canceled, it means that the touch input is tracked by a
      // gesture like swipe to scroll, pinch to zoom or DnD.  So, it means that
      // a normal touch sequence finished.  Then, we shouldn't give `:hover`
      // state to the element underneath the last touch point anymore.  For
      // example, it's odd that new element which comes underneath the first
      // touch position gets `:hover` style even though the scroll is caused
      // by swipe (i.e., has moved the touch position).
      ClearMouseLocationIfSetByTouch(*aEvent->AsPointerEvent());
      break;
    }
    default:
      break;
  }
}

// static
void PresShell::RecordModifiers(WidgetGUIEvent* aEvent) {
  switch (aEvent->mMessage) {
    case eKeyPress:
    case eKeyUp:
    case eKeyDown:
    case eMouseMove:
    case eMouseUp:
    case eMouseDown:
    case eMouseEnterIntoWidget:
    case eMouseExitFromWidget:
    case eMouseActivate:
    case eMouseTouchDrag:
    case eMouseLongTap:
    case eMouseRawUpdate:
    case eMouseExploreByTouch:
    case ePointerCancel:
    case eContextMenu:
    case eTouchStart:
    case eTouchMove:
    case eTouchEnd:
    case eTouchCancel:
    case eTouchPointerCancel:
    case eTouchRawUpdate:
    case eWheel:
      sCurrentModifiers = aEvent->AsInputEvent()->mModifiers;
      break;
    default:
      break;
  }
}

void PresShell::nsSynthMouseMoveEvent::Revoke() {
  if (mPresShell) {
    mPresShell->GetPresContext()->RefreshDriver()->RemoveRefreshObserver(
        this, FlushType::Display);
    mPresShell = nullptr;
  }
}

static CallState FlushThrottledStyles(Document& aDocument) {
  PresShell* presShell = aDocument.GetPresShell();
  if (presShell && presShell->IsVisible()) {
    if (nsPresContext* presContext = presShell->GetPresContext()) {
      presContext->RestyleManager()->UpdateOnlyAnimationStyles();
    }
  }

  aDocument.EnumerateSubDocuments(FlushThrottledStyles);
  return CallState::Continue;
}

bool PresShell::CanDispatchEvent(const WidgetGUIEvent* aEvent) const {
  bool rv =
      mPresContext && !mHaveShutDown && nsContentUtils::IsSafeToRunScript();
  if (aEvent) {
    rv &= (aEvent && aEvent->mWidget && !aEvent->mWidget->Destroyed());
  }
  return rv;
}

/* static */
PresShell* PresShell::GetShellForEventTarget(nsIFrame* aFrame,
                                             nsIContent* aContent) {
  if (aFrame) {
    return aFrame->PresShell();
  }
  if (aContent) {
    Document* doc = aContent->GetComposedDoc();
    if (!doc) {
      return nullptr;
    }
    return doc->GetPresShell();
  }
  return nullptr;
}

/* static */
PresShell* PresShell::GetShellForTouchEvent(WidgetGUIEvent* aEvent) {
  switch (aEvent->mMessage) {
    case eTouchMove:
    case eTouchRawUpdate:
    case eTouchCancel:
    case eTouchEnd: {
      // get the correct shell to dispatch to
      WidgetTouchEvent* touchEvent = aEvent->AsTouchEvent();
      for (dom::Touch* touch : touchEvent->mTouches) {
        if (!touch) {
          return nullptr;
        }

        RefPtr<dom::Touch> oldTouch =
            TouchManager::GetCapturedTouch(touch->Identifier());
        if (!oldTouch) {
          return nullptr;
        }

        nsIContent* const content =
            nsIContent::FromEventTargetOrNull(oldTouch->GetTarget());
        if (!content) {
          return nullptr;
        }

        if (PresShell* const presShell = content->OwnerDoc()->GetPresShell()) {
          return presShell;
        }
      }
      return nullptr;
    }
    default:
      return nullptr;
  }
}

nsresult PresShell::HandleEvent(nsIFrame* aFrameForPresShell,
                                WidgetGUIEvent* aGUIEvent,
                                bool aDontRetargetEvents,
                                nsEventStatus* aEventStatus) {
  MOZ_ASSERT(aGUIEvent);

  RecordModifiers(aGUIEvent);

  AutoWeakFrame weakFrameForPresShell(aFrameForPresShell);

  // Running tests must not expect that some mouse boundary events are fired
  // when something occurs in the parent process, e.g., when a popup is
  // opened/closed at the last mouse cursor position in the parent process (the
  // position may be different from the position which stored in this process).
  // Therefore, let's ignore synthesized mouse events coming form another
  // process if and only if they are not caused by the API.
  if (aGUIEvent->CameFromAnotherProcess() && XRE_IsContentProcess() &&
      !aGUIEvent->mFlags.mIsSynthesizedForTests) {
    const PointerInfo* const lastMouseInfo =
        PointerEventHandler::GetLastMouseInfo();
    if (lastMouseInfo && lastMouseInfo->mIsSynthesizedForTests) {
      switch (aGUIEvent->mMessage) {
        // Synthesized eMouseMove will case mouse boundary events like
        // mouseover, mouseout, and :hover state is changed at dispatching the
        // events.
        case eMouseMove:
        // eMouseExitFromWidget comes from the parent process if the cursor
        // crosses a puppet widget boundary.  Then, the event will be handled as
        // a synthesized eMouseMove in this process and may cause unexpected
        // `mouseout` and `mouseleave`.
        case eMouseExitFromWidget:
        // eMouseEnterIntoWidget causes updating the hover state under the event
        // position which may be different from the last cursor position
        // synthesized in this process.
        case eMouseEnterIntoWidget:
          if (!aGUIEvent->AsMouseEvent()->IsReal()) {
            return NS_OK;
          }
          break;
        default:
          break;
      }
    }
  }

  // Here we are granting some delays to ensure that user input events are
  // created while the page content may not be visible to the user are not
  // processed.
  // The main purpose of this is to avoid user inputs are handled in the
  // new document where as the user inputs were originally targeting some
  // content in the old document.
  if (!CanHandleUserInputEvents(aGUIEvent)) {
    return NS_OK;
  }

  // If there is a composition and we got a pointing device events which may not
  // impossible to continue the composition, we should notify the editor of the
  // event before dispatching it.  Then, composition will be commited before
  // the editor loses focus.  This behavior is compatible with Chrome.
  // FIXME: Perhaps, we should do same thing before dispatching touch events.
  switch (aGUIEvent->mMessage) {
    case eMouseDown:
    case eMouseUp: {
      nsPIDOMWindowOuter* const focusedWindow =
          nsFocusManager::GetFocusedWindowStatic();
      if (!focusedWindow) {
        break;
      }
      Document* const focusedDocument = focusedWindow->GetExtantDoc();
      if (!focusedDocument) {
        break;
      }
      nsPresContext* const focusedPresContext =
          focusedDocument->GetPresContext();
      if (!focusedPresContext) {
        break;
      }
      const RefPtr<TextComposition> textComposition =
          IMEStateManager::GetTextCompositionFor(focusedPresContext);
      if (!textComposition) {
        break;
      }
      // If there is a composition and it's managed by an editor, let's notify
      // the editor of mouse button event.  The editor commits the composition
      // unless IME consumes the event.
      if (RefPtr<EditorBase> editorBase = textComposition->GetEditorBase()) {
        MOZ_ASSERT(aGUIEvent->AsMouseEvent());
        editorBase->WillHandleMouseButtonEvent(*aGUIEvent->AsMouseEvent());
      }
      // Otherwise, we should commit the orphan composition instead.
      else if (nsCOMPtr<nsIWidget> widget = textComposition->GetWidget()) {
        textComposition->RequestToCommit(widget, false);
      }
      if (!CanHandleUserInputEvents(aGUIEvent)) {
        return NS_OK;
      }
      // Before bug 1945988, we dispatched the mouse button event without
      // committing composition and the editor will commit composition.
      // However, for compatibility with the other browsers, we started
      // committing composition before dispatching the mouse event.  To keep
      // the traditional behavior, we should compute aFrameForPresShell if it's
      // reframed by dispatching the composition events (and input events)
      // above.  Otherwise, we stop dispatching the mouse button events newly in
      // such case.
      if (MOZ_UNLIKELY(!weakFrameForPresShell.IsAlive())) {
        FlushPendingNotifications(FlushType::Layout);
        if (MOZ_UNLIKELY(IsDestroying())) {
          return NS_OK;
        }
        nsIFrame* const newFrameForPresShell = GetRootFrame();
        if (MOZ_UNLIKELY(!newFrameForPresShell)) {
          return NS_OK;
        }
        weakFrameForPresShell = newFrameForPresShell;
      }
      break;
    }
    default:
      break;
  }

  if (mPresContext) {
    switch (aGUIEvent->mMessage) {
      case eMouseMove:
      case eMouseRawUpdate:
        if (!aGUIEvent->AsMouseEvent()->IsReal()) {
          break;
        }
        [[fallthrough]];
      case eMouseDown:
      case eMouseUp: {
        // We should flush pending mousemove event now because some mouse
        // boundary events which should've already been dispatched before a user
        // input may have not been dispatched.  E.g., if a mousedown event
        // listener removed or appended an element under the cursor and mouseup
        // event comes immediately after that, mouseover or mouseout may have
        // not been dispatched on the new element yet.
        // XXX If eMouseMove is not propery dispatched before eMouseDown and
        // a `mousedown` event listener removes the event target or its
        // ancestor, eMouseOver will be dispatched between eMouseDown and
        // eMouseUp.  That could cause unexpected behavior if a `mouseover`
        // event listener assumes it's always disptached before `mousedown`.
        // However, we're not sure whether it could happen with users' input.
        // FIXME: Perhaps, we need to do this for all events which are directly
        // caused by user input, e.g., eKeyDown, etc.
        const RefPtr<PresShell> rootPresShell =
            IsRoot() ? this : GetRootPresShell();
        if (rootPresShell && rootPresShell->mSynthMouseMoveEvent.IsPending()) {
          RefPtr<nsSynthMouseMoveEvent> synthMouseMoveEvent =
              rootPresShell->mSynthMouseMoveEvent.get();
          synthMouseMoveEvent->Run();
          if (IsDestroying()) {
            return NS_OK;
          }
          // XXX If the frame or "this" is reframed, it might be better to
          // recompute the frame.  However, it could treat the user input on
          // unexpected element.  Therefore, we should not do that until we'd
          // get a bug report caused by that.
          if (MOZ_UNLIKELY(!weakFrameForPresShell.IsAlive())) {
            return NS_OK;
          }
        }
        break;
      }
      default:
        break;
    }
  }

  // If the event may cause ePointerMove, we need to dispatch ePointerRawUpdate
  // before that if and only if there are some `pointerrawupdate` event
  // listeners.  Note that if a `pointerrawupdate` event listener destroys its
  // document/window, we need to dispatch the following pointer event (e.g.,
  // ePointerMove) in the parent document/window with the parent PresShell.
  // Therefore, we need to consider the target PresShell for each event
  // (ePointerRawUpdate and the following pointer event) in
  // EventHandler::HandleEvent().  Thus, we need to dispatch the internal event
  // for ePointerRawUpdate before calling EventHandler::HandleEvent() below.
  if (!aDontRetargetEvents &&
      StaticPrefs::dom_event_pointer_rawupdate_enabled()) {
    nsresult rv = EnsurePrecedingPointerRawUpdate(
        weakFrameForPresShell, *aGUIEvent, aDontRetargetEvents);
    if (NS_FAILED(rv)) {
      return rv;
    }
    if (!CanHandleUserInputEvents(aGUIEvent)) {
      return NS_OK;
    }
  }

  EventHandler eventHandler(*this);
  return eventHandler.HandleEvent(weakFrameForPresShell, aGUIEvent,
                                  aDontRetargetEvents, aEventStatus);
}

nsresult PresShell::EnsurePrecedingPointerRawUpdate(
    AutoWeakFrame& aWeakFrameForPresShell, const WidgetGUIEvent& aSourceEvent,
    bool aDontRetargetEvents) {
  MOZ_ASSERT(StaticPrefs::dom_event_pointer_rawupdate_enabled());
  if (PointerEventHandler::ToPointerEventMessage(&aSourceEvent) !=
      ePointerMove) {
    return NS_OK;
  }

  // We should not dispatch ePointerRawUpdate directly because dispatching
  // it requires some steps which are defined by "fire a pointer event" section
  // in the spec.  https://w3c.github.io/pointerevents/#dfn-fire-a-pointer-event
  // We handle the steps when we call DispatchPrecedingPointerEvent().
  // Therefore, this method dispatches eMouseRawUpdate or eTouchRawUpdate event
  // if the event should follow a ePointerRawUpdate.  Then,
  // HandleEventUsingCoordinates() will stop handling the internal events after
  // calling DispatchPrecedingPointerEvent().

  MOZ_ASSERT(aSourceEvent.mMessage != eMouseRawUpdate);
  MOZ_ASSERT(aSourceEvent.mMessage != eTouchRawUpdate);

  // If no window in the browser child has `pointerrawupdate` event listener,
  // we should do nothing.
  if (auto* const browserChild = BrowserChild::GetFrom(this)) {
    if (!browserChild->HasPointerRawUpdateEventListeners()) {
      return NS_OK;
    }
  }

  if (const WidgetMouseEvent* const mouseEvent = aSourceEvent.AsMouseEvent()) {
    // If `convertToPointer` is `false`, it means that we've already handled the
    // event to dispatch a preceding pointer event.  Therefore, its preceding
    // event should've already been handled.
    // If `convertToPointerRawUpdate` is `false`, it means that the event was in
    // the queue in BrowserChild and BrowserChild has already dispatched
    // `eMouseRawUpdate`. Therefore, we don't need to dispatch it again here.
    if (mouseEvent->IsSynthesized() || !mouseEvent->convertToPointer ||
        !mouseEvent->convertToPointerRawUpdate) {
      return NS_OK;
    }
    WidgetMouseEvent mouseRawUpdateEvent(*mouseEvent);
    mouseRawUpdateEvent.mMessage = eMouseRawUpdate;
    mouseRawUpdateEvent.mCoalescedWidgetEvents = nullptr;
    // PointerEvent.button of `pointerrawupdate` should always be -1 if the
    // source event is not eMouseDown nor eMouseUp.  PointerEventHandler cannot
    // distinguish whether eMouseRawUpdate is caused by eMouseDown/eMouseUp or
    // not.  Therefore, we need to set the proper value in the latter case here
    // (In the former case, the copy constructor did it already).
    if (mouseEvent->mMessage != eMouseDown &&
        mouseEvent->mMessage != eMouseUp) {
      mouseRawUpdateEvent.mButton = MouseButton::eNotPressed;
    }
    nsEventStatus rawUpdateStatus = nsEventStatus_eIgnore;
    EventHandler eventHandler(*this);
    return eventHandler.HandleEvent(aWeakFrameForPresShell,
                                    &mouseRawUpdateEvent, aDontRetargetEvents,
                                    &rawUpdateStatus);
  }
  if (const WidgetTouchEvent* const touchEvent = aSourceEvent.AsTouchEvent()) {
    WidgetTouchEvent touchRawUpdate(*touchEvent,
                                    WidgetTouchEvent::CloneTouches::No);
    touchRawUpdate.mMessage = eTouchRawUpdate;
    touchRawUpdate.mTouches.Clear();
    for (const RefPtr<Touch>& touch : touchEvent->mTouches) {
      // If `convertToPointer` is `false`, it means that we've already handled
      // the event to dispatch a preceding pointer event.  Therefore, its
      // preceding event should've already been handled.
      // If ShouldConvertTouchToPointer() returns `false`, the touch is not an
      // active pointer or the touch hasn't been changed from the previous
      // state.  Therefore, we don't need to dispatch ePointerRawUpdate for the
      // touch.
      if (!touch->convertToPointerRawUpdate ||
          !TouchManager::ShouldConvertTouchToPointer(touch, &touchRawUpdate)) {
        continue;
      }
      auto newTouch = MakeRefPtr<Touch>(*touch);
      newTouch->mMessage = eTouchRawUpdate;
      newTouch->mCoalescedWidgetEvents = nullptr;
      touchRawUpdate.mTouches.AppendElement(std::move(newTouch));
    }
    nsEventStatus rawUpdateStatus = nsEventStatus_eIgnore;
    if (touchRawUpdate.mTouches.IsEmpty()) {
      return NS_OK;
    }
    EventHandler eventHandler(*this);
    return eventHandler.HandleEvent(aWeakFrameForPresShell, &touchRawUpdate,
                                    aDontRetargetEvents, &rawUpdateStatus);
  }
  MOZ_ASSERT_UNREACHABLE("Handle the event to dispatch ePointerRawUpdate");
  return NS_OK;
}

bool PresShell::EventHandler::UpdateFocusSequenceNumber(
    nsIFrame* aFrameForPresShell, uint64_t aEventFocusSequenceNumber) {
  uint64_t focusSequenceNumber;
  nsMenuPopupFrame* popup = do_QueryFrame(aFrameForPresShell);
  if (popup) {
    focusSequenceNumber = popup->GetAPZFocusSequenceNumber();
  } else {
    focusSequenceNumber = mPresShell->mAPZFocusSequenceNumber;
  }
  if (focusSequenceNumber >= aEventFocusSequenceNumber) {
    return false;
  }

  if (popup) {
    popup->UpdateAPZFocusSequenceNumber(aEventFocusSequenceNumber);
  } else {
    mPresShell->mAPZFocusSequenceNumber = aEventFocusSequenceNumber;
  }
  return true;
}

nsresult PresShell::EventHandler::HandleEvent(
    AutoWeakFrame& aWeakFrameForPresShell, WidgetGUIEvent* aGUIEvent,
    bool aDontRetargetEvents, nsEventStatus* aEventStatus) {
  MOZ_ASSERT(aGUIEvent);
  MOZ_DIAGNOSTIC_ASSERT(aGUIEvent->IsTrusted());
  MOZ_ASSERT(aEventStatus);

  NS_ASSERTION(aWeakFrameForPresShell.IsAlive(),
               "aWeakFrameForPresShell should refer a frame");

  // Update the latest focus sequence number with this new sequence number;
  // the next transasction that gets sent to the compositor will carry this over
  if (UpdateFocusSequenceNumber(aWeakFrameForPresShell.GetFrame(),
                                aGUIEvent->mFocusSequenceNumber)) {
    if (aWeakFrameForPresShell.IsAlive() &&
        StaticPrefs::apz_keyboard_focus_optimization()) {
      aWeakFrameForPresShell->SchedulePaint(nsIFrame::PAINT_COMPOSITE_ONLY);
    }
  }

  if (mPresShell->IsDestroying() ||
      (PresShell::sDisableNonTestMouseEvents &&
       !aGUIEvent->mFlags.mIsSynthesizedForTests &&
       aGUIEvent->HasMouseEventMessage())) {
    return NS_OK;
  }

  mPresShell->RecordPointerLocation(aGUIEvent);

  const bool wasFrameForPresShellNull = !aWeakFrameForPresShell.GetFrame();
  if (MaybeHandleEventWithAccessibleCaret(aWeakFrameForPresShell, aGUIEvent,
                                          aEventStatus)) {
    // Handled by AccessibleCaretEventHub.
    return NS_OK;
  }

  if (MaybeDiscardEvent(aGUIEvent)) {
    // Cannot handle the event for now.
    return NS_OK;
  }

  if (!aDontRetargetEvents) {
    const DebugOnly<bool> wasFrameForPresShellAlive =
        aWeakFrameForPresShell.IsAlive();
    // If aGUIEvent should be handled in another PresShell, we should call its
    // HandleEvent() and do nothing here.
    nsresult rv = NS_OK;
    if (MaybeHandleEventWithAnotherPresShell(aWeakFrameForPresShell, aGUIEvent,
                                             aEventStatus, &rv)) {
      // Handled by another PresShell or nobody can handle the event.
      return rv;
    }
    // If MaybeHandleEventWithAnotherPresShell() returns false, it shouldn't
    // have run any script.  So, aWeakFrameForPresShell must be alive.
    MOZ_ASSERT_IF(wasFrameForPresShellAlive, aWeakFrameForPresShell.IsAlive());
  }

  if (MaybeDiscardOrDelayKeyboardEvent(aGUIEvent)) {
    // The event is discarded or put into the delayed event queue.
    return NS_OK;
  }

  if (aGUIEvent->IsUsingCoordinates()) {
    return HandleEventUsingCoordinates(aWeakFrameForPresShell, aGUIEvent,
                                       aEventStatus, aDontRetargetEvents);
  }

  // Activation events need to be dispatched even if no frame was found, since
  // we don't want the focus to be out of sync.
  if (MOZ_UNLIKELY(wasFrameForPresShellNull)) {
    if (!NS_EVENT_NEEDS_FRAME(aGUIEvent)) {
      // Push nullptr for both current event target content and frame since
      // there is no frame but the event does not require a frame.
      AutoCurrentEventInfoSetter eventInfoSetter(*this);
      return HandleEventWithCurrentEventInfo(aGUIEvent, aEventStatus, true,
                                             nullptr);
    }

    if (aGUIEvent->HasKeyEventMessage()) {
      // Keypress events in new blank tabs should not be completely thrown away.
      // Retarget them -- the parent chrome shell might make use of them.
      return RetargetEventToParent(aGUIEvent, aEventStatus);
    }

    return NS_OK;
  }

  if (aGUIEvent->IsTargetedAtFocusedContent()) {
    return HandleEventAtFocusedContent(aGUIEvent, aEventStatus);
  }

  return HandleEventWithFrameForPresShell(aWeakFrameForPresShell, aGUIEvent,
                                          aEventStatus);
}

nsresult PresShell::EventHandler::HandleEventUsingCoordinates(
    AutoWeakFrame& aWeakFrameForPresShell, WidgetGUIEvent* aGUIEvent,
    nsEventStatus* aEventStatus, bool aDontRetargetEvents) {
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(aGUIEvent->IsUsingCoordinates());
  MOZ_ASSERT(aEventStatus);

  // Flush pending notifications to handle the event with the latest layout.
  // But if it causes destroying the frame for mPresShell, stop handling the
  // event. (why?)
  MaybeFlushPendingNotifications(aGUIEvent);
  if (MOZ_UNLIKELY(!aWeakFrameForPresShell.IsAlive())) {
    *aEventStatus = nsEventStatus_eIgnore;
    return NS_OK;
  }

  // If we are trying to dispatch an ePointerRawUpdate but it's not allowed in
  // the (maybe retargetted) document, we should not flush the capture state
  // below.
  if (aGUIEvent->mMessage == eMouseRawUpdate ||
      aGUIEvent->mMessage == eTouchRawUpdate) {
    EventTargetDataWithCapture eventTargetData =
        EventTargetDataWithCapture::QueryEventTargetUsingCoordinates(
            *this, aWeakFrameForPresShell,
            EventTargetDataWithCapture::Query::PendingState, aGUIEvent);
    if (!PointerEventHandler::NeedToDispatchPointerRawUpdate(
            eventTargetData.GetDocument())) {
      return NS_OK;
    }
    // Then, we need to recompute the target with processing the pending pointer
    // capture.  Note that the result may be differnet since `gotpointercapture`
    // event listener does something tricky things.
  }

  EventTargetDataWithCapture eventTargetData =
      EventTargetDataWithCapture::QueryEventTargetUsingCoordinates(
          *this, aWeakFrameForPresShell,
          EventTargetDataWithCapture::Query::LatestState, aGUIEvent,
          aEventStatus);
  if (MOZ_UNLIKELY(!eventTargetData.CanHandleEvent())) {
    // We cannot handle the event within the PresShell anymore.  Let's stop
    // handling the event without returning error since it's not illegal
    // case.
    return NS_OK;
  }
  if (MOZ_UNLIKELY(!eventTargetData.GetFrame())) {
    if (eventTargetData.mPointerCapturingElement &&
        aWeakFrameForPresShell.IsAlive()) {
      return HandleEventWithPointerCapturingContentWithoutItsFrame(
          aWeakFrameForPresShell, aGUIEvent,
          MOZ_KnownLive(eventTargetData.mPointerCapturingElement),
          aEventStatus);
    }
    return NS_OK;
  }

  // Suppress mouse event if it's being targeted at an element inside
  // a document which needs events suppressed
  if (MaybeDiscardOrDelayMouseEvent(eventTargetData.GetFrame(), aGUIEvent)) {
    return NS_OK;
  }

  // Check if we have an active EventStateManager which isn't the
  // EventStateManager of the current PresContext.  If that is the case, and
  // mouse is over some ancestor document, forward event handling to the
  // active document.  This way content can get mouse events even when mouse
  // is over the chrome or outside the window.
  if (eventTargetData.MaybeRetargetToActiveDocument(aGUIEvent) &&
      NS_WARN_IF(!eventTargetData.GetFrame())) {
    return NS_OK;
  }

  // Wheel events only apply to elements. If this is a wheel event, attempt to
  // update the event target from the current wheel transaction before we
  // compute the element from the target frame.
  eventTargetData.UpdateWheelEventTarget(aGUIEvent);

  if (!eventTargetData.ComputeElementFromFrame(aGUIEvent)) {
    return NS_OK;
  }
  // Note that even if ComputeElementFromFrame() returns true,
  // eventTargetData.mContent can be nullptr here.

  // Dispatch a pointer event if Pointer Events is enabled.  Note that if
  // pointer event listeners change the layout, eventTargetData is
  // automatically updated.
  if (!DispatchPrecedingPointerEvent(
          aWeakFrameForPresShell, aGUIEvent,
          MOZ_KnownLive(eventTargetData.mPointerCapturingElement),
          aDontRetargetEvents, &eventTargetData, aEventStatus)) {
    return NS_OK;
  }

  // Handle the event in the correct shell.
  // We pass the subshell's root frame as the frame to start from. This is
  // the only correct alternative; if the event was captured then it
  // must have been captured by us or some ancestor shell and we
  // now ask the subshell to dispatch it normally.
  EventHandler eventHandler(*eventTargetData.mPresShell);
  AutoCurrentEventInfoSetter eventInfoSetter(eventHandler, aGUIEvent->mMessage,
                                             eventTargetData);
  // eventTargetData is on the stack and is guaranteed to keep its
  // mOverrideClickTarget alive, so we can just use MOZ_KnownLive here.
  nsresult rv = eventHandler.HandleEventWithCurrentEventInfo(
      aGUIEvent, aEventStatus, true,
      MOZ_KnownLive(eventTargetData.mOverrideClickTarget));
  if (NS_FAILED(rv) ||
      MOZ_UNLIKELY(eventTargetData.mPresShell->IsDestroying())) {
    return rv;
  }

  if (aGUIEvent->mMessage == eTouchEnd) {
    MaybeSynthesizeCompatMouseEventsForTouchEnd(aGUIEvent->AsTouchEvent(),
                                                aEventStatus);
  }

  return NS_OK;
}

// static
PresShell::EventHandler::EventTargetDataWithCapture::EventTargetDataWithCapture(
    EventHandler& aEventHandler, AutoWeakFrame& aWeakFrameForPresShell,
    Query aQueryState, WidgetGUIEvent* aGUIEvent,
    nsEventStatus* aEventStatus /* = nullptr*/)
    : EventTargetData(aWeakFrameForPresShell.GetFrame()) {
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(aGUIEvent->IsUsingCoordinates());
  // EventHandler::GetFrameToHandleNonTouchEvent() may need to flush pending
  // notifications of the target child document if eMouseDown or eMouseUp.
  // Currently, this class does not support the case with Query::PendingState.
  MOZ_ASSERT_IF(aQueryState == Query::PendingState,
                aGUIEvent->mMessage != eMouseDown);
  MOZ_ASSERT_IF(aQueryState == Query::PendingState,
                aGUIEvent->mMessage != eMouseUp);

  const bool queryLatestState = aQueryState == Query::LatestState;

#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
  nsMutationGuard mutationGuard;
  const auto assertMutation = MakeScopeExit([&]() {
    if (!queryLatestState) {
      MOZ_DIAGNOSTIC_ASSERT(!mutationGuard.Mutated(0));
    }
  });
  Maybe<JS::AutoAssertNoGC> assertNoGC;
  if (!queryLatestState) {
    assertNoGC.emplace();
  }
#endif  // #ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED

  // XXX Retrieving capturing content here.  However, some of the following
  //     methods allow to run script.  So, isn't it possible the capturing
  //     content outdated?
  mCapturingContent = EventHandler::GetCapturingContentFor(aGUIEvent);
  if (queryLatestState) {
    if (GetDocument() && aGUIEvent->mClass == eTouchEventClass) {
      PointerLockManager::Unlock("TouchEvent");
    }
    // XXX If aGUIEvent is eMouseRawUpdate or eTouchRawUpdate and it's
    // dispatched by BrowserChild, i.e., the event won't cause ePointerMove
    // immediately after ePointerRawUpdate, should we skip fluhsing pending
    // animations here? Doing this could cause different animation result while
    // the user moves mouse cursor during a long animation whether there is a
    // `pointerrawupdate` event listener or not.
    aEventHandler.MaybeFlushThrottledStyles(aWeakFrameForPresShell);
    // Previously, MaybeFlushThrottledStyles() recomputed the closest ancestor
    // frame for view of mPresShell if it's reframed.  Therefore, we should keep
    // computing it here.
    // FIXME: GetFrame() may be target content's frame if aGUIEvent is a touch
    // event.  So, we need to use different computation for such cases.
    if (MOZ_UNLIKELY(!aWeakFrameForPresShell.IsAlive())) {
      Clear();
      MOZ_ASSERT(!CanHandleEvent());
      return;
    }
  }

  AutoWeakFrame weakRootFrameToHandleEvent =
      aEventHandler.ComputeRootFrameToHandleEvent(
          aWeakFrameForPresShell.GetFrame(), aGUIEvent, mCapturingContent,
          &mCapturingContentIgnored, &mCaptureRetargeted);
  if (mCapturingContentIgnored) {
    mCapturingContent = nullptr;
  }

  // The order to generate pointer event is
  // 1. check pending pointer capture.
  // 2. check if there is a capturing content.
  // 3. hit test
  // 4. dispatch pointer events
  // 5. check whether the targets of all Touch instances are in the same
  //    document and suppress invalid instances.
  // 6. dispatch mouse or touch events.

  // Try to keep frame for following check, because frame can be damaged
  // during MaybeProcessPointerCapture.
  if (queryLatestState) {
    PointerEventHandler::MaybeProcessPointerCapture(aGUIEvent);
    // Prevent application crashes, in case damaged frame.
    if (NS_WARN_IF(!weakRootFrameToHandleEvent.IsAlive())) {
      Clear();
      MOZ_ASSERT(!CanHandleEvent());
      return;
    }
  }

  // We want to query the pointer capture element which **will** capture the
  // following pointer event.  If we've already processed the pointer capture
  // above, current override element is it.  Otherwise, we will process the
  // pending pointer capture before dispatching a pointer event.  Therefore,
  // the pending pointer capture element will be the next override element
  // if and only if they are different.  (If they are the same element, the
  // element will keep capturing the pointer.  So, referring to the pending
  // element is also fine in the case.)
  mPointerCapturingElement =
      queryLatestState
          ? PointerEventHandler::GetPointerCapturingElement(aGUIEvent)
          : PointerEventHandler::GetPendingPointerCapturingElement(aGUIEvent);

  if (mPointerCapturingElement) {
    weakRootFrameToHandleEvent = mPointerCapturingElement->GetPrimaryFrame();
    if (!weakRootFrameToHandleEvent.IsAlive()) {
      // The caller should not keep handling the event with the frame stored by
      // the super class.  Therefore, we need to clear the frame.
      ClearFrameToHandleEvent();
      // Although the pointer capturing element does not have a frame, the event
      // should be handled on the element.
      MOZ_ASSERT(CanHandleEvent());
      return;
    }
  }

  const WidgetMouseEvent* mouseEvent = aGUIEvent->AsMouseEvent();
  const bool isWindowLevelMouseExit =
      (aGUIEvent->mMessage == eMouseExitFromWidget) &&
      (mouseEvent &&
       (mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePlatformTopLevel ||
        mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePuppet));

  // Get the frame at the event point. However, don't do this if we're
  // capturing and retargeting the event because the captured frame will
  // be used instead below. Also keep using the root frame if we're dealing
  // with a window-level mouse exit event since we want to start sending
  // mouse out events at the root EventStateManager.
  SetFrameAndComputePresShell(weakRootFrameToHandleEvent.GetFrame());
  if (!mCaptureRetargeted && !isWindowLevelMouseExit &&
      !mPointerCapturingElement) {
    if (!aEventHandler.ComputeEventTargetFrameAndPresShellAtEventPoint(
            weakRootFrameToHandleEvent, aGUIEvent, this)) {
      Clear();
      MOZ_ASSERT(!CanHandleEvent());
      if (aEventStatus) {
        *aEventStatus = nsEventStatus_eIgnore;
      }
      return;
    }
  }

  // if a node is capturing the mouse, check if the event needs to be
  // retargeted at the capturing content instead. This will be the case when
  // capture retargeting is being used, no frame was found or the frame's
  // content is not a descendant of the capturing content.
  if (mCapturingContent && !mPointerCapturingElement &&
      (PresShell::sCapturingContentInfo.mRetargetToElement ||
       !GetFrameContent() ||
       !nsContentUtils::ContentIsCrossDocDescendantOf(GetFrameContent(),
                                                      mCapturingContent))) {
    if (nsIFrame* const capturingFrame = mCapturingContent->GetPrimaryFrame()) {
      SetFrameAndComputePresShell(capturingFrame);
    }
  }

  MOZ_ASSERT(CanHandleEvent());
}

bool PresShell::EventHandler::MaybeFlushPendingNotifications(
    WidgetGUIEvent* aGUIEvent) {
  MOZ_ASSERT(aGUIEvent);

  switch (aGUIEvent->mMessage) {
    case eMouseDown:
    case eMouseUp:  // XXX How about eContextMenu?
    {
      if (NS_WARN_IF(!mPresShell->GetPresContext())) {
        return false;
      }
      MOZ_KnownLive(mPresShell)->FlushPendingNotifications(FlushType::Layout);
      return true;
    }
    default:
      return false;
  }
}

// The type of coordinates to use for hit-testing input events
// that are relative to the RCD's viewport frame.
// On most platforms, use visual coordinates so that scrollbars
// can be targeted.
// On mobile, use layout coordinates because hit-testing in
// visual coordinates clashes with mobile viewport sizing, where
// the ViewportFrame is sized to the initial containing block
// (ICB) size, which is in layout coordinates. This is fine
// because we don't need to be able to target scrollbars on mobile
// (scrollbar dragging isn't supported).
static ViewportType ViewportTypeForInputEventsRelativeToRoot() {
#ifdef MOZ_WIDGET_ANDROID
  return ViewportType::Layout;
#else
  return ViewportType::Visual;
#endif
}

nsIFrame* PresShell::EventHandler::GetFrameToHandleNonTouchEvent(
    AutoWeakFrame& aWeakRootFrameToHandleEvent, WidgetGUIEvent* aGUIEvent) {
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(aGUIEvent->mClass != eTouchEventClass);

  if (MOZ_UNLIKELY(!aWeakRootFrameToHandleEvent.IsAlive())) {
    return nullptr;
  }

  Document* doc = GetDocument();
  if (MOZ_UNLIKELY(doc && doc->RenderingSuppressedForViewTransitions())) {
    Element* root = doc->GetRootElement();
    return root ? root->GetPrimaryFrame() : nullptr;
  }

  ViewportType viewportType = ViewportType::Layout;
  if (aWeakRootFrameToHandleEvent->Type() == LayoutFrameType::Viewport) {
    nsPresContext* pc = aWeakRootFrameToHandleEvent->PresContext();
    if (pc->IsChrome()) {
      viewportType = ViewportType::Visual;
    } else if (pc->IsRootContentDocumentCrossProcess()) {
      viewportType = ViewportTypeForInputEventsRelativeToRoot();
    }
  }
  RelativeTo relativeTo{aWeakRootFrameToHandleEvent.GetFrame(), viewportType};
  nsPoint eventPoint =
      nsLayoutUtils::GetEventCoordinatesRelativeTo(aGUIEvent, relativeTo);

  uint32_t flags = 0;
  if (aGUIEvent->IsMouseEventClassOrHasClickRelatedPointerEvent()) {
    WidgetMouseEvent* mouseEvent = aGUIEvent->AsMouseEvent();
    if (mouseEvent && mouseEvent->mIgnoreRootScrollFrame) {
      flags |= INPUT_IGNORE_ROOT_SCROLL_FRAME;
    }
  }

  nsIFrame* targetFrame =
      FindFrameTargetedByInputEvent(aGUIEvent, relativeTo, eventPoint, flags);
  if (!targetFrame) {
    return aWeakRootFrameToHandleEvent.GetFrame();
  }

  if (targetFrame->PresShell() == mPresShell) {
    // If found target is in mPresShell, we've already found it in the latest
    // layout so that we can use it.
    return targetFrame;
  }

  // If target is in a child document, we've not flushed its layout yet.
  PresShell* childPresShell = targetFrame->PresShell();
  EventHandler childEventHandler(*childPresShell);
  const AutoWeakFrame targetFrameWeak(targetFrame);
  const DebugOnly<bool> flushedPendingNotifications =
      childEventHandler.MaybeFlushPendingNotifications(aGUIEvent);
  if (!aWeakRootFrameToHandleEvent.IsAlive()) {
    // Stop handling the event if the root frame to handle event is destroyed
    // by the reflow. (but why?)
    return nullptr;
  }
  if (targetFrameWeak.IsAlive()) {
    // If the target frame is alive, we don't need to recompute the target.
    return targetFrame;
  }
  MOZ_ASSERT(flushedPendingNotifications);

  // Finally, we need to recompute the target with the latest layout.
  targetFrame =
      FindFrameTargetedByInputEvent(aGUIEvent, relativeTo, eventPoint, flags);

  return targetFrame ? targetFrame : aWeakRootFrameToHandleEvent.GetFrame();
}

bool PresShell::EventHandler::ComputeEventTargetFrameAndPresShellAtEventPoint(
    AutoWeakFrame& aWeakRootFrameToHandleEvent, WidgetGUIEvent* aGUIEvent,
    EventTargetData* aEventTargetData) {
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(aEventTargetData);

  if (aGUIEvent->mClass == eTouchEventClass) {
    nsIFrame* targetFrameAtTouchEvent = TouchManager::SetupTarget(
        aGUIEvent->AsTouchEvent(), aWeakRootFrameToHandleEvent.GetFrame());
    aEventTargetData->SetFrameAndComputePresShell(targetFrameAtTouchEvent);
    return true;
  }

  nsIFrame* targetFrame =
      GetFrameToHandleNonTouchEvent(aWeakRootFrameToHandleEvent, aGUIEvent);
  aEventTargetData->SetFrameAndComputePresShell(targetFrame);
  return !!aEventTargetData->GetFrame();
}

bool PresShell::EventHandler::DispatchPrecedingPointerEvent(
    AutoWeakFrame& aWeakFrameForPresShell, WidgetGUIEvent* aGUIEvent,
    Element* aPointerCapturingElement, bool aDontRetargetEvents,
    EventTargetData* aEventTargetData, nsEventStatus* aEventStatus) {
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(aEventTargetData);
  MOZ_ASSERT(aEventStatus);

  // Dispatch pointer events from the mouse or touch events. Regarding
  // pointer events from mouse, we should dispatch those pointer events to
  // the same target as the source mouse events. We pass the frame found
  // in hit test to PointerEventHandler and dispatch pointer events to it.
  //
  // Regarding pointer events from touch, the behavior is different. Touch
  // events are dispatched to the same target as the target of touchstart.
  // Multiple touch points must be dispatched to the same document. Pointer
  // events from touch can be dispatched to different documents. We Pass the
  // original frame to PointerEventHandler, reentry PresShell::HandleEvent,
  // and do hit test for each point.
  auto targetFrameOrError = [&]() -> Result<nsIFrame*, nsresult> {
    if (aGUIEvent->mClass == eTouchEventClass) {
      // If aWeakFrameForPresShell has already been reframed before this is
      // called, we don't need to handle the event.
      if (MOZ_UNLIKELY(!aWeakFrameForPresShell.IsAlive())) {
        return Err(NS_ERROR_FAILURE);
      }
      return aWeakFrameForPresShell.GetFrame();
    }
    return aEventTargetData->GetFrame();
  }();
  if (MOZ_UNLIKELY(targetFrameOrError.isErr())) {
    return false;
  }
  nsIFrame* targetFrame = targetFrameOrError.unwrap();

  if (aPointerCapturingElement) {
    Result<nsIContent*, nsresult> overrideClickTargetOrError =
        GetOverrideClickTarget(aGUIEvent, aWeakFrameForPresShell.GetFrame(),
                               aPointerCapturingElement);
    if (MOZ_UNLIKELY(overrideClickTargetOrError.isErr())) {
      return false;
    }
    aEventTargetData->mOverrideClickTarget =
        overrideClickTargetOrError.unwrap();
    aEventTargetData->mPresShell =
        PresShell::GetShellForEventTarget(nullptr, aPointerCapturingElement);
    if (!aEventTargetData->mPresShell) {
      // If we can't process event for the capturing content, release
      // the capture.
      PointerEventHandler::ReleaseIfCaptureByDescendant(
          aPointerCapturingElement);
      return false;
    }

    targetFrame = aPointerCapturingElement->GetPrimaryFrame();
    aEventTargetData->SetFrameAndContent(targetFrame, aPointerCapturingElement);
  }

  AutoWeakFrame weakTargetFrame(targetFrame);
  AutoWeakFrame weakFrame(aEventTargetData->GetFrame());
  nsCOMPtr<nsIContent> pointerEventTargetContent(
      aEventTargetData->GetContent());
  RefPtr<PresShell> presShell(aEventTargetData->mPresShell);
  nsCOMPtr<nsIContent> mouseOrTouchEventTargetContent;
  PointerEventHandler::DispatchPointerFromMouseOrTouch(
      presShell, aEventTargetData->GetFrame(), pointerEventTargetContent,
      aPointerCapturingElement, aGUIEvent, aDontRetargetEvents, aEventStatus,
      getter_AddRefs(mouseOrTouchEventTargetContent));

  const bool maybeCallerCanHandleEvent =
      aGUIEvent->mMessage != eMouseRawUpdate &&
      aGUIEvent->mMessage != eTouchRawUpdate;

  // If the target frame is alive, the caller should keep handling the event
  // unless event target frame is destroyed.
  if (weakTargetFrame.IsAlive() && weakFrame.IsAlive()) {
    aEventTargetData->UpdateTouchEventTarget(aGUIEvent);
    return maybeCallerCanHandleEvent;
  }

  presShell->FlushPendingNotifications(FlushType::Layout);
  if (MOZ_UNLIKELY(mPresShell->IsDestroying())) {
    return false;
  }

  // The spec defines that mouse events must be dispatched to the same target as
  // the pointer event.
  // The Touch Events spec defines that touch events must be dispatched to the
  // same target as touch start and the other browsers dispatch touch events
  // even if the touch event target is not connected to the document.
  // Retargetting the event is handled by AutoPointerEventTargetUpdater and
  // mouseOrTouchEventTargetContent stores the result.

  // If the target is no longer participating in its ownerDocument's tree,
  // fire the event at the original target's nearest ancestor node.
  if (!mouseOrTouchEventTargetContent) {
    MOZ_ASSERT(aGUIEvent->IsMouseEventClassOrHasClickRelatedPointerEvent());
    return false;
  }

  aEventTargetData->SetFrameAndContent(
      mouseOrTouchEventTargetContent->GetPrimaryFrame(),
      mouseOrTouchEventTargetContent);
  aEventTargetData->mPresShell =
      mouseOrTouchEventTargetContent->IsInComposedDoc()
          ? PresShell::GetShellForEventTarget(aEventTargetData->GetFrame(),
                                              aEventTargetData->GetContent())
          : mouseOrTouchEventTargetContent->OwnerDoc()->GetPresShell();

  // If new target PresShel is not found, we cannot keep handling the event.
  if (!aEventTargetData->mPresShell) {
    return false;
  }

  aEventTargetData->UpdateTouchEventTarget(aGUIEvent);
  return maybeCallerCanHandleEvent;
}

/**
 * Event retargetting may retarget a mouse event and change the reference point.
 * If event retargetting changes the reference point of a event that accessible
 * caret will not handle, restore the original reference point.
 */
class AutoEventTargetPointResetter {
 public:
  explicit AutoEventTargetPointResetter(WidgetGUIEvent* aGUIEvent)
      : mGUIEvent(aGUIEvent),
        mRefPoint(aGUIEvent->mRefPoint),
        mHandledByAccessibleCaret(false) {}

  void SetHandledByAccessibleCaret() { mHandledByAccessibleCaret = true; }

  ~AutoEventTargetPointResetter() {
    if (!mHandledByAccessibleCaret) {
      mGUIEvent->mRefPoint = mRefPoint;
    }
  }

 private:
  WidgetGUIEvent* mGUIEvent;
  LayoutDeviceIntPoint mRefPoint;
  bool mHandledByAccessibleCaret;
};

bool PresShell::EventHandler::MaybeHandleEventWithAccessibleCaret(
    AutoWeakFrame& aWeakFrameForPresShell, WidgetGUIEvent* aGUIEvent,
    nsEventStatus* aEventStatus) {
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(aEventStatus);

  // Don't dispatch event to AccessibleCaretEventHub when the event status
  // is nsEventStatus_eConsumeNoDefault. This might be happened when content
  // preventDefault on the pointer events. In such case, we also call
  // preventDefault on mouse events to stop default behaviors.
  if (*aEventStatus == nsEventStatus_eConsumeNoDefault) {
    return false;
  }

  if (!AccessibleCaretEnabled(GetDocument()->GetDocShell())) {
    return false;
  }

  // AccessibleCaretEventHub handles only mouse, touch, and keyboard events.
  if (!aGUIEvent->IsMouseEventClassOrHasClickRelatedPointerEvent() &&
      aGUIEvent->mClass != eTouchEventClass &&
      aGUIEvent->mClass != eKeyboardEventClass) {
    return false;
  }

  // AccessibleCaretEventHub::HandleEvent may return nsEventStatus_eIgnore to
  // allow the context menu to appear correctly on desktop Firefox (see
  // AccessibleCaretEventHub::LongTapState::OnLongTap). When this happens, and
  // the event hub at the event location is the same as the hub attached to
  // the currently‑focused window, HandleEvent would be invoked a second time.
  // Avoid the duplicate call by explicitly checking for this condition.
  AccessibleCaretEventHub* alreadyHandledEventHub = nullptr;

  AutoEventTargetPointResetter autoEventTargetPointResetter(aGUIEvent);
  // First, try the event hub at the event point to handle a long press to
  // select a word in an unfocused window.
  do {
    EventTargetData eventTargetData(nullptr);
    if (!ComputeEventTargetFrameAndPresShellAtEventPoint(
            aWeakFrameForPresShell, aGUIEvent, &eventTargetData)) {
      break;
    }

    if (!eventTargetData.mPresShell) {
      break;
    }

    RefPtr<AccessibleCaretEventHub> eventHub =
        eventTargetData.mPresShell->GetAccessibleCaretEventHub();
    if (!eventHub) {
      break;
    }
    alreadyHandledEventHub = eventHub.get();

    *aEventStatus = eventHub->HandleEvent(aGUIEvent);
    if (*aEventStatus != nsEventStatus_eConsumeNoDefault) {
      break;
    }

    // If the event is consumed, cancel APZC panning by setting
    // mMultipleActionsPrevented.
    aGUIEvent->mFlags.mMultipleActionsPrevented = true;
    autoEventTargetPointResetter.SetHandledByAccessibleCaret();
    return true;
  } while (false);

  // Then, we target the event to the event hub at the focused window.
  nsCOMPtr<nsPIDOMWindowOuter> window = GetFocusedDOMWindowInOurWindow();
  if (!window) {
    return false;
  }
  RefPtr<Document> retargetEventDoc = window->GetExtantDoc();
  if (!retargetEventDoc) {
    return false;
  }
  RefPtr<PresShell> presShell = retargetEventDoc->GetPresShell();
  if (!presShell) {
    return false;
  }

  RefPtr<AccessibleCaretEventHub> eventHub =
      presShell->GetAccessibleCaretEventHub();
  if (!eventHub || eventHub.get() == alreadyHandledEventHub) {
    return false;
  }
  *aEventStatus = eventHub->HandleEvent(aGUIEvent);
  if (*aEventStatus != nsEventStatus_eConsumeNoDefault) {
    return false;
  }
  // If the event is consumed, cancel APZC panning by setting
  // mMultipleActionsPrevented.
  aGUIEvent->mFlags.mMultipleActionsPrevented = true;
  autoEventTargetPointResetter.SetHandledByAccessibleCaret();
  return true;
}

void PresShell::EventHandler::MaybeSynthesizeCompatMouseEventsForTouchEnd(
    const WidgetTouchEvent* aTouchEndEvent,
    const nsEventStatus* aStatus) const {
  MOZ_ASSERT(aTouchEndEvent->mMessage == eTouchEnd);

  // If the eTouchEnd event is dispatched via APZ, APZCCallbackHelper dispatches
  // a set of mouse events with better handling.  Therefore, we don't need to
  // handle that here.
  if (!aTouchEndEvent->mFlags.mIsSynthesizedForTests ||
      StaticPrefs::test_events_async_enabled()) {
    return;
  }

  auto cleanUpPointerCapturingElementAtLastPointerUp = MakeScopeExit([]() {
    PointerEventHandler::ReleasePointerCapturingElementAtLastPointerUp();
  });

  // If the tap was consumed or 2 or more touches occurred, we don't need the
  // compatibility mouse events.
  if (*aStatus == nsEventStatus_eConsumeNoDefault ||
      !TouchManager::IsSingleTapEndToDoDefault(aTouchEndEvent)) {
    return;
  }

  if (NS_WARN_IF(!aTouchEndEvent->mWidget)) {
    return;
  }

  nsCOMPtr<nsIWidget> widget = aTouchEndEvent->mWidget;

  // NOTE: I think that we don't need to implement a double click here becase
  // WebDriver does not support a way to synthesize a double click and Chrome
  // does not fire "dblclick" even if doing `pointerDown().pointerUp()` twice.
  // FIXME: Currently we don't support long tap.
  RefPtr<PresShell> presShell = mPresShell;
  for (const EventMessage message : {eMouseMove, eMouseDown, eMouseUp}) {
    if (MOZ_UNLIKELY(presShell->IsDestroying())) {
      break;
    }
    nsIFrame* const frameForPresShell = presShell->GetRootFrame();
    if (!frameForPresShell) {
      break;
    }
    WidgetMouseEvent event(true, message, widget, WidgetMouseEvent::eReal);
    event.mFlags.mIsSynthesizedForTests =
        aTouchEndEvent->mFlags.mIsSynthesizedForTests;
    event.mRefPoint = aTouchEndEvent->mTouches[0]->mRefPoint;
    event.mButton = MouseButton::ePrimary;
    event.mButtons = message == eMouseDown ? MouseButtonsFlag::ePrimaryFlag
                                           : MouseButtonsFlag::eNoButtons;
    event.mInputSource = MouseEvent_Binding::MOZ_SOURCE_TOUCH;
    event.mClickCount = message == eMouseMove ? 0 : 1;
    event.mModifiers = aTouchEndEvent->mModifiers;
    event.pointerId = aTouchEndEvent->mTouches[0]->mIdentifier;
    event.convertToPointer = false;
    if (TouchManager::IsPrecedingTouchPointerDownConsumedByContent()) {
      event.PreventDefault(false);
      event.mFlags.mOnlyChromeDispatch = true;
    }
    nsEventStatus mouseEventStatus = nsEventStatus_eIgnore;
    presShell->HandleEvent(frameForPresShell, &event, false, &mouseEventStatus);
  }
}

bool PresShell::EventHandler::MaybeDiscardEvent(WidgetGUIEvent* aGUIEvent) {
  MOZ_ASSERT(aGUIEvent);

  // If it is safe to dispatch events now, don't discard the event.
  if (nsContentUtils::IsSafeToRunScript()) {
    return false;
  }

  // If the event does not cause dispatching DOM event (i.e., internal event),
  // we can keep handling it even when it's not safe to run script.
  if (!aGUIEvent->IsAllowedToDispatchDOMEvent()) {
    return false;
  }

  // If the event is a composition event, we need to let IMEStateManager know
  // it's discarded because it needs to listen all composition events to manage
  // TextComposition instance.
  if (aGUIEvent->mClass == eCompositionEventClass) {
    IMEStateManager::OnCompositionEventDiscarded(
        aGUIEvent->AsCompositionEvent());
  }

#ifdef DEBUG
  if (aGUIEvent->IsIMERelatedEvent()) {
    nsPrintfCString warning("%s event is discarded",
                            ToChar(aGUIEvent->mMessage));
    NS_WARNING(warning.get());
  }
#endif  // #ifdef DEBUG

  nsContentUtils::WarnScriptWasIgnored(GetDocument());
  return true;
}

// static
nsIContent* PresShell::EventHandler::GetCapturingContentFor(
    WidgetGUIEvent* aGUIEvent) {
  if (aGUIEvent->mClass != ePointerEventClass &&
      aGUIEvent->mClass != eWheelEventClass &&
      !aGUIEvent->HasMouseEventMessage()) {
    return nullptr;
  }

  // PointerEventHandler may synthesize ePointerMove event before releasing the
  // mouse capture (it's done by a default handler of eMouseUp) after handling
  // ePointerUp.  Then, we need to dispatch pointer boundary events for the
  // element under the pointer to emulate a pointer move after a pointer
  // capture.  Therefore, we need to ignore the capturing element if the event
  // dispatcher requests it.
  if (aGUIEvent->ShouldIgnoreCapturingContent()) {
    return nullptr;
  }

  return PresShell::GetCapturingContent();
}

bool PresShell::EventHandler::GetRetargetEventDocument(
    WidgetGUIEvent* aGUIEvent, Document** aRetargetEventDocument) {
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(aRetargetEventDocument);

  *aRetargetEventDocument = nullptr;

  // key and IME related events should not cross top level window boundary.
  // Basically, such input events should be fired only on focused widget.
  // However, some IMEs might need to clean up composition after focused
  // window is deactivated.  And also some tests on MozMill want to test key
  // handling on deactivated window because MozMill window can be activated
  // during tests.  So, there is no merit the events should be redirected to
  // active window.  So, the events should be handled on the last focused
  // content in the last focused DOM window in same top level window.
  // Note, if no DOM window has been focused yet, we can discard the events.
  if (aGUIEvent->IsTargetedAtFocusedWindow()) {
    nsCOMPtr<nsPIDOMWindowOuter> window = GetFocusedDOMWindowInOurWindow();
    // No DOM window in same top level window has not been focused yet,
    // discard the events.
    if (!window) {
      return false;
    }

    RefPtr<Document> retargetEventDoc = window->GetExtantDoc();
    if (!retargetEventDoc) {
      return false;
    }
    retargetEventDoc.forget(aRetargetEventDocument);
    return true;
  }

  const nsIContent* const capturingContent =
      aGUIEvent->ShouldIgnoreCapturingContent()
          ? nullptr
          : EventHandler::GetCapturingContentFor(aGUIEvent);
  if (capturingContent) {
    // if the mouse is being captured then retarget the mouse event at the
    // document that is being captured.
    RefPtr<Document> retargetEventDoc = capturingContent->GetComposedDoc();
    retargetEventDoc.forget(aRetargetEventDocument);
    return true;
  }

#ifdef ANDROID
  if (aGUIEvent->mClass == eTouchEventClass ||
      aGUIEvent->IsMouseEventClassOrHasClickRelatedPointerEvent() ||
      aGUIEvent->mClass == eWheelEventClass) {
    RefPtr<Document> retargetEventDoc = mPresShell->GetPrimaryContentDocument();
    retargetEventDoc.forget(aRetargetEventDocument);
    return true;
  }
#endif  // #ifdef ANDROID

  // When we don't find another document to handle the event, we need to keep
  // handling the event by ourselves.
  return true;
}

nsIFrame* PresShell::EventHandler::GetFrameForHandlingEventWith(
    WidgetGUIEvent* aGUIEvent, Document* aRetargetDocument,
    nsIFrame* aFrameForPresShell) {
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(aRetargetDocument);

  RefPtr<PresShell> retargetPresShell = aRetargetDocument->GetPresShell();
  // Even if the document doesn't have PresShell, i.e., it's invisible, we
  // need to dispatch only KeyboardEvent in its nearest visible document
  // because key focus shouldn't be caught by invisible document.
  if (!retargetPresShell) {
    if (!aGUIEvent->HasKeyEventMessage()) {
      return nullptr;
    }
    Document* retargetEventDoc = aRetargetDocument;
    while (!retargetPresShell) {
      retargetEventDoc = retargetEventDoc->GetInProcessParentDocument();
      if (!retargetEventDoc) {
        return nullptr;
      }
      retargetPresShell = retargetEventDoc->GetPresShell();
    }
  }

  // If the found PresShell is this instance, caller needs to keep handling
  // aGUIEvent by itself.  Therefore, return the given frame which was set
  // to aFrame of HandleEvent().
  if (retargetPresShell == mPresShell) {
    return aFrameForPresShell;
  }

  // Use root frame of the new PresShell if there is.
  nsIFrame* rootFrame = retargetPresShell->GetRootFrame();
  if (rootFrame) {
    return rootFrame;
  }

  // Otherwise, and if aGUIEvent requires content of PresShell, caller should
  // stop handling the event.
  if (aGUIEvent->mMessage == eQueryTextContent ||
      aGUIEvent->IsContentCommandEvent()) {
    return nullptr;
  }

  // Otherwise, use nearest ancestor frame which includes the PresShell.
  return retargetPresShell->GetRootFrame();
}

bool PresShell::EventHandler::MaybeHandleEventWithAnotherPresShell(
    AutoWeakFrame& aWeakFrameForPresShell, WidgetGUIEvent* aGUIEvent,
    nsEventStatus* aEventStatus, nsresult* aRv) {
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(aEventStatus);
  MOZ_ASSERT(aRv);

  *aRv = NS_OK;

  RefPtr<Document> retargetEventDoc;
  if (!GetRetargetEventDocument(aGUIEvent, getter_AddRefs(retargetEventDoc))) {
    // Nobody can handle this event.  So, treat as handled by somebody to make
    // caller do nothing anymore.
    return true;
  }

  // If there is no proper retarget document, the caller should handle the
  // event by itself.
  if (!retargetEventDoc) {
    return false;
  }

  nsIFrame* frame = GetFrameForHandlingEventWith(
      aGUIEvent, retargetEventDoc, aWeakFrameForPresShell.GetFrame());
  if (!frame) {
    // Nobody can handle this event.  So, treat as handled by somebody to make
    // caller do nothing anymore.
    // NOTE: If aWeakFrameForPresShell does not refer to a frame (i.e., it's
    // already been reframed) and aGUIEvent needs to be handled in mPresShell,
    // we are here because GetFrameForHandlingEventWith() returns
    // aWeakFrameForPresShell.GetFrame() as-is. In the case, we don't need to
    // handle aGUIEvent, so, it's fine to return true from this method.
    return true;
  }

  // If we reached same frame as set to HandleEvent(), the caller should handle
  // the event by itself.
  if (frame == aWeakFrameForPresShell.GetFrame()) {
    return false;
  }

  // We need to handle aGUIEvent with another PresShell.
  RefPtr<PresShell> presShell = frame->PresContext()->PresShell();
  *aRv = presShell->HandleEvent(frame, aGUIEvent, true, aEventStatus);
  return true;
}

bool PresShell::EventHandler::MaybeDiscardOrDelayKeyboardEvent(
    WidgetGUIEvent* aGUIEvent) {
  MOZ_ASSERT(aGUIEvent);

  if (aGUIEvent->mClass != eKeyboardEventClass) {
    return false;
  }

  Document* document = GetDocument();
  if (!document || !document->EventHandlingSuppressed()) {
    return false;
  }

  MOZ_ASSERT_IF(InputTaskManager::CanSuspendInputEvent(),
                !InputTaskManager::Get()->IsSuspended());

  if (aGUIEvent->mMessage == eKeyDown) {
    mPresShell->mNoDelayedKeyEvents = true;
  } else if (!mPresShell->mNoDelayedKeyEvents) {
    UniquePtr<DelayedKeyEvent> delayedKeyEvent =
        MakeUnique<DelayedKeyEvent>(aGUIEvent->AsKeyboardEvent());
    mPresShell->mDelayedEvents.AppendElement(std::move(delayedKeyEvent));
  }
  aGUIEvent->mFlags.mIsSuppressedOrDelayed = true;
  return true;
}

bool PresShell::EventHandler::MaybeDiscardOrDelayMouseEvent(
    nsIFrame* aFrameToHandleEvent, WidgetGUIEvent* aGUIEvent) {
  MOZ_ASSERT(aFrameToHandleEvent);
  MOZ_ASSERT(aGUIEvent);

  // We must not need to let suspend listeners know ePointerRawUpdate events.
  // And also the delayed events will be dispatched via widget.  Therefore,
  // ePointerRawUpdate event will be dispatched by PresShell::HandleEvent()
  // again.
  if (aGUIEvent->mMessage == eMouseRawUpdate ||
      aGUIEvent->mMessage == eTouchRawUpdate ||
      aGUIEvent->mMessage == ePointerRawUpdate) {
    return false;
  }

  if (!aGUIEvent->IsMouseEventClassOrHasClickRelatedPointerEvent() &&
      aGUIEvent->mMessage != eTouchStart) {
    return false;
  }

  if (!aFrameToHandleEvent->PresContext()
           ->Document()
           ->EventHandlingSuppressed()) {
    return false;
  }

  MOZ_ASSERT_IF(InputTaskManager::CanSuspendInputEvent() &&
                    aGUIEvent->mMessage != eMouseMove,
                !InputTaskManager::Get()->IsSuspended());

  RefPtr<PresShell> ps = aFrameToHandleEvent->PresShell();

  switch (aGUIEvent->mMessage) {
    case eTouchStart: {
      // If we receive a single touch start during the suppression, its
      // compatibility mouse events should not be fired later because the single
      // tap sequence has not been sent to the web app.
      const WidgetTouchEvent* const touchEvent = aGUIEvent->AsTouchEvent();
      if (touchEvent->mTouches.Length() == 1) {
        ps->mNoDelayedSingleTap = true;
      }
      // We won't dispatch eTouchStart as a delayed event later so that return
      // false.
      return false;
    }
    case eMouseDown: {
      // If we receive a click sequence start during the suppression, we should
      // not fire `click` event later because its sequence has not been send to
      // the web app.  Note that if the eMouseDown is caused by a touch, we may
      // have already sent the touch sequence to the web app.  In such case,
      // the eMouseDown is NOT start of the click sequence.
      const WidgetMouseEvent* const mouseEvent = aGUIEvent->AsMouseEvent();
      if (ps->mNoDelayedSingleTap ||
          mouseEvent->mInputSource != MouseEvent_Binding::MOZ_SOURCE_TOUCH) {
        ps->mNoDelayedMouseEvents = true;
        break;
      }
      // Otherwise, put the event into the queue.
      [[fallthrough]];
    }
    case eMouseUp:
    case eMouseExitFromWidget: {
      if (ps->mNoDelayedMouseEvents) {
        break;
      }
      UniquePtr<DelayedMouseEvent> delayedMouseEvent =
          MakeUnique<DelayedMouseEvent>(aGUIEvent->AsMouseEvent());
      ps->mDelayedEvents.AppendElement(std::move(delayedMouseEvent));
      break;
    }
    case eContextMenu: {
      if (ps->mNoDelayedMouseEvents) {
        break;
      }
      // contextmenu is triggered after right mouseup on Windows and right
      // mousedown on other platforms.
      UniquePtr<DelayedPointerEvent> delayedPointerEvent =
          MakeUnique<DelayedPointerEvent>(aGUIEvent->AsPointerEvent());
      ps->mDelayedEvents.AppendElement(std::move(delayedPointerEvent));
      break;
    }
    default:
      break;
  }

  // If there is a suppressed event listener associated with the document,
  // notify it about the suppressed mouse event. This allows devtools
  // features to continue receiving mouse events even when the devtools
  // debugger has paused execution in a page.
  RefPtr<EventListener> suppressedListener = aFrameToHandleEvent->PresContext()
                                                 ->Document()
                                                 ->GetSuppressedEventListener();
  if (!suppressedListener ||
      aGUIEvent->AsMouseEvent()->mReason == WidgetMouseEvent::eSynthesized) {
    return true;
  }

  if (auto* target = aFrameToHandleEvent->GetEventTargetContent(aGUIEvent)) {
    aGUIEvent->mTarget = target;
  }

  nsCOMPtr<EventTarget> eventTarget = aGUIEvent->mTarget;
  RefPtr<Event> event = EventDispatcher::CreateEvent(
      eventTarget, aFrameToHandleEvent->PresContext(), aGUIEvent, u""_ns);

  suppressedListener->HandleEvent(*event);
  return true;
}

void PresShell::EventHandler::MaybeFlushThrottledStyles(
    AutoWeakFrame& aWeakFrameForPresShell) {
  if (!GetDocument()) {
    return;
  }

  PresShell* rootPresShell = mPresShell->GetRootPresShell();
  if (NS_WARN_IF(!rootPresShell)) {
    return;
  }
  Document* rootDocument = rootPresShell->GetDocument();
  if (NS_WARN_IF(!rootDocument)) {
    return;
  }

  {  // scope for scriptBlocker.
    nsAutoScriptBlocker scriptBlocker;
    FlushThrottledStyles(*rootDocument);
  }

  if (MOZ_UNLIKELY(!aWeakFrameForPresShell.IsAlive()) &&
      MOZ_LIKELY(!mPresShell->IsDestroying())) {
    // FIXME: aWeakFrameForPresShell may be target content's frame if aGUIEvent
    // of the caller is a touch event.  So, we need to use different computation
    // for such cases.
    aWeakFrameForPresShell = mPresShell->GetRootFrame();
  }
}

nsIFrame* PresShell::EventHandler::ComputeRootFrameToHandleEvent(
    nsIFrame* aFrameForPresShell, WidgetGUIEvent* aGUIEvent,
    nsIContent* aCapturingContent, bool* aIsCapturingContentIgnored,
    bool* aIsCaptureRetargeted) {
  MOZ_ASSERT(aFrameForPresShell);
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(aIsCapturingContentIgnored);
  MOZ_ASSERT(aIsCaptureRetargeted);

  nsIFrame* rootFrameToHandleEvent = ComputeRootFrameToHandleEventWithPopup(
      aFrameForPresShell, aGUIEvent, aCapturingContent,
      aIsCapturingContentIgnored);
  if (*aIsCapturingContentIgnored) {
    // If the capturing content is ignored, we don't need to respect it.
    return rootFrameToHandleEvent;
  }

  if (!aCapturingContent) {
    return rootFrameToHandleEvent;
  }

  *aIsCapturingContentIgnored = false;
  *aIsCaptureRetargeted = false;

  // If a capture is active, determine if the BrowsingContext is active. If
  // not, clear the capture and target the mouse event normally instead. This
  // would occur if the mouse button is held down while a tab change occurs.
  // If the BrowsingContext is active, look for a scrolling container.
  BrowsingContext* bc = GetPresContext()->Document()->GetBrowsingContext();
  if (!bc || !bc->IsActive()) {
    ClearMouseCapture();
    *aIsCapturingContentIgnored = true;
    return rootFrameToHandleEvent;
  }

  *aIsCaptureRetargeted = !!PresShell::sCapturingContentInfo.mRetargetToElement;

  // As a special case, if a listbox is capturing, return its scrolled frame,
  // see bug 519693.
  // FIXME(emilio): This is super inconsistent, there should be a better way of
  // making that work.
  if (nsListControlFrame* lcf =
          do_QueryFrame(aCapturingContent->GetPrimaryFrame())) {
    return lcf->GetScrolledFrame();
  }
  return rootFrameToHandleEvent;
}

nsIFrame* PresShell::EventHandler::ComputeRootFrameToHandleEventWithPopup(
    nsIFrame* aRootFrameToHandleEvent, WidgetGUIEvent* aGUIEvent,
    nsIContent* aCapturingContent, bool* aIsCapturingContentIgnored) {
  MOZ_ASSERT(aRootFrameToHandleEvent);
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(aIsCapturingContentIgnored);

  *aIsCapturingContentIgnored = false;

  nsPresContext* framePresContext = aRootFrameToHandleEvent->PresContext();
  nsPresContext* rootPresContext = framePresContext->GetRootPresContext();
  NS_ASSERTION(rootPresContext == GetPresContext()->GetRootPresContext(),
               "How did we end up outside the connected "
               "prescontext hierarchy?");
  nsIFrame* popupFrame = nsLayoutUtils::GetPopupFrameForEventCoordinates(
      rootPresContext, aGUIEvent);
  if (!popupFrame) {
    return aRootFrameToHandleEvent;
  }

  // If a remote browser is currently capturing input break out if we
  // detect a chrome generated popup.
  // XXXedgar, do we need to check fission OOP iframe?
  if (aCapturingContent &&
      EventStateManager::IsTopLevelRemoteTarget(aCapturingContent)) {
    *aIsCapturingContentIgnored = true;
  }

  // If the popupFrame is an ancestor of the 'frame', the frame should
  // handle the event, otherwise, the popup should handle it.
  if (nsContentUtils::ContentIsCrossDocDescendantOf(
          framePresContext->GetPresShell()->GetDocument(),
          popupFrame->GetContent())) {
    return aRootFrameToHandleEvent;
  }

  // If we aren't starting our event dispatch from the root frame of the
  // root prescontext, then someone must be capturing the mouse. In that
  // case we only want to use the popup list if the capture is
  // inside the popup.
  if (framePresContext == rootPresContext &&
      aRootFrameToHandleEvent == FrameConstructor()->GetRootFrame()) {
    return popupFrame;
  }

  if (aCapturingContent && !*aIsCapturingContentIgnored &&
      aCapturingContent->IsInclusiveDescendantOf(popupFrame->GetContent())) {
    return popupFrame;
  }

  return aRootFrameToHandleEvent;
}

nsresult
PresShell::EventHandler::HandleEventWithPointerCapturingContentWithoutItsFrame(
    AutoWeakFrame& aWeakFrameForPresShell, WidgetGUIEvent* aGUIEvent,
    Element* aPointerCapturingElement, nsEventStatus* aEventStatus) {
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(aPointerCapturingElement);
  MOZ_ASSERT(!aPointerCapturingElement->GetPrimaryFrame(),
             "Handle the event with frame rather than only with the content");
  MOZ_ASSERT(aEventStatus);

  RefPtr<PresShell> presShellForCapturingContent =
      PresShell::GetShellForEventTarget(nullptr, aPointerCapturingElement);
  if (!presShellForCapturingContent) {
    // If we can't process event for the capturing content, release
    // the capture.
    PointerEventHandler::ReleaseIfCaptureByDescendant(aPointerCapturingElement);
    // Since we don't dispatch ePointeUp nor ePointerCancel in this case,
    // EventStateManager::PostHandleEvent does not have a chance to dispatch
    // ePointerLostCapture event.  Therefore, we need to dispatch it here.
    PointerEventHandler::MaybeImplicitlyReleasePointerCapture(aGUIEvent);
    return NS_OK;
  }

  Result<nsIContent*, nsresult> overrideClickTargetOrError =
      GetOverrideClickTarget(aGUIEvent, aWeakFrameForPresShell.GetFrame(),
                             aPointerCapturingElement);
  if (MOZ_UNLIKELY(overrideClickTargetOrError.isErr())) {
    return NS_OK;
  }
  nsCOMPtr<nsIContent> overrideClickTarget =
      overrideClickTargetOrError.unwrap();

  // Dispatch events to the capturing content even it's frame is
  // destroyed.
  PointerEventHandler::DispatchPointerFromMouseOrTouch(
      presShellForCapturingContent, nullptr, aPointerCapturingElement,
      aPointerCapturingElement, aGUIEvent, false, aEventStatus, nullptr);

  if (presShellForCapturingContent == mPresShell) {
    return HandleEventWithTarget(aGUIEvent, nullptr, aPointerCapturingElement,
                                 aEventStatus, true, nullptr,
                                 overrideClickTarget);
  }

  EventHandler eventHandlerForCapturingContent(
      std::move(presShellForCapturingContent));
  return eventHandlerForCapturingContent.HandleEventWithTarget(
      aGUIEvent, nullptr, aPointerCapturingElement, aEventStatus, true, nullptr,
      overrideClickTarget);
}

nsresult PresShell::EventHandler::HandleEventAtFocusedContent(
    WidgetGUIEvent* aGUIEvent, nsEventStatus* aEventStatus) {
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(aGUIEvent->IsTargetedAtFocusedContent());
  MOZ_ASSERT(aEventStatus);

  AutoCurrentEventInfoSetter eventInfoSetter(*this);

  RefPtr<Element> eventTargetElement =
      ComputeFocusedEventTargetElement(aGUIEvent);

  // mCurrentEventTarget is cleared by eventInfoSetter and
  // ComputeFocusedEventTargetElement shouldn't set it again.
  MOZ_ASSERT(!mPresShell->mCurrentEventTarget.IsSet());

  if (eventTargetElement) {
    nsresult rv = NS_OK;
    if (MaybeHandleEventWithAnotherPresShell(eventTargetElement, aGUIEvent,
                                             aEventStatus, &rv)) {
      return rv;
    }
  }

  // If we cannot handle the event with mPresShell, let's try to handle it
  // with parent PresShell.
  // However, we don't want to handle IME related events with parent document
  // because it may leak the content of parent document and the IME state was
  // set for the empty document.  So, dispatching on the parent document may be
  // handled by nobody. Additionally, IMEContentObserver may send notifications
  // to PuppetWidget in a content process while document which is in the design
  // mode but does not have content nodes has focus.  At that time, PuppetWidget
  // makes ContentCacheInChild collect the latest content data with dispatching
  // query content events.  Therefore, we want they handle in the empty document
  // rather than the parent document.  So, we must not retarget in this case
  // anyway.
  mPresShell->mCurrentEventTarget.SetFrameAndContent(
      aGUIEvent->mMessage, nullptr, eventTargetElement);
  if (aGUIEvent->mClass != eCompositionEventClass &&
      aGUIEvent->mClass != eQueryContentEventClass &&
      aGUIEvent->mClass != eSelectionEventClass &&
      (!mPresShell->GetCurrentEventContent() ||
       !mPresShell->GetCurrentEventFrame() ||
       InZombieDocument(mPresShell->mCurrentEventTarget.mContent))) {
    return RetargetEventToParent(aGUIEvent, aEventStatus);
  }

  nsresult rv =
      HandleEventWithCurrentEventInfo(aGUIEvent, aEventStatus, true, nullptr);
  return rv;
}

Element* PresShell::EventHandler::ComputeFocusedEventTargetElement(
    WidgetGUIEvent* aGUIEvent) {
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(aGUIEvent->IsTargetedAtFocusedContent());

  // key and IME related events go to the focused frame in this DOM window.
  nsPIDOMWindowOuter* window = GetDocument()->GetWindow();
  nsCOMPtr<nsPIDOMWindowOuter> focusedWindow;
  Element* eventTargetElement = nsFocusManager::GetFocusedDescendant(
      window, nsFocusManager::eOnlyCurrentWindow,
      getter_AddRefs(focusedWindow));

  // otherwise, if there is no focused content or the focused content has
  // no frame, just use the root content. This ensures that key events
  // still get sent to the window properly if nothing is focused or if a
  // frame goes away while it is focused.
  if (!eventTargetElement || !eventTargetElement->GetPrimaryFrame()) {
    eventTargetElement = GetDocument()->GetUnfocusedKeyEventTarget();
  }

  switch (aGUIEvent->mMessage) {
    case eKeyDown:
      sLastKeyDownEventTargetElement = eventTargetElement;
      return eventTargetElement;
    case eKeyPress:
    case eKeyUp:
      if (!sLastKeyDownEventTargetElement) {
        return eventTargetElement;
      }
      // If a different element is now focused for the keypress/keyup event
      // than what was focused during the keydown event, check if the new
      // focused element is not in a chrome document any more, and if so,
      // retarget the event back at the keydown target. This prevents a
      // content area from grabbing the focus from chrome in-between key
      // events.
      if (eventTargetElement) {
        bool keyDownIsChrome = nsContentUtils::IsChromeDoc(
            sLastKeyDownEventTargetElement->GetComposedDoc());
        if (keyDownIsChrome != nsContentUtils::IsChromeDoc(
                                   eventTargetElement->GetComposedDoc()) ||
            (keyDownIsChrome && BrowserParent::GetFrom(eventTargetElement))) {
          eventTargetElement = sLastKeyDownEventTargetElement;
        }
      }

      if (aGUIEvent->mMessage == eKeyUp) {
        sLastKeyDownEventTargetElement = nullptr;
      }
      [[fallthrough]];
    default:
      return eventTargetElement;
  }
}

bool PresShell::EventHandler::MaybeHandleEventWithAnotherPresShell(
    Element* aEventTargetElement, WidgetGUIEvent* aGUIEvent,
    nsEventStatus* aEventStatus, nsresult* aRv) {
  MOZ_ASSERT(aEventTargetElement);
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(!aGUIEvent->IsUsingCoordinates());
  MOZ_ASSERT(aEventStatus);
  MOZ_ASSERT(aRv);

  Document* eventTargetDocument = aEventTargetElement->OwnerDoc();
  if (!eventTargetDocument || eventTargetDocument == GetDocument()) {
    *aRv = NS_OK;
    return false;
  }

  RefPtr<PresShell> eventTargetPresShell = eventTargetDocument->GetPresShell();
  if (!eventTargetPresShell) {
    *aRv = NS_OK;
    return true;  // No PresShell can handle the event.
  }

  EventHandler eventHandler(std::move(eventTargetPresShell));
  *aRv = eventHandler.HandleRetargetedEvent(aGUIEvent, aEventStatus,
                                            aEventTargetElement);
  return true;
}

nsresult PresShell::EventHandler::HandleEventWithFrameForPresShell(
    AutoWeakFrame& aWeakFrameForPresShell, WidgetGUIEvent* aGUIEvent,
    nsEventStatus* aEventStatus) {
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(!aGUIEvent->IsUsingCoordinates());
  MOZ_ASSERT(!aGUIEvent->IsTargetedAtFocusedContent());
  MOZ_ASSERT(aEventStatus);

  AutoCurrentEventInfoSetter eventInfoSetter(
      *this, EventTargetInfo(aGUIEvent->mMessage,
                             aWeakFrameForPresShell.GetFrame(), nullptr));

  nsresult rv = NS_OK;
  if (mPresShell->GetCurrentEventFrame()) {
    rv =
        HandleEventWithCurrentEventInfo(aGUIEvent, aEventStatus, true, nullptr);
  }

  return rv;
}

Document* PresShell::GetPrimaryContentDocument() {
  nsPresContext* context = GetPresContext();
  if (!context || !context->IsRoot()) {
    return nullptr;
  }

  nsCOMPtr<nsIDocShellTreeItem> shellAsTreeItem = context->GetDocShell();
  if (!shellAsTreeItem) {
    return nullptr;
  }

  nsCOMPtr<nsIDocShellTreeOwner> owner;
  shellAsTreeItem->GetTreeOwner(getter_AddRefs(owner));
  if (!owner) {
    return nullptr;
  }

  // now get the primary content shell (active tab)
  nsCOMPtr<nsIDocShellTreeItem> item;
  owner->GetPrimaryContentShell(getter_AddRefs(item));
  nsCOMPtr<nsIDocShell> childDocShell = do_QueryInterface(item);
  if (!childDocShell) {
    return nullptr;
  }

  return childDocShell->GetExtantDocument();
}

nsresult PresShell::EventHandler::HandleEventWithTarget(
    WidgetEvent* aEvent, nsIFrame* aNewEventFrame, nsIContent* aNewEventContent,
    nsEventStatus* aEventStatus, bool aIsHandlingNativeEvent,
    nsIContent** aTargetContent, nsIContent* aOverrideClickTarget) {
  MOZ_ASSERT(aEvent);
  MOZ_DIAGNOSTIC_ASSERT(aEvent->IsTrusted());
  MOZ_ASSERT(!aNewEventFrame || aNewEventFrame->PresShell() == mPresShell,
             "wrong shell");
  // NOTE: We don't require that the document still have a PresShell.
  // See bug 1375940.
  NS_ASSERTION(!aNewEventContent || aNewEventContent->IsInComposedDoc(),
               "event for content that isn't in a document");
  NS_ENSURE_STATE(!aNewEventContent ||
                  aNewEventContent->GetComposedDoc() == GetDocument());
  if (aEvent->mClass == ePointerEventClass ||
      aEvent->mClass == eDragEventClass) {
    mPresShell->RecordPointerLocation(aEvent->AsMouseEvent());
  }
  AutoPointerEventTargetUpdater updater(mPresShell, aEvent, aNewEventFrame,
                                        aNewEventContent, aTargetContent);
  AutoCurrentEventInfoSetter eventInfoSetter(
      *this,
      EventTargetInfo(aEvent->mMessage, aNewEventFrame, aNewEventContent));
  nsresult rv = HandleEventWithCurrentEventInfo(aEvent, aEventStatus, false,
                                                aOverrideClickTarget);
  return rv;
}

namespace {

class MOZ_RAII AutoEventHandler final {
 public:
  AutoEventHandler(WidgetEvent* aEvent, Document* aDocument) : mEvent(aEvent) {
    MOZ_ASSERT(mEvent);
    MOZ_ASSERT(mEvent->IsTrusted());

    if (mEvent->mMessage == eMouseDown) {
      PresShell::ReleaseCapturingContent();
      PresShell::AllowMouseCapture(true);
    }
    if (NeedsToUpdateCurrentMouseBtnState()) {
      WidgetMouseEvent* mouseEvent = mEvent->AsMouseEvent();
      if (mouseEvent) {
        EventStateManager::sCurrentMouseBtn = mouseEvent->mButton;
      }
    }
  }

  ~AutoEventHandler() {
    if (mEvent->mMessage == eMouseDown) {
      PresShell::AllowMouseCapture(false);
    }
    if (NeedsToUpdateCurrentMouseBtnState()) {
      EventStateManager::sCurrentMouseBtn = MouseButton::eNotPressed;
    }
  }

 protected:
  bool NeedsToUpdateCurrentMouseBtnState() const {
    return mEvent->mMessage == eMouseDown || mEvent->mMessage == eMouseUp ||
           mEvent->mMessage == ePointerDown || mEvent->mMessage == ePointerUp;
  }

  WidgetEvent* mEvent;
};

}  // anonymous namespace

nsresult PresShell::EventHandler::HandleEventWithCurrentEventInfo(
    WidgetEvent* aEvent, nsEventStatus* aEventStatus,
    bool aIsHandlingNativeEvent, nsIContent* aOverrideClickTarget) {
  MOZ_ASSERT(aEvent);
  MOZ_ASSERT(aEventStatus);

  RefPtr<EventStateManager> manager = GetPresContext()->EventStateManager();

  // If we cannot handle the event with mPresShell because of no target,
  // just record the response time.
  // XXX Is this intentional?  In such case, the score is really good because
  //     of nothing to do.  So, it may make average and median better.
  if (NS_EVENT_NEEDS_FRAME(aEvent) && !mPresShell->GetCurrentEventFrame() &&
      !mPresShell->GetCurrentEventContent()) {
    RecordEventHandlingResponsePerformance(aEvent);
    return NS_OK;
  }

  if (mPresShell->mCurrentEventTarget.mContent &&
      aEvent->IsTargetedAtFocusedWindow() &&
      aEvent->AllowFlushingPendingNotifications()) {
    if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
      // This may run script now.  So, mPresShell might be destroyed after here.
      nsCOMPtr<nsIContent> currentEventContent =
          mPresShell->mCurrentEventTarget.mContent;
      fm->FlushBeforeEventHandlingIfNeeded(currentEventContent);
    }
  }

  bool touchIsNew = false;
  if (!PrepareToDispatchEvent(aEvent, aEventStatus, &touchIsNew)) {
    return NS_OK;
  }

  // We finished preparing to dispatch the event.  So, let's record the
  // performance.
  RecordEventPreparationPerformance(aEvent);

  AutoHandlingUserInputStatePusher userInpStatePusher(
      UserActivation::IsUserInteractionEvent(aEvent), aEvent);
  AutoEventHandler eventHandler(aEvent, GetDocument());
  AutoPopupStatePusher popupStatePusher(
      PopupBlocker::GetEventPopupControlState(aEvent));

  // FIXME. If the event was reused, we need to clear the old target,
  // bug 329430
  aEvent->mTarget = nullptr;

  nsresult rv = DispatchEvent(manager, aEvent, touchIsNew, aEventStatus,
                              aOverrideClickTarget);

  if (!mPresShell->IsDestroying() && aIsHandlingNativeEvent &&
      aEvent->mClass != eQueryContentEventClass) {
    // Ensure that notifications to IME should be sent before getting next
    // native event from the event queue.
    // XXX Should we check the event message or event class instead of
    //     using aIsHandlingNativeEvent?
    manager->TryToFlushPendingNotificationsToIME();
  }

  FinalizeHandlingEvent(aEvent, aEventStatus);

  RecordEventHandlingResponsePerformance(aEvent);

  return rv;  // Result of DispatchEvent()
}

nsresult PresShell::EventHandler::DispatchEvent(
    EventStateManager* aEventStateManager, WidgetEvent* aEvent,
    bool aTouchIsNew, nsEventStatus* aEventStatus,
    nsIContent* aOverrideClickTarget) {
  MOZ_ASSERT(aEventStateManager);
  MOZ_ASSERT(aEvent);
  MOZ_ASSERT(aEventStatus);

  // 1. Give event to event manager for pre event state changes and
  //    generation of synthetic events.
  {  // Scope for presContext
    RefPtr<nsPresContext> presContext = GetPresContext();
    nsCOMPtr<nsIContent> eventContent =
        mPresShell->mCurrentEventTarget.mContent;
    nsresult rv = aEventStateManager->PreHandleEvent(
        presContext, aEvent, mPresShell->mCurrentEventTarget.mFrame,
        eventContent, aEventStatus, aOverrideClickTarget);
    if (NS_FAILED(rv)) {
      return rv;
    }
    // Let's retarget eMouseMove target if the preceding mouse boundary events
    // caused removing the target from the tree and EventStateManager knows that
    // the deepest connected mouseenter target which was an ancestor of the
    // removed target.  This matches with Chrome Canary with enabling the
    // new mouse/pointer boundary event feature.  However, they stop dispatching
    // "pointermove" in the same case.  Therefore, for now, we should do this
    // only for eMouseMove.
    if (eventContent && aEvent->mMessage == eMouseMove &&
        (!eventContent->IsInComposedDoc() ||
         eventContent->OwnerDoc() != mPresShell->GetDocument())) {
      const OverOutElementsWrapper* const boundaryEventTargets =
          aEventStateManager->GetExtantMouseBoundaryEventTarget();
      const nsIContent* outEventTarget =
          boundaryEventTargets ? boundaryEventTargets->GetOutEventTarget()
                               : nullptr;
      nsIContent* const deepestLeaveEventTarget =
          boundaryEventTargets
              ? boundaryEventTargets->GetDeepestLeaveEventTarget()
              : nullptr;
      // If the last "over" target (next "out" target) is there, it means that
      // it was temporarily removed.  In such case, EventStateManager treats
      // it as never disconnected.  Therefore, we need to do nothing here.
      // Additionally, if there is no last deepest "enter" event target, we
      // lost the target.  Therefore, we should keep the traditional behavior,
      // to dispatch it on the Document node.
      if (!outEventTarget && deepestLeaveEventTarget) {
        nsIFrame* const frame =
            deepestLeaveEventTarget->GetPrimaryFrame(FlushType::Layout);
        if (MOZ_UNLIKELY(mPresShell->IsDestroying())) {
          return NS_OK;
        }
        if (frame) {
          mPresShell->mCurrentEventTarget.mFrame = frame;
          mPresShell->mCurrentEventTarget.mContent = deepestLeaveEventTarget;
        }
      }
    }
  }

  // 2. Give event to the DOM for third party and JS use.
  bool wasHandlingKeyBoardEvent = nsContentUtils::IsHandlingKeyBoardEvent();
  if (aEvent->mClass == eKeyboardEventClass) {
    nsContentUtils::SetIsHandlingKeyBoardEvent(true);
  }
  // If EventStateManager or something wants reply from remote process and
  // needs to win any other event listeners in chrome, the event is both
  // stopped its propagation and marked as "waiting reply from remote
  // process".  In this case, PresShell shouldn't dispatch the event into
  // the DOM tree because they don't have a chance to stop propagation in
  // the system event group.  On the other hand, if its propagation is not
  // stopped, that means that the event may be reserved by chrome.  If it's
  // reserved by chrome, the event shouldn't be sent to any remote
  // processes.  In this case, PresShell needs to dispatch the event to
  // the DOM tree for checking if it's reserved.
  if (aEvent->IsAllowedToDispatchDOMEvent() &&
      !(aEvent->PropagationStopped() &&
        aEvent->IsWaitingReplyFromRemoteProcess())) {
    MOZ_ASSERT(nsContentUtils::IsSafeToRunScript(),
               "Somebody changed aEvent to cause a DOM event!");
    nsPresShellEventCB eventCB(mPresShell);
    if (nsIFrame* target = mPresShell->GetCurrentEventFrame()) {
      if (target->OnlySystemGroupDispatch(aEvent->mMessage)) {
        aEvent->StopPropagation();
      }
    }
    if (aEvent->mClass == eTouchEventClass) {
      DispatchTouchEventToDOM(aEvent, aEventStatus, &eventCB, aTouchIsNew);
    } else {
      DispatchEventToDOM(aEvent, aEventStatus, &eventCB);
    }
  }

  nsContentUtils::SetIsHandlingKeyBoardEvent(wasHandlingKeyBoardEvent);

  if (mPresShell->IsDestroying()) {
    return NS_OK;
  }

  // 3. Give event to event manager for post event state changes and
  //    generation of synthetic events.
  // Refetch the prescontext, in case it changed.
  RefPtr<nsPresContext> presContext = GetPresContext();
  return aEventStateManager->PostHandleEvent(
      presContext, aEvent, mPresShell->GetCurrentEventFrame(), aEventStatus,
      aOverrideClickTarget);
}

bool PresShell::EventHandler::PrepareToDispatchEvent(
    WidgetEvent* aEvent, nsEventStatus* aEventStatus, bool* aTouchIsNew) {
  MOZ_ASSERT(aEvent->IsTrusted());
  MOZ_ASSERT(aEventStatus);
  MOZ_ASSERT(aTouchIsNew);

  *aTouchIsNew = false;
  if (aEvent->IsUserAction()) {
    mPresShell->mHasHandledUserInput = true;
  }

  switch (aEvent->mMessage) {
    case eKeyPress:
    case eKeyDown:
    case eKeyUp: {
      WidgetKeyboardEvent* keyboardEvent = aEvent->AsKeyboardEvent();
      MaybeHandleKeyboardEventBeforeDispatch(keyboardEvent);
      return true;
    }
    case eMouseRawUpdate:
      MOZ_ASSERT_UNREACHABLE(
          "eMouseRawUpdate shouldn't be handled as a DOM event");
      return false;

    case eMouseMove: {
      bool allowCapture = EventStateManager::GetActiveEventStateManager() &&
                          GetPresContext() &&
                          GetPresContext()->EventStateManager() ==
                              EventStateManager::GetActiveEventStateManager();
      PresShell::AllowMouseCapture(allowCapture);
      return true;
    }
    case eDrop: {
      nsCOMPtr<nsIDragSession> session =
          nsContentUtils::GetDragSession(GetPresContext());
      if (session) {
        bool onlyChromeDrop = false;
        session->GetOnlyChromeDrop(&onlyChromeDrop);
        if (onlyChromeDrop) {
          aEvent->mFlags.mOnlyChromeDispatch = true;
        }
      }
      return true;
    }
    case eDragExit: {
      if (!StaticPrefs::dom_event_dragexit_enabled()) {
        aEvent->mFlags.mOnlyChromeDispatch = true;
      }
      return true;
    }
    case eContextMenu: {
      // If we cannot open context menu even though eContextMenu is fired, we
      // should stop dispatching it into the DOM.
      WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
      if (mouseEvent->IsContextMenuKeyEvent() &&
          !AdjustContextMenuKeyEvent(mouseEvent)) {
        return false;
      }

      // If "Shift" state is active, context menu should be forcibly opened even
      // if web apps want to prevent it since we respect our users' intention.
      // In this case, we don't fire "contextmenu" event on web content because
      // of not cancelable.
      if (mouseEvent->IsShift() &&
          StaticPrefs::dom_event_contextmenu_shift_suppresses_event()) {
        aEvent->mFlags.mOnlyChromeDispatch = true;
        aEvent->mFlags.mRetargetToNonNativeAnonymous = true;
      }
      return true;
    }
    case eTouchStart:
    case eTouchMove:
    case eTouchEnd:
    case eTouchCancel:
    case eTouchPointerCancel:
      return mPresShell->mTouchManager.PreHandleEvent(
          aEvent, aEventStatus, *aTouchIsNew,
          mPresShell->mCurrentEventTarget.mContent);
    case eTouchRawUpdate:
      MOZ_ASSERT_UNREACHABLE(
          "eTouchRawUpdate shouldn't be handled as a DOM event");
      return false;
    default:
      return true;
  }
}

void PresShell::EventHandler::FinalizeHandlingEvent(
    WidgetEvent* aEvent, const nsEventStatus* aStatus) {
  switch (aEvent->mMessage) {
    case eKeyPress:
    case eKeyDown:
    case eKeyUp: {
      if (aEvent->AsKeyboardEvent()->mKeyCode == NS_VK_ESCAPE) {
        if (aEvent->mMessage == eKeyUp) {
          // Reset this flag after key up is handled.
          mPresShell->mIsLastChromeOnlyEscapeKeyConsumed = false;
        } else {
          if (aEvent->mFlags.mOnlyChromeDispatch &&
              aEvent->mFlags.mDefaultPreventedByChrome) {
            mPresShell->mIsLastChromeOnlyEscapeKeyConsumed = true;
          }
          if (aEvent->mMessage == eKeyDown &&
              !aEvent->mFlags.mDefaultPrevented) {
            if (RefPtr<Document> doc = GetDocument()) {
              if (StaticPrefs::dom_closewatcher_enabled()) {
                doc->ProcessCloseRequest();
              } else {
                doc->HandleEscKey();
              }
            }
          }
        }
      }
      if (aEvent->mMessage == eKeyDown) {
        mPresShell->mIsLastKeyDownCanceled = aEvent->mFlags.mDefaultPrevented;
      }
      break;
    }
    case eMouseUp:
      // reset the capturing content now that the mouse button is up
      PresShell::ReleaseCapturingContent();
      break;
    case eMouseRawUpdate:
      MOZ_ASSERT_UNREACHABLE(
          "eMouseRawUpdate shouldn't be handled as a DOM event");
      break;
    case eMouseMove:
      PresShell::AllowMouseCapture(false);
      break;
    case eDrag:
    case eDragEnd:
    case eDragEnter:
    case eDragExit:
    case eDragLeave:
    case eDragOver:
    case eDrop: {
      // After any drag event other than dragstart (which is handled
      // separately, as we need to collect the data first), the DataTransfer
      // needs to be made protected, and then disconnected.
      DataTransfer* dataTransfer = aEvent->AsDragEvent()->mDataTransfer;
      if (dataTransfer) {
        dataTransfer->Disconnect();
      }
      break;
    }
    case eTouchStart:
    case eTouchMove:
    case eTouchEnd:
    case eTouchCancel:
    case eTouchPointerCancel:
    case eMouseLongTap:
    case eContextMenu: {
      mPresShell->mTouchManager.PostHandleEvent(aEvent, aStatus);
      break;
    }
    case eTouchRawUpdate:
      MOZ_ASSERT_UNREACHABLE(
          "eTouchRawUpdate shouldn't be handled as a DOM event");
      break;
    default:
      break;
  }

  if (WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent()) {
    if (mouseEvent->mSynthesizeMoveAfterDispatch) {
      PointerEventHandler::SynthesizeMoveToDispatchBoundaryEvents(mouseEvent);
    }
  }
}

void PresShell::MaybeExitKeyboardLockedFullscreen(
    WidgetKeyboardEvent* aKeyboardEvent, Document* aFullscreenRoot) {
  // No recorded keydown?
  if (mFirstUnmatchedEscapeKeyDownForFullscreen.IsNull()) {
    return;
  }
  const bool escapeKeyDeltaLargeEnough =
      (aKeyboardEvent->mTimeStamp -
       mFirstUnmatchedEscapeKeyDownForFullscreen) >=
      TimeDuration::FromMilliseconds(
          StaticPrefs::dom_fullscreen_keyboard_lock_long_press_interval());

  if (escapeKeyDeltaLargeEnough) {
    Document::AsyncExitFullscreen(aFullscreenRoot);
    if (XRE_IsParentProcess() && (PointerLockManager::GetLockedRemoteTarget() ||
                                  PointerLockManager::IsLocked())) {
      PointerLockManager::Unlock("EscapeKey");
    }
  }
}

void PresShell::EventHandler::MaybeHandleKeyboardEventBeforeDispatch(
    WidgetKeyboardEvent* aKeyboardEvent) {
  MOZ_ASSERT(aKeyboardEvent);

  if (aKeyboardEvent->mKeyCode != NS_VK_ESCAPE) {
    mPresShell->CleanupFullscreenState();
    return;
  }

  // If we're in fullscreen mode, exit from it forcibly when Escape key is
  // pressed.
  Document* doc = mPresShell->GetCurrentEventContent()
                      ? mPresShell->mCurrentEventTarget.mContent->OwnerDoc()
                      : nullptr;
  Document* root = nsContentUtils::GetInProcessSubtreeRootDocument(doc);
  if (root && root->GetFullscreenElement()) {
    Document* fullscreenLeaf = Document::GetFullscreenLeaf(root);
    if (fullscreenLeaf->HasFullscreenKeyboardLockEnabled()) {
      if (aKeyboardEvent->mMessage == eKeyDown) {
        // Instead of exiting fullscreen on a single press of the escape key, we
        // now wait for the escape key to be held for longer than a given
        // interval before exiting.
        if (!aKeyboardEvent->mIsRepeat) {
          mPresShell->mHasShownFullscreenWarningForCurrentEscapeKeyLongPress =
              false;
          mPresShell->mFirstUnmatchedEscapeKeyDownForFullscreen =
              aKeyboardEvent->mTimeStamp;

          if (mPresShell->ShouldShowFullscreenKeyboardLockWarning(
                  *aKeyboardEvent)) {
            nsContentUtils::DispatchEventOnlyToChrome(
                root, root, u"MozDOMFullscreen:WarnAboutKeyboardLock"_ns,
                CanBubble::eYes, Cancelable::eNo, /* DefaultAction */ nullptr);
          }
          return;
        }

        MOZ_ASSERT(aKeyboardEvent->mIsRepeat);
        if (mPresShell->ShouldShowFullscreenKeyboardLockWarning(
                *aKeyboardEvent)) {
          nsContentUtils::DispatchEventOnlyToChrome(
              root, root, u"MozDOMFullscreen:WarnAboutKeyboardLock"_ns,
              CanBubble::eYes, Cancelable::eNo, /* DefaultAction */ nullptr);
        }

        mPresShell->MaybeExitKeyboardLockedFullscreen(aKeyboardEvent, root);
      } else if (aKeyboardEvent->mMessage == eKeyUp) {
        // When keyboard key repeat is disabled by the OS, no repeat keydown
        // events are generated while holding Escape. Check on keyup whether the
        // key was held long enough to exit fullscreen.
        mPresShell->MaybeExitKeyboardLockedFullscreen(aKeyboardEvent, root);
      }

      // If fullscreen keyboard-lock is enabled, return here, as we don't allow
      // escaping from pointerlock when escape is pressed.
      return;
    }

    // Prevent default action on ESC key press when exiting
    // DOM fullscreen mode. This prevents the browser ESC key
    // handler from stopping all loads in the document, which
    // would cause <video> loads to stop.
    // XXX We need to claim the Escape key event which will be
    //     dispatched only into chrome is already consumed by
    //     content because we need to prevent its default here
    //     for some reasons (not sure) but we need to detect
    //     if a chrome event handler will call PreventDefault()
    //     again and check it later.
    aKeyboardEvent->PreventDefaultBeforeDispatch(CrossProcessForwarding::eStop);
    aKeyboardEvent->mFlags.mOnlyChromeDispatch = true;

    // The event listeners in chrome can prevent this ESC behavior by
    // calling prevent default on the preceding keydown/press events.
    if (aKeyboardEvent->mMessage == eKeyUp) {
      bool shouldExitFullscreen =
          !mPresShell->mIsLastChromeOnlyEscapeKeyConsumed;
      if (!shouldExitFullscreen) {
        if (mPresShell->mLastConsumedEscapeKeyUpForFullscreen &&
            (aKeyboardEvent->mTimeStamp -
             mPresShell->mLastConsumedEscapeKeyUpForFullscreen) <=
                TimeDuration::FromMilliseconds(
                    StaticPrefs::
                        dom_fullscreen_force_exit_on_multiple_escape_interval())) {
          shouldExitFullscreen = true;
          mPresShell->mLastConsumedEscapeKeyUpForFullscreen = TimeStamp();
        } else {
          mPresShell->mLastConsumedEscapeKeyUpForFullscreen =
              aKeyboardEvent->mTimeStamp;
        }
      }

      if (shouldExitFullscreen) {
        // ESC key released while in DOM fullscreen mode.
        // Fully exit fullscreen mode for the browser window and documents
        // that received the event.
        Document::AsyncExitFullscreen(root);
      }
    }
  }

  if (XRE_IsParentProcess() &&
      !mPresShell->mIsLastChromeOnlyEscapeKeyConsumed) {
    if (PointerLockManager::GetLockedRemoteTarget() ||
        PointerLockManager::IsLocked()) {
      // XXX See above comment to understand the reason why this needs
      //     to claim that the Escape key event is consumed by content
      //     even though it will be dispatched only into chrome.
      aKeyboardEvent->PreventDefaultBeforeDispatch(
          CrossProcessForwarding::eStop);
      aKeyboardEvent->mFlags.mOnlyChromeDispatch = true;
      if (aKeyboardEvent->mMessage == eKeyUp) {
        PointerLockManager::Unlock("EscapeKey");
      }
    }
  }
}

void PresShell::EventHandler::RecordEventPreparationPerformance(
    const WidgetEvent* aEvent) {
  MOZ_ASSERT(aEvent);

  switch (aEvent->mMessage) {
    case eKeyPress:
    case eKeyDown:
    case eKeyUp:
      if (aEvent->AsKeyboardEvent()->ShouldInteractionTimeRecorded()) {
        GetPresContext()->RecordInteractionTime(
            nsPresContext::InteractionType::KeyInteraction, aEvent->mTimeStamp);
      }
      glean::layout::input_event_queued_keyboard.AccumulateRawDuration(
          TimeStamp::Now() - aEvent->mTimeStamp);
      return;

    case eMouseDown:
    case eMouseUp:
      glean::layout::input_event_queued_click.AccumulateRawDuration(
          TimeStamp::Now() - aEvent->mTimeStamp);
      [[fallthrough]];
    case ePointerDown:
    case ePointerUp:
      GetPresContext()->RecordInteractionTime(
          nsPresContext::InteractionType::ClickInteraction, aEvent->mTimeStamp);
      return;

    case eMouseRawUpdate:
      MOZ_ASSERT_UNREACHABLE(
          "eMouseRawUpdate shouldn't be handled as a DOM event");
      break;
    case eMouseMove:
      GetPresContext()->RecordInteractionTime(
          nsPresContext::InteractionType::MouseMoveInteraction,
          aEvent->mTimeStamp);
      return;

    default:
      return;
  }
}

void PresShell::EventHandler::RecordEventHandlingResponsePerformance(
    const WidgetEvent* aEvent) {
  if (!Telemetry::CanRecordBase() || aEvent->mTimeStamp.IsNull() ||
      aEvent->mTimeStamp <= mPresShell->mLastOSWake ||
      !aEvent->AsInputEvent()) {
    return;
  }

  TimeStamp now = TimeStamp::Now();
  TimeDuration duration = now - aEvent->mTimeStamp;
  glean::layout::input_event_response.AccumulateRawDuration(duration);
  if (GetDocument() &&
      GetDocument()->GetReadyStateEnum() != Document::READYSTATE_COMPLETE) {
    glean::layout::load_input_event_response.AccumulateRawDuration(duration);
  }

  if (!sLastInputProcessed || sLastInputProcessed < aEvent->mTimeStamp) {
    if (sLastInputProcessed) {
      // This input event was created after we handled the last one.
      // Accumulate the previous events' coalesced duration.
      glean::layout::input_event_response_coalesced.AccumulateRawDuration(
          sLastInputProcessed - sLastInputCreated);

      if (MOZ_UNLIKELY(!PresShell::sProcessInteractable)) {
        // For content process, we use the ready state of
        // top-level-content-document to know if the process has finished the
        // start-up.
        // For parent process, see the topic
        // 'sessionstore-one-or-no-tab-restored' in PresShell::Observe.
        if (XRE_IsContentProcess() && GetDocument() &&
            GetDocument()->IsTopLevelContentDocument()) {
          switch (GetDocument()->GetReadyStateEnum()) {
            case Document::READYSTATE_INTERACTIVE:
            case Document::READYSTATE_COMPLETE:
              PresShell::sProcessInteractable = true;
              break;
            default:
              break;
          }
        }
      }
    }
    sLastInputCreated = aEvent->mTimeStamp;
  } else if (aEvent->mTimeStamp < sLastInputCreated) {
    // This event was created before the last input. May be processing out
    // of order, so coalesce backwards, too.
    sLastInputCreated = aEvent->mTimeStamp;
  }
  sLastInputProcessed = now;
}

// static
nsIPrincipal*
PresShell::EventHandler::GetDocumentPrincipalToCompareWithBlacklist(
    PresShell& aPresShell) {
  nsPresContext* presContext = aPresShell.GetPresContext();
  if (NS_WARN_IF(!presContext)) {
    return nullptr;
  }
  return presContext->Document()->GetPrincipalForPrefBasedHacks();
}

nsresult PresShell::EventHandler::DispatchEventToDOM(
    WidgetEvent* aEvent, nsEventStatus* aEventStatus,
    nsPresShellEventCB* aEventCB) {
  nsresult rv = NS_OK;
  nsCOMPtr<nsINode> eventTarget = mPresShell->mCurrentEventTarget.mContent;
  nsPresShellEventCB* eventCBPtr = aEventCB;
  if (!eventTarget) {
    nsCOMPtr<nsIContent> targetContent;
    if (mPresShell->mCurrentEventTarget.mFrame) {
      targetContent =
          mPresShell->mCurrentEventTarget.mFrame->GetEventTargetContent(aEvent);
    }
    if (targetContent) {
      eventTarget = targetContent;
    } else if (GetDocument()) {
      eventTarget = GetDocument();
      // If we don't have any content, the callback wouldn't probably
      // do nothing.
      eventCBPtr = nullptr;
    }
  }
  if (eventTarget) {
    if (eventTarget->OwnerDoc()->ShouldResistFingerprinting(
            RFPTarget::WidgetEvents) &&
        aEvent->IsBlockedForFingerprintingResistance()) {
      aEvent->mFlags.mOnlySystemGroupDispatchInContent = true;
    } else if (aEvent->mMessage == eKeyPress) {
      // If eKeyPress event is marked as not dispatched in the default event
      // group in web content, it's caused by non-printable key or key
      // combination.  In this case, UI Events declares that browsers
      // shouldn't dispatch keypress event.  However, some web apps may be
      // broken with this strict behavior due to historical issue.
      // Therefore, we need to keep dispatching keypress event for such keys
      // even with breaking the standard.
      // Similarly, the other browsers sets non-zero value of keyCode or
      // charCode of keypress event to the other.  Therefore, we should
      // behave so, however, some web apps may be broken.  On such web apps,
      // we should keep using legacy our behavior.
      if (!mPresShell->mInitializedWithKeyPressEventDispatchingBlacklist) {
        mPresShell->mInitializedWithKeyPressEventDispatchingBlacklist = true;
        nsCOMPtr<nsIPrincipal> principal =
            GetDocumentPrincipalToCompareWithBlacklist(*mPresShell);
        if (principal) {
          mPresShell->mForceDispatchKeyPressEventsForNonPrintableKeys =
              principal->IsURIInPrefList(
                  "dom.keyboardevent.keypress.hack.dispatch_non_printable_"
                  "keys") ||
              principal->IsURIInPrefList(
                  "dom.keyboardevent.keypress.hack."
                  "dispatch_non_printable_keys.addl");

          mPresShell->mForceUseLegacyKeyCodeAndCharCodeValues |=
              principal->IsURIInPrefList(
                  "dom.keyboardevent.keypress.hack."
                  "use_legacy_keycode_and_charcode") ||
              principal->IsURIInPrefList(
                  "dom.keyboardevent.keypress.hack."
                  "use_legacy_keycode_and_charcode.addl");
        }
      }
      if (mPresShell->mForceDispatchKeyPressEventsForNonPrintableKeys) {
        aEvent->mFlags.mOnlySystemGroupDispatchInContent = false;
      }
      if (mPresShell->mForceUseLegacyKeyCodeAndCharCodeValues) {
        aEvent->AsKeyboardEvent()->mUseLegacyKeyCodeAndCharCodeValues = true;
      }
    }

    if (aEvent->mClass == eCompositionEventClass) {
      RefPtr<nsPresContext> presContext = GetPresContext();
      RefPtr<BrowserParent> browserParent =
          IMEStateManager::GetActiveBrowserParent();
      IMEStateManager::DispatchCompositionEvent(
          eventTarget, presContext, browserParent, aEvent->AsCompositionEvent(),
          aEventStatus, eventCBPtr);
    } else {
      if (aEvent->IsMouseEventClassOrHasClickRelatedPointerEvent()) {
        PointerEventHandler::RecordMouseButtons(*aEvent->AsMouseEvent());
#ifdef DEBUG
        if (eventTarget->IsContent() && !eventTarget->IsElement()) {
          NS_WARNING(nsPrintfCString(
                         "%s (IsReal()=%s) target is not an elemnet content "
                         "node, %s\n",
                         ToChar(aEvent->mMessage),
                         aEvent->AsMouseEvent()->IsReal() ? "true" : "false",
                         ToString(*eventTarget).c_str())
                         .get());
          MOZ_CRASH("MouseEvent target must be an element");
        }
#endif  // #ifdef DEBUG
      }
      if (aEvent->mClass == eMouseEventClass) {
        MOZ_ASSERT(aEvent->AsMouseEvent());
        PointerEventHandler::WillDispatchMouseEventToDOM(
            *aEvent->AsMouseEvent());
      }
      RefPtr<nsPresContext> presContext = GetPresContext();
      EventDispatcher::Dispatch(eventTarget, presContext, aEvent, nullptr,
                                aEventStatus, eventCBPtr);
    }
  }
  return rv;
}

void PresShell::EventHandler::DispatchTouchEventToDOM(
    WidgetEvent* aEvent, nsEventStatus* aEventStatus,
    nsPresShellEventCB* aEventCB, bool aTouchIsNew) {
  MOZ_ASSERT(aEvent->mMessage != eTouchRawUpdate);
  // calling preventDefault on touchstart or the first touchmove for a
  // point prevents mouse events. calling it on the touchend should
  // prevent click dispatching.
  bool canPrevent = (aEvent->mMessage == eTouchStart) ||
                    (aEvent->mMessage == eTouchMove && aTouchIsNew) ||
                    (aEvent->mMessage == eTouchEnd);
  bool preventDefault = false;
  nsEventStatus tmpStatus = nsEventStatus_eIgnore;
  WidgetTouchEvent* touchEvent = aEvent->AsTouchEvent();

  // loop over all touches and dispatch events on any that have changed
  for (dom::Touch* touch : touchEvent->mTouches) {
    // We should remove all suppressed touch instances in
    // TouchManager::PreHandleEvent.
    MOZ_ASSERT(!touch->mIsTouchEventSuppressed);

    if (!touch || !touch->mChanged) {
      continue;
    }

    nsCOMPtr<EventTarget> targetPtr = touch->mTarget;
    nsCOMPtr<nsIContent> content = do_QueryInterface(targetPtr);
    if (!content) {
      continue;
    }

    Document* doc = content->OwnerDoc();
    nsIContent* capturingContent = PresShell::GetCapturingContent();
    if (capturingContent) {
      if (capturingContent->OwnerDoc() != doc) {
        // Wrong document, don't dispatch anything.
        continue;
      }
      content = capturingContent;
    }
    // copy the event
    MOZ_ASSERT(touchEvent->IsTrusted());
    WidgetTouchEvent newEvent(true, touchEvent->mMessage, touchEvent->mWidget);
    newEvent.AssignTouchEventData(*touchEvent, false);
    newEvent.mTarget = targetPtr;
    newEvent.mFlags.mHandledByAPZ = touchEvent->mFlags.mHandledByAPZ;

    RefPtr<PresShell> contentPresShell;
    if (doc == GetDocument()) {
      contentPresShell = doc->GetPresShell();
      if (contentPresShell) {
        // XXXsmaug huge hack. Pushing possibly capturing content,
        //         even though event target is something else.
        contentPresShell->PushCurrentEventInfo(EventTargetInfo(
            newEvent.mMessage, content->GetPrimaryFrame(), content));
      }
    }

    RefPtr<nsPresContext> presContext = doc->GetPresContext();
    if (!presContext) {
      if (contentPresShell) {
        contentPresShell->PopCurrentEventInfo();
      }
      continue;
    }

    tmpStatus = nsEventStatus_eIgnore;
    EventDispatcher::Dispatch(targetPtr, presContext, &newEvent, nullptr,
                              &tmpStatus, aEventCB);
    if (nsEventStatus_eConsumeNoDefault == tmpStatus ||
        newEvent.mFlags.mMultipleActionsPrevented) {
      preventDefault = true;
    }

    if (newEvent.mFlags.mMultipleActionsPrevented) {
      touchEvent->mFlags.mMultipleActionsPrevented = true;
    }

    if (contentPresShell) {
      contentPresShell->PopCurrentEventInfo();
    }
  }

  if (preventDefault && canPrevent) {
    *aEventStatus = nsEventStatus_eConsumeNoDefault;
  } else {
    *aEventStatus = nsEventStatus_eIgnore;
  }
}

// Dispatch event to content only (NOT full processing)
// See also HandleEventWithTarget which does full event processing.
nsresult PresShell::HandleDOMEventWithTarget(nsIContent* aTargetContent,
                                             WidgetEvent* aEvent,
                                             nsEventStatus* aStatus) {
  nsresult rv = NS_OK;

  PushCurrentEventInfo(
      EventTargetInfo(aEvent->mMessage, nullptr, aTargetContent));

  // Bug 41013: Check if the event should be dispatched to content.
  // It's possible that we are in the middle of destroying the window
  // and the js context is out of date. This check detects the case
  // that caused a crash in bug 41013, but there may be a better way
  // to handle this situation!
  nsCOMPtr<nsISupports> container = mPresContext->GetContainerWeak();
  if (container) {
    // Dispatch event to content
    rv = EventDispatcher::Dispatch(aTargetContent, mPresContext, aEvent,
                                   nullptr, aStatus);
  }

  PopCurrentEventInfo();
  return rv;
}

// See the method above.
nsresult PresShell::HandleDOMEventWithTarget(nsIContent* aTargetContent,
                                             Event* aEvent,
                                             nsEventStatus* aStatus) {
  nsresult rv = NS_OK;

  PushCurrentEventInfo(EventTargetInfo(aEvent->WidgetEventPtr()->mMessage,
                                       nullptr, aTargetContent));
  nsCOMPtr<nsISupports> container = mPresContext->GetContainerWeak();
  if (container) {
    rv = EventDispatcher::DispatchDOMEvent(aTargetContent, nullptr, aEvent,
                                           mPresContext, aStatus);
  }

  PopCurrentEventInfo();
  return rv;
}

bool PresShell::EventHandler::AdjustContextMenuKeyEvent(
    WidgetMouseEvent* aMouseEvent) {
  // if a menu is open, open the context menu relative to the active item on the
  // menu.
  if (nsXULPopupManager* pm = nsXULPopupManager::GetInstance()) {
    nsIFrame* popupFrame = pm->GetTopPopup(widget::PopupType::Menu);
    if (popupFrame) {
      nsIFrame* itemFrame = (static_cast<nsMenuPopupFrame*>(popupFrame))
                                ->GetCurrentMenuItemFrame();
      if (!itemFrame) {
        itemFrame = popupFrame;
      }

      nsCOMPtr<nsIWidget> widget = popupFrame->GetNearestWidget();
      aMouseEvent->mWidget = widget;
      LayoutDeviceIntPoint widgetPoint = widget->WidgetToScreenOffset();
      aMouseEvent->mRefPoint =
          LayoutDeviceIntPoint::FromAppUnitsToNearest(
              itemFrame->GetScreenRectInAppUnits().BottomLeft(),
              itemFrame->PresContext()->AppUnitsPerDevPixel()) -
          widgetPoint;

      mPresShell->mCurrentEventTarget.SetFrameAndContent(
          aMouseEvent->mMessage, itemFrame,
          itemFrame->GetContent()
              ? itemFrame->GetContent()
                    ->GetInclusiveFlattenedTreeAncestorElement()
              : nullptr);

      return true;
    }
  }

  // If we're here because of the key-equiv for showing context menus, we
  // have to twiddle with the NS event to make sure the context menu comes
  // up in the upper left of the relevant content area before we create
  // the DOM event. Since we never call InitMouseEvent() on the event,
  // the client X/Y will be 0,0. We can make use of that if the widget is null.
  // Use the root widget since it's most likely to exist, and the coordinates
  // returned by GetCurrentItemAndPositionForElement are relative to it.
  nsRootPresContext* rootPC = GetPresContext()->GetRootPresContext();
  aMouseEvent->mRefPoint = LayoutDeviceIntPoint();
  if (rootPC) {
    aMouseEvent->mWidget = rootPC->PresShell()->GetRootWidget();
    if (aMouseEvent->mWidget) {
      // default the refpoint to the topleft of our document
      if (nsIFrame* rootFrame = FrameConstructor()->GetRootFrame()) {
        auto frameToWidgetOffset =
            nsLayoutUtils::FrameToWidgetOffset(rootFrame, aMouseEvent->mWidget);
        MOZ_ASSERT(frameToWidgetOffset, "If rootPC has a widget, so should we");
        if (frameToWidgetOffset) {
          aMouseEvent->mRefPoint = LayoutDeviceIntPoint::FromAppUnitsToNearest(
              *frameToWidgetOffset, GetPresContext()->AppUnitsPerDevPixel());
        }
      }
    }
  } else {
    aMouseEvent->mWidget = nullptr;
  }

  // see if we should use the caret position for the popup
  LayoutDeviceIntPoint caretPoint;
  // Beware! This may flush notifications via synchronous
  // ScrollSelectionIntoView.
  if (PrepareToUseCaretPosition(MOZ_KnownLive(aMouseEvent->mWidget),
                                caretPoint)) {
    // caret position is good
    int32_t devPixelRatio = GetPresContext()->AppUnitsPerDevPixel();
    caretPoint = LayoutDeviceIntPoint::FromAppUnitsToNearest(
        ViewportUtils::LayoutToVisual(
            LayoutDeviceIntPoint::ToAppUnits(caretPoint, devPixelRatio),
            GetPresContext()->PresShell()),
        devPixelRatio);
    aMouseEvent->mRefPoint = caretPoint;
    return true;
  }

  // If we're here because of the key-equiv for showing context menus, we
  // have to reset the event target to the currently focused element. Get it
  // from the focus controller.
  RefPtr<Element> currentFocus = nsFocusManager::GetFocusedElementStatic();

  // Reset event coordinates relative to focused frame in view
  if (currentFocus) {
    nsCOMPtr<nsIContent> currentPointElement;
    GetCurrentItemAndPositionForElement(
        currentFocus, getter_AddRefs(currentPointElement),
        aMouseEvent->mRefPoint, MOZ_KnownLive(aMouseEvent->mWidget));
    if (currentPointElement) {
      mPresShell->mCurrentEventTarget.SetFrameAndContent(
          aMouseEvent->mMessage, nullptr, currentPointElement);
      mPresShell->GetCurrentEventFrame();
    }
  }

  return true;
}

// PresShell::EventHandler::PrepareToUseCaretPosition
//
//    This checks to see if we should use the caret position for popup context
//    menus. Returns true if the caret position should be used, and the
//    coordinates of that position is returned in aTargetPt. This function
//    will also scroll the window as needed to make the caret visible.
//
//    The event widget should be the widget that generated the event, and
//    whose coordinate system the resulting event's mRefPoint should be
//    relative to.  The returned point is in device pixels realtive to the
//    widget passed in.
bool PresShell::EventHandler::PrepareToUseCaretPosition(
    nsIWidget* aEventWidget, LayoutDeviceIntPoint& aTargetPt) {
  nsresult rv;

  // check caret visibility
  RefPtr<nsCaret> caret = mPresShell->GetActiveCaret();
  NS_ENSURE_TRUE(caret, false);

  bool caretVisible = caret->IsVisible();
  if (!caretVisible) {
    return false;
  }

  // caret selection, this is a temporary weak reference, so no refcounting is
  // needed
  Selection* domSelection = caret->GetSelection();
  NS_ENSURE_TRUE(domSelection, false);

  // since the match could be an anonymous textnode inside a
  // <textarea> or text <input>, we need to get the outer frame
  // note: frames are not refcounted
  nsIFrame* frame = nullptr;  // may be nullptr
  nsINode* node = domSelection->GetFocusNode();
  NS_ENSURE_TRUE(node, false);
  nsCOMPtr<nsIContent> content = nsIContent::FromNode(node);
  if (content) {
    nsIContent* nonNative = content->FindFirstNonChromeOnlyAccessContent();
    content = nonNative;
  }

  if (content) {
    // It seems like ScrollSelectionIntoView should be enough, but it's
    // not. The problem is that scrolling the selection into view when it is
    // below the current viewport will align the top line of the frame exactly
    // with the bottom of the window. This is fine, BUT, the popup event causes
    // the control to be re-focused which does this exact call to
    // ScrollContentIntoView, which has a one-pixel disagreement of whether the
    // frame is actually in view. The result is that the frame is aligned with
    // the top of the window, but the menu is still at the bottom.
    //
    // Doing this call first forces the frame to be in view, eliminating the
    // problem. The only difference in the result is that if your cursor is in
    // an edit box below the current view, you'll get the edit box aligned with
    // the top of the window. This is arguably better behavior anyway.
    rv = MOZ_KnownLive(mPresShell)
             ->ScrollContentIntoView(
                 content,
                 AxisScrollParams(WhereToScroll::Nearest,
                                  WhenToScroll::IfNotVisible),
                 AxisScrollParams(WhereToScroll::Nearest,
                                  WhenToScroll::IfNotVisible),
                 ScrollFlags::ScrollOverflowHidden);
    NS_ENSURE_SUCCESS(rv, false);
    frame = content->GetPrimaryFrame();
    NS_WARNING_ASSERTION(frame, "No frame for focused content?");
  }

  // Actually scroll the selection (ie caret) into view. Note that this must
  // be synchronous since we will be checking the caret position on the screen.
  //
  // Be easy about errors, and just don't scroll in those cases. Better to have
  // the correct menu at a weird place than the wrong menu.
  // After ScrollSelectionIntoView(), the pending notifications might be
  // flushed and PresShell/PresContext/Frames may be dead. See bug 418470.
  const nsCOMPtr<nsISelectionController> selCon =
      frame ? frame->GetSelectionController()
            : static_cast<nsISelectionController*>(mPresShell);
  if (selCon) {
    rv = selCon->ScrollSelectionIntoView(
        SelectionType::eNormal, nsISelectionController::SELECTION_FOCUS_REGION,
        SelectionScrollMode::SyncFlush);
    NS_ENSURE_SUCCESS(rv, false);
  }

  nsPresContext* presContext = GetPresContext();

  if (!aEventWidget) {
    return false;
  }
  // get caret position relative to the closest widget
  nsRect caretCoords;
  nsIFrame* caretFrame = caret->GetGeometry(&caretCoords);
  if (!caretFrame) {
    return false;
  }

  if (aEventWidget) {
    if (auto offset =
            nsLayoutUtils::FrameToWidgetOffset(caretFrame, aEventWidget)) {
      caretCoords.MoveBy(*offset);
    }
  }

  // caret coordinates are in app units, convert to pixels
  aTargetPt.x =
      presContext->AppUnitsToDevPixels(caretCoords.x + caretCoords.width);
  aTargetPt.y =
      presContext->AppUnitsToDevPixels(caretCoords.y + caretCoords.height);

  // make sure rounding doesn't return a pixel which is outside the caret
  // (e.g. one line lower)
  aTargetPt.y -= 1;

  return true;
}

void PresShell::EventHandler::GetCurrentItemAndPositionForElement(
    Element* aFocusedElement, nsIContent** aTargetToUse,
    LayoutDeviceIntPoint& aTargetPt, nsIWidget* aRootWidget) {
  nsCOMPtr<nsIContent> focusedContent = aFocusedElement;
  MOZ_KnownLive(mPresShell)
      ->ScrollContentIntoView(focusedContent, AxisScrollParams(),
                              AxisScrollParams(),
                              ScrollFlags::ScrollOverflowHidden);

  nsPresContext* presContext = GetPresContext();

  bool istree = false, checkLineHeight = true;
  nscoord extraTreeY = 0;

  // Set the position to just underneath the current item for multi-select
  // lists or just underneath the selected item for single-select lists. If
  // the element is not a list, or there is no selection, leave the position
  // as is.
  nsCOMPtr<Element> item;
  nsCOMPtr<nsIDOMXULMultiSelectControlElement> multiSelect =
      aFocusedElement->AsXULMultiSelectControl();
  if (multiSelect) {
    checkLineHeight = false;

    int32_t currentIndex;
    multiSelect->GetCurrentIndex(&currentIndex);
    if (currentIndex >= 0) {
      RefPtr<XULTreeElement> tree = XULTreeElement::FromNode(focusedContent);
      // Tree view special case (tree items have no frames)
      // Get the focused row and add its coordinates, which are already in
      // pixels
      // XXX Boris, should we create a new interface so that this doesn't
      // need to know about trees? Something like nsINodelessChildCreator
      // which could provide the current focus coordinates?
      if (tree) {
        tree->EnsureRowIsVisible(currentIndex);
        int32_t firstVisibleRow = tree->GetFirstVisibleRow();
        int32_t rowHeight = tree->RowHeight();

        extraTreeY += nsPresContext::CSSPixelsToAppUnits(
            (currentIndex - firstVisibleRow + 1) * rowHeight);
        istree = true;

        RefPtr<nsTreeColumns> cols = tree->GetColumns();
        if (cols) {
          nsTreeColumn* col = cols->GetFirstColumn();
          if (col) {
            RefPtr<Element> colElement = col->Element();
            nsIFrame* frame = colElement->GetPrimaryFrame();
            if (frame) {
              extraTreeY += frame->GetSize().height;
            }
          }
        }
      } else {
        multiSelect->GetCurrentItem(getter_AddRefs(item));
      }
    }
  } else {
    // don't check menulists as the selected item will be inside a popup.
    nsCOMPtr<nsIDOMXULMenuListElement> menulist =
        aFocusedElement->AsXULMenuList();
    if (!menulist) {
      nsCOMPtr<nsIDOMXULSelectControlElement> select =
          aFocusedElement->AsXULSelectControl();
      if (select) {
        checkLineHeight = false;
        select->GetSelectedItem(getter_AddRefs(item));
      }
    }
  }

  if (item) {
    focusedContent = item;
  }

  if (nsIFrame* frame = focusedContent->GetPrimaryFrame()) {
    NS_ASSERTION(
        frame->PresContext() == GetPresContext(),
        "handling event for focused content that is not in our document?");

    nsPoint widgetOffset;
    if (aRootWidget) {
      if (auto offset =
              nsLayoutUtils::FrameToWidgetOffset(frame, aRootWidget)) {
        widgetOffset = *offset;
      }
    }

    // Start context menu down and to the right from top left of frame
    // use the lineheight. This is a good distance to move the context
    // menu away from the top left corner of the frame. If we always
    // used the frame height, the context menu could end up far away,
    // for example when we're focused on linked images.
    // On the other hand, we want to use the frame height if it's less
    // than the current line height, so that the context menu appears
    // associated with the correct frame.
    nscoord extra = 0;
    if (!istree) {
      extra = frame->GetSize().height;
      if (checkLineHeight) {
        ScrollContainerFrame* scrollContainerFrame =
            nsLayoutUtils::GetNearestScrollContainerFrame(
                frame, nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN |
                           nsLayoutUtils::SCROLLABLE_FIXEDPOS_FINDS_ROOT);
        if (scrollContainerFrame) {
          nsSize scrollAmount = scrollContainerFrame->GetLineScrollAmount();
          int32_t APD = presContext->AppUnitsPerDevPixel();
          int32_t scrollAPD =
              scrollContainerFrame->PresContext()->AppUnitsPerDevPixel();
          scrollAmount = scrollAmount.ScaleToOtherAppUnits(scrollAPD, APD);
          if (extra > scrollAmount.height) {
            extra = scrollAmount.height;
          }
        }
      }
    }

    aTargetPt.x = presContext->AppUnitsToDevPixels(widgetOffset.x);
    aTargetPt.y =
        presContext->AppUnitsToDevPixels(widgetOffset.y + extra + extraTreeY);
  }

  NS_IF_ADDREF(*aTargetToUse = focusedContent);
}

bool PresShell::ShouldIgnoreInvalidation() {
  return mPaintingSuppressed || !mIsActive || mIsNeverPainting;
}

void PresShell::WillPaint() {
  // Check the simplest things first.  In particular, it's important to
  // check mIsActive before making any of the more expensive calls such
  // as GetRootPresContext, for the case of a browser with a large
  // number of tabs.
  // Don't bother doing anything if we still have painting suppressed or we are
  // not active.
  if (!mIsActive || mPaintingSuppressed || !IsVisible()) {
    return;
  }

  nsRootPresContext* rootPresContext = mPresContext->GetRootPresContext();
  if (!rootPresContext) {
    // In some edge cases, such as when we don't have a root frame yet,
    // we can't find the root prescontext. There's nothing to do in that
    // case.
    return;
  }

  rootPresContext->FlushWillPaintObservers();
  if (mIsDestroying) {
    return;
  }

  // Process reflows, if we have them, to reduce flicker due to invalidates and
  // reflow being interspersed.  Note that we _do_ allow this to be
  // interruptible; if we can't do all the reflows it's better to flicker a bit
  // than to freeze up.
  FlushPendingNotifications(ChangesToFlush(FlushType::InterruptibleLayout,
                                           /* aFlushAnimations = */ false,
                                           /* aUpdateRelevancy = */ false));
  if (mIsDestroying) {
    return;
  }
  mDocument->EnumerateSubDocuments(
      [](Document& aSubdoc) MOZ_CAN_RUN_SCRIPT_BOUNDARY_LAMBDA {
        if (RefPtr ps = aSubdoc.GetPresShell()) {
          if (!ps->IsUnderHiddenEmbedderElement()) {
            ps->WillPaint();
          }
        }
        return CallState::Continue;
      });
}

void PresShell::DidPaintWindow() {
  if (mHasReceivedPaintMessage) {
    return;
  }
  mHasReceivedPaintMessage = true;
  nsPIDOMWindowOuter* win = mDocument->GetWindow();
  if (!win || !nsGlobalWindowOuter::Cast(win)->IsChromeWindow()) {
    return;
  }
  if (nsCOMPtr<nsIObserverService> obsvc = services::GetObserverService()) {
    obsvc->NotifyObservers(win, "widget-first-paint", nullptr);
  }
}

nsSubDocumentFrame* PresShell::GetInProcessEmbedderFrame() const {
  nsIFrame* f = mEmbedderFrame.GetFrame();
  MOZ_ASSERT_IF(f, f->IsSubDocumentFrame());
  return static_cast<nsSubDocumentFrame*>(f);
}

bool PresShell::IsVisible() const {
  return mIsActive && !IsUnderHiddenEmbedderElement();
}

void PresShell::SuppressDisplayport(bool aEnabled) {
  if (aEnabled) {
    mActiveSuppressDisplayport++;
  } else if (mActiveSuppressDisplayport > 0) {
    bool isSuppressed = IsDisplayportSuppressed();
    mActiveSuppressDisplayport--;
    if (isSuppressed && !IsDisplayportSuppressed()) {
      // We unsuppressed the displayport, trigger a paint
      if (nsIFrame* rootFrame = mFrameConstructor->GetRootFrame()) {
        rootFrame->SchedulePaint();
      }
    }
  }
}

static bool sDisplayPortSuppressionRespected = true;

void PresShell::RespectDisplayportSuppression(bool aEnabled) {
  bool isSuppressed = IsDisplayportSuppressed();
  sDisplayPortSuppressionRespected = aEnabled;
  if (isSuppressed && !IsDisplayportSuppressed()) {
    // We unsuppressed the displayport, trigger a paint
    if (nsIFrame* rootFrame = mFrameConstructor->GetRootFrame()) {
      rootFrame->SchedulePaint();
    }
  }
}

bool PresShell::IsDisplayportSuppressed() {
  return sDisplayPortSuppressionRespected && mActiveSuppressDisplayport > 0;
}

static CallState FreezeSubDocument(Document& aDocument) {
  if (PresShell* presShell = aDocument.GetPresShell()) {
    presShell->Freeze();
  }
  return CallState::Continue;
}

void PresShell::Freeze(bool aIncludeSubDocuments) {
  mUpdateApproximateFrameVisibilityEvent.Revoke();

  MaybeReleaseCapturingContent();

  if (mCaret) {
    SetCaretEnabled(false);
  }

  mPaintingSuppressed = true;

  if (aIncludeSubDocuments && mDocument) {
    mDocument->EnumerateSubDocuments(FreezeSubDocument);
  }

  nsPresContext* presContext = GetPresContext();
  if (presContext) {
    presContext->DisableInteractionTimeRecording();
    if (presContext->RefreshDriver()->GetPresContext() == presContext) {
      presContext->RefreshDriver()->Freeze();
    }

    if (nsPresContext* rootPresContext = presContext->GetRootPresContext()) {
      rootPresContext->ResetUserInputEventsAllowed();
    }
  }

  mFrozen = true;
  if (mDocument) {
    UpdateImageLockingState();
  }
}

void PresShell::FireOrClearDelayedEvents(bool aFireEvents) {
  mNoDelayedMouseEvents = false;
  mNoDelayedKeyEvents = false;
  mNoDelayedSingleTap = false;
  if (!aFireEvents) {
    mDelayedEvents.Clear();
    return;
  }

  if (mDocument) {
    RefPtr<Document> doc = mDocument;
    while (!mIsDestroying && mDelayedEvents.Length() &&
           !doc->EventHandlingSuppressed()) {
      UniquePtr<DelayedEvent> ev = std::move(mDelayedEvents[0]);
      mDelayedEvents.RemoveElementAt(0);
      if (ev->IsKeyPressEvent() && mIsLastKeyDownCanceled) {
        continue;
      }
      ev->Dispatch();
    }
    if (!doc->EventHandlingSuppressed()) {
      mDelayedEvents.Clear();
    }
  }
}

void PresShell::Thaw(bool aIncludeSubDocuments) {
  nsPresContext* presContext = GetPresContext();
  if (presContext &&
      presContext->RefreshDriver()->GetPresContext() == presContext) {
    presContext->RefreshDriver()->Thaw();
  }

  if (aIncludeSubDocuments && mDocument) {
    mDocument->EnumerateSubDocuments([](Document& aSubDoc) {
      if (PresShell* presShell = aSubDoc.GetPresShell()) {
        presShell->Thaw();
      }
      return CallState::Continue;
    });
  }

  // Get the activeness of our presshell, as this might have changed
  // while we were in the bfcache
  ActivenessMaybeChanged();

  // We're now unfrozen
  mFrozen = false;
  UpdateImageLockingState();

  UnsuppressPainting();

  // In case the above UnsuppressPainting call didn't start the
  // refresh driver, we manually start the refresh driver to
  // ensure nsPresContext::MaybeIncreaseMeasuredTicksSinceLoading
  // can be called for user input events handling.
  if (presContext && presContext->IsRoot()) {
    if (!presContext->RefreshDriver()->HasPendingTick()) {
      presContext->RefreshDriver()->InitializeTimer();
    }
  }
}

//--------------------------------------------------------
// Start of protected and private methods on the PresShell
//--------------------------------------------------------

void PresShell::WillCauseReflow() {
  nsContentUtils::AddScriptBlocker();
  ++mChangeNestCount;
}

void PresShell::DidCauseReflow() {
  NS_ASSERTION(mChangeNestCount != 0, "Unexpected call to DidCauseReflow()");
  --mChangeNestCount;
  nsContentUtils::RemoveScriptBlocker();
}

void PresShell::WillDoReflow() {
  mDocument->FlushUserFontSet();

  mPresContext->FlushCounterStyles();

  mPresContext->FlushFontFeatureValues();

  mPresContext->FlushFontPaletteValues();

  mLastReflowStart = GetPerformanceNowUnclamped();
}

void PresShell::DidDoReflow(bool aInterruptible) {
  MOZ_ASSERT(mPendingDidDoReflow);
  if (!nsContentUtils::IsSafeToRunScript()) {
    // If we're reflowing while script-blocked (e.g. from container query
    // updates), defer our reflow callbacks until the end of our next layout
    // flush.
    SetNeedLayoutFlush();
    return;
  }

  auto clearPendingDidDoReflow =
      MakeScopeExit([&] { mPendingDidDoReflow = false; });

  mHiddenContentInForcedLayout.Clear();

  HandlePostedReflowCallbacks(aInterruptible);

  if (mIsDestroying) {
    return;
  }

  {
    nsAutoScriptBlocker scriptBlocker;
    AutoAssertNoFlush noReentrantFlush(*this);
    if (nsCOMPtr<nsIDocShell> docShell = mPresContext->GetDocShell()) {
      DOMHighResTimeStamp now = GetPerformanceNowUnclamped();
      docShell->NotifyReflowObservers(aInterruptible, mLastReflowStart, now);
    }

    SynthesizeMouseMove(false);

    mPresContext->NotifyMissingFonts();
  }

  if (mIsDestroying) {
    return;
  }

  if (mDirtyRoots.IsEmpty()) {
    // We only unsuppress painting if we're out of reflows.  It's pointless to
    // do so if reflows are still pending, since reflows are just going to
    // thrash the frames around some more.  By waiting we avoid an overeager
    // "jitter" effect.
    if (mShouldUnsuppressPainting) {
      mShouldUnsuppressPainting = false;
      UnsuppressAndInvalidate();
    }
  } else {
    // If any new reflow commands were enqueued during the reflow (or we didn't
    // reflow everything because we were interrupted), schedule another reflow
    // event to process them.
    //
    // Note that we want to do this after DidDoReflow(), since that method can
    // change whether there are dirty roots around by flushing, and there's no
    // point in posting a reflow event just to have the flush revoke it.
    EnsureLayoutFlush();
  }
}

DOMHighResTimeStamp PresShell::GetPerformanceNowUnclamped() {
  DOMHighResTimeStamp now = 0;

  if (nsPIDOMWindowInner* window = mDocument->GetInnerWindow()) {
    Performance* perf = window->GetPerformance();

    if (perf) {
      now = perf->NowUnclamped();
    }
  }

  return now;
}

bool PresShell::DoReflow(nsIFrame* target, bool aInterruptible,
                         OverflowChangedTracker* aOverflowTracker) {
  nsIURI* uri = mDocument->GetDocumentURI();
  AUTO_PROFILER_LABEL_DYNAMIC_NSCSTRING_RELEVANT_FOR_JS(
      "Reflow", LAYOUT_Reflow, uri ? uri->GetSpecOrDefault() : "N/A"_ns);

  PerfStats::AutoMetricRecording<PerfStats::Metric::Reflowing> autoRecording;

  gfxTextPerfMetrics* tp = mPresContext->GetTextPerfMetrics();
  TimeStamp timeStart;
  if (tp) {
    tp->Accumulate();
    tp->reflowCount++;
    timeStart = TimeStamp::Now();
  }

  // set up a cache that saves all nodes contained in each selection,
  // allowing a fast lookup in `nsTextFrame::IsFrameSelected()`.
  // This cache only lives throughout this reflow call.
  SelectionNodeCache cache(*this);

  // Schedule a paint, but don't actually mark this frame as changed for
  // retained DL building purposes. If any child frames get moved, then
  // they will schedule paint again. We could probaby skip this, and just
  // schedule a similar paint when a frame is deleted.
  target->SchedulePaint(nsIFrame::PAINT_DEFAULT, false);

  Maybe<uint64_t> innerWindowID;
  if (auto* window = mDocument->GetInnerWindow()) {
    innerWindowID = Some(window->WindowID());
  }
  AutoProfilerTracing tracingLayoutFlush(
      aInterruptible ? "Reflow (interruptible)" : "Reflow (sync)",
      geckoprofiler::category::LAYOUT, std::move(mReflowCause), innerWindowID);
  mReflowCause = nullptr;

  FlushPendingScrollAnchorSelections();

  const bool isRoot = target == mFrameConstructor->GetRootFrame();

  MOZ_ASSERT(isRoot || aOverflowTracker,
             "caller must provide overflow tracker when reflowing "
             "non-root frames");

  // CreateReferenceRenderingContext can return nullptr
  UniquePtr<gfxContext> rcx(CreateReferenceRenderingContext());

#ifdef DEBUG
  mCurrentReflowRoot = target;
#endif

  // If the target frame is the root of the frame hierarchy, then
  // use all the available space. If it's simply a `reflow root',
  // then use the target frame's size as the available space.
  WritingMode wm = target->GetWritingMode();
  LogicalSize size(wm);
  if (isRoot) {
    size = LogicalSize(wm, mPresContext->GetVisibleArea().Size());
  } else {
    size = target->GetLogicalSize();
  }

  OverflowAreas oldOverflow;  // initialized and used only when !isRoot
  if (!isRoot) {
    oldOverflow = target->GetOverflowAreas();
  }

  NS_ASSERTION(!target->GetNextInFlow() && !target->GetPrevInFlow(),
               "reflow roots should never split");

  // Don't pass size directly to the reflow input, since a
  // constrained height implies page/column breaking.
  LogicalSize reflowSize(wm, size.ISize(wm), NS_UNCONSTRAINEDSIZE);
  ReflowInput reflowInput(mPresContext, target, rcx.get(), reflowSize,
                          ReflowInput::InitFlag::CallerWillInit);

  if (isRoot) {
    reflowInput.Init(mPresContext);
  } else {
    // Initialize reflow input with current used border and padding,
    // in case this was set specially by the parent frame when the reflow root
    // was reflowed by its parent.
    reflowInput.Init(mPresContext, Nothing(),
                     Some(target->GetLogicalUsedBorder(wm)),
                     Some(target->GetLogicalUsedPadding(wm)));
  }

  // fix the computed height
  NS_ASSERTION(reflowInput.ComputedPhysicalMargin() == nsMargin(0, 0, 0, 0),
               "reflow input should not set margin for reflow roots");
  if (size.BSize(wm) != NS_UNCONSTRAINEDSIZE) {
    nscoord computedBSize =
        size.BSize(wm) -
        reflowInput.ComputedLogicalBorderPadding(wm).BStartEnd(wm);
    computedBSize = std::max(computedBSize, 0);
    reflowInput.SetComputedBSize(computedBSize);
  }
  NS_ASSERTION(
      reflowInput.ComputedISize() ==
          size.ISize(wm) -
              reflowInput.ComputedLogicalBorderPadding(wm).IStartEnd(wm),
      "reflow input computed incorrect inline size");

  mPresContext->ReflowStarted(aInterruptible);
  mIsReflowing = true;

  nsReflowStatus status;
  ReflowOutput desiredSize(reflowInput);
  target->Reflow(mPresContext, desiredSize, reflowInput, status);

  // If an incremental reflow is initiated at a frame other than the
  // root frame, then its desired size had better not change!  If it's
  // initiated at the root, then the size better not change unless its
  // height was unconstrained to start with.
  nsRect boundsRelativeToTarget =
      nsRect(0, 0, desiredSize.Width(), desiredSize.Height());
  const bool isBSizeLimitReflow =
      isRoot && size.BSize(wm) == NS_UNCONSTRAINEDSIZE;
  NS_ASSERTION(isBSizeLimitReflow || desiredSize.Size(wm) == size,
               "non-root frame's desired size changed during an "
               "incremental reflow");
  NS_ASSERTION(status.IsEmpty(), "reflow roots should never split");

  target->SetSize(boundsRelativeToTarget.Size());
  target->DidReflow(mPresContext, nullptr);
  if (target->IsInScrollAnchorChain()) {
    ScrollAnchorContainer* container = ScrollAnchorContainer::FindFor(target);
    PostPendingScrollAnchorAdjustment(container);
  }
  if (MOZ_UNLIKELY(isBSizeLimitReflow)) {
    mPresContext->SetVisibleArea(boundsRelativeToTarget);
  }

#ifdef DEBUG
  mCurrentReflowRoot = nullptr;
#endif

  if (!isRoot && oldOverflow != target->GetOverflowAreas()) {
    // The overflow area changed.  Propagate this change to ancestors.
    aOverflowTracker->AddFrame(target->GetParent(),
                               OverflowChangedTracker::CHILDREN_CHANGED);
  }

  NS_ASSERTION(
      mPresContext->HasPendingInterrupt() || mFramesToDirty.Count() == 0,
      "Why do we need to dirty anything if not interrupted?");

  mIsReflowing = false;
  bool interrupted = mPresContext->HasPendingInterrupt();
  if (interrupted) {
    // Make sure target gets reflowed again.
    for (const auto& key : mFramesToDirty) {
      // Mark frames dirty until target frame.
      for (nsIFrame* f = key; f && !f->IsSubtreeDirty(); f = f->GetParent()) {
        f->AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN);
        if (f->IsFlexItem()) {
          nsFlexContainerFrame::MarkCachedFlexMeasurementsDirty(f);
        }

        if (f == target) {
          break;
        }
      }
    }

    NS_ASSERTION(target->IsSubtreeDirty(), "Why is the target not dirty?");
    mDirtyRoots.Add(target);
    SetNeedLayoutFlush();

    // Clear mFramesToDirty after we've done the target->IsSubtreeDirty()
    // assertion so that if it fails it's easier to see what's going on.
#ifdef NOISY_INTERRUPTIBLE_REFLOW
    printf("mFramesToDirty.Count() == %u\n", mFramesToDirty.Count());
#endif /* NOISY_INTERRUPTIBLE_REFLOW */
    mFramesToDirty.Clear();

    // Any FlushPendingNotifications with interruptible reflows
    // should be suppressed now. We don't want to do extra reflow work
    // before our reflow event happens.
    mWasLastReflowInterrupted = true;
    EnsureLayoutFlush();
  }

  // dump text perf metrics for reflows with significant text processing
  if (tp) {
    if (tp->current.numChars > 100) {
      TimeDuration reflowTime = TimeStamp::Now() - timeStart;
      LogTextPerfStats(tp, this, tp->current, reflowTime.ToMilliseconds(),
                       eLog_reflow, nullptr);
    }
    tp->Accumulate();
  }

  return !interrupted;
}

// used with Telemetry metrics
#define NS_LONG_REFLOW_TIME_MS 5000

bool PresShell::ProcessReflowCommands(bool aInterruptible) {
  if (mDirtyRoots.IsEmpty() && !mShouldUnsuppressPainting &&
      !mPendingDidDoReflow) {
    // Nothing to do; bail out
    return true;
  }

  const bool wasProcessingReflowCommands = mProcessingReflowCommands;
  auto restoreProcessingReflowCommands = MakeScopeExit(
      [&] { mProcessingReflowCommands = wasProcessingReflowCommands; });
  mProcessingReflowCommands = true;

  auto timerStart = mozilla::TimeStamp::Now();
  bool interrupted = false;
  if (!mDirtyRoots.IsEmpty()) {
    // If reflow is interruptible, then make a note of our deadline.
    const PRIntervalTime deadline =
        aInterruptible
            ? PR_IntervalNow() + PR_MicrosecondsToInterval(gMaxRCProcessingTime)
            : (PRIntervalTime)0;

    // Scope for the reflow entry point
    nsAutoScriptBlocker scriptBlocker;
    WillDoReflow();
    AUTO_LAYOUT_PHASE_ENTRY_POINT(GetPresContext(), Reflow);

    OverflowChangedTracker overflowTracker;

    do {
      // Send an incremental reflow notification to the target frame.
      nsIFrame* target = mDirtyRoots.PopShallowestRoot();

      if (!target->IsSubtreeDirty()) {
        // It's not dirty anymore, which probably means the notification
        // was posted in the middle of a reflow (perhaps with a reflow
        // root in the middle).  Don't do anything.
        continue;
      }

      interrupted = !DoReflow(target, aInterruptible, &overflowTracker);

      // Keep going until we're out of reflow commands, or we've run
      // past our deadline, or we're interrupted.
    } while (!interrupted && !mDirtyRoots.IsEmpty() &&
             (!aInterruptible || PR_IntervalNow() < deadline));

    interrupted = !mDirtyRoots.IsEmpty();

    overflowTracker.Flush();

    if (!interrupted) {
      // We didn't get interrupted. Go ahead and perform scroll anchor
      // adjustments.
      FlushPendingScrollAnchorAdjustments();
    }
    mPendingDidDoReflow = true;
  }

  // Exiting the scriptblocker might have killed us. If we were processing
  // scroll commands, let the outermost call deal with it.
  if (!mIsDestroying && mPendingDidDoReflow && !wasProcessingReflowCommands) {
    DidDoReflow(aInterruptible);
  }

  {
    TimeDuration elapsed = TimeStamp::Now() - timerStart;
    int32_t intElapsed = int32_t(elapsed.ToMilliseconds());
    if (intElapsed > NS_LONG_REFLOW_TIME_MS) {
      glean::layout::long_reflow_interruptible
          .EnumGet(aInterruptible
                       ? glean::layout::LongReflowInterruptibleLabel::eTrue
                       : glean::layout::LongReflowInterruptibleLabel::eFalse)
          .Add();
    }
  }

  return !interrupted;
}

bool PresShell::DoFlushLayout(bool aInterruptible) {
  mFrameConstructor->RecalcQuotesAndCounters();
  return ProcessReflowCommands(aInterruptible);
}

void PresShell::WindowSizeMoveDone() {
  if (mPresContext) {
    EventStateManager::ClearGlobalActiveContent(nullptr);
    ClearMouseCapture();
  }
}

NS_IMETHODIMP
PresShell::Observe(nsISupports* aSubject, const char* aTopic,
                   const char16_t* aData) {
  if (mIsDestroying) {
    NS_WARNING("our observers should have been unregistered by now");
    return NS_OK;
  }

  if (!nsCRT::strcmp(aTopic, "memory-pressure")) {
    if (!AssumeAllFramesVisible() &&
        mPresContext->IsRootContentDocumentInProcess()) {
      DoUpdateApproximateFrameVisibility(/* aRemoveOnly = */ true);
    }
    return NS_OK;
  }

  if (!nsCRT::strcmp(aTopic, NS_WIDGET_WAKE_OBSERVER_TOPIC)) {
    mLastOSWake = TimeStamp::Now();
    return NS_OK;
  }

  // For parent process, user may expect the UI is interactable after a
  // tab (previously opened page or home page) has restored.
  if (!nsCRT::strcmp(aTopic, "sessionstore-one-or-no-tab-restored")) {
    MOZ_ASSERT(XRE_IsParentProcess());
    sProcessInteractable = true;

    nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
    if (os) {
      os->RemoveObserver(this, "sessionstore-one-or-no-tab-restored");
    }
    return NS_OK;
  }

  if (!nsCRT::strcmp(aTopic, "font-info-updated")) {
    // See how gfxPlatform::ForceGlobalReflow encodes this.
    bool needsReframe = aData && !!aData[0];
    mPresContext->ForceReflowForFontInfoUpdate(needsReframe);
    return NS_OK;
  }

  // The "look-and-feel-changed" notification for JS observers will be
  // dispatched HandleGlobalThemeChange once LookAndFeel caches are cleared.
  if (!nsCRT::strcmp(aTopic, "internal-look-and-feel-changed")) {
    // See how LookAndFeel::NotifyChangedAllWindows encodes this.
    auto kind = widget::ThemeChangeKind(aData[0]);
    mPresContext->ThemeChanged(kind);
    return NS_OK;
  }

  NS_WARNING(nsPrintfCString("unrecognized topic %s", aTopic).get());
  return NS_ERROR_FAILURE;
}

bool PresShell::AddRefreshObserver(nsARefreshObserver* aObserver,
                                   FlushType aFlushType,
                                   const char* aObserverDescription) {
  nsPresContext* presContext = GetPresContext();
  if (MOZ_UNLIKELY(!presContext)) {
    return false;
  }
  presContext->RefreshDriver()->AddRefreshObserver(aObserver, aFlushType,
                                                   aObserverDescription);
  return true;
}

bool PresShell::RemoveRefreshObserver(nsARefreshObserver* aObserver,
                                      FlushType aFlushType) {
  nsPresContext* presContext = GetPresContext();
  return presContext && presContext->RefreshDriver()->RemoveRefreshObserver(
                            aObserver, aFlushType);
}

bool PresShell::AddPostRefreshObserver(nsAPostRefreshObserver* aObserver) {
  nsPresContext* presContext = GetPresContext();
  if (!presContext) {
    return false;
  }
  presContext->RefreshDriver()->AddPostRefreshObserver(aObserver);
  return true;
}

bool PresShell::RemovePostRefreshObserver(nsAPostRefreshObserver* aObserver) {
  nsPresContext* presContext = GetPresContext();
  if (!presContext) {
    return false;
  }
  presContext->RefreshDriver()->RemovePostRefreshObserver(aObserver);
  return true;
}

void PresShell::ScheduleFlush() {
  if (MOZ_UNLIKELY(IsDestroying()) ||
      MOZ_UNLIKELY(mDocument->GetBFCacheEntry())) {
    return;
  }
  mPresContext->RefreshDriver()->ScheduleRenderingPhase(RenderingPhase::Layout);
}

//------------------------------------------------------
// End of protected and private methods on the PresShell
//------------------------------------------------------

//------------------------------------------------------------------
//-- Delayed event Classes Impls
//------------------------------------------------------------------

PresShell::DelayedInputEvent::DelayedInputEvent()
    : DelayedEvent(), mEvent(nullptr) {}

PresShell::DelayedInputEvent::~DelayedInputEvent() { delete mEvent; }

void PresShell::DelayedInputEvent::Dispatch() {
  if (!mEvent || !mEvent->mWidget) {
    return;
  }
  nsCOMPtr<nsIWidget> widget = mEvent->mWidget;
  widget->DispatchEvent(mEvent);
}

PresShell::DelayedMouseEvent::DelayedMouseEvent(WidgetMouseEvent* aEvent) {
  MOZ_DIAGNOSTIC_ASSERT(aEvent->IsTrusted());
  WidgetMouseEvent* mouseEvent =
      new WidgetMouseEvent(true, aEvent->mMessage, aEvent->mWidget,
                           aEvent->mReason, aEvent->mContextMenuTrigger);
  mouseEvent->AssignMouseEventData(*aEvent, false);
  mEvent = mouseEvent;
}

PresShell::DelayedPointerEvent::DelayedPointerEvent(
    WidgetPointerEvent* aEvent) {
  MOZ_DIAGNOSTIC_ASSERT(aEvent->IsTrusted());
  MOZ_ASSERT(aEvent->mMessage == eContextMenu);
  WidgetPointerEvent* pointerEvent = new WidgetPointerEvent(
      true, aEvent->mMessage, aEvent->mWidget, aEvent->mContextMenuTrigger);
  pointerEvent->AssignPointerEventData(*aEvent, false);
  mEvent = pointerEvent;
}

PresShell::DelayedKeyEvent::DelayedKeyEvent(WidgetKeyboardEvent* aEvent) {
  MOZ_DIAGNOSTIC_ASSERT(aEvent->IsTrusted());
  WidgetKeyboardEvent* keyEvent =
      new WidgetKeyboardEvent(true, aEvent->mMessage, aEvent->mWidget);
  keyEvent->AssignKeyEventData(*aEvent, false);
  keyEvent->mFlags.mIsSynthesizedForTests =
      aEvent->mFlags.mIsSynthesizedForTests;
  keyEvent->mFlags.mIsSuppressedOrDelayed = true;
  mEvent = keyEvent;
}

bool PresShell::DelayedKeyEvent::IsKeyPressEvent() {
  return mEvent->mMessage == eKeyPress;
}

#ifdef DEBUG
// Layout debugging hooks
void PresShell::ListComputedStyles(FILE* out, int32_t aIndent) {
  nsIFrame* rootFrame = GetRootFrame();
  if (rootFrame) {
    rootFrame->Style()->List(out, aIndent);
  }

  // The root element's frame's ComputedStyle is the root of a separate tree.
  Element* rootElement = mDocument->GetRootElement();
  if (rootElement) {
    nsIFrame* rootElementFrame = rootElement->GetPrimaryFrame();
    if (rootElementFrame) {
      rootElementFrame->Style()->List(out, aIndent);
    }
  }
}
#endif

#if defined(DEBUG) || defined(MOZ_LAYOUT_DEBUGGER)
void PresShell::ListStyleSheets(FILE* out, int32_t aIndent) {
  auto ListStyleSheetsAtOrigin = [this, out, aIndent](StyleOrigin origin) {
    int32_t sheetCount = StyleSet()->SheetCount(origin);
    for (int32_t i = 0; i < sheetCount; ++i) {
      StyleSet()->SheetAt(origin, i)->List(out, aIndent);
    }
  };

  ListStyleSheetsAtOrigin(StyleOrigin::UserAgent);
  ListStyleSheetsAtOrigin(StyleOrigin::User);
  ListStyleSheetsAtOrigin(StyleOrigin::Author);
}
#endif

//=============================================================
//=============================================================
//-- Debug Reflow Counts
//=============================================================
//=============================================================
#ifdef MOZ_REFLOW_PERF
//-------------------------------------------------------------
void PresShell::DumpReflows() {
  if (mReflowCountMgr) {
    nsAutoCString uriStr;
    if (mDocument) {
      nsIURI* uri = mDocument->GetDocumentURI();
      if (uri) {
        uri->GetPathQueryRef(uriStr);
      }
    }
    mReflowCountMgr->DisplayTotals(uriStr.get());
    mReflowCountMgr->DisplayHTMLTotals(uriStr.get());
    mReflowCountMgr->DisplayDiffsInTotals();
  }
}

//-------------------------------------------------------------
void PresShell::CountReflows(const char* aName, nsIFrame* aFrame) {
  if (mReflowCountMgr) {
    mReflowCountMgr->Add(aName, aFrame);
  }
}

//-------------------------------------------------------------
void PresShell::PaintCount(const char* aName, gfxContext* aRenderingContext,
                           nsPresContext* aPresContext, nsIFrame* aFrame,
                           const nsPoint& aOffset, uint32_t aColor) {
  if (mReflowCountMgr) {
    mReflowCountMgr->PaintCount(aName, aRenderingContext, aPresContext, aFrame,
                                aOffset, aColor);
  }
}

//-------------------------------------------------------------
void PresShell::SetPaintFrameCount(bool aPaintFrameCounts) {
  if (mReflowCountMgr) {
    mReflowCountMgr->SetPaintFrameCounts(aPaintFrameCounts);
  }
}

bool PresShell::IsPaintingFrameCounts() {
  if (mReflowCountMgr) return mReflowCountMgr->IsPaintingFrameCounts();
  return false;
}

//------------------------------------------------------------------
//-- Reflow Counter Classes Impls
//------------------------------------------------------------------

//------------------------------------------------------------------
ReflowCounter::ReflowCounter(ReflowCountMgr* aMgr) : mMgr(aMgr) {
  ClearTotals();
  SetTotalsCache();
}

//------------------------------------------------------------------
void ReflowCounter::ClearTotals() { mTotal = 0; }

//------------------------------------------------------------------
void ReflowCounter::SetTotalsCache() { mCacheTotal = mTotal; }

//------------------------------------------------------------------
void ReflowCounter::CalcDiffInTotals() { mCacheTotal = mTotal - mCacheTotal; }

//------------------------------------------------------------------
void ReflowCounter::DisplayTotals(const char* aStr) {
  DisplayTotals(mTotal, aStr ? aStr : "Totals");
}

//------------------------------------------------------------------
void ReflowCounter::DisplayDiffTotals(const char* aStr) {
  DisplayTotals(mCacheTotal, aStr ? aStr : "Diff Totals");
}

//------------------------------------------------------------------
void ReflowCounter::DisplayHTMLTotals(const char* aStr) {
  DisplayHTMLTotals(mTotal, aStr ? aStr : "Totals");
}

//------------------------------------------------------------------
void ReflowCounter::DisplayTotals(uint32_t aTotal, const char* aTitle) {
  // figure total
  if (aTotal == 0) {
    return;
  }
  ReflowCounter* gTots = (ReflowCounter*)mMgr->LookUp(kGrandTotalsStr);

  printf("%25s\t", aTitle);
  printf("%d\t", aTotal);
  if (gTots != this && aTotal > 0) {
    gTots->Add(aTotal);
  }
}

//------------------------------------------------------------------
void ReflowCounter::DisplayHTMLTotals(uint32_t aTotal, const char* aTitle) {
  if (aTotal == 0) {
    return;
  }

  ReflowCounter* gTots = (ReflowCounter*)mMgr->LookUp(kGrandTotalsStr);
  FILE* fd = mMgr->GetOutFile();
  if (!fd) {
    return;
  }

  fprintf(fd, "<tr><td><center>%s</center></td>", aTitle);
  fprintf(fd, "<td><center>%d</center></td></tr>\n", aTotal);

  if (gTots != this && aTotal > 0) {
    gTots->Add(aTotal);
  }
}

//------------------------------------------------------------------
//-- ReflowCountMgr
//------------------------------------------------------------------

#  define KEY_BUF_SIZE_FOR_PTR \
    24  // adequate char[] buffer to sprintf a pointer

ReflowCountMgr::ReflowCountMgr() : mCounts(10), mIndiFrameCounts(10) {
  mCycledOnce = false;
  mDumpFrameCounts = false;
  mDumpFrameByFrameCounts = false;
  mPaintFrameByFrameCounts = false;
}

//------------------------------------------------------------------
ReflowCountMgr::~ReflowCountMgr() = default;

//------------------------------------------------------------------
ReflowCounter* ReflowCountMgr::LookUp(const char* aName) {
  return mCounts.Get(aName);
}

//------------------------------------------------------------------
void ReflowCountMgr::Add(const char* aName, nsIFrame* aFrame) {
  NS_ASSERTION(aName != nullptr, "Name shouldn't be null!");

  if (mDumpFrameCounts) {
    auto* const counter = mCounts.GetOrInsertNew(aName, this);
    counter->Add();
  }

  if ((mDumpFrameByFrameCounts || mPaintFrameByFrameCounts) &&
      aFrame != nullptr) {
    char key[KEY_BUF_SIZE_FOR_PTR];
    SprintfLiteral(key, "%p", (void*)aFrame);
    auto* const counter =
        mIndiFrameCounts
            .LookupOrInsertWith(key,
                                [&aName, &aFrame, this]() {
                                  auto counter =
                                      MakeUnique<IndiReflowCounter>(this);
                                  counter->mFrame = aFrame;
                                  counter->mName.AssignASCII(aName);
                                  return counter;
                                })
            .get();
    // this eliminates extra counts from super classes
    if (counter && counter->mName.EqualsASCII(aName)) {
      counter->mCount++;
      counter->mCounter.Add(1);
    }
  }
}

//------------------------------------------------------------------
void ReflowCountMgr::PaintCount(const char* aName,
                                gfxContext* aRenderingContext,
                                nsPresContext* aPresContext, nsIFrame* aFrame,
                                const nsPoint& aOffset, uint32_t aColor) {
  if (mPaintFrameByFrameCounts && aFrame != nullptr) {
    char key[KEY_BUF_SIZE_FOR_PTR];
    SprintfLiteral(key, "%p", (void*)aFrame);
    IndiReflowCounter* counter = mIndiFrameCounts.Get(key);
    if (counter != nullptr && counter->mName.EqualsASCII(aName)) {
      DrawTarget* drawTarget = aRenderingContext->GetDrawTarget();
      int32_t appUnitsPerDevPixel = aPresContext->AppUnitsPerDevPixel();

      aRenderingContext->Save();
      gfxPoint devPixelOffset =
          nsLayoutUtils::PointToGfxPoint(aOffset, appUnitsPerDevPixel);
      aRenderingContext->SetMatrixDouble(
          aRenderingContext->CurrentMatrixDouble().PreTranslate(
              devPixelOffset));

      // We don't care about the document language or user fonts here;
      // just get a default Latin font.
      nsFont font(StyleGenericFontFamily::Serif, Length::FromPixels(11));
      nsFontMetrics::Params params;
      params.language = nsGkAtoms::x_western;
      params.textPerf = aPresContext->GetTextPerfMetrics();
      params.featureValueLookup = aPresContext->GetFontFeatureValuesLookup();
      RefPtr<nsFontMetrics> fm = aPresContext->GetMetricsFor(font, params);

      char buf[16];
      int len = SprintfLiteral(buf, "%d", counter->mCount);
      nscoord x = 0, y = fm->MaxAscent();
      nscoord width, height = fm->MaxHeight();
      fm->SetTextRunRTL(false);
      width = fm->GetWidth(buf, len, drawTarget);

      sRGBColor color;
      sRGBColor color2;
      if (aColor != 0) {
        color = sRGBColor::FromABGR(aColor);
        color2 = sRGBColor(0.f, 0.f, 0.f);
      } else {
        gfx::Float rc = 0.f, gc = 0.f, bc = 0.f;
        if (counter->mCount < 5) {
          rc = 1.f;
          gc = 1.f;
        } else if (counter->mCount < 11) {
          gc = 1.f;
        } else {
          rc = 1.f;
        }
        color = sRGBColor(rc, gc, bc);
        color2 = sRGBColor(rc / 2, gc / 2, bc / 2);
      }

      nsRect rect(0, 0, width + 15, height + 15);
      Rect devPxRect =
          NSRectToSnappedRect(rect, appUnitsPerDevPixel, *drawTarget);
      ColorPattern black(ToDeviceColor(sRGBColor::OpaqueBlack()));
      drawTarget->FillRect(devPxRect, black);

      aRenderingContext->SetColor(color2);
      fm->DrawString(buf, len, x + 15, y + 15, aRenderingContext);
      aRenderingContext->SetColor(color);
      fm->DrawString(buf, len, x, y, aRenderingContext);

      aRenderingContext->Restore();
    }
  }
}

//------------------------------------------------------------------
void ReflowCountMgr::DoGrandTotals() {
  mCounts.WithEntryHandle(kGrandTotalsStr, [this](auto&& entry) {
    if (!entry) {
      entry.Insert(MakeUnique<ReflowCounter>(this));
    } else {
      entry.Data()->ClearTotals();
    }
  });

  printf("\t\t\t\tTotal\n");
  for (uint32_t i = 0; i < 78; i++) {
    printf("-");
  }
  printf("\n");
  for (const auto& entry : mCounts) {
    entry.GetData()->DisplayTotals(entry.GetKey());
  }
}

static void RecurseIndiTotals(
    nsPresContext* aPresContext,
    nsClassHashtable<nsCharPtrHashKey, IndiReflowCounter>& aHT,
    nsIFrame* aParentFrame, int32_t aLevel) {
  if (aParentFrame == nullptr) {
    return;
  }

  char key[KEY_BUF_SIZE_FOR_PTR];
  SprintfLiteral(key, "%p", (void*)aParentFrame);
  IndiReflowCounter* counter = aHT.Get(key);
  if (counter) {
    counter->mHasBeenOutput = true;
    char* name = ToNewCString(counter->mName);
    for (int32_t i = 0; i < aLevel; i++) printf(" ");
    printf("%s - %p   [%d][", name, (void*)aParentFrame, counter->mCount);
    printf("%d", counter->mCounter.GetTotal());
    printf("]\n");
    free(name);
  }

  for (nsIFrame* child : aParentFrame->PrincipalChildList()) {
    RecurseIndiTotals(aPresContext, aHT, child, aLevel + 1);
  }
}

//------------------------------------------------------------------
void ReflowCountMgr::DoIndiTotalsTree() {
  printf("\n------------------------------------------------\n");
  printf("-- Individual Frame Counts\n");
  printf("------------------------------------------------\n");

  if (mPresShell) {
    nsIFrame* rootFrame = mPresShell->GetRootFrame();
    RecurseIndiTotals(mPresContext, mIndiFrameCounts, rootFrame, 0);
    printf("------------------------------------------------\n");
    printf("-- Individual Counts of Frames not in Root Tree\n");
    printf("------------------------------------------------\n");
    for (const auto& counter : mIndiFrameCounts.Values()) {
      if (!counter->mHasBeenOutput) {
        char* name = ToNewCString(counter->mName);
        printf("%s - %p   [%d][", name, (void*)counter->mFrame,
               counter->mCount);
        printf("%d", counter->mCounter.GetTotal());
        printf("]\n");
        free(name);
      }
    }
  }
}

//------------------------------------------------------------------
void ReflowCountMgr::DoGrandHTMLTotals() {
  mCounts.WithEntryHandle(kGrandTotalsStr, [this](auto&& entry) {
    if (!entry) {
      entry.Insert(MakeUnique<ReflowCounter>(this));
    } else {
      entry.Data()->ClearTotals();
    }
  });

  static const char* titles[] = {"Class", "Reflows"};
  fprintf(mFD, "<tr>");
  for (const char* title : titles) {
    fprintf(mFD, "<td><center><b>%s<b></center></td>", title);
  }
  fprintf(mFD, "</tr>\n");

  for (const auto& entry : mCounts) {
    entry.GetData()->DisplayHTMLTotals(entry.GetKey());
  }
}

//------------------------------------
void ReflowCountMgr::DisplayTotals(const char* aStr) {
  if (mDumpFrameCounts) {
    DoGrandTotals();
  }
  if (mDumpFrameByFrameCounts) {
    DoIndiTotalsTree();
  }
}
//------------------------------------
void ReflowCountMgr::DisplayHTMLTotals(const char* aStr) {
#  ifdef WIN32x  // XXX NOT XP!
  char name[1024];

  char* sptr = strrchr(aStr, '/');
  if (sptr) {
    sptr++;
    strcpy(name, sptr);
    char* eptr = strrchr(name, '.');
    if (eptr) {
      *eptr = 0;
    }
    strcat(name, "_stats.html");
  }
  mFD = fopen(name, "w");
  if (mFD) {
    fprintf(mFD, "<html><head><title>Reflow Stats</title></head><body>\n");
    const char* title = aStr ? aStr : "No name";
    fprintf(mFD,
            "<center><b>%s</b><br><table border=1 "
            "style=\"background-color:#e0e0e0\">",
            title);
    DoGrandHTMLTotals();
    fprintf(mFD, "</center></table>\n");
    fprintf(mFD, "</body></html>\n");
    fclose(mFD);
    mFD = nullptr;
  }
#  endif  // not XP!
}

//------------------------------------------------------------------
void ReflowCountMgr::ClearTotals() {
  for (const auto& data : mCounts.Values()) {
    data->ClearTotals();
  }
}

//------------------------------------------------------------------
void ReflowCountMgr::ClearGrandTotals() {
  mCounts.WithEntryHandle(kGrandTotalsStr, [&](auto&& entry) {
    if (!entry) {
      entry.Insert(MakeUnique<ReflowCounter>(this));
    } else {
      entry.Data()->ClearTotals();
      entry.Data()->SetTotalsCache();
    }
  });
}

//------------------------------------------------------------------
void ReflowCountMgr::DisplayDiffsInTotals() {
  if (mCycledOnce) {
    printf("Differences\n");
    for (int32_t i = 0; i < 78; i++) {
      printf("-");
    }
    printf("\n");
    ClearGrandTotals();
  }

  for (const auto& entry : mCounts) {
    if (mCycledOnce) {
      entry.GetData()->CalcDiffInTotals();
      entry.GetData()->DisplayDiffTotals(entry.GetKey());
    }
    entry.GetData()->SetTotalsCache();
  }

  mCycledOnce = true;
}

#endif  // MOZ_REFLOW_PERF

nsIFrame* PresShell::GetAbsoluteContainingBlock(nsIFrame* aFrame) {
  return FrameConstructor()->GetAbsoluteContainingBlock(
      aFrame, nsCSSFrameConstructor::ABS_POS);
}

nsIFrame* PresShell::GetAnchorPosAnchor(
    const ScopedNameRef& aName, const nsIFrame* aPositionedFrame) const {
  MOZ_ASSERT(aName.mName);
  MOZ_ASSERT(!aName.mName->IsEmpty());
  MOZ_ASSERT(mLazyAnchorPosAnchorChanges.IsEmpty());
  if (aName.mName == nsGkAtoms::AnchorPosImplicitAnchor) {
    return AnchorPositioningUtils::GetAnchorPosImplicitAnchor(aPositionedFrame)
        .mAnchorFrame;
  }
  if (const auto& entry = mAnchorPosAnchors.Lookup(aName.mName)) {
    return AnchorPositioningUtils::FindFirstAcceptableAnchor(
        aName, aPositionedFrame, entry.Data());
  }
  return nullptr;
}

void PresShell::CollectAnchorNames(const nsIFrame* aPositionedFrame,
                                   nsTArray<nsString>& aResult) {
  const auto* pos = aPositionedFrame->StylePosition();
  StyleCascadeLevel anchorTreeScope = pos->mPositionAnchor.scope;

  for (auto iter = mAnchorPosAnchors.Iter(); !iter.Done(); iter.Next()) {
    const auto& name = iter.Key();
    ScopedNameRef scopedName{name, anchorTreeScope};
    if (AnchorPositioningUtils::FindFirstAcceptableAnchor(
            scopedName, aPositionedFrame, iter.Data())) {
      aResult.AppendElement(nsDependentAtomString(name));
    }
  }
}

void PresShell::AddAnchorPosAnchorImpl(const nsAtom* aName, nsIFrame* aFrame,
                                       bool aForMerge) {
  MOZ_ASSERT(aName);

  auto& entry = mAnchorPosAnchors.LookupOrInsertWith(
      aName, []() { return nsTArray<nsIFrame*>(); });

  if (entry.IsEmpty()) {
    entry.AppendElement(aFrame);
    return;
  }

  struct FrameTreeComparator {
    nsIFrame* mFrame;

    int32_t operator()(nsIFrame* aOther) const {
      return nsLayoutUtils::CompareTreePosition(mFrame, aOther, nullptr);
    }
  };

  FrameTreeComparator cmp{aFrame};

  size_t matchOrInsertionIdx = entry.Length();
  // If the same element is already in the array,
  // someone forgot to call RemoveAnchorPosAnchor.
  if (BinarySearchIf(entry, 0, entry.Length(), cmp, &matchOrInsertionIdx)) {
    if (entry.ElementAt(matchOrInsertionIdx) == aFrame) {
      // nsLayoutUtils::CompareTreePosition() returns 0 when the frames are
      // in different documents or child lists. This could indicate that
      // the tree is being restructured and we can defer anchor insertion
      // to a MergeAnchorPosAnchors call after the restructuring is complete.
      MOZ_ASSERT_UNREACHABLE("Attempt to insert a frame twice was made");
      return;
    }
    MOZ_ASSERT(!entry.Contains(aFrame));

    if (!aForMerge) {
      // nsLayoutUtils::CompareTreePosition() returns 0 when the frames are
      // in different documents or child lists. This could indicate that
      // the tree is being restructured and we can defer anchor insertion
      // to a MergeAnchorPosAnchors call after the restructuring is complete.
      mLazyAnchorPosAnchorChanges.AppendElement(
          AnchorPosAnchorChange{RefPtr<const nsAtom>(aName), aFrame});
      return;
    }
  }

  MOZ_ASSERT(!entry.Contains(aFrame));
  entry.InsertElementAt(matchOrInsertionIdx, aFrame);
}

void PresShell::AddAnchorPosAnchor(const nsAtom* aName, nsIFrame* aFrame) {
  AddAnchorPosAnchorImpl(aName, aFrame, /* aForMerge = */ false);
}

void PresShell::RemoveAnchorPosAnchor(const nsAtom* aName, nsIFrame* aFrame) {
  MOZ_ASSERT(aName);

  if (!mLazyAnchorPosAnchorChanges.IsEmpty()) {
    mLazyAnchorPosAnchorChanges.RemoveElementsBy(
        [&](const AnchorPosAnchorChange& change) {
          return change.mFrame == aFrame;
        });
  }

  auto entry = mAnchorPosAnchors.Lookup(aName);
  if (!entry) {
    return;  // Nothing to remove.
  }

#ifdef ACCESSIBILITY
  if (nsAccessibilityService* accService = GetAccService()) {
    accService->NotifyAnchorRemoved(this, aFrame);
  }
#endif

  auto& anchorArray = entry.Data();

  // XXX: Once the implementation is more complete,
  // we should probably assert here that anchorArray
  // is not empty and aFrame is in it.

  anchorArray.RemoveElement(aFrame);
  if (anchorArray.IsEmpty()) {
    entry.Remove();
  }
}

void PresShell::MergeAnchorPosAnchorChanges() {
  for (const auto& [name, frame] : mLazyAnchorPosAnchorChanges) {
    AddAnchorPosAnchorImpl(name, frame, /* aForMerge = */ true);
  }

  mLazyAnchorPosAnchorChanges.Clear();
}

static bool NeedReflowForAnchorPos(
    const nsIFrame* aAnchor, const nsIFrame* aPositioned,
    const Maybe<AnchorPosResolutionData>& aData) {
  const bool validityChanged = (aAnchor && !aData) || (!aAnchor && aData);
  if (validityChanged) {
    return true;
  }
  if (!aData) {
    // Was invalid, still invalid. No more consideration needed.
    return false;
  }
  // Was valid, still valid Did the referenced value change?
  if (!aAnchor) {
    MOZ_ASSERT_UNREACHABLE("Anchor is supposed to be valid");
    return false;
  }
  const auto& anchorReference = aData.ref();
  const auto border = aPositioned->GetParent()->GetUsedBorder();
  const nsPoint borderTopLeft{border.left, border.top};
  const auto anchorRect = AnchorPositioningUtils::ReassembleAnchorRect(
                              aAnchor, aPositioned->GetParent()) -
                          borderTopLeft;
  if (anchorReference.mSize != anchorRect.Size()) {
    // Size changed, needs reflow.
    return true;
  }
  if (!anchorReference.mOffsetData) {
    // Didn't resolve offsets, no need to reflow based on it.
    return false;
  }

  const auto nearestScrollFrameInfo =
      AnchorPositioningUtils::GetNearestScrollFrame(aAnchor);
  if (anchorReference.mOffsetData->mDistanceToNearestScrollContainer !=
      nearestScrollFrameInfo.mDistance) {
    // Scroll container relationship changed, need to reflow.
    return true;
  }

  const auto newOrigin = anchorRect.TopLeft();
  const auto& prevOrigin = anchorReference.mOffsetData.ref().mOrigin;
  // Did the offset change?
  return newOrigin != prevOrigin;
}

struct DefaultAnchorInfo {
  const nsAtom* mName;
  StyleCascadeLevel mTreeScope;
  const nsIFrame* mAnchor;
  DistanceToNearestScrollContainer mDistanceToNearestScrollContainer;
};

PresShell::AnchorPosUpdateResult PresShell::UpdateAnchorPosLayout() {
  if (mAnchorPosPositioned.IsEmpty()) {
    return AnchorPosUpdateResult::NotApplicable;
  }

  // Flush the layout, so that positioned frames' anchor references are valid.
  DoFlushLayout(/* aInterruptible = */ false);

  auto result = AnchorPosUpdateResult::Flushed;
  AUTO_PROFILER_MARKER_UNTYPED("UpdateAnchorPosLayout", LAYOUT, {});
  for (auto* positioned : mAnchorPosPositioned) {
    MOZ_ASSERT(positioned->IsAbsolutelyPositioned(),
               "Anchor positioned frame is not absolutely positioned?");
    const auto* anchorPosReferenceData =
        positioned->GetProperty(nsIFrame::AnchorPosReferences());
    // Note that it's possible (Though unlikely) to register as anchor
    // positioned but not actually make any anchor resolution - e.g.
    // `position-anchor` is set, but no other anchor positioning property is
    // used.
    if (!anchorPosReferenceData || anchorPosReferenceData->IsEmpty()) {
      continue;
    }
    if (positioned->HasAnyStateBits(NS_FRAME_IS_DIRTY)) {
      // Already marked for reflow.
      continue;
    }
    const auto defaultAnchorInfo = [&]() -> Maybe<DefaultAnchorInfo> {
      auto usedAnchorName = AnchorPositioningUtils::GetUsedAnchorName(
          positioned, ScopedNameRef{nullptr, StyleCascadeLevel::Default()});
      if (!usedAnchorName) {
        return Nothing{};
      }
      const ScopedNameRef& usedName = *usedAnchorName;
      const auto* anchor = GetAnchorPosAnchor(usedName, positioned);
      if (!anchor) {
        return Nothing{};
      }
      const auto nearestScrollFrame =
          AnchorPositioningUtils::GetNearestScrollFrame(anchor);
      return Some(DefaultAnchorInfo{usedName.mName, usedName.mTreeScope, anchor,
                                    nearestScrollFrame.mDistance});
    }();
    bool shouldReflow = false;
    if (defaultAnchorInfo &&
        defaultAnchorInfo->mDistanceToNearestScrollContainer !=
            anchorPosReferenceData->mDistanceToDefaultScrollContainer) {
      // Default anchor's nearest scroller changed, reflow.
      shouldReflow = true;
    } else {
      const auto GetAnchor =
          [&](const ScopedNameRef& aNameRef,
              const nsIFrame* aPositioned) -> const nsIFrame* {
        if (!defaultAnchorInfo) {
          return GetAnchorPosAnchor(aNameRef, aPositioned);
        }
        const auto* defaultAnchorName = defaultAnchorInfo->mName;
        if (aNameRef.mName != defaultAnchorName) {
          return GetAnchorPosAnchor(aNameRef, aPositioned);
        }
        return defaultAnchorInfo->mAnchor;
      };
      for (const auto& kv : *anchorPosReferenceData) {
        const auto& data = kv.GetData();
        const auto& anchorKey = kv.GetKey();
        const auto* anchor = GetAnchor(anchorKey, positioned);
        if (NeedReflowForAnchorPos(anchor, positioned, data)) {
          shouldReflow = true;
          break;
        }
      }
    }
    if (shouldReflow) {
      result = AnchorPosUpdateResult::NeedReflow;
      MarkPositionedFrameForReflow(positioned);
    }
  }
  return result;
}

void PresShell::ActivenessMaybeChanged() {
  if (!mDocument) {
    return;
  }
  SetIsActive(ComputeActiveness());
}

// A PresShell being active means that it is visible (or close to be visible, if
// the front-end is warming it). That means that when it is active we always
// tick its refresh driver at full speed if needed.
//
// Image documents behave specially in the sense that they are always "active"
// and never "in the active tab". However these documents tick manually so
// there's not much to worry about there.
bool PresShell::ComputeActiveness() const {
  MOZ_LOG(gLog, LogLevel::Debug,
          ("PresShell::ComputeActiveness(%s, %d)\n",
           mDocument->GetDocumentURI()
               ? mDocument->GetDocumentURI()->GetSpecOrDefault().get()
               : "(no uri)",
           mIsActive));

  Document* doc = mDocument;

  if (doc->IsBeingUsedAsImage()) {
    // Documents used as an image can remain active. They do not tick their
    // refresh driver if not painted, and they can't run script or such so they
    // can't really observe much else.
    //
    // Image docs can be displayed in multiple docs at the same time so the "in
    // active tab" bool doesn't make much sense for them.
    return true;
  }

  if (Document* displayDoc = doc->GetDisplayDocument()) {
    // Ok, we're an external resource document -- we need to use our display
    // document's docshell to determine "IsActive" status, since we lack
    // a browsing context of our own.
    MOZ_ASSERT(!doc->GetBrowsingContext(),
               "external resource doc shouldn't have its own BC");
    doc = displayDoc;
  }

  BrowsingContext* bc = doc->GetBrowsingContext();
  const bool inActiveTab = bc && bc->IsActive();

  MOZ_LOG(gLog, LogLevel::Debug,
          (" > BrowsingContext %p  active: %d", bc, inActiveTab));

  if (StaticPrefs::layout_testing_top_level_always_active() && bc &&
      bc->IsTop()) {
    MOZ_LOG(gLog, LogLevel::Debug, (" > Activeness overridden by pref"));
    return true;
  }

  if (bc && bc->GetControlsDocumentPiP()) {
    MOZ_ASSERT(inActiveTab,
               "BrowsingContext should be active due to PiP window");
    MOZ_LOG(gLog, LogLevel::Debug,
            (" > BrowsingContext controls a PiP window"));
    return true;
  }

  Document* root = nsContentUtils::GetInProcessSubtreeRootDocument(doc);
  if (auto* browserChild = BrowserChild::GetFrom(root->GetDocShell())) {
    // We might want to activate a tab even though the browsing-context is not
    // active if the BrowserChild is considered visible. This serves two
    // purposes:
    //
    //  * For top-level tabs, we use this for tab warming. The browsing-context
    //    might still be inactive, but we want to activate the pres shell and
    //    the refresh driver.
    //
    //  * For oop iframes, we do want to throttle them if they're not visible.
    //
    // TODO(emilio): Consider unifying the in-process vs. fission iframe
    // throttling code (in-process throttling for non-visible iframes lives
    // right now in Document::ShouldThrottleFrameRequests(), but that only
    // throttles rAF).
    if (!browserChild->IsVisible()) {
      MOZ_LOG(gLog, LogLevel::Debug,
              (" > BrowserChild %p is not visible", browserChild));
      return false;
    }

    // If the browser is visible but just due to be preserving layers
    // artificially, we do want to fall back to the browsing context activeness
    // instead. Otherwise we do want to be active for the use cases above.
    if (!browserChild->IsPreservingLayers()) {
      MOZ_LOG(gLog, LogLevel::Debug,
              (" > BrowserChild %p is visible and not preserving layers",
               browserChild));
      return true;
    }
    MOZ_LOG(
        gLog, LogLevel::Debug,
        (" > BrowserChild %p is visible and preserving layers", browserChild));
  }
  return inActiveTab;
}

void PresShell::SetIsActive(bool aIsActive) {
  MOZ_ASSERT(mDocument, "should only be called with a document");

  const bool activityChanged = mIsActive != aIsActive;

  mIsActive = aIsActive;

  nsPresContext* presContext = GetPresContext();
  if (presContext &&
      presContext->RefreshDriver()->GetPresContext() == presContext) {
    presContext->RefreshDriver()->SetActivity(aIsActive);
  }

  if (activityChanged) {
    // Propagate state-change to my resource documents' PresShells and other
    // subdocuments.
    //
    // Note that it is fine to not propagate to fission iframes. Those will
    // become active / inactive as needed as a result of they getting painted /
    // not painted eventually.
    auto recurse = [aIsActive](Document& aSubDoc) {
      if (PresShell* presShell = aSubDoc.GetPresShell()) {
        presShell->SetIsActive(aIsActive);
      }
      return CallState::Continue;
    };
    mDocument->EnumerateExternalResources(recurse);
    mDocument->EnumerateSubDocuments(recurse);
  }

  UpdateImageLockingState();

  if (activityChanged) {
#if defined(MOZ_WIDGET_ANDROID)
    if (!aIsActive && presContext &&
        presContext->IsRootContentDocumentCrossProcess()) {
      // Reset the dynamic toolbar offset state.
      presContext->UpdateDynamicToolbarOffset(0);
    }
#endif
  }

  if (aIsActive) {
#ifdef ACCESSIBILITY
    if (nsAccessibilityService* accService = GetAccService()) {
      accService->PresShellActivated(this);
    }
#endif
    if (nsIFrame* rootFrame = GetRootFrame()) {
      rootFrame->SchedulePaint();
    }
  }
}

MobileViewportManager* PresShell::GetMobileViewportManager() const {
  return mMobileViewportManager;
}

Maybe<MobileViewportManager::ManagerType> UseMobileViewportManager(
    PresShell* aPresShell, Document* aDocument) {
  // If we're not using APZ, we won't be able to zoom, so there is no
  // point in having an MVM.
  if (nsIWidget* widget = aPresShell->GetNearestWidget()) {
    if (!widget->AsyncPanZoomEnabled()) {
      return Nothing();
    }
  }
  if (nsLayoutUtils::ShouldHandleMetaViewport(aDocument)) {
    return Some(MobileViewportManager::ManagerType::VisualAndMetaViewport);
  }
  if (nsLayoutUtils::AllowZoomingForDocument(aDocument)) {
    return Some(MobileViewportManager::ManagerType::VisualViewportOnly);
  }
  return Nothing();
}

void PresShell::MaybeRecreateMobileViewportManager(bool aAfterInitialization) {
  // Determine if we require a MobileViewportManager, and what kind if so. We
  // need one any time we allow resolution zooming for a document, and any time
  // we want to obey <meta name="viewport"> tags for it.
  Maybe<MobileViewportManager::ManagerType> mvmType =
      UseMobileViewportManager(this, mDocument);

  if (mvmType.isNothing() && !mMobileViewportManager) {
    // We don't need one and don't have it. So we're done.
    return;
  }
  if (mvmType && mMobileViewportManager &&
      *mvmType == mMobileViewportManager->GetManagerType()) {
    // We need one and we have one of the correct type, so we're done.
    return;
  }

  if (!mPresContext->IsRootContentDocumentCrossProcess()) {
    MOZ_ASSERT(!mMobileViewportManager, "We never create MVMs for subframes");
    return;
  }

  if (mMobileViewportManager) {
    // We have one, but we need to either destroy it completely to replace it
    // with another one of the correct type. So either way, let's destroy the
    // one we have.
    mMobileViewportManager->Destroy();
    mMobileViewportManager = nullptr;
    mMVMContext = nullptr;

    ResetVisualViewportSize();
  }

  if (mvmType) {
    // Let's create the MVM of the type that we need. At this point we shouldn't
    // have one.
    MOZ_ASSERT(!mMobileViewportManager);

    mMVMContext = MakeRefPtr<GeckoMVMContext>(mDocument, this);
    mMobileViewportManager =
        MakeRefPtr<MobileViewportManager>(mMVMContext, *mvmType);
    if (MOZ_UNLIKELY(
            MOZ_LOG_TEST(MobileViewportManager::gLog, LogLevel::Debug))) {
      nsIURI* uri = mDocument->GetDocumentURI();
      MOZ_LOG(
          MobileViewportManager::gLog, LogLevel::Debug,
          ("Created MVM %p (type %d) for URI %s", mMobileViewportManager.get(),
           (int)*mvmType, uri ? uri->GetSpecOrDefault().get() : "(null)"));
    }
    if (BrowserChild* browserChild = BrowserChild::GetFrom(this)) {
      mMobileViewportManager->UpdateKeyboardHeight(
          browserChild->GetKeyboardHeight());
    }
  }

  if (aAfterInitialization) {
    // Setting the initial viewport will trigger a reflow.
    if (mMobileViewportManager) {
      mMobileViewportManager->SetInitialViewport();
    } else {
      // Force a reflow to our correct layout viewport size.
      ForceResizeReflowWithCurrentDimensions();
    }
    // After we clear out the MVM and the MVMContext, also reset the
    // resolution to 1.
    SetResolutionAndScaleTo(1.0f, ResolutionChangeOrigin::MainThreadRestore);
  }
}

bool PresShell::UsesMobileViewportSizing() const {
  return mMobileViewportManager &&
         nsLayoutUtils::ShouldHandleMetaViewport(mDocument);
}

/*
 * Determines the current image locking state. Called when one of the
 * dependent factors changes.
 */
void PresShell::UpdateImageLockingState() {
  // We're locked if we're both thawed and active.
  const bool locked = !mFrozen && mIsActive;
  if (locked == mDocument->GetLockingImages()) {
    return;
  }
  mDocument->SetLockingImages(locked);
  if (locked) {
    // Request decodes for visible image frames; we want to start decoding as
    // quickly as possible when we get foregrounded to minimize flashing.
    for (const auto& key : mApproximatelyVisibleFrames) {
      if (nsImageFrame* imageFrame = do_QueryFrame(key)) {
        imageFrame->MaybeDecodeForPredictedSize();
      }
    }
  }
}

nsIWidget* PresShell::GetRootWidget() const {
  if (!mPresContext) {
    return nullptr;
  }
  for (nsPresContext* pc = mPresContext; pc; pc = pc->GetParentPresContext()) {
    if (auto* widget = pc->PresShell()->GetOwnWidget()) {
      return widget;
    }
  }
  return nullptr;
}

PresShell* PresShell::GetRootPresShell() const {
  if (mPresContext) {
    nsPresContext* rootPresContext = mPresContext->GetRootPresContext();
    if (rootPresContext) {
      return rootPresContext->PresShell();
    }
  }
  return nullptr;
}

void PresShell::AddSizeOfIncludingThis(nsWindowSizes& aSizes) const {
  MallocSizeOf mallocSizeOf = aSizes.mState.mMallocSizeOf;
  mFrameArena.AddSizeOfExcludingThis(aSizes, Arena::ArenaKind::PresShell);
  aSizes.mLayoutPresShellSize += mallocSizeOf(this);
  if (mCaret) {
    aSizes.mLayoutPresShellSize += mCaret->SizeOfIncludingThis(mallocSizeOf);
  }
  aSizes.mLayoutPresShellSize +=
      mApproximatelyVisibleFrames.ShallowSizeOfExcludingThis(mallocSizeOf) +
      mFramesToDirty.ShallowSizeOfExcludingThis(mallocSizeOf) +
      mPendingScrollAnchorSelection.ShallowSizeOfExcludingThis(mallocSizeOf) +
      mPendingScrollAnchorAdjustment.ShallowSizeOfExcludingThis(mallocSizeOf);

  aSizes.mLayoutTextRunsSize += SizeOfTextRuns(mallocSizeOf);

  aSizes.mLayoutPresContextSize +=
      mPresContext->SizeOfIncludingThis(mallocSizeOf);

  mFrameConstructor->AddSizeOfIncludingThis(aSizes);
}

size_t PresShell::SizeOfTextRuns(MallocSizeOf aMallocSizeOf) const {
  nsIFrame* rootFrame = mFrameConstructor->GetRootFrame();
  if (!rootFrame) {
    return 0;
  }

  // clear the TEXT_RUN_MEMORY_ACCOUNTED flags
  nsLayoutUtils::SizeOfTextRunsForFrames(rootFrame, nullptr,
                                         /* clear = */ true);

  // collect the total memory in use for textruns
  return nsLayoutUtils::SizeOfTextRunsForFrames(rootFrame, aMallocSizeOf,
                                                /* clear = */ false);
}

void PresShell::MarkPositionedFrameForReflow(nsIFrame* aFrame) {
  // Abspos frames don't affect intrinsic sizes of ancestors.
  FrameNeedsReflow(aFrame, IntrinsicDirty::None, NS_FRAME_HAS_DIRTY_CHILDREN,
                   ReflowRootHandling::PositionOrSizeChange);
}

void PresShell::MarkFixedFramesForReflow() {
  if (nsIFrame* rootFrame = mFrameConstructor->GetRootFrame()) {
    const nsFrameList& childList =
        rootFrame->GetChildList(FrameChildListID::Absolute);
    for (nsIFrame* childFrame : childList) {
      MarkPositionedFrameForReflow(childFrame);
    }
  }
}

void PresShell::MarkStickyFramesForReflow() {
  ScrollContainerFrame* sc = GetRootScrollContainerFrame();
  if (!sc) {
    return;
  }

  StickyScrollContainer* ssc = sc->GetStickyContainer();
  if (!ssc) {
    return;
  }

  ssc->MarkFramesForReflow();
}

static void AppendSubtree(nsIDocShell* aDocShell,
                          nsTArray<nsCOMPtr<nsIDocumentViewer>>& aArray) {
  if (nsCOMPtr<nsIDocumentViewer> viewer = aDocShell->GetDocViewer()) {
    aArray.AppendElement(viewer);
  }

  int32_t n = aDocShell->GetInProcessChildCount();
  for (int32_t i = 0; i < n; i++) {
    nsCOMPtr<nsIDocShellTreeItem> childItem;
    aDocShell->GetInProcessChildAt(i, getter_AddRefs(childItem));
    if (childItem) {
      nsCOMPtr<nsIDocShell> child(do_QueryInterface(childItem));
      AppendSubtree(child, aArray);
    }
  }
}

void PresShell::MaybeReflowForInflationScreenSizeChange() {
  nsPresContext* pc = GetPresContext();
  const bool fontInflationWasEnabled = FontSizeInflationEnabled();
  RecomputeFontSizeInflationEnabled();
  bool changed = false;
  if (FontSizeInflationEnabled() && FontSizeInflationMinTwips() != 0) {
    pc->ScreenSizeInchesForFontInflation(&changed);
  }

  changed = changed || fontInflationWasEnabled != FontSizeInflationEnabled();
  if (!changed) {
    return;
  }
  if (nsCOMPtr<nsIDocShell> docShell = pc->GetDocShell()) {
    nsTArray<nsCOMPtr<nsIDocumentViewer>> array;
    AppendSubtree(docShell, array);
    for (uint32_t i = 0, iEnd = array.Length(); i < iEnd; ++i) {
      nsCOMPtr<nsIDocumentViewer> viewer = array[i];
      if (RefPtr<PresShell> descendantPresShell = viewer->GetPresShell()) {
        nsIFrame* rootFrame = descendantPresShell->GetRootFrame();
        if (rootFrame) {
          descendantPresShell->FrameNeedsReflow(
              rootFrame, IntrinsicDirty::FrameAncestorsAndDescendants,
              NS_FRAME_IS_DIRTY);
        }
      }
    }
  }
}

void PresShell::CompleteChangeToVisualViewportSize() {
  // This can get called during reflow, if the caller wants to get the latest
  // visual viewport size after scrollbars have been added/removed. In such a
  // case, we don't need to mark things as dirty because the things that we
  // would mark dirty either just got updated (the root scrollframe's
  // scrollbars), or will be laid out later during this reflow cycle (fixed-pos
  // items). Callers that update the visual viewport during a reflow are
  // responsible for maintaining these invariants.
  if (!mIsReflowing) {
    if (ScrollContainerFrame* sf = GetRootScrollContainerFrame()) {
      sf->MarkScrollbarsDirtyForReflow();
    }
    MarkFixedFramesForReflow();
  }

  MaybeReflowForInflationScreenSizeChange();

  if (auto* window = nsGlobalWindowInner::Cast(mDocument->GetInnerWindow())) {
    window->VisualViewport()->PostResizeEvent();
  }
}

void PresShell::SetVisualViewportSize(nscoord aWidth, nscoord aHeight) {
  MOZ_ASSERT(aWidth >= 0.0 && aHeight >= 0.0);

  if (!mVisualViewportSizeSet || mVisualViewportSize.width != aWidth ||
      mVisualViewportSize.height != aHeight) {
    mVisualViewportSizeSet = true;
    mVisualViewportSize.width = aWidth;
    mVisualViewportSize.height = aHeight;

    CompleteChangeToVisualViewportSize();
  }
}

void PresShell::ResetVisualViewportSize() {
  if (mVisualViewportSizeSet) {
    mVisualViewportSizeSet = false;
    mVisualViewportSize.width = 0;
    mVisualViewportSize.height = 0;

    CompleteChangeToVisualViewportSize();
  }
}

void PresShell::SetNeedsWindowPropertiesSync() {
  if (XRE_IsContentProcess() || !IsRoot()) {
    // Window properties are only relevant to top level widgets in the parent
    // process
    return;
  }
  mNeedsWindowPropertiesSync = true;
  SchedulePaint();
}

nsSize PresShell::GetVisualViewportSize() const {
  NS_ASSERTION(mVisualViewportSizeSet,
               "asking for visual viewport size when its not set?");
  DynamicToolbarState state = GetDynamicToolbarState();
  return (state == DynamicToolbarState::InTransition ||
          state == DynamicToolbarState::Collapsed)
             ? GetVisualViewportSizeUpdatedByDynamicToolbar()
             : mVisualViewportSize;
}

bool PresShell::SetVisualViewportOffset(const nsPoint& aScrollOffset,
                                        const nsPoint& aPrevLayoutScrollPos) {
  nsPoint newOffset = aScrollOffset;
  ScrollContainerFrame* rootScrollContainerFrame =
      GetRootScrollContainerFrame();
  if (rootScrollContainerFrame) {
    // See the comment in ScrollContainerFrame::Reflow above the call to
    // SetVisualViewportOffset for why we need to do this.
    nsRect scrollRange =
        rootScrollContainerFrame->GetScrollRangeForUserInputEvents();
    if (!scrollRange.Contains(newOffset)) {
      newOffset.x = std::min(newOffset.x, scrollRange.XMost());
      newOffset.x = std::max(newOffset.x, scrollRange.x);
      newOffset.y = std::min(newOffset.y, scrollRange.YMost());
      newOffset.y = std::max(newOffset.y, scrollRange.y);
    }
  }

  // Careful here not to call GetVisualViewportOffset to get the previous visual
  // viewport offset because if mVisualViewportOffset is nothing then we'll get
  // the layout scroll position directly from the scroll frame and it has likely
  // already been updated.
  nsPoint prevOffset = aPrevLayoutScrollPos;
  if (mVisualViewportOffset.isSome()) {
    prevOffset = *mVisualViewportOffset;
  }
  if (prevOffset == newOffset) {
    return false;
  }

  mVisualViewportOffset = Some(newOffset);

  if (auto* window = nsGlobalWindowInner::Cast(mDocument->GetInnerWindow())) {
    window->VisualViewport()->PostScrollEvent(prevOffset, aPrevLayoutScrollPos);
  }

  if (IsVisualViewportSizeSet() && rootScrollContainerFrame) {
    rootScrollContainerFrame->Anchor()->UserScrolled();
  }

  if (gfxPlatform::UseDesktopZoomingScrollbars()) {
    if (rootScrollContainerFrame) {
      rootScrollContainerFrame->UpdateScrollbarPosition();
    }
  }

  return true;
}

void PresShell::ResetVisualViewportOffset() { mVisualViewportOffset.reset(); }

void PresShell::RefreshViewportSize() {
  if (mMobileViewportManager) {
    mMobileViewportManager->RefreshViewportSize(false);
  }
}

void PresShell::ScrollToVisual(const nsPoint& aVisualViewportOffset,
                               ScrollOffsetUpdateType aUpdateType,
                               ScrollMode aMode) {
  if (aMode == ScrollMode::Smooth || aMode == ScrollMode::SmoothMsd) {
    if (ScrollContainerFrame* sf = GetRootScrollContainerFrame()) {
      if (sf->SmoothScrollVisual(aVisualViewportOffset, aUpdateType, aMode)) {
        return;
      }
    }
  }

  // If the caller asked for instant scroll, or if we failed
  // to do a smooth scroll, do an instant scroll.
  SetPendingVisualScrollUpdate(aVisualViewportOffset, aUpdateType);
}

void PresShell::SetPendingVisualScrollUpdate(
    const nsPoint& aVisualViewportOffset, ScrollOffsetUpdateType aUpdateType) {
  mPendingVisualScrollUpdate =
      Some(VisualScrollUpdate{aVisualViewportOffset, aUpdateType});

  // The pending update is picked up during the next paint.
  // Schedule a paint to make sure one will happen.
  if (nsIFrame* rootFrame = GetRootFrame()) {
    rootFrame->SchedulePaint();
  }
}

void PresShell::ClearPendingVisualScrollUpdate() {
  if (mPendingVisualScrollUpdate && mPendingVisualScrollUpdate->mAcknowledged) {
    mPendingVisualScrollUpdate = mozilla::Nothing();
  }
}

void PresShell::AcknowledgePendingVisualScrollUpdate() {
  MOZ_ASSERT(mPendingVisualScrollUpdate);
  mPendingVisualScrollUpdate->mAcknowledged = true;
}

nsPoint PresShell::GetVisualViewportOffsetRelativeToLayoutViewport() const {
  return GetVisualViewportOffset() - GetLayoutViewportOffset();
}

nsPoint PresShell::GetLayoutViewportOffset() const {
  nsPoint result;
  if (ScrollContainerFrame* sf = GetRootScrollContainerFrame()) {
    result = sf->GetScrollPosition();
  }
  return result;
}

nsSize PresShell::GetLayoutViewportSize() const {
  nsSize result;
  if (ScrollContainerFrame* sf = GetRootScrollContainerFrame()) {
    result = sf->GetScrollPortRect().Size();
  }
  return result;
}

nsSize PresShell::GetInnerSize() const {
  if (ScrollContainerFrame* sf = GetRootScrollContainerFrame()) {
    return sf->GetSizeForWindowInnerSize();
  }
  return mPresContext->GetVisibleArea().Size();
}

nsSize PresShell::GetVisualViewportSizeUpdatedByDynamicToolbar() const {
  NS_ASSERTION(mVisualViewportSizeSet,
               "asking for visual viewport size when its not set?");
  if (!mMobileViewportManager) {
    return mVisualViewportSize;
  }

  MOZ_ASSERT(GetDynamicToolbarState() == DynamicToolbarState::InTransition ||
             GetDynamicToolbarState() == DynamicToolbarState::Collapsed);

  nsSize sizeUpdatedByDynamicToolbar =
      mMobileViewportManager->GetVisualViewportSizeUpdatedByDynamicToolbar();
  return sizeUpdatedByDynamicToolbar == nsSize() ? mVisualViewportSize
                                                 : sizeUpdatedByDynamicToolbar;
}

nsSize PresShell::GetFixedViewportSize() const {
  nsSize layoutViewportSize = GetLayoutViewportSize();
  if (!mPresContext->IsKeyboardHiddenOrResizesContentMode()) {
    return layoutViewportSize;
  }
  layoutViewportSize.height +=
      mPresContext->GetBimodalDynamicToolbarHeightForFixedPosInAppUnits();
  return layoutViewportSize;
}

void PresShell::RecomputeFontSizeInflationEnabled() {
  mFontSizeInflationEnabled = DetermineFontSizeInflationState();
}

bool PresShell::DetermineFontSizeInflationState() {
  MOZ_ASSERT(mPresContext, "our pres context should not be null");
  if (mPresContext->IsChrome()) {
    return false;
  }

  if (FontSizeInflationEmPerLine() == 0 && FontSizeInflationMinTwips() == 0) {
    return false;
  }

  // Force-enabling font inflation always trumps the heuristics here.
  if (!FontSizeInflationForceEnabled()) {
    if (BrowserChild* tab = BrowserChild::GetFrom(this)) {
      // We're in a child process.  Cancel inflation if we're not
      // async-pan zoomed.
      if (!tab->AsyncPanZoomEnabled()) {
        return false;
      }
    }
  }

  Maybe<LayoutDeviceIntSize> displaySize;
  // The MVM already caches the top-level content viewer size and is therefore
  // the fastest way of getting that data.
  if (mPresContext->IsRootContentDocumentCrossProcess()) {
    if (mMobileViewportManager) {
      displaySize = Some(mMobileViewportManager->DisplaySize());
    }
  } else if (PresShell* rootPresShell = GetRootPresShell()) {
    // With any luck, we can get at the root content document without any cross-
    // process shenanigans.
    if (auto mvm = rootPresShell->GetMobileViewportManager()) {
      displaySize = Some(mvm->DisplaySize());
    }
  }

  if (!displaySize) {
    // Unfortunately, it looks like the root content document lives in a
    // different process. For consistency's sake it would be best to always use
    // the content viewer size of the root content document, but it's not worth
    // the effort, because this only makes a difference in the case of pages
    // with an explicitly sized viewport (neither "width=device-width" nor a
    // completely missing viewport tag) being loaded within a frame, which is
    // hopefully a relatively exotic case.
    // More to the point, these viewport size and zoom-based calculations don't
    // really make sense for frames anyway, so instead of creating a way to
    // access the content viewer size of the top level document cross-process,
    // we probably rather want frames to simply inherit the font inflation state
    // of their top-level parent and should therefore invest any time spent on
    // getting things to work cross-process into that (bug 1724311).

    // Until we get around to that though, we just use the content viewer size
    // of however high we can get within the same process.

    // (This also serves as a fallback code path if the MVM isn't available,
    // e.g. when debugging in non-e10s mode on Desktop.)
    nsPresContext* topContext =
        mPresContext->GetInProcessRootContentDocumentPresContext();
    LayoutDeviceIntSize result;
    if (!nsLayoutUtils::GetDocumentViewerSize(topContext, result)) {
      return false;
    }
    displaySize = Some(result);
  }

  ScreenIntSize screenSize = ViewAs<ScreenPixel>(
      displaySize.value(),
      PixelCastJustification::LayoutDeviceIsScreenForBounds);
  nsViewportInfo vInf = GetDocument()->GetViewportInfo(screenSize);

  CSSToScreenScale defaultScale =
      mPresContext->CSSToDevPixelScale() * LayoutDeviceToScreenScale(1.0);

  if (vInf.GetDefaultZoom() >= defaultScale || vInf.IsAutoSizeEnabled()) {
    return false;
  }

  return true;
}

static nsIWidget* GetPresContextContainerWidget(nsPresContext* aPresContext) {
  nsCOMPtr<nsISupports> container = aPresContext->Document()->GetContainer();
  nsCOMPtr<nsIBaseWindow> baseWindow = do_QueryInterface(container);
  if (!baseWindow) {
    return nullptr;
  }

  nsCOMPtr<nsIWidget> mainWidget;
  baseWindow->GetMainWidget(getter_AddRefs(mainWidget));
  return mainWidget;
}

static bool IsTopLevelWidget(nsIWidget* aWidget) {
  using WindowType = mozilla::widget::WindowType;

  auto windowType = aWidget->GetWindowType();
  return windowType == WindowType::TopLevel ||
         windowType == WindowType::Dialog || windowType == WindowType::Popup;
}

PresShell::WindowSizeConstraints PresShell::GetWindowSizeConstraints() {
  nsSize minSize(0, 0);
  nsSize maxSize(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
  nsIFrame* rootFrame = FrameConstructor()->GetRootElementStyleFrame();
  if (!rootFrame || !mPresContext) {
    return {minSize, maxSize};
  }
  const auto* pos = rootFrame->StylePosition();
  const auto anchorResolutionParams =
      AnchorPosResolutionParams::From(rootFrame);
  if (const auto styleMinWidth = pos->GetMinWidth(anchorResolutionParams);
      styleMinWidth->ConvertsToLength()) {
    minSize.width = styleMinWidth->ToLength();
  }
  if (const auto styleMinHeight = pos->GetMinHeight(anchorResolutionParams);
      styleMinHeight->ConvertsToLength()) {
    minSize.height = styleMinHeight->ToLength();
  }
  if (const auto maxWidth = pos->GetMaxWidth(anchorResolutionParams);
      maxWidth->ConvertsToLength()) {
    maxSize.width = maxWidth->ToLength();
  }
  if (const auto maxHeight = pos->GetMaxHeight(anchorResolutionParams);
      maxHeight->ConvertsToLength()) {
    maxSize.height = maxHeight->ToLength();
  }
  return {minSize, maxSize};
}

void PresShell::PaintSynchronously() {
  MOZ_ASSERT(!mIsPainting, "re-entrant paint?");
  if (IsNeverPainting() || IsPaintingSuppressed() || !IsVisible() ||
      MOZ_UNLIKELY(NS_WARN_IF(mIsPainting))) {
    return;
  }
  RefPtr widget = GetOwnWidget();
  if (!widget) {
    // We were asked to paint a non-root pres shell, or an already-detached
    // shell.
    return;
  }
  MOZ_ASSERT(widget->IsTopLevelWidget());
  if (!widget->NeedsPaint()) {
    return;
  }

  // FIXME: This might not be needed now except for widget paints
  // (WillPaintWindow) and maybe FlushWillPaintObservers.
  WillPaint();

  if (MOZ_UNLIKELY(mIsDestroying)) {
    return;
  }

  FlushDelayedResize();

  mIsPainting = true;
  auto cleanUpPaintingBit = MakeScopeExit([&] { mIsPainting = false; });
  nsAutoScriptBlocker blocker;
  RefPtr<WindowRenderer> renderer = widget->GetWindowRenderer();
  PaintAndRequestComposite(GetRootFrame(), renderer, PaintFlags::None);
}

void PresShell::SyncWindowPropertiesIfNeeded() {
  if (!mNeedsWindowPropertiesSync) {
    return;
  }

  mNeedsWindowPropertiesSync = false;

  RefPtr pc = mPresContext;
  if (!pc) {
    return;
  }

  nsCOMPtr<nsIWidget> windowWidget = GetPresContextContainerWidget(pc);
  if (!windowWidget || !IsTopLevelWidget(windowWidget)) {
    return;
  }

  nsIFrame* rootFrame = FrameConstructor()->GetRootElementStyleFrame();
  if (!rootFrame) {
    return;
  }

  // Apply color scheme to the top level window widget.
  windowWidget->SetColorScheme(
      Some(LookAndFeel::ColorSchemeForFrame(rootFrame)));

  AutoWeakFrame weak(rootFrame);
  auto* canvas = GetCanvasFrame();
  windowWidget->SetTransparencyMode(nsLayoutUtils::GetFrameTransparency(
      canvas ? canvas : rootFrame, rootFrame));
  if (!weak.IsAlive()) {
    return;
  }

  const auto& constraints = GetWindowSizeConstraints();
  nsContainerFrame::SetSizeConstraints(pc, windowWidget, constraints.mMinSize,
                                       constraints.mMaxSize);
}

nsresult PresShell::HasRuleProcessorUsedByMultipleStyleSets(uint32_t aSheetType,
                                                            bool* aRetVal) {
  *aRetVal = false;
  return NS_OK;
}

void PresShell::NotifyStyleSheetServiceSheetAdded(StyleSheet* aSheet,
                                                  uint32_t aSheetType) {
  switch (aSheetType) {
    case nsIStyleSheetService::AGENT_SHEET:
      AddAgentSheet(aSheet);
      break;
    case nsIStyleSheetService::USER_SHEET:
      AddUserSheet(aSheet);
      break;
    case nsIStyleSheetService::AUTHOR_SHEET:
      AddAuthorSheet(aSheet);
      break;
    default:
      MOZ_ASSERT_UNREACHABLE("unexpected aSheetType value");
      break;
  }
}

void PresShell::NotifyStyleSheetServiceSheetRemoved(StyleSheet* aSheet,
                                                    uint32_t aSheetType) {
  StyleSet()->RemoveStyleSheet(*aSheet);
  mDocument->ApplicableStylesChanged();
}

Result<nsIContent*, nsresult> PresShell::EventHandler::GetOverrideClickTarget(
    WidgetGUIEvent* aGUIEvent, nsIFrame* aFrameForPresShell,
    nsIContent* aPointerCapturingContent) {
  if (aGUIEvent->mMessage != eMouseUp) {
    return nullptr;
  }

  // If aFrameForPresShell has already been reframed before this is called,
  // we cannot keep handling aGUIEvent.
  auto overrideClickTargetOrError = [&]() -> Result<nsIContent*, nsresult> {
    if (PointerEventHandler::ShouldDispatchClickEventOnCapturingElement() &&
        aPointerCapturingContent) {
      return aGUIEvent->AsMouseEvent()->mInputSource ==
                     MouseEvent_Binding::MOZ_SOURCE_TOUCH
                 // If the event is a compatibility mouse event of Touch Events,
                 // `click` event target should be the element capturing the
                 // touch (Note that eTouchStart caused implicit pointer capture
                 // by default when the web app does not use the pointer capture
                 // API).  However, if the web app released the pointer capture,
                 // the target should be the closest common ancestor of
                 // ePointerDown and ePointerUp.  These things will be handled
                 // by EventStateManager::SetClickCount().  Therefore, we should
                 // not override the click event target for a single tap here.
                 ? nullptr
                 // On the other hand, we want to use the pointer capturing
                 // element as the target of `click` event caused by other input
                 // devices.
                 : aPointerCapturingContent;
    }

    if (MOZ_UNLIKELY(!aFrameForPresShell)) {
      return Err(NS_ERROR_FAILURE);
    }

    MOZ_ASSERT(aGUIEvent->mClass == eMouseEventClass);
    WidgetMouseEvent* mouseEvent = aGUIEvent->AsMouseEvent();

    uint32_t flags = 0;
    RelativeTo relativeTo{aFrameForPresShell};
    nsPoint eventPoint =
        nsLayoutUtils::GetEventCoordinatesRelativeTo(aGUIEvent, relativeTo);
    if (mouseEvent->mIgnoreRootScrollFrame) {
      flags |= INPUT_IGNORE_ROOT_SCROLL_FRAME;
    }

    nsIFrame* target =
        FindFrameTargetedByInputEvent(aGUIEvent, relativeTo, eventPoint, flags);
    if (!target) {
      return nullptr;
    }
    return target->GetContent();
  }();
  if (MOZ_UNLIKELY(overrideClickTargetOrError.isErr())) {
    return overrideClickTargetOrError;
  }
  return overrideClickTargetOrError.inspect()
             ? overrideClickTargetOrError.inspect()
                   ->GetInclusiveFlattenedTreeAncestorElement()
             : nullptr;
}

/******************************************************************************
 * PresShell::EventHandler::EventTargetData
 ******************************************************************************/

void PresShell::EventHandler::EventTargetData::SetFrameAndComputePresShell(
    nsIFrame* aFrameToHandleEvent) {
  if (aFrameToHandleEvent) {
    mFrame = aFrameToHandleEvent;
    mPresShell = aFrameToHandleEvent->PresShell();
  } else {
    mFrame = nullptr;
    mPresShell = nullptr;
  }
}

void PresShell::EventHandler::EventTargetData::
    SetFrameAndComputePresShellAndContent(nsIFrame* aFrameToHandleEvent,
                                          WidgetGUIEvent* aGUIEvent) {
  MOZ_ASSERT(aFrameToHandleEvent);
  MOZ_ASSERT(aGUIEvent);

  SetFrameAndComputePresShell(aFrameToHandleEvent);
  SetContentForEventFromFrame(aGUIEvent);
}

void PresShell::EventHandler::EventTargetData::SetContentForEventFromFrame(
    WidgetGUIEvent* aGUIEvent) {
  MOZ_ASSERT(mFrame);
  mContent = mFrame->GetEventTargetContent(aGUIEvent);
  AssertIfEventTargetContentAndFrameContentMismatch(aGUIEvent);
}

nsIContent* PresShell::EventHandler::EventTargetData::GetFrameContent() const {
  return mFrame ? mFrame->GetContent() : nullptr;
}

void PresShell::EventHandler::EventTargetData::
    AssertIfEventTargetContentAndFrameContentMismatch(
        const WidgetGUIEvent* aGUIEvent) const {
#ifdef DEBUG
  if (!mContent || !mFrame || !mFrame->GetContent()) {
    return;
  }

  // If we know the event, we can compute the target correctly.
  if (aGUIEvent) {
    MOZ_ASSERT(mContent == mFrame->GetEventTargetContent(aGUIEvent));
    return;
  }
  // If clicking an image map, mFrame should be the image frame, but mContent
  // should be the area element which handles the event at the position.
  if (mContent->IsHTMLElement(nsGkAtoms::area)) {
    MOZ_ASSERT(mContent->GetPrimaryFrame() == mFrame);
    return;
  }

  // Otherwise, we can check only whether mContent is an inclusive ancestor
  // element or not.
  if (!mContent->IsElement()) {
    MOZ_ASSERT(mContent == mFrame->GetContent());
    return;
  }
  const Element* const closestInclusiveAncestorElement =
      mFrame->GetContent()->GetInclusiveFlattenedTreeAncestorElement();
  if (closestInclusiveAncestorElement == mContent) {
    return;
  }
  if (closestInclusiveAncestorElement->IsInNativeAnonymousSubtree() &&
      (mContent == closestInclusiveAncestorElement
                       ->FindFirstNonChromeOnlyAccessContent())) {
    return;
  }
  NS_WARNING(nsPrintfCString("mContent=%s", ToString(*mContent).c_str()).get());
  NS_WARNING(nsPrintfCString("mFrame->GetContent()=%s",
                             ToString(*mFrame->GetContent()).c_str())
                 .get());
  MOZ_ASSERT(mContent == mFrame->GetContent());
#endif  // #ifdef DEBUG
}

bool PresShell::EventHandler::EventTargetData::MaybeRetargetToActiveDocument(
    WidgetGUIEvent* aGUIEvent) {
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(mFrame);
  MOZ_ASSERT(mPresShell);
  MOZ_ASSERT(!mContent, "Doesn't support to retarget the content");

  EventStateManager* activeESM =
      EventStateManager::GetActiveEventStateManager();
  if (!activeESM) {
    return false;
  }

  if (aGUIEvent->mClass != ePointerEventClass &&
      !aGUIEvent->HasMouseEventMessage()) {
    return false;
  }

  if (activeESM == GetEventStateManager()) {
    return false;
  }

  if (aGUIEvent->ShouldIgnoreCapturingContent()) {
    return false;
  }

  nsPresContext* activePresContext = activeESM->GetPresContext();
  if (!activePresContext) {
    return false;
  }

  PresShell* activePresShell = activePresContext->GetPresShell();
  if (!activePresShell) {
    return false;
  }

  // Note, currently for backwards compatibility we don't forward mouse events
  // to the active document when mouse is over some subdocument.
  if (!nsContentUtils::ContentIsCrossDocDescendantOf(
          activePresShell->GetDocument(), GetDocument())) {
    return false;
  }

  SetFrameAndComputePresShell(activePresShell->GetRootFrame());
  return true;
}

bool PresShell::EventHandler::EventTargetData::ComputeElementFromFrame(
    WidgetGUIEvent* aGUIEvent) {
  MOZ_ASSERT(aGUIEvent);
  MOZ_ASSERT(aGUIEvent->IsUsingCoordinates());
  MOZ_ASSERT(mPresShell);
  MOZ_ASSERT(mFrame);

  SetContentForEventFromFrame(aGUIEvent);

  // If there is no content for this frame, target it anyway.  Some frames can
  // be targeted but do not have content, particularly windows with scrolling
  // off.
  if (!mContent) {
    return true;
  }

  // Bug 103055, bug 185889: mouse events apply to *elements*, not all nodes.
  // Thus we get the nearest element parent here.
  // XXX we leave the frame the same even if we find an element parent, so that
  // the text frame will receive the event (selection and friends are the ones
  // who care about that anyway)
  //
  // We use weak pointers because during this tight loop, the node
  // will *not* go away.  And this happens on every mousemove.
  mContent = mContent->GetInclusiveFlattenedTreeAncestorElement();

  // If we found an element, target it.  Otherwise, target *nothing*.
  return !!mContent;
}

void PresShell::EventHandler::EventTargetData::UpdateWheelEventTarget(
    WidgetGUIEvent* aGUIEvent) {
  MOZ_ASSERT(aGUIEvent);

  if (aGUIEvent->mMessage != eWheel) {
    return;
  }

  // If the stored event target is removed, we will not get an event target
  // frame from the wheel transaction here.
  nsIFrame* groupFrame = WheelTransaction::GetEventTargetFrame();
  if (!groupFrame) {
    return;
  }

  // If we have a stored event target from the wheel transaction, override
  // the event target.
  SetFrameAndComputePresShellAndContent(groupFrame, aGUIEvent);
}

void PresShell::EventHandler::EventTargetData::UpdateTouchEventTarget(
    WidgetGUIEvent* aGUIEvent) {
  MOZ_ASSERT(aGUIEvent);

  if (aGUIEvent->mClass != eTouchEventClass) {
    return;
  }

  if (aGUIEvent->mMessage == eTouchStart) {
    WidgetTouchEvent* touchEvent = aGUIEvent->AsTouchEvent();
    nsIFrame* newFrame =
        TouchManager::SuppressInvalidPointsAndGetTargetedFrame(touchEvent);
    if (!newFrame) {
      return;
    }
    SetFrameAndComputePresShellAndContent(newFrame, aGUIEvent);
    return;
  }

  PresShell* newPresShell = PresShell::GetShellForTouchEvent(aGUIEvent);
  if (!newPresShell) {
    return;  // XXX Why don't we stop handling the event in this case?
  }

  // Touch events (except touchstart) are dispatching to the captured
  // element. Get correct shell from it.
  mPresShell = newPresShell;
}

void PresShell::EndPaint() {
  ClearPendingVisualScrollUpdate();

  if (mDocument) {
    mDocument->EnumerateSubDocuments([](Document& aSubDoc) {
      if (PresShell* presShell = aSubDoc.GetPresShell()) {
        presShell->EndPaint();
      }
      return CallState::Continue;
    });

    if (nsPresContext* presContext = GetPresContext()) {
      if (PerformanceMainThread* perf =
              presContext->GetPerformanceMainThread()) {
        perf->FinalizeLCPEntriesForText();
      }
    }
  }
}

bool PresShell::GetZoomableByAPZ() const {
  return mZoomConstraintsClient && mZoomConstraintsClient->GetAllowZoom();
}

bool PresShell::ReflowForHiddenContentIfNeeded() {
  if (mHiddenContentInForcedLayout.IsEmpty()) {
    return false;
  }
  mDocument->FlushPendingNotifications(FlushType::Layout);
  mHiddenContentInForcedLayout.Clear();
  return true;
}

void PresShell::UpdateHiddenContentInForcedLayout(nsIFrame* aFrame) {
  if (!aFrame || !aFrame->IsSubtreeDirty()) {
    return;
  }

  nsIFrame* topmostFrameWithContentHidden = nullptr;
  for (nsIFrame* cur = aFrame->GetInFlowParent(); cur;
       cur = cur->GetInFlowParent()) {
    if (cur->HidesContent()) {
      topmostFrameWithContentHidden = cur;
      mHiddenContentInForcedLayout.Insert(cur->GetContent());
    }
  }

  if (mHiddenContentInForcedLayout.IsEmpty()) {
    return;
  }

  // Queue and immediately flush a reflow for this node.
  MOZ_ASSERT(topmostFrameWithContentHidden);
  FrameNeedsReflow(topmostFrameWithContentHidden, IntrinsicDirty::None,
                   NS_FRAME_IS_DIRTY);
}

void PresShell::EnsureReflowIfFrameHasHiddenContent(nsIFrame* aFrame) {
  MOZ_ASSERT(mHiddenContentInForcedLayout.IsEmpty());

  UpdateHiddenContentInForcedLayout(aFrame);
  ReflowForHiddenContentIfNeeded();
}

bool PresShell::IsForcingLayoutForHiddenContent(const nsIFrame* aFrame) const {
  return mHiddenContentInForcedLayout.Contains(aFrame->GetContent());
}

void PresShell::UpdateRelevancyOfContentVisibilityAutoFrames() {
  if (mContentVisibilityRelevancyToUpdate.isEmpty()) {
    return;
  }

  for (nsIFrame* frame : mContentVisibilityAutoFrames) {
    frame->UpdateIsRelevantContent(mContentVisibilityRelevancyToUpdate);
  }

  if (nsPresContext* presContext = GetPresContext()) {
    presContext->UpdateHiddenByContentVisibilityForAnimationsIfNeeded();
  }

  mContentVisibilityRelevancyToUpdate.clear();
}

void PresShell::ScheduleContentRelevancyUpdate(ContentRelevancyReason aReason) {
  if (MOZ_UNLIKELY(mIsDestroying)) {
    return;
  }
  mContentVisibilityRelevancyToUpdate += aReason;
  EnsureLayoutFlush();
}

PresShell::ProximityToViewportResult PresShell::DetermineProximityToViewport() {
  ProximityToViewportResult result;
  if (mContentVisibilityAutoFrames.IsEmpty()) {
    return result;
  }

  auto margin = LengthPercentage::FromPercentage(
      StaticPrefs::layout_css_content_visibility_relevant_content_margin() /
      100.0f);

  auto rootMargin = StyleRect<LengthPercentage>::WithAllSides(margin);

  auto input = DOMIntersectionObserver::ComputeInput(
      *mDocument, /* aRoot = */ nullptr, &rootMargin, nullptr);

  for (nsIFrame* frame : mContentVisibilityAutoFrames) {
    auto* element = frame->GetContent()->AsElement();
    result.mAnyScrollIntoViewFlag |=
        element->TemporarilyVisibleForScrolledIntoViewDescendant();

    // 14.2.3.1
    Maybe<bool> oldVisibility = element->GetVisibleForContentVisibility();
    bool checkForInitialDetermination =
        oldVisibility.isNothing() &&
        (element->GetContentRelevancy().isNothing() ||
         element->GetContentRelevancy()->isEmpty());

    // 14.2.3.2
    bool intersects =
        DOMIntersectionObserver::Intersect(
            input, *element, DOMIntersectionObserver::BoxToUse::OverflowClip,
            DOMIntersectionObserver::IsForProximityToViewport::Yes)
            .Intersects();
    element->SetVisibleForContentVisibility(intersects);

    // 14.2.3.3
    if (checkForInitialDetermination && intersects) {
      // Initial determination happens sync, otherwise on the next rendering
      // opportunity.
      frame->UpdateIsRelevantContent(ContentRelevancyReason::Visible);
      result.mHadInitialDetermination = true;
    } else if (oldVisibility.isNothing() || *oldVisibility != intersects) {
      ScheduleContentRelevancyUpdate(ContentRelevancyReason::Visible);
    }
  }
  if (nsPresContext* presContext = GetPresContext()) {
    presContext->UpdateHiddenByContentVisibilityForAnimationsIfNeeded();
  }

  return result;
}

void PresShell::ClearTemporarilyVisibleForScrolledIntoViewDescendantFlags()
    const {
  for (nsIFrame* frame : mContentVisibilityAutoFrames) {
    frame->GetContent()
        ->AsElement()
        ->SetTemporarilyVisibleForScrolledIntoViewDescendant(false);
  }
}

void PresShell::UpdateContentRelevancyImmediately(
    ContentRelevancyReason aReason) {
  if (MOZ_UNLIKELY(mIsDestroying)) {
    return;
  }

  mContentVisibilityRelevancyToUpdate += aReason;

  EnsureLayoutFlush();
  UpdateRelevancyOfContentVisibilityAutoFrames();
}

void PresShell::CleanupFullscreenState() {
  mFirstUnmatchedEscapeKeyDownForFullscreen = TimeStamp();
  mEscapeKeyDownCountForFullscreenKeyboardLockWarning = 0;
  mLastEscapeKeyDownTimeForFullscreenKeyboardLockWarning = TimeStamp();
  mHasShownFullscreenWarningForCurrentEscapeKeyLongPress = false;
}

bool PresShell::ShouldShowFullscreenKeyboardLockWarning(
    const WidgetKeyboardEvent& aKeyboardEvent) {
  MOZ_ASSERT(aKeyboardEvent.mMessage == eKeyDown);
  MOZ_ASSERT(aKeyboardEvent.mKeyCode == NS_VK_ESCAPE);

  if (!XRE_IsParentProcess()) {
    // We trigger the fullscreen warning from the parent process.
    return false;
  }

  if (aKeyboardEvent.mIsRepeat) {
    // Only when we are in tracking a long press of the escape key and haven't
    // shown the warning for the current long press yet.
    if (mFirstUnmatchedEscapeKeyDownForFullscreen &&
        !mHasShownFullscreenWarningForCurrentEscapeKeyLongPress) {
      if ((aKeyboardEvent.mTimeStamp -
           mFirstUnmatchedEscapeKeyDownForFullscreen) >=
          TimeDuration::FromMilliseconds(
              StaticPrefs::
                  dom_fullscreen_keyboard_lock_long_press_warning_interval())) {
        mHasShownFullscreenWarningForCurrentEscapeKeyLongPress = true;
        return true;
      }
    }
    return false;
  }

  MOZ_ASSERT(!aKeyboardEvent.mIsRepeat);
  const TimeStamp previousEscapeKeyDownTime =
      mLastEscapeKeyDownTimeForFullscreenKeyboardLockWarning;
  mLastEscapeKeyDownTimeForFullscreenKeyboardLockWarning =
      aKeyboardEvent.mTimeStamp;

  const bool escapeKeyDownWithinWarnInterval =
      previousEscapeKeyDownTime &&
      (aKeyboardEvent.mTimeStamp - previousEscapeKeyDownTime) <=
          TimeDuration::FromMilliseconds(
              StaticPrefs::
                  dom_fullscreen_keyboard_lock_triple_click_warn_interval());
  if (!escapeKeyDownWithinWarnInterval) {
    // If the escape keys were pressed outside of the warning interval, start
    // a new count.
    mEscapeKeyDownCountForFullscreenKeyboardLockWarning = 1;
    return false;
  }

  mEscapeKeyDownCountForFullscreenKeyboardLockWarning += 1;
  if (mEscapeKeyDownCountForFullscreenKeyboardLockWarning < 3) {
    return false;
  }

  // If the escape key has been pressed 3 or more times within the warning
  // interval, trigger the warning and reset the counter and timestamp.
  mEscapeKeyDownCountForFullscreenKeyboardLockWarning = 0;
  mLastEscapeKeyDownTimeForFullscreenKeyboardLockWarning = TimeStamp();
  return true;
}