mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/layout/base/nsIPresShell.h

2081 строка
75 KiB
C++
Исходник Ответственный История

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/* a presentation of a document, part 2 */
#ifndef nsIPresShell_h___
#define nsIPresShell_h___
#include "mozilla/ArenaObjectID.h"
#include "mozilla/EventForwards.h"
#include "mozilla/FlushType.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/ScrollTypes.h"
#include "mozilla/ServoStyleSet.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/StyleSheet.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/WeakPtr.h"
#include "FrameMetrics.h"
#include "GeckoProfiler.h"
#include "gfxPoint.h"
#include "nsTHashtable.h"
#include "nsHashKeys.h"
#include "nsISupports.h"
#include "nsIContent.h"
#include "nsISelectionController.h"
#include "nsQueryFrame.h"
#include "nsStringFwd.h"
#include "nsCoord.h"
#include "nsColor.h"
#include "nsFrameManager.h"
#include "nsRect.h"
#include "nsRegionFwd.h"
#include <stdio.h> // for FILE definition
#include "nsChangeHint.h"
#include "nsRefPtrHashtable.h"
#include "nsClassHashtable.h"
#include "nsPresArena.h"
#include "nsIImageLoadingContent.h"
#include "nsMargin.h"
#include "nsFrameState.h"
#include "nsStubDocumentObserver.h"
#include "nsCOMArray.h"
#include "Units.h"
#ifdef MOZ_REFLOW_PERF
class ReflowCountMgr;
#endif
class gfxContext;
struct nsCallbackEventRequest;
class nsDocShell;
class nsIFrame;
class nsPresContext;
class nsWindowSizes;
class nsViewManager;
class nsView;
class nsIPageSequenceFrame;
class nsCanvasFrame;
class nsCaret;
namespace mozilla {
class AccessibleCaretEventHub;
class OverflowChangedTracker;
class StyleSheet;
} // namespace mozilla
class nsFrameSelection;
class nsFrameManager;
class nsILayoutHistoryState;
class nsIReflowCallback;
class nsCSSFrameConstructor;
template <class E>
class nsCOMArray;
class AutoWeakFrame;
class MobileViewportManager;
class WeakFrame;
class nsIScrollableFrame;
class nsDisplayList;
class nsDisplayListBuilder;
class nsPIDOMWindowOuter;
struct nsPoint;
class nsINode;
struct nsRect;
class nsRegion;
class nsRefreshDriver;
class nsAutoCauseReflowNotifier;
class nsARefreshObserver;
class nsAPostRefreshObserver;
#ifdef ACCESSIBILITY
class nsAccessibilityService;
namespace mozilla {
namespace a11y {
class DocAccessible;
} // namespace a11y
} // namespace mozilla
#endif
class nsITimer;
namespace mozilla {
class EventStates;
namespace dom {
class Element;
class Event;
class Document;
class HTMLSlotElement;
class Touch;
class Selection;
class ShadowRoot;
} // namespace dom
namespace layout {
class ScrollAnchorContainer;
} // namespace layout
namespace layers {
class LayerManager;
} // namespace layers
namespace gfx {
class SourceSurface;
} // namespace gfx
} // namespace mozilla
// Flags to pass to SetCapturingContent
//
// when assigning capture, ignore whether capture is allowed or not
#define CAPTURE_IGNOREALLOWED 1
// true if events should be targeted at the capturing content or its children
#define CAPTURE_RETARGETTOELEMENT 2
// true if the current capture wants drags to be prevented
#define CAPTURE_PREVENTDRAG 4
// true when the mouse is pointer locked, and events are sent to locked element
#define CAPTURE_POINTERLOCK 8
typedef struct CapturingContentInfo {
// capture should only be allowed during a mousedown event
bool mAllowed;
bool mPointerLock;
bool mRetargetToElement;
bool mPreventDrag;
mozilla::StaticRefPtr<nsIContent> mContent;
} CapturingContentInfo;
// b7b89561-4f03-44b3-9afa-b47e7f313ffb
#define NS_IPRESSHELL_IID \
{ \
0xb7b89561, 0x4f03, 0x44b3, { \
0x9a, 0xfa, 0xb4, 0x7e, 0x7f, 0x31, 0x3f, 0xfb \
} \
}
// debug VerifyReflow flags
#define VERIFY_REFLOW_ON 0x01
#define VERIFY_REFLOW_NOISY 0x02
#define VERIFY_REFLOW_ALL 0x04
#define VERIFY_REFLOW_DUMP_COMMANDS 0x08
#define VERIFY_REFLOW_NOISY_RC 0x10
#define VERIFY_REFLOW_REALLY_NOISY_RC 0x20
#define VERIFY_REFLOW_DURING_RESIZE_REFLOW 0x40
#undef NOISY_INTERRUPTIBLE_REFLOW
enum nsRectVisibility {
nsRectVisibility_kVisible,
nsRectVisibility_kAboveViewport,
nsRectVisibility_kBelowViewport,
nsRectVisibility_kLeftOfViewport,
nsRectVisibility_kRightOfViewport
};
/**
* Presentation shell interface. Presentation shells are the
* controlling point for managing the presentation of a document. The
* presentation shell holds a live reference to the document, the
* presentation context, the style manager, the style set and the root
* frame. <p>
*
* When this object is Release'd, it will release the document, the
* presentation context, the style manager, the style set and the root
* frame.
*/
class nsIPresShell : public nsStubDocumentObserver {
public:
NS_DECLARE_STATIC_IID_ACCESSOR(NS_IPRESSHELL_IID)
protected:
typedef mozilla::dom::Document Document;
typedef mozilla::layers::FrameMetrics FrameMetrics;
typedef mozilla::layers::LayerManager LayerManager;
typedef mozilla::gfx::SourceSurface SourceSurface;
enum eRenderFlag {
STATE_IGNORING_VIEWPORT_SCROLLING = 0x1,
STATE_DRAWWINDOW_NOT_FLUSHING = 0x2
};
typedef uint8_t RenderFlags; // for storing the above flags
public:
nsIPresShell();
/**
* All callers are responsible for calling |Destroy| after calling
* |EndObservingDocument|. It needs to be separate only because form
* controls incorrectly store their data in the frames rather than the
* content model and printing calls |EndObservingDocument| multiple
* times to make form controls behave nicely when printed.
*/
virtual void Destroy() = 0;
bool IsDestroying() { return mIsDestroying; }
/**
* All frames owned by the shell are allocated from an arena. They
* are also recycled using free lists. Separate free lists are
* maintained for each frame type (aID), which must always correspond
* to the same aSize value. AllocateFrame is infallible and will abort
* on out-of-memory.
*/
void* AllocateFrame(nsQueryFrame::FrameIID aID, size_t aSize) {
void* result = mFrameArena.AllocateByFrameID(aID, aSize);
RecordAlloc(result);
return result;
}
void FreeFrame(nsQueryFrame::FrameIID aID, void* aPtr) {
RecordFree(aPtr);
if (!mIsDestroying) mFrameArena.FreeByFrameID(aID, aPtr);
}
/**
* This is for allocating other types of objects (not frames). Separate free
* lists are maintained for each type (aID), which must always correspond to
* the same aSize value. AllocateByObjectID is infallible and will abort on
* out-of-memory.
*/
void* AllocateByObjectID(mozilla::ArenaObjectID aID, size_t aSize) {
void* result = mFrameArena.AllocateByObjectID(aID, aSize);
RecordAlloc(result);
return result;
}
void FreeByObjectID(mozilla::ArenaObjectID aID, void* aPtr) {
RecordFree(aPtr);
if (!mIsDestroying) mFrameArena.FreeByObjectID(aID, aPtr);
}
Document* GetDocument() const { return mDocument; }
nsPresContext* GetPresContext() const { return mPresContext; }
nsViewManager* GetViewManager() const { return mViewManager; }
nsRefreshDriver* GetRefreshDriver() const;
#ifdef ACCESSIBILITY
/**
* Return the document accessible for this pres shell if there is one.
*/
mozilla::a11y::DocAccessible* GetDocAccessible() const {
return mDocAccessible;
}
/**
* Set the document accessible for this pres shell.
*/
void SetDocAccessible(mozilla::a11y::DocAccessible* aDocAccessible) {
mDocAccessible = aDocAccessible;
}
#endif
inline mozilla::ServoStyleSet* StyleSet() const;
nsCSSFrameConstructor* FrameConstructor() const {
return mFrameConstructor.get();
}
/* Enable/disable author style level. Disabling author style disables the
* entire author level of the cascade, including the HTML preshint level.
*/
// XXX these could easily be inlined, but there is a circular #include
// problem with nsStyleSet.
void SetAuthorStyleDisabled(bool aDisabled);
bool GetAuthorStyleDisabled() const;
/**
* Update the style set somehow to take into account changed prefs which
* affect document styling.
*/
void UpdatePreferenceStyles();
/**
* FrameSelection will return the Frame based selection API.
* You cannot go back and forth anymore with QI between nsIDOM sel and
* nsIFrame sel.
*/
already_AddRefed<nsFrameSelection> FrameSelection();
/**
* ConstFrameSelection returns an object which methods are safe to use for
* example in nsIFrame code.
*/
const nsFrameSelection* ConstFrameSelection() const { return mSelection; }
// Start receiving notifications from our document. If called after Destroy,
// this will be ignored.
void BeginObservingDocument();
// Stop receiving notifications from our document. If called after Destroy,
// this will be ignored.
void EndObservingDocument();
bool IsObservingDocument() const { return mIsObservingDocument; }
/**
* Return whether Initialize() was previously called.
*/
bool DidInitialize() const { return mDidInitialize; }
/**
* Perform initialization. Constructs the frame for the root content
* object and then enqueues a reflow of the frame model.
*
* Callers of this method must hold a reference to this shell that
* is guaranteed to survive through arbitrary script execution.
* Calling Initialize can execute arbitrary script.
*/
virtual nsresult Initialize() = 0;
enum class ResizeReflowOptions : uint32_t {
// the resulting BSize should be exactly as given
eBSizeExact,
// the resulting BSize can be less than the given one, producing
// shrink-to-fit sizing in the block dimension
eBSizeLimit
};
/**
* Reflow the frame model into a new width and height. The
* coordinates for aWidth and aHeight must be in standard nscoord's.
*/
MOZ_CAN_RUN_SCRIPT virtual nsresult ResizeReflow(
nscoord aWidth, nscoord aHeight, nscoord aOldWidth = 0,
nscoord aOldHeight = 0,
ResizeReflowOptions aOptions = ResizeReflowOptions::eBSizeExact) = 0;
/**
* Do the same thing as ResizeReflow but even if ResizeReflowOverride was
* called previously.
*/
MOZ_CAN_RUN_SCRIPT virtual nsresult ResizeReflowIgnoreOverride(
nscoord aWidth, nscoord aHeight, nscoord aOldWidth, nscoord aOldHeight,
ResizeReflowOptions aOptions = ResizeReflowOptions::eBSizeExact) = 0;
/**
* Returns true if the platform/pref or docshell require a meta viewport.
*/
virtual bool GetIsViewportOverridden() = 0;
/**
* Note that the assumptions that determine the need for a meta viewport
* may have changed.
*/
virtual void UpdateViewportOverridden(bool aAfterInitialization) = 0;
/**
* Get the MobileViewportManager used to manage the document's mobile
* viewport. Will return null in situations where we don't have a mobile
* viewport, and for documents that are not the root content document.
*/
virtual RefPtr<MobileViewportManager> GetMobileViewportManager() const = 0;
/**
* Return true if the presshell expects layout flush.
*/
virtual bool IsLayoutFlushObserver() = 0;
/**
* Called when document load completes.
*/
virtual void LoadComplete() = 0;
/**
* This calls through to the frame manager to get the root frame.
*/
nsIFrame* GetRootFrame() const { return mFrameManager->GetRootFrame(); }
/*
* Get root scroll frame from FrameManager()->GetRootFrame().
*/
nsIFrame* GetRootScrollFrame() const;
/*
* The same as GetRootScrollFrame, but returns an nsIScrollableFrame
*/
nsIScrollableFrame* GetRootScrollFrameAsScrollable() const;
/**
* Get the current focused content or DOM selection that should be the
* target for scrolling.
*/
already_AddRefed<nsIContent> GetContentForScrolling() const;
/**
* Get the DOM selection that should be the target for scrolling, if there
* is no focused content.
*/
already_AddRefed<nsIContent> GetSelectedContentForScrolling() const;
/**
* Gets nearest scrollable frame from the specified content node. The frame
* is scrollable with overflow:scroll or overflow:auto in some direction when
* aDirection is eEither. Otherwise, this returns a nearest frame that is
* scrollable in the specified direction.
*/
enum ScrollDirection { eHorizontal, eVertical, eEither };
nsIScrollableFrame* GetScrollableFrameToScrollForContent(
nsIContent* aContent, ScrollDirection aDirection);
/**
* Gets nearest scrollable frame from current focused content or DOM
* selection if there is no focused content. The frame is scrollable with
* overflow:scroll or overflow:auto in some direction when aDirection is
* eEither. Otherwise, this returns a nearest frame that is scrollable in
* the specified direction.
*/
nsIScrollableFrame* GetScrollableFrameToScroll(ScrollDirection aDirection);
/**
* Gets nearest ancestor scrollable frame from aFrame. The frame is
* scrollable with overflow:scroll or overflow:auto in some direction when
* aDirection is eEither. Otherwise, this returns a nearest frame that is
* scrollable in the specified direction.
*/
nsIScrollableFrame* GetNearestScrollableFrame(nsIFrame* aFrame,
ScrollDirection aDirection);
/**
* Returns the page sequence frame associated with the frame hierarchy.
* Returns nullptr if not a paginated view.
*/
nsIPageSequenceFrame* GetPageSequenceFrame() const;
/**
* Returns the canvas frame associated with the frame hierarchy.
* Returns nullptr if is XUL document.
*/
nsCanvasFrame* GetCanvasFrame() const;
void PostPendingScrollAnchorSelection(
mozilla::layout::ScrollAnchorContainer* aContainer);
void FlushPendingScrollAnchorSelections();
void PostPendingScrollAnchorAdjustment(
mozilla::layout::ScrollAnchorContainer* aContainer);
/**
* Tell the pres shell that a frame needs to be marked dirty and needs
* Reflow. It's OK if this is an ancestor of the frame needing reflow as
* long as the ancestor chain between them doesn't cross a reflow root.
*
* The bit to add should be NS_FRAME_IS_DIRTY, NS_FRAME_HAS_DIRTY_CHILDREN
* or nsFrameState(0); passing 0 means that dirty bits won't be set on the
* frame or its ancestors/descendants, but that intrinsic widths will still
* be marked dirty. Passing aIntrinsicDirty = eResize and aBitToAdd = 0
* would result in no work being done, so don't do that.
*/
enum IntrinsicDirty {
// XXXldb eResize should be renamed
eResize, // don't mark any intrinsic widths dirty
eTreeChange, // mark intrinsic widths dirty on aFrame and its ancestors
eStyleChange // Do eTreeChange, plus all of aFrame's descendants
};
enum ReflowRootHandling {
ePositionOrSizeChange, // aFrame is changing position or size
eNoPositionOrSizeChange, // ... NOT changing ...
eInferFromBitToAdd // is changing iff (aBitToAdd == NS_FRAME_IS_DIRTY)
// Note: With eStyleChange, these can also apply to out-of-flows
// in addition to aFrame.
};
void FrameNeedsReflow(nsIFrame* aFrame, IntrinsicDirty aIntrinsicDirty,
nsFrameState aBitToAdd,
ReflowRootHandling aRootHandling = eInferFromBitToAdd);
/**
* Calls FrameNeedsReflow on all fixed position children of the root frame.
*/
void MarkFixedFramesForReflow(IntrinsicDirty aIntrinsicDirty);
/**
* Tell the presshell that the given frame's reflow was interrupted. This
* will mark as having dirty children a path from the given frame (inclusive)
* to the nearest ancestor with a dirty subtree, or to the reflow root
* currently being reflowed if no such ancestor exists (inclusive). This is
* to be done immediately after reflow of the current reflow root completes.
* This method must only be called during reflow, and the frame it's being
* called on must be in the process of being reflowed when it's called. This
* method doesn't mark any intrinsic widths dirty and doesn't add any bits
* other than NS_FRAME_HAS_DIRTY_CHILDREN.
*/
void FrameNeedsToContinueReflow(nsIFrame* aFrame);
void CancelAllPendingReflows();
void NotifyCounterStylesAreDirty();
bool FrameIsAncestorOfDirtyRoot(nsIFrame* aFrame) const;
/**
* Destroy the frames for aElement, and reconstruct them asynchronously if
* needed.
*
* Note that this may destroy frames for an ancestor instead.
*/
void DestroyFramesForAndRestyle(mozilla::dom::Element* aElement);
/**
* Handles all the layout stuff needed when the slot assignment for an element
* is about to change.
*
* Only called when the slot attribute of the element changes, the rest of
* the changes should be handled in ShadowRoot.
*/
void SlotAssignmentWillChange(mozilla::dom::Element& aElement,
mozilla::dom::HTMLSlotElement* aOldSlot,
mozilla::dom::HTMLSlotElement* aNewSlot);
void PostRecreateFramesFor(mozilla::dom::Element*);
void RestyleForAnimation(mozilla::dom::Element*, mozilla::RestyleHint);
/**
* Determine if it is safe to flush all pending notifications.
*/
bool IsSafeToFlush() const;
/**
* Informs the document's FontFaceSet that the refresh driver ticked,
* flushing style and layout.
*/
void NotifyFontFaceSetOnRefresh();
/**
* Flush pending notifications of the type specified. This method
* will not affect the content model; it'll just affect style and
* frames. Callers that actually want up-to-date presentation (other
* than the document itself) should probably be calling
* Document::FlushPendingNotifications.
*
* This method can execute script, which can destroy this presshell object
* unless someone is holding a reference to it on the stack. The presshell
* itself will ensure it lives up until the method returns, but callers who
* plan to use the presshell after this call should hold a strong ref
* themselves!
*
* @param aType the type of notifications to flush
*/
MOZ_CAN_RUN_SCRIPT
void FlushPendingNotifications(mozilla::FlushType aType) {
if (!NeedFlush(aType)) {
return;
}
DoFlushPendingNotifications(aType);
}
MOZ_CAN_RUN_SCRIPT
void FlushPendingNotifications(mozilla::ChangesToFlush aType) {
if (!NeedFlush(aType.mFlushType)) {
return;
}
DoFlushPendingNotifications(aType);
}
protected:
/**
* Implementation methods for FlushPendingNotifications.
*/
MOZ_CAN_RUN_SCRIPT
virtual void DoFlushPendingNotifications(mozilla::FlushType aType) = 0;
MOZ_CAN_RUN_SCRIPT
virtual void DoFlushPendingNotifications(mozilla::ChangesToFlush aType) = 0;
public:
/**
* Whether we might need a flush for the given flush type. If this
* function returns false, we definitely don't need to flush.
*
* @param aFlushType The flush type to check. This must be
* >= FlushType::Style. This also returns true if a throttled
* animation flush is required.
*/
bool NeedFlush(mozilla::FlushType aType) const {
// We check mInFlush to handle re-entrant calls to FlushPendingNotifications
// by reporting that we always need a flush in that case. Otherwise,
// we could end up missing needed flushes, since we clear the mNeedXXXFlush
// flags at the top of FlushPendingNotifications.
MOZ_ASSERT(aType >= mozilla::FlushType::Style);
return mNeedStyleFlush ||
(mNeedLayoutFlush &&
aType >= mozilla::FlushType::InterruptibleLayout) ||
aType >= mozilla::FlushType::Display ||
mNeedThrottledAnimationFlush || mInFlush;
}
inline void EnsureStyleFlush();
inline void SetNeedStyleFlush();
inline void SetNeedLayoutFlush();
inline void SetNeedThrottledAnimationFlush();
// Removes ourself from the list of layout / style / and resize refresh driver
// observers.
//
// Right now this is only used for documents in the BFCache, so if you want to
// use this for anything else you need to ensure we don't end up in those
// lists after calling this, but before calling StartObservingRefreshDriver
// again.
//
// That is handled by the mDocument->GetBFCacheEntry checks in
// DoObserve*Flushes functions, though that could conceivably become a boolean
// member in the shell if needed.
//
// Callers are responsible of manually calling StartObservingRefreshDriver
// again.
void StopObservingRefreshDriver();
void StartObservingRefreshDriver();
bool ObservingStyleFlushes() const { return mObservingStyleFlushes; }
bool ObservingLayoutFlushes() const { return mObservingLayoutFlushes; }
void ObserveStyleFlushes() {
if (!ObservingStyleFlushes()) DoObserveStyleFlushes();
}
bool NeedStyleFlush() const { return mNeedStyleFlush; }
/**
* Returns true if we might need to flush layout, even if we haven't scheduled
* one yet (as opposed to HasPendingReflow, which returns true if a flush is
* scheduled or will soon be scheduled).
*/
bool NeedLayoutFlush() const { return mNeedLayoutFlush; }
/**
* Callbacks will be called even if reflow itself fails for
* some reason.
*/
nsresult PostReflowCallback(nsIReflowCallback* aCallback);
void CancelReflowCallback(nsIReflowCallback* aCallback);
void ScheduleBeforeFirstPaint();
void UnsuppressAndInvalidate();
void ClearFrameRefs(nsIFrame* aFrame);
/**
* Get a reference rendering context. This is a context that should not
* be rendered to, but is suitable for measuring text and performing
* other non-rendering operations. Guaranteed to return non-null.
*/
already_AddRefed<gfxContext> CreateReferenceRenderingContext();
/**
* Informs the pres shell that the document is now at the anchor with
* the given name. If |aScroll| is true, scrolls the view of the
* document so that the anchor with the specified name is displayed at
* the top of the window. If |aAnchorName| is empty, then this informs
* the pres shell that there is no current target, and |aScroll| must
* be false. If |aAdditionalScrollFlags| is nsIPresShell::SCROLL_SMOOTH_AUTO
* and |aScroll| is true, the scrolling may be performed with an animation.
*/
nsresult GoToAnchor(const nsAString& aAnchorName, bool aScroll,
uint32_t aAdditionalScrollFlags = 0);
/**
* Tells the presshell to scroll again to the last anchor scrolled to by
* GoToAnchor, if any. This scroll only happens if the scroll
* position has not changed since the last GoToAnchor. This is called
* by nsDocumentViewer::LoadComplete. This clears the last anchor
* scrolled to by GoToAnchor (we don't want to keep it alive if it's
* removed from the DOM), so don't call this more than once.
*/
nsresult ScrollToAnchor();
enum {
SCROLL_TOP = 0,
SCROLL_BOTTOM = 100,
SCROLL_LEFT = 0,
SCROLL_RIGHT = 100,
SCROLL_CENTER = 50,
SCROLL_MINIMUM = -1
};
enum WhenToScroll {
SCROLL_ALWAYS,
SCROLL_IF_NOT_VISIBLE,
SCROLL_IF_NOT_FULLY_VISIBLE
};
typedef struct ScrollAxis {
int16_t mWhereToScroll;
WhenToScroll mWhenToScroll : 8;
bool mOnlyIfPerceivedScrollableDirection : 1;
/**
* aWhere:
* Either a percentage or a special value. nsIPresShell defines:
* * (Default) SCROLL_MINIMUM = -1: The visible area is scrolled the
* minimum amount to show as much as possible of the frame. This won't
* hide any initially visible part of the frame.
* * SCROLL_TOP = 0: The frame's upper edge is aligned with the top edge
* of the visible area.
* * SCROLL_BOTTOM = 100: The frame's bottom edge is aligned with the
* bottom edge of the visible area.
* * SCROLL_LEFT = 0: The frame's left edge is aligned with the left edge
* of the visible area.
* * SCROLL_RIGHT = 100: The frame's right edge is aligned* with the right
* edge of the visible area.
* * SCROLL_CENTER = 50: The frame is centered along the axis the
* ScrollAxis is used for.
*
* Other values are treated as a percentage, and the point*"percent"
* down the frame is placed at the point "percent" down the visible area.
*
* aWhen:
* * (Default) SCROLL_IF_NOT_FULLY_VISIBLE: Move the frame only if it is
* not fully visible (including if it's not visible at all). Note that
* in this case if the frame is too large to fit in view, it will only
* be scrolled if more of it can fit than is already in view.
* * SCROLL_IF_NOT_VISIBLE: Move the frame only if none of it is visible.
* * SCROLL_ALWAYS: Move the frame regardless of its current visibility.
*
* aOnlyIfPerceivedScrollableDirection:
* If the direction is not a perceived scrollable direction (i.e. no
* scrollbar showing and less than one device pixel of scrollable
* distance), don't scroll. Defaults to false.
*/
explicit ScrollAxis(int16_t aWhere = SCROLL_MINIMUM,
WhenToScroll aWhen = SCROLL_IF_NOT_FULLY_VISIBLE,
bool aOnlyIfPerceivedScrollableDirection = false)
: mWhereToScroll(aWhere),
mWhenToScroll(aWhen),
mOnlyIfPerceivedScrollableDirection(
aOnlyIfPerceivedScrollableDirection) {}
} ScrollAxis;
/**
* Scrolls the view of the document so that the primary frame of the content
* is displayed in the window. Layout is flushed before scrolling.
*
* @param aContent The content object of which primary frame should be
* scrolled into view.
* @param aVertical How to align the frame vertically and when to do so.
* This is a ScrollAxis of Where and When.
* @param aHorizontal How to align the frame horizontally and when to do so.
* This is a ScrollAxis of Where and When.
* @param aFlags If SCROLL_FIRST_ANCESTOR_ONLY is set, only the nearest
* scrollable ancestor is scrolled, otherwise all
* scrollable ancestors may be scrolled if necessary.
* If SCROLL_OVERFLOW_HIDDEN is set then we may scroll in a
* direction even if overflow:hidden is specified in that
* direction; otherwise we will not scroll in that direction
* when overflow:hidden is set for that direction.
* If SCROLL_NO_PARENT_FRAMES is set then we only scroll
* nodes in this document, not in any parent documents which
* contain this document in a iframe or the like.
* If SCROLL_SMOOTH is set and CSSOM-VIEW scroll-behavior
* is enabled, we will scroll smoothly using
* nsIScrollableFrame::ScrollMode::SMOOTH_MSD; otherwise,
* nsIScrollableFrame::ScrollMode::INSTANT will be used.
* If SCROLL_SMOOTH_AUTO is set, the CSSOM-View
* scroll-behavior attribute is set to 'smooth' on the
* scroll frame, and CSSOM-VIEW scroll-behavior is enabled,
* we will scroll smoothly using
* nsIScrollableFrame::ScrollMode::SMOOTH_MSD; otherwise,
* nsIScrollableFrame::ScrollMode::INSTANT will be used.
*/
nsresult ScrollContentIntoView(nsIContent* aContent, ScrollAxis aVertical,
ScrollAxis aHorizontal, uint32_t aFlags);
enum {
SCROLL_FIRST_ANCESTOR_ONLY = 0x01,
SCROLL_OVERFLOW_HIDDEN = 0x02,
SCROLL_NO_PARENT_FRAMES = 0x04,
SCROLL_SMOOTH = 0x08,
SCROLL_SMOOTH_AUTO = 0x10,
SCROLL_SNAP = 0x20,
SCROLL_IGNORE_SCROLL_MARGIN_AND_PADDING = 0x40
};
/**
* Scrolls the view of the document so that the given area of a frame
* is visible, if possible. Layout is not flushed before scrolling.
*
* @param aRect relative to aFrame
* @param aVertical see ScrollContentIntoView and ScrollAxis
* @param aHorizontal see ScrollContentIntoView and ScrollAxis
* @param aFlags if SCROLL_FIRST_ANCESTOR_ONLY is set, only the
* nearest scrollable ancestor is scrolled, otherwise all
* scrollable ancestors may be scrolled if necessary
* if SCROLL_OVERFLOW_HIDDEN is set then we may scroll in a direction
* even if overflow:hidden is specified in that direction; otherwise
* we will not scroll in that direction when overflow:hidden is
* set for that direction
* If SCROLL_NO_PARENT_FRAMES is set then we only scroll
* nodes in this document, not in any parent documents which
* contain this document in a iframe or the like.
* If SCROLL_IGNORE_SCROLL_MARGIN_AND_PADDING is set we ignore scroll-margin
* value specified for |aFrame| and scroll-padding value for the scroll
* container. This option is typically used to locate poped-up frames into
* view.
* @return true if any scrolling happened, false if no scrolling happened
*/
bool ScrollFrameRectIntoView(nsIFrame* aFrame, const nsRect& aRect,
ScrollAxis aVertical, ScrollAxis aHorizontal,
uint32_t aFlags);
/**
* Determine if a rectangle specified in the frame's coordinate system
* intersects "enough" with the viewport to be considered visible. This
* is not a strict test against the viewport -- it's a test against
* the intersection of the viewport and the frame's ancestor scrollable
* frames. If it doesn't intersect enough, return a value indicating
* which direction the frame's topmost ancestor scrollable frame would
* need to be scrolled to bring the frame into view.
* @param aFrame frame that aRect coordinates are specified relative to
* @param aRect rectangle in twips to test for visibility
* @param aMinTwips is the minimum distance in from the edge of the
* visible area that an object must be to be counted
* visible
* @return nsRectVisibility_kVisible if the rect is visible
* nsRectVisibility_kAboveViewport
* nsRectVisibility_kBelowViewport
* nsRectVisibility_kLeftOfViewport
* nsRectVisibility_kRightOfViewport rectangle is outside the
* topmost ancestor scrollable frame in the specified direction
*/
virtual nsRectVisibility GetRectVisibility(nsIFrame* aFrame,
const nsRect& aRect,
nscoord aMinTwips) const = 0;
/**
* Suppress notification of the frame manager that frames are
* being destroyed.
*/
void SetIgnoreFrameDestruction(bool aIgnore);
/**
* Notification sent by a frame informing the pres shell that it is about to
* be destroyed.
* This allows any outstanding references to the frame to be cleaned up
*/
void NotifyDestroyingFrame(nsIFrame* aFrame);
/**
* Get the AccessibleCaretEventHub, if it exists. AddRefs it.
*/
already_AddRefed<mozilla::AccessibleCaretEventHub>
GetAccessibleCaretEventHub() const;
/**
* Get the caret, if it exists. AddRefs it.
*/
already_AddRefed<nsCaret> GetCaret() const;
/**
* Set the current caret to a new caret. To undo this, call RestoreCaret.
*/
void SetCaret(nsCaret* aNewCaret);
/**
* Restore the caret to the original caret that this pres shell was created
* with.
*/
void RestoreCaret();
/**
* Should the images have borders etc. Actual visual effects are determined
* by the frames. Visual effects may not effect layout, only display.
* Takes effect on next repaint, does not force a repaint itself.
*
* @param aInEnable if true, visual selection effects are enabled
* if false visual selection effects are disabled
*/
NS_IMETHOD SetSelectionFlags(int16_t aInEnable) = 0;
/**
* Gets the current state of non text selection effects
* @return current state of non text selection,
* as set by SetDisplayNonTextSelection
*/
int16_t GetSelectionFlags() const { return mSelectionFlags; }
virtual mozilla::dom::Selection* GetCurrentSelection(
mozilla::SelectionType aSelectionType) = 0;
/**
* Gets a selection controller for the focused content in the DOM window
* for mDocument.
*
* @param aFocusedContent If there is focused content in the DOM window,
* the focused content will be returned. This may
* be nullptr if it's not necessary.
* @return A selection controller for focused content.
* E.g., if an <input> element has focus, returns
* the independent selection controller of it.
* If the DOM window does not have focused content
* (similar to Document.activeElement), returns
* nullptr.
*/
virtual already_AddRefed<nsISelectionController>
GetSelectionControllerForFocusedContent(
nsIContent** aFocusedContent = nullptr) = 0;
/**
* Interface to dispatch events via the presshell
* @note The caller must have a strong reference to the PresShell.
*/
virtual nsresult HandleEventWithTarget(
mozilla::WidgetEvent* aEvent, nsIFrame* aFrame, nsIContent* aContent,
nsEventStatus* aStatus, bool aIsHandlingNativeEvent = false,
nsIContent** aTargetContent = nullptr,
nsIContent* aOverrideClickTarget = nullptr) = 0;
/**
* Dispatch event to content only (NOT full processing)
* @note The caller must have a strong reference to the PresShell.
*/
virtual nsresult HandleDOMEventWithTarget(nsIContent* aTargetContent,
mozilla::WidgetEvent* aEvent,
nsEventStatus* aStatus) = 0;
/**
* Dispatch event to content only (NOT full processing)
* @note The caller must have a strong reference to the PresShell.
*/
virtual nsresult HandleDOMEventWithTarget(nsIContent* aTargetContent,
mozilla::dom::Event* aEvent,
nsEventStatus* aStatus) = 0;
/**
* Return whether or not the event is valid to be dispatched
*/
virtual bool CanDispatchEvent(
const mozilla::WidgetGUIEvent* aEvent = nullptr) const = 0;
/**
* Gets the current target event frame from the PresShell
*/
nsIFrame* GetCurrentEventFrame();
/**
* Gets the current target event frame from the PresShell
*/
already_AddRefed<nsIContent> GetEventTargetContent(
mozilla::WidgetEvent* aEvent);
/**
* Get and set the history state for the current document
*/
virtual nsresult CaptureHistoryState(
nsILayoutHistoryState** aLayoutHistoryState) = 0;
/**
* Determine if reflow is currently locked
* returns true if reflow is locked, false otherwise
*/
bool IsReflowLocked() const { return mIsReflowing; }
/**
* Called to find out if painting is suppressed for this presshell. If it is
* suppressd, we don't allow the painting of any layer but the background, and
* we don't recur into our children.
*/
bool IsPaintingSuppressed() const { return mPaintingSuppressed; }
/**
* Pause painting by freezing the refresh driver of this and all parent
* presentations. This may not have the desired effect if this pres shell
* has its own refresh driver.
*/
virtual void PausePainting() = 0;
/**
* Resume painting by thawing the refresh driver of this and all parent
* presentations. This may not have the desired effect if this pres shell
* has its own refresh driver.
*/
virtual void ResumePainting() = 0;
/**
* Unsuppress painting.
*/
virtual void UnsuppressPainting() = 0;
/**
* Get the set of agent style sheets for this presentation
*/
virtual nsresult GetAgentStyleSheets(
nsTArray<RefPtr<mozilla::StyleSheet>>& aSheets) = 0;
/**
* Replace the set of agent style sheets
*/
virtual nsresult SetAgentStyleSheets(
const nsTArray<RefPtr<mozilla::StyleSheet>>& aSheets) = 0;
/**
* Add an override style sheet for this presentation
*/
virtual nsresult AddOverrideStyleSheet(mozilla::StyleSheet* aSheet) = 0;
/**
* Remove an override style sheet
*/
virtual nsresult RemoveOverrideStyleSheet(mozilla::StyleSheet* aSheet) = 0;
/**
* Reconstruct frames for all elements in the document
*/
virtual void ReconstructFrames() = 0;
/**
* Notify that a content node's state has changed
*/
virtual void ContentStateChanged(
Document* aDocument, nsIContent* aContent,
mozilla::EventStates aStateMask) override = 0;
/**
* See if reflow verification is enabled. To enable reflow verification add
* "verifyreflow:1" to your MOZ_LOG environment variable (any non-zero
* debug level will work). Or, call SetVerifyReflowEnable with true.
*/
static bool GetVerifyReflowEnable();
/**
* Set the verify-reflow enable flag.
*/
static void SetVerifyReflowEnable(bool aEnabled);
nsIFrame* GetAbsoluteContainingBlock(nsIFrame* aFrame);
#ifdef MOZ_REFLOW_PERF
virtual void DumpReflows() = 0;
virtual void CountReflows(const char* aName, nsIFrame* aFrame) = 0;
virtual void PaintCount(const char* aName, gfxContext* aRenderingContext,
nsPresContext* aPresContext, nsIFrame* aFrame,
const nsPoint& aOffset, uint32_t aColor) = 0;
virtual void SetPaintFrameCount(bool aOn) = 0;
virtual bool IsPaintingFrameCounts() = 0;
#endif
#ifdef DEBUG
// Debugging hooks
virtual void ListComputedStyles(FILE* out, int32_t aIndent = 0) = 0;
virtual void ListStyleSheets(FILE* out, int32_t aIndent = 0) = 0;
#endif
#ifdef ACCESSIBILITY
/**
* Return true if accessibility is active.
*/
static bool IsAccessibilityActive();
/**
* Return accessibility service if accessibility is active.
*/
static nsAccessibilityService* AccService();
#endif
/**
* Stop all active elements (plugins and the caret) in this presentation and
* in the presentations of subdocuments. Resets painting to a suppressed
* state.
* XXX this should include image animations
*/
virtual void Freeze() = 0;
bool IsFrozen() { return mFrozen; }
/**
* Restarts active elements (plugins) in this presentation and in the
* presentations of subdocuments, then do a full invalidate of the content
* area.
*/
virtual void Thaw() = 0;
virtual void FireOrClearDelayedEvents(bool aFireEvents) = 0;
/**
* When this shell is disconnected from its containing docshell, we
* lose our container pointer. However, we'd still like to be able to target
* user events at the docshell's parent. This pointer allows us to do that.
* It should not be used for any other purpose.
*/
void SetForwardingContainer(const mozilla::WeakPtr<nsDocShell>& aContainer);
/**
* Render the document into an arbitrary gfxContext
* Designed for getting a picture of a document or a piece of a document
* Note that callers will generally want to call FlushPendingNotifications
* to get an up-to-date view of the document
* @param aRect is the region to capture into the offscreen buffer, in the
* root frame's coordinate system (if aIgnoreViewportScrolling is false)
* or in the root scrolled frame's coordinate system
* (if aIgnoreViewportScrolling is true). The coordinates are in appunits.
* @param aFlags see below;
* set RENDER_IS_UNTRUSTED if the contents may be passed to malicious
* agents. E.g. we might choose not to paint the contents of sensitive widgets
* such as the file name in a file upload widget, and we might choose not
* to paint themes.
* set RENDER_IGNORE_VIEWPORT_SCROLLING to ignore
* clipping and scrollbar painting due to scrolling in the viewport
* set RENDER_CARET to draw the caret if one would be visible
* (by default the caret is never drawn)
* set RENDER_USE_LAYER_MANAGER to force rendering to go through
* the layer manager for the window. This may be unexpectedly slow
* (if the layer manager must read back data from the GPU) or low-quality
* (if the layer manager reads back pixel data and scales it
* instead of rendering using the appropriate scaling). It may also
* slow everything down if the area rendered does not correspond to the
* normal visible area of the window.
* set RENDER_ASYNC_DECODE_IMAGES to avoid having images synchronously
* decoded during rendering.
* (by default images decode synchronously with RenderDocument)
* set RENDER_DOCUMENT_RELATIVE to render the document as if there has been
* no scrolling and interpret |aRect| relative to the document instead of the
* CSS viewport. Only considered if RENDER_IGNORE_VIEWPORT_SCROLLING is set
* or the document is in ignore viewport scrolling mode
* (nsIPresShell::SetIgnoreViewportScrolling/IgnoringViewportScrolling).
* @param aBackgroundColor a background color to render onto
* @param aRenderedContext the gfxContext to render to. We render so that
* one CSS pixel in the source document is rendered to one unit in the current
* transform.
*/
enum {
RENDER_IS_UNTRUSTED = 0x01,
RENDER_IGNORE_VIEWPORT_SCROLLING = 0x02,
RENDER_CARET = 0x04,
RENDER_USE_WIDGET_LAYERS = 0x08,
RENDER_ASYNC_DECODE_IMAGES = 0x10,
RENDER_DOCUMENT_RELATIVE = 0x20,
RENDER_DRAWWINDOW_NOT_FLUSHING = 0x40
};
virtual nsresult RenderDocument(const nsRect& aRect, uint32_t aFlags,
nscolor aBackgroundColor,
gfxContext* aRenderedContext) = 0;
enum { RENDER_IS_IMAGE = 0x100, RENDER_AUTO_SCALE = 0x80 };
/**
* Renders a node aNode to a surface and returns it. The aRegion may be used
* to clip the rendering. This region is measured in CSS pixels from the
* edge of the presshell area. The aPoint, aScreenRect and aFlags arguments
* function in a similar manner as RenderSelection.
*/
virtual already_AddRefed<mozilla::gfx::SourceSurface> RenderNode(
nsINode* aNode, const mozilla::Maybe<mozilla::CSSIntRegion>& aRegion,
const mozilla::LayoutDeviceIntPoint aPoint,
mozilla::LayoutDeviceIntRect* aScreenRect, uint32_t aFlags) = 0;
/**
* Renders a selection to a surface and returns it. This method is primarily
* intended to create the drag feedback when dragging a selection.
*
* aScreenRect will be filled in with the bounding rectangle of the
* selection area on screen.
*
* If the area of the selection is large and the RENDER_AUTO_SCALE flag is
* set, the image will be scaled down. The argument aPoint is used in this
* case as a reference point when determining the new screen rectangle after
* scaling. Typically, this will be the mouse position, so that the screen
* rectangle is positioned such that the mouse is over the same point in the
* scaled image as in the original. When scaling does not occur, the mouse
* point isn't used because the position can be determined from the displayed
* frames.
*/
virtual already_AddRefed<mozilla::gfx::SourceSurface> RenderSelection(
mozilla::dom::Selection* aSelection,
const mozilla::LayoutDeviceIntPoint aPoint,
mozilla::LayoutDeviceIntRect* aScreenRect, uint32_t aFlags) = 0;
void AddAutoWeakFrame(AutoWeakFrame* aWeakFrame);
void AddWeakFrame(WeakFrame* aWeakFrame);
void RemoveAutoWeakFrame(AutoWeakFrame* aWeakFrame);
void RemoveWeakFrame(WeakFrame* aWeakFrame);
#ifdef DEBUG
nsIFrame* GetDrawEventTargetFrame() { return mDrawEventTargetFrame; }
#endif
/**
* Stop or restart non synthetic test mouse event handling on *all*
* presShells.
*
* @param aDisable If true, disable all non synthetic test mouse
* events on all presShells. Otherwise, enable them.
*/
virtual void DisableNonTestMouseEvents(bool aDisable) = 0;
/**
* Record the background color of the most recently drawn canvas. This color
* is composited on top of the user's default background color and then used
* to draw the background color of the canvas. See PresShell::Paint,
* PresShell::PaintDefaultBackground, and nsDocShell::SetupNewViewer;
* bug 488242, bug 476557 and other bugs mentioned there.
*/
void SetCanvasBackground(nscolor aColor) { mCanvasBackgroundColor = aColor; }
nscolor GetCanvasBackground() { return mCanvasBackgroundColor; }
/**
* Use the current frame tree (if it exists) to update the background
* color of the most recently drawn canvas.
*/
virtual void UpdateCanvasBackground() = 0;
/**
* Add a solid color item to the bottom of aList with frame aFrame and bounds
* aBounds. Checks first if this needs to be done by checking if aFrame is a
* canvas frame (if the FORCE_DRAW flag is passed then this check is skipped).
* aBackstopColor is composed behind the background color of the canvas, it is
* transparent by default.
*
* We attempt to make the background color part of the scrolled canvas (to
* reduce transparent layers), and if async scrolling is enabled (and the
* background is opaque) then we add a second, unscrolled item to handle the
* checkerboarding case.
*
* ADD_FOR_SUBDOC should be specified when calling this for a subdocument, and
* LayoutUseContainersForRootFrame might cause the whole list to be scrolled.
* In that case the second unscrolled item will be elided.
*
* APPEND_UNSCROLLED_ONLY only attempts to add the unscrolled item, so that
* we can add it manually after LayoutUseContainersForRootFrame has built the
* scrolling ContainerLayer.
*/
enum {
FORCE_DRAW = 0x01,
ADD_FOR_SUBDOC = 0x02,
APPEND_UNSCROLLED_ONLY = 0x04,
};
virtual void AddCanvasBackgroundColorItem(
nsDisplayListBuilder& aBuilder, nsDisplayList& aList, nsIFrame* aFrame,
const nsRect& aBounds, nscolor aBackstopColor = NS_RGBA(0, 0, 0, 0),
uint32_t aFlags = 0) = 0;
/**
* Add a solid color item to the bottom of aList with frame aFrame and
* bounds aBounds representing the dark grey background behind the page of a
* print preview presentation.
*/
virtual void AddPrintPreviewBackgroundItem(nsDisplayListBuilder& aBuilder,
nsDisplayList& aList,
nsIFrame* aFrame,
const nsRect& aBounds) = 0;
/**
* Computes the backstop color for the view: transparent if in a transparent
* widget, otherwise the PresContext default background color. This color is
* only visible if the contents of the view as a whole are translucent.
*/
virtual nscolor ComputeBackstopColor(nsView* aDisplayRoot) = 0;
void ObserveNativeAnonMutationsForPrint(bool aObserve) {
mObservesMutationsForPrint = aObserve;
}
bool ObservesNativeAnonMutationsForPrint() {
return mObservesMutationsForPrint;
}
virtual nsresult SetIsActive(bool aIsActive) = 0;
bool IsActive() { return mIsActive; }
// mouse capturing
static CapturingContentInfo gCaptureInfo;
/**
* When capturing content is set, it traps all mouse events and retargets
* them at this content node. If capturing is not allowed
* (gCaptureInfo.mAllowed is false), then capturing is not set. However, if
* the CAPTURE_IGNOREALLOWED flag is set, the allowed state is ignored and
* capturing is set regardless. To disable capture, pass null for the value
* of aContent.
*
* If CAPTURE_RETARGETTOELEMENT is set, all mouse events are targeted at
* aContent only. Otherwise, mouse events are targeted at aContent or its
* descendants. That is, descendants of aContent receive mouse events as
* they normally would, but mouse events outside of aContent are retargeted
* to aContent.
*
* If CAPTURE_PREVENTDRAG is set then drags are prevented from starting while
* this capture is active.
*
* If CAPTURE_POINTERLOCK is set, similar to CAPTURE_RETARGETTOELEMENT, then
* events are targeted at aContent, but capturing is held more strongly (i.e.,
* calls to SetCapturingContent won't unlock unless CAPTURE_POINTERLOCK is
* set again).
*/
static void SetCapturingContent(nsIContent* aContent, uint8_t aFlags);
/**
* Return the active content currently capturing the mouse if any.
*/
static nsIContent* GetCapturingContent() { return gCaptureInfo.mContent; }
/**
* Allow or disallow mouse capturing.
*/
static void AllowMouseCapture(bool aAllowed) {
gCaptureInfo.mAllowed = aAllowed;
}
/**
* Returns true if there is an active mouse capture that wants to prevent
* drags.
*/
static bool IsMouseCapturePreventingDrag() {
return gCaptureInfo.mPreventDrag && gCaptureInfo.mContent;
}
/**
* Keep track of how many times this presshell has been rendered to
* a window.
*/
uint64_t GetPaintCount() { return mPaintCount; }
void IncrementPaintCount() { ++mPaintCount; }
/**
* Get the root DOM window of this presShell.
*/
virtual already_AddRefed<nsPIDOMWindowOuter> GetRootWindow() = 0;
/**
* This returns the focused DOM window under our top level window.
* I.e., when we are deactive, this returns the *last* focused DOM window.
*/
virtual already_AddRefed<nsPIDOMWindowOuter>
GetFocusedDOMWindowInOurWindow() = 0;
/**
* Get the focused content under this window.
*/
already_AddRefed<nsIContent> GetFocusedContentInOurWindow() const;
/**
* Get the layer manager for the widget of the root view, if it has
* one.
*/
virtual LayerManager* GetLayerManager() = 0;
/**
* Return true iff there is a widget rendering this presShell and that
* widget is APZ-enabled.
*/
virtual bool AsyncPanZoomEnabled() = 0;
/**
* Track whether we're ignoring viewport scrolling for the purposes
* of painting. If we are ignoring, then layers aren't clipped to
* the CSS viewport and scrollbars aren't drawn.
*/
virtual void SetIgnoreViewportScrolling(bool aIgnore) = 0;
bool IgnoringViewportScrolling() const {
return mRenderFlags & STATE_IGNORING_VIEWPORT_SCROLLING;
}
/**
* Set a "resolution" for the document, which if not 1.0 will
* allocate more or fewer pixels for rescalable content by a factor
* of |resolution| in both dimensions. Return NS_OK iff the
* resolution bounds are sane, and the resolution of this was
* actually updated.
*
* Also increase the scale of the content by the same amount
* (that's the "AndScaleTo" part).
*
* The resolution defaults to 1.0.
*
* |aOrigin| specifies who originated the resolution change. For changes
* sent by APZ, pass ChangeOrigin::eApz. For changes sent by the main thread,
* use pass ChangeOrigin::eMainThread (similar to the |aOrigin| parameter of
* nsIScrollableFrame::ScrollToCSSPixels()).
*/
enum class ChangeOrigin : uint8_t {
eApz,
eMainThread,
};
virtual nsresult SetResolutionAndScaleTo(float aResolution,
ChangeOrigin aOrigin) = 0;
float GetResolution() const { return mResolution.valueOr(1.0); }
virtual float GetCumulativeResolution() = 0;
/**
* Accessors for a flag that tracks whether the most recent change to
* the pres shell's resolution was originated by the main thread.
*/
bool IsResolutionUpdated() const { return mResolutionUpdated; }
void SetResolutionUpdated(bool aUpdated) { mResolutionUpdated = aUpdated; }
/**
* Returns true if the resolution has ever been changed by APZ.
*/
bool IsResolutionUpdatedByApz() const { return mResolutionUpdatedByApz; }
/**
* Calculate the cumulative scale resolution from this document up to
* but not including the root document.
*/
virtual float GetCumulativeNonRootScaleResolution() = 0;
/**
* Used by session restore code to restore a resolution before the first
* paint.
*/
virtual void SetRestoreResolution(
float aResolution, mozilla::LayoutDeviceIntSize aDisplaySize) = 0;
/**
* Returns whether we are in a DrawWindow() call that used the
* DRAWWINDOW_DO_NOT_FLUSH flag.
*/
bool InDrawWindowNotFlushing() const {
return mRenderFlags & STATE_DRAWWINDOW_NOT_FLUSHING;
}
/**
* Set the isFirstPaint flag.
*/
void SetIsFirstPaint(bool aIsFirstPaint) { mIsFirstPaint = aIsFirstPaint; }
/**
* Get the isFirstPaint flag.
*/
bool GetIsFirstPaint() const { return mIsFirstPaint; }
uint32_t GetPresShellId() { return mPresShellId; }
/**
* Dispatch a mouse move event based on the most recent mouse position if
* this PresShell is visible. This is used when the contents of the page
* moved (aFromScroll is false) or scrolled (aFromScroll is true).
*/
virtual void SynthesizeMouseMove(bool aFromScroll) = 0;
enum PaintFlags {
/* Update the layer tree and paint PaintedLayers. If this is not specified,
* we may still have to do it if the layer tree lost PaintedLayer contents
* we need for compositing. */
PAINT_LAYERS = 0x01,
/* Composite layers to the window. */
PAINT_COMPOSITE = 0x02,
/* Sync-decode images. */
PAINT_SYNC_DECODE_IMAGES = 0x04
};
virtual void Paint(nsView* aViewToPaint, const nsRegion& aDirtyRegion,
uint32_t aFlags) = 0;
MOZ_CAN_RUN_SCRIPT
virtual nsresult HandleEvent(nsIFrame* aFrame,
mozilla::WidgetGUIEvent* aEvent,
bool aDontRetargetEvents,
nsEventStatus* aEventStatus) = 0;
virtual bool ShouldIgnoreInvalidation() = 0;
/**
* Notify that we're going to call Paint with PAINT_COMPOSITE.
* Fires on the presshell for the painted widget.
* This is issued at a time when it's safe to modify widget geometry.
*/
virtual void WillPaintWindow() = 0;
/**
* Notify that we called Paint with PAINT_COMPOSITE.
* Fires on the presshell for the painted widget.
* This is issued at a time when it's safe to modify widget geometry.
*/
virtual void DidPaintWindow() = 0;
/**
* Ensures that the refresh driver is running, and schedules a view
* manager flush on the next tick.
*
* @param aType PAINT_DELAYED_COMPRESS : Schedule a paint to be executed after
* a delay, and put FrameLayerBuilder in 'compressed' mode that avoids short
* cut optimizations.
*/
enum PaintType { PAINT_DEFAULT, PAINT_DELAYED_COMPRESS };
virtual void ScheduleViewManagerFlush(PaintType aType = PAINT_DEFAULT) = 0;
virtual void ClearMouseCaptureOnView(nsView* aView) = 0;
virtual bool IsVisible() = 0;
MOZ_CAN_RUN_SCRIPT
void DispatchSynthMouseMove(mozilla::WidgetGUIEvent* aEvent);
/* Temporarily ignore the Displayport for better paint performance. We
* trigger a repaint once suppression is disabled. Without that
* the displayport may get left at the suppressed size for an extended
* period of time and result in unnecessary checkerboarding (see bug
* 1255054). */
virtual void SuppressDisplayport(bool aEnabled) = 0;
/* Whether or not displayport suppression should be turned on. Note that
* this only affects the return value of |IsDisplayportSuppressed()|, and
* doesn't change the value of the internal counter.
*/
virtual void RespectDisplayportSuppression(bool aEnabled) = 0;
/* Whether or not the displayport is currently suppressed. */
virtual bool IsDisplayportSuppressed() = 0;
virtual void AddSizeOfIncludingThis(nsWindowSizes& aWindowSizes) const = 0;
/**
* Methods that retrieve the cached font inflation preferences.
*/
uint32_t FontSizeInflationEmPerLine() const {
return mFontSizeInflationEmPerLine;
}
uint32_t FontSizeInflationMinTwips() const {
return mFontSizeInflationMinTwips;
}
uint32_t FontSizeInflationLineThreshold() const {
return mFontSizeInflationLineThreshold;
}
bool FontSizeInflationForceEnabled() const {
return mFontSizeInflationForceEnabled;
}
bool FontSizeInflationDisabledInMasterProcess() const {
return mFontSizeInflationDisabledInMasterProcess;
}
bool FontSizeInflationEnabled() const { return mFontSizeInflationEnabled; }
/**
* Recomputes whether font-size inflation is enabled.
*/
void RecomputeFontSizeInflationEnabled();
/**
* Return true if the most recent interruptible reflow was interrupted.
*/
bool IsReflowInterrupted() const { return mWasLastReflowInterrupted; }
/**
* Return true if the the interruptible reflows have to be suppressed.
* This may happen only if if the most recent reflow was interrupted.
*/
bool SuppressInterruptibleReflows() const {
return mWasLastReflowInterrupted;
}
//////////////////////////////////////////////////////////////////////////////
// Approximate frame visibility tracking public API.
//////////////////////////////////////////////////////////////////////////////
/// Schedule an update of the list of approximately visible frames "soon".
/// This lets the refresh driver know that we want a visibility update in the
/// near future. The refresh driver applies its own heuristics and throttling
/// to decide when to actually perform the visibility update.
virtual void ScheduleApproximateFrameVisibilityUpdateSoon() = 0;
/// Schedule an update of the list of approximately visible frames "now". The
/// update runs asynchronously, but it will be posted to the event loop
/// immediately. Prefer the "soon" variation of this method when possible, as
/// this variation ignores the refresh driver's heuristics.
virtual void ScheduleApproximateFrameVisibilityUpdateNow() = 0;
/// Clears the current list of approximately visible frames on this pres shell
/// and replaces it with frames that are in the display list @aList.
virtual void RebuildApproximateFrameVisibilityDisplayList(
const nsDisplayList& aList) = 0;
virtual void RebuildApproximateFrameVisibility(nsRect* aRect = nullptr,
bool aRemoveOnly = false) = 0;
/// Ensures @aFrame is in the list of approximately visible frames.
virtual void EnsureFrameInApproximatelyVisibleList(nsIFrame* aFrame) = 0;
/// Removes @aFrame from the list of approximately visible frames if present.
virtual void RemoveFrameFromApproximatelyVisibleList(nsIFrame* aFrame) = 0;
/// Whether we should assume all frames are visible.
virtual bool AssumeAllFramesVisible() = 0;
/**
* Returns whether the document's style set's rule processor for the
* specified level of the cascade is shared by multiple style sets.
*
* @param aSheetType One of the nsIStyleSheetService.*_SHEET constants.
*/
nsresult HasRuleProcessorUsedByMultipleStyleSets(uint32_t aSheetType,
bool* aRetVal);
/**
* Returns whether or not the document has ever handled user input
*/
virtual bool HasHandledUserInput() const = 0;
virtual void FireResizeEvent() = 0;
void NativeAnonymousContentRemoved(nsIContent* aAnonContent);
/**
* See HTMLDocument.setKeyPressEventModel() in HTMLDocument.webidl for the
* detail.
*/
virtual void SetKeyPressEventModel(uint16_t aKeyPressEventModel) = 0;
protected:
/**
* Refresh observer management.
*/
void DoObserveStyleFlushes();
void DoObserveLayoutFlushes();
/**
* Does the actual work of figuring out the current state of font size
* inflation.
*/
bool DetermineFontSizeInflationState();
void RecordAlloc(void* aPtr) {
#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
MOZ_DIAGNOSTIC_ASSERT(!mAllocatedPointers.Contains(aPtr));
mAllocatedPointers.PutEntry(aPtr);
#endif
}
void RecordFree(void* aPtr) {
#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
MOZ_DIAGNOSTIC_ASSERT(mAllocatedPointers.Contains(aPtr));
mAllocatedPointers.RemoveEntry(aPtr);
#endif
}
void PushCurrentEventInfo(nsIFrame* aFrame, nsIContent* aContent);
void PopCurrentEventInfo();
nsIContent* GetCurrentEventContent();
public:
bool AddRefreshObserver(nsARefreshObserver* aObserver,
mozilla::FlushType aFlushType);
bool RemoveRefreshObserver(nsARefreshObserver* aObserver,
mozilla::FlushType aFlushType);
bool AddPostRefreshObserver(nsAPostRefreshObserver* aObserver);
bool RemovePostRefreshObserver(nsAPostRefreshObserver* aObserver);
// If a frame in the subtree rooted at aFrame is capturing the mouse then
// clears that capture.
static void ClearMouseCapture(nsIFrame* aFrame);
void SetVisualViewportSize(nscoord aWidth, nscoord aHeight);
void ResetVisualViewportSize();
bool IsVisualViewportSizeSet() { return mVisualViewportSizeSet; }
nsSize GetVisualViewportSize() {
NS_ASSERTION(mVisualViewportSizeSet,
"asking for visual viewport size when its not set?");
return mVisualViewportSize;
}
// This function handles all the work after VisualViewportSize is set
// or reset.
void CompleteChangeToVisualViewportSize();
/**
* The return value indicates whether the offset actually changed.
*/
bool SetVisualViewportOffset(const nsPoint& aScrollOffset,
const nsPoint& aPrevLayoutScrollPos);
nsPoint GetVisualViewportOffset() const {
return mVisualViewportOffset.valueOr(nsPoint());
}
bool IsVisualViewportOffsetSet() const {
return mVisualViewportOffset.isSome();
}
nsPoint GetVisualViewportOffsetRelativeToLayoutViewport() const;
// Represents an update to the visual scroll offset that will be sent to APZ.
// The update type is used to determine priority compared to other scroll
// updates.
struct VisualScrollUpdate {
nsPoint mVisualScrollOffset;
FrameMetrics::ScrollOffsetUpdateType mUpdateType;
};
// Ask APZ in the next transaction to scroll to the given visual viewport
// offset (relative to the document).
// Use this sparingly, as it will clobber JS-driven scrolling that happens
// in the same frame. This is mostly intended to be used in special
// situations like "first paint" or session restore.
// If scrolling "far away", i.e. not just within the existing layout
// viewport, it's recommended to use both nsIScrollableFrame.ScrollTo*()
// (via window.scrollTo if calling from JS) *and* this function; otherwise,
// temporary checkerboarding may result.
// Please request APZ review if adding a new call site.
void ScrollToVisual(const nsPoint& aVisualViewportOffset,
FrameMetrics::ScrollOffsetUpdateType aUpdateType,
mozilla::ScrollMode aMode);
void ClearPendingVisualScrollUpdate() {
mPendingVisualScrollUpdate = mozilla::Nothing();
}
const mozilla::Maybe<VisualScrollUpdate>& GetPendingVisualScrollUpdate()
const {
return mPendingVisualScrollUpdate;
}
nsPoint GetLayoutViewportOffset() const;
nsSize GetLayoutViewportSize() const;
virtual void WindowSizeMoveDone() = 0;
virtual void SysColorChanged() = 0;
virtual void ThemeChanged() = 0;
virtual void BackingScaleFactorChanged() = 0;
/**
* Documents belonging to an invisible DocShell must not be painted ever.
*/
bool IsNeverPainting() { return mIsNeverPainting; }
void SetNeverPainting(bool aNeverPainting) {
mIsNeverPainting = aNeverPainting;
}
/**
* True if a reflow event has been scheduled, or is going to be scheduled
* to run in the future.
*/
bool HasPendingReflow() const {
return mObservingLayoutFlushes || mReflowContinueTimer;
}
void SyncWindowProperties(nsView* aView);
virtual Document* GetPrimaryContentDocument() = 0;
// aSheetType is one of the nsIStyleSheetService *_SHEET constants.
void NotifyStyleSheetServiceSheetAdded(mozilla::StyleSheet* aSheet,
uint32_t aSheetType);
void NotifyStyleSheetServiceSheetRemoved(mozilla::StyleSheet* aSheet,
uint32_t aSheetType);
struct MOZ_RAII AutoAssertNoFlush {
explicit AutoAssertNoFlush(nsIPresShell& aShell)
: mShell(aShell), mOldForbidden(mShell.mForbiddenToFlush) {
mShell.mForbiddenToFlush = true;
}
~AutoAssertNoFlush() { mShell.mForbiddenToFlush = mOldForbidden; }
nsIPresShell& mShell;
const bool mOldForbidden;
};
protected:
friend class nsRefreshDriver;
friend class ::nsAutoCauseReflowNotifier;
void WillCauseReflow();
void DidCauseReflow();
void CancelPostedReflowCallbacks();
void FlushPendingScrollAnchorAdjustments();
void SetPendingVisualScrollUpdate(
const nsPoint& aVisualViewportOffset,
FrameMetrics::ScrollOffsetUpdateType aUpdateType);
#ifdef DEBUG
MOZ_CAN_RUN_SCRIPT_BOUNDARY bool VerifyIncrementalReflow();
MOZ_CAN_RUN_SCRIPT_BOUNDARY void DoVerifyReflow();
void VerifyHasDirtyRootAncestor(nsIFrame* aFrame);
void ShowEventTargetDebug();
bool mInVerifyReflow = false;
// The reflow root under which we're currently reflowing. Null when
// not in reflow.
nsIFrame* mCurrentReflowRoot = nullptr;
#endif
#ifdef MOZ_REFLOW_PERF
mozilla::UniquePtr<ReflowCountMgr> mReflowCountMgr;
#endif
// Helper for ScrollContentIntoView
void DoScrollContentIntoView();
/**
* Methods to handle changes to user and UA sheet lists that we get
* notified about.
*/
void AddUserSheet(mozilla::StyleSheet*);
void AddAgentSheet(mozilla::StyleSheet*);
void AddAuthorSheet(mozilla::StyleSheet*);
void RemoveSheet(mozilla::SheetType, mozilla::StyleSheet*);
void RemovePreferenceStyles();
void WillDoReflow();
// This data is stored as a content property (nsGkAtoms::scrolling) on
// mContentToScrollTo when we have a pending ScrollIntoView.
struct ScrollIntoViewData {
ScrollAxis mContentScrollVAxis;
ScrollAxis mContentScrollHAxis;
uint32_t mContentToScrollToFlags;
};
static mozilla::LazyLogModule gLog;
DOMHighResTimeStamp GetPerformanceNowUnclamped();
// The callback for the mReflowContinueTimer timer.
static void sReflowContinueCallback(nsITimer* aTimer, void* aPresShell);
bool ScheduleReflowOffTimer();
// MaybeScheduleReflow checks if posting a reflow is needed, then checks if
// the last reflow was interrupted. In the interrupted case ScheduleReflow is
// called off a timer, otherwise it is called directly.
void MaybeScheduleReflow();
// Actually schedules a reflow. This should only be called by
// MaybeScheduleReflow and the reflow timer ScheduleReflowOffTimer
// sets up.
void ScheduleReflow();
// DoReflow returns whether the reflow finished without interruption
// If aFrame is not the root frame, the caller must pass a non-null
// aOverflowTracker.
bool DoReflow(nsIFrame* aFrame, bool aInterruptible,
mozilla::OverflowChangedTracker* aOverflowTracker);
// IMPORTANT: The ownership implicit in the following member variables
// has been explicitly checked. If you add any members to this class,
// please make the ownership explicit (pinkerton, scc).
// These are the same Document and PresContext owned by the DocViewer.
// we must share ownership.
RefPtr<Document> mDocument;
RefPtr<nsPresContext> mPresContext;
// The document's style set owns it but we maintain a ref, may be null.
RefPtr<mozilla::StyleSheet> mPrefStyleSheet;
mozilla::UniquePtr<nsCSSFrameConstructor> mFrameConstructor;
nsViewManager* mViewManager; // [WEAK] docViewer owns it so I don't have to
nsPresArena<8192> mFrameArena;
RefPtr<nsFrameSelection> mSelection;
RefPtr<nsCaret> mCaret;
RefPtr<nsCaret> mOriginalCaret;
RefPtr<mozilla::AccessibleCaretEventHub> mAccessibleCaretEventHub;
// Pointer into mFrameConstructor - this is purely so that GetRootFrame() can
// be inlined:
nsFrameManager* mFrameManager;
mozilla::WeakPtr<nsDocShell> mForwardingContainer;
#ifdef ACCESSIBILITY
mozilla::a11y::DocAccessible* mDocAccessible;
#endif
// The `performance.now()` value when we last started to process reflows.
DOMHighResTimeStamp mLastReflowStart{0.0};
// At least on Win32 and Mac after interupting a reflow we need to post
// the resume reflow event off a timer to avoid event starvation because
// posted messages are processed before other messages when the modal
// moving/sizing loop is running, see bug 491700 for details.
nsCOMPtr<nsITimer> mReflowContinueTimer;
#ifdef DEBUG
nsIFrame* mDrawEventTargetFrame = nullptr;
#endif
#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
// We track allocated pointers in a debug-only hashtable to assert against
// missing/double frees.
nsTHashtable<nsPtrHashKey<void>> mAllocatedPointers;
#endif
nsCOMPtr<nsIContent> mLastAnchorScrolledTo;
// Information needed to properly handle scrolling content into view if the
// pre-scroll reflow flush can be interrupted. mContentToScrollTo is non-null
// between the initial scroll attempt and the first time we finish processing
// all our dirty roots. mContentToScrollTo has a content property storing the
// details for the scroll operation, see ScrollIntoViewData above.
nsCOMPtr<nsIContent> mContentToScrollTo;
nscoord mLastAnchorScrollPositionY = 0;
// Count of the number of times this presshell has been painted to a window.
uint64_t mPaintCount;
nsSize mVisualViewportSize;
mozilla::Maybe<nsPoint> mVisualViewportOffset;
// A pending visual scroll offset that we will ask APZ to scroll to
// during the next transaction. Cleared when we send the transaction.
// Only applicable to the RCD pres shell.
mozilla::Maybe<VisualScrollUpdate> mPendingVisualScrollUpdate;
// A list of stack weak frames. This is a pointer to the last item in the
// list.
AutoWeakFrame* mAutoWeakFrames;
// A hash table of heap allocated weak frames.
nsTHashtable<nsPtrHashKey<WeakFrame>> mWeakFrames;
class DirtyRootsList {
public:
// Add a dirty root.
void Add(nsIFrame* aFrame);
// Remove this frame if present.
void Remove(nsIFrame* aFrame);
// Remove and return one of the shallowest dirty roots from the list.
// (If two roots are at the same depth, order is indeterminate.)
nsIFrame* PopShallowestRoot();
// Remove all dirty roots.
void Clear();
// Is this frame one of the dirty roots?
bool Contains(nsIFrame* aFrame) const;
// Are there no dirty roots?
bool IsEmpty() const;
// Is the given frame an ancestor of any dirty root?
bool FrameIsAncestorOfDirtyRoot(nsIFrame* aFrame) const;
private:
struct FrameAndDepth {
nsIFrame* mFrame;
const uint32_t mDepth;
// Easy conversion to nsIFrame*, as it's the most likely need.
operator nsIFrame*() const { return mFrame; }
// Used to sort by reverse depths, i.e., deeper < shallower.
class CompareByReverseDepth {
public:
bool Equals(const FrameAndDepth& aA, const FrameAndDepth& aB) const {
return aA.mDepth == aB.mDepth;
}
bool LessThan(const FrameAndDepth& aA, const FrameAndDepth& aB) const {
// Reverse depth! So '>' instead of '<'.
return aA.mDepth > aB.mDepth;
}
};
};
// List of all known dirty roots, sorted by decreasing depths.
nsTArray<FrameAndDepth> mList;
};
// Reflow roots that need to be reflowed.
DirtyRootsList mDirtyRoots;
#ifdef MOZ_GECKO_PROFILER
// These two fields capture call stacks of any changes that require a restyle
// or a reflow. Only the first change per restyle / reflow is recorded (the
// one that caused a call to SetNeedStyleFlush() / SetNeedLayoutFlush()).
UniqueProfilerBacktrace mStyleCause;
UniqueProfilerBacktrace mReflowCause;
#endif
// Most recent canvas background color.
nscolor mCanvasBackgroundColor;
// Used to force allocation and rendering of proportionally more or
// less pixels in both dimensions.
mozilla::Maybe<float> mResolution;
int16_t mSelectionFlags;
// This is used to protect ourselves from triggering reflow while in the
// middle of frame construction and the like... it really shouldn't be
// needed, one hopes, but it is for now.
uint16_t mChangeNestCount;
// Flags controlling how our document is rendered. These persist
// between paints and so are tied with retained layer pixels.
// PresShell flushes retained layers when the rendering state
// changes in a way that prevents us from being able to (usefully)
// re-use old pixels.
RenderFlags mRenderFlags;
bool mDidInitialize : 1;
bool mIsDestroying : 1;
bool mIsReflowing : 1;
bool mIsObservingDocument : 1;
// Whether we shouldn't ever get to FlushPendingNotifications. This flag is
// meant only to sanity-check / assert that FlushPendingNotifications doesn't
// happen during certain periods of time. It shouldn't be made public nor used
// for other purposes.
bool mForbiddenToFlush : 1;
// We've been disconnected from the document. We will refuse to paint the
// document until either our timer fires or all frames are constructed.
bool mIsDocumentGone : 1;
bool mHaveShutDown : 1;
// For all documents we initially lock down painting.
bool mPaintingSuppressed : 1;
bool mLastRootReflowHadUnconstrainedBSize : 1;
// Indicates that it is safe to unlock painting once all pending reflows
// have been processed.
bool mShouldUnsuppressPainting : 1;
bool mIgnoreFrameDestruction : 1;
bool mIsActive : 1;
bool mFrozen : 1;
bool mIsFirstPaint : 1;
bool mObservesMutationsForPrint : 1;
// Whether the most recent interruptible reflow was actually interrupted:
bool mWasLastReflowInterrupted : 1;
bool mVisualViewportSizeSet : 1;
// True if a layout flush might not be a no-op
bool mNeedLayoutFlush : 1;
// True if a style flush might not be a no-op
bool mNeedStyleFlush : 1;
// True if we're observing the refresh driver for style flushes.
bool mObservingStyleFlushes : 1;
// True if we're observing the refresh driver for layout flushes, that is, if
// we have a reflow scheduled.
//
// Guaranteed to be false if mReflowContinueTimer is non-null.
bool mObservingLayoutFlushes : 1;
bool mResizeEventPending : 1;
// True if there are throttled animations that would be processed when
// performing a flush with mFlushAnimations == true.
bool mNeedThrottledAnimationFlush : 1;
bool mFontSizeInflationForceEnabled : 1;
bool mFontSizeInflationDisabledInMasterProcess : 1;
bool mFontSizeInflationEnabled : 1;
bool mPaintingIsFrozen : 1;
// If a document belongs to an invisible DocShell, this flag must be set
// to true, so we can avoid any paint calls for widget related to this
// presshell.
bool mIsNeverPainting : 1;
// Whether the most recent change to the pres shell resolution was
// originated by the main thread.
bool mResolutionUpdated : 1;
// True if the resolution has been ever changed by APZ.
bool mResolutionUpdatedByApz : 1;
uint32_t mPresShellId;
// Cached font inflation values. This is done to prevent changing of font
// inflation until a page is reloaded.
uint32_t mFontSizeInflationEmPerLine;
uint32_t mFontSizeInflationMinTwips;
uint32_t mFontSizeInflationLineThreshold;
// Whether we're currently under a FlushPendingNotifications.
// This is used to handle flush reentry correctly.
// NOTE: This can't be a bitfield since AutoRestore has a reference to this
// variable.
bool mInFlush;
nsIFrame* mCurrentEventFrame;
nsCOMPtr<nsIContent> mCurrentEventContent;
nsTArray<nsIFrame*> mCurrentEventFrameStack;
nsCOMArray<nsIContent> mCurrentEventContentStack;
// Set of frames that we should mark with NS_FRAME_HAS_DIRTY_CHILDREN after
// we finish reflowing mCurrentReflowRoot.
nsTHashtable<nsPtrHashKey<nsIFrame>> mFramesToDirty;
nsTHashtable<nsPtrHashKey<nsIScrollableFrame>> mPendingScrollAnchorSelection;
nsTHashtable<nsPtrHashKey<nsIScrollableFrame>> mPendingScrollAnchorAdjustment;
nsCallbackEventRequest* mFirstCallbackEventRequest = nullptr;
nsCallbackEventRequest* mLastCallbackEventRequest = nullptr;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsIPresShell, NS_IPRESSHELL_IID)
#endif /* nsIPresShell_h___ */
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку