| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/Firefox/layout/base/ (Firefox Browser Version 153.0.1©) Datei vom 27.6.2026 mit Größe 465 kB |
|
Quelle PresShell.cpp Sprache: C |
|||||||||||||||
|
/* 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 "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,31 #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()) { // Set focus navigation starting point, so that focus navigation still // starts from this element. element->OwnerDoc()->SetFocusNavigationStartingPoint(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* aFra 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 dedicated sequential // focus navigation starting point 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->SetFocusNavigationStartingPoint(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)) { if (lastMouseInfo->HasLastState()) { 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& aM if (aMouseEvent.mMessage == eMouseMove && aMouseEvent.IsSynthesized()) { return false; } PointerEventHandler::RecordMouseState(*this, aMouseEvent); mLastMousePointerId = Some(aMouseEvent.pointerId); return true; }; const auto ClearMouseLocation = [&](const WidgetMouseEvent& aM 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 } 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(¤tIndex); 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; }
¤ Dauer der Verarbeitung: 1.534 Sekunden (vorverarbeitet am 2026-09-29) ¤*© Formatika GbR, Deutschland |
|
||||||||||||||
2026-10-09