summaryrefslogtreecommitdiffstats
path: root/dom/base/DOMIntersectionObserver.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/base/DOMIntersectionObserver.cpp')
-rw-r--r--dom/base/DOMIntersectionObserver.cpp839
1 files changed, 839 insertions, 0 deletions
diff --git a/dom/base/DOMIntersectionObserver.cpp b/dom/base/DOMIntersectionObserver.cpp
new file mode 100644
index 0000000000..9b34e261c4
--- /dev/null
+++ b/dom/base/DOMIntersectionObserver.cpp
@@ -0,0 +1,839 @@
+/* -*- 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/. */
+
+#include "DOMIntersectionObserver.h"
+#include "nsCSSPropertyID.h"
+#include "nsIFrame.h"
+#include "nsContainerFrame.h"
+#include "nsIScrollableFrame.h"
+#include "nsContentUtils.h"
+#include "nsLayoutUtils.h"
+#include "nsRefreshDriver.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "mozilla/ServoBindings.h"
+#include "mozilla/dom/BrowserChild.h"
+#include "mozilla/dom/BrowsingContext.h"
+#include "mozilla/dom/DocumentInlines.h"
+#include "mozilla/dom/HTMLImageElement.h"
+#include "Units.h"
+
+namespace mozilla::dom {
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DOMIntersectionObserverEntry)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(DOMIntersectionObserverEntry)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(DOMIntersectionObserverEntry)
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(DOMIntersectionObserverEntry, mOwner,
+ mRootBounds, mBoundingClientRect,
+ mIntersectionRect, mTarget)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DOMIntersectionObserver)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+ NS_INTERFACE_MAP_ENTRY(DOMIntersectionObserver)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(DOMIntersectionObserver)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(DOMIntersectionObserver)
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(DOMIntersectionObserver)
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(DOMIntersectionObserver)
+ NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(DOMIntersectionObserver)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+ tmp->Disconnect();
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mOwner)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocument)
+ if (tmp->mCallback.is<RefPtr<dom::IntersectionCallback>>()) {
+ ImplCycleCollectionUnlink(
+ tmp->mCallback.as<RefPtr<dom::IntersectionCallback>>());
+ }
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mRoot)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mQueuedEntries)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(DOMIntersectionObserver)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOwner)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocument)
+ if (tmp->mCallback.is<RefPtr<dom::IntersectionCallback>>()) {
+ ImplCycleCollectionTraverse(
+ cb, tmp->mCallback.as<RefPtr<dom::IntersectionCallback>>(), "mCallback",
+ 0);
+ }
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRoot)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mQueuedEntries)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+DOMIntersectionObserver::DOMIntersectionObserver(
+ already_AddRefed<nsPIDOMWindowInner>&& aOwner,
+ dom::IntersectionCallback& aCb)
+ : mOwner(aOwner),
+ mDocument(mOwner->GetExtantDoc()),
+ mCallback(RefPtr<dom::IntersectionCallback>(&aCb)),
+ mConnected(false) {}
+
+already_AddRefed<DOMIntersectionObserver> DOMIntersectionObserver::Constructor(
+ const GlobalObject& aGlobal, dom::IntersectionCallback& aCb,
+ ErrorResult& aRv) {
+ return Constructor(aGlobal, aCb, IntersectionObserverInit(), aRv);
+}
+
+already_AddRefed<DOMIntersectionObserver> DOMIntersectionObserver::Constructor(
+ const GlobalObject& aGlobal, dom::IntersectionCallback& aCb,
+ const IntersectionObserverInit& aOptions, ErrorResult& aRv) {
+ nsCOMPtr<nsPIDOMWindowInner> window =
+ do_QueryInterface(aGlobal.GetAsSupports());
+ if (!window) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+ RefPtr<DOMIntersectionObserver> observer =
+ new DOMIntersectionObserver(window.forget(), aCb);
+
+ if (!aOptions.mRoot.IsNull()) {
+ if (aOptions.mRoot.Value().IsElement()) {
+ observer->mRoot = aOptions.mRoot.Value().GetAsElement();
+ } else {
+ MOZ_ASSERT(aOptions.mRoot.Value().IsDocument());
+ observer->mRoot = aOptions.mRoot.Value().GetAsDocument();
+ }
+ }
+
+ if (!observer->SetRootMargin(aOptions.mRootMargin)) {
+ aRv.ThrowSyntaxError("rootMargin must be specified in pixels or percent.");
+ return nullptr;
+ }
+
+ if (aOptions.mThreshold.IsDoubleSequence()) {
+ const Sequence<double>& thresholds =
+ aOptions.mThreshold.GetAsDoubleSequence();
+ observer->mThresholds.SetCapacity(thresholds.Length());
+ for (const auto& thresh : thresholds) {
+ if (thresh < 0.0 || thresh > 1.0) {
+ aRv.ThrowRangeError<dom::MSG_THRESHOLD_RANGE_ERROR>();
+ return nullptr;
+ }
+ observer->mThresholds.AppendElement(thresh);
+ }
+ observer->mThresholds.Sort();
+ } else {
+ double thresh = aOptions.mThreshold.GetAsDouble();
+ if (thresh < 0.0 || thresh > 1.0) {
+ aRv.ThrowRangeError<dom::MSG_THRESHOLD_RANGE_ERROR>();
+ return nullptr;
+ }
+ observer->mThresholds.AppendElement(thresh);
+ }
+
+ return observer.forget();
+}
+
+static void LazyLoadCallback(
+ const Sequence<OwningNonNull<DOMIntersectionObserverEntry>>& aEntries) {
+ for (const auto& entry : aEntries) {
+ MOZ_ASSERT(entry->Target()->IsHTMLElement(nsGkAtoms::img));
+ if (entry->IsIntersecting()) {
+ static_cast<HTMLImageElement*>(entry->Target())
+ ->StopLazyLoading(HTMLImageElement::StartLoading::Yes);
+ }
+ }
+}
+
+static void ContentVisibilityCallback(
+ const Sequence<OwningNonNull<DOMIntersectionObserverEntry>>& aEntries) {
+ for (const auto& entry : aEntries) {
+ entry->Target()->SetVisibleForContentVisibility(entry->IsIntersecting());
+
+ if (RefPtr<Document> doc = entry->Target()->GetComposedDoc()) {
+ if (RefPtr<PresShell> presShell = doc->GetPresShell()) {
+ presShell->ScheduleContentRelevancyUpdate(
+ ContentRelevancyReason::Visible);
+ }
+ }
+ }
+}
+
+static LengthPercentage PrefMargin(float aValue, bool aIsPercentage) {
+ return aIsPercentage ? LengthPercentage::FromPercentage(aValue / 100.0f)
+ : LengthPercentage::FromPixels(aValue);
+}
+
+DOMIntersectionObserver::DOMIntersectionObserver(Document& aDocument,
+ NativeCallback aCallback)
+ : mOwner(aDocument.GetInnerWindow()),
+ mDocument(&aDocument),
+ mCallback(aCallback),
+ mConnected(false) {}
+
+already_AddRefed<DOMIntersectionObserver>
+DOMIntersectionObserver::CreateLazyLoadObserver(Document& aDocument) {
+ RefPtr<DOMIntersectionObserver> observer =
+ new DOMIntersectionObserver(aDocument, LazyLoadCallback);
+ observer->mThresholds.AppendElement(0.0f);
+
+#define SET_MARGIN(side_, side_lower_) \
+ observer->mRootMargin.Get(eSide##side_) = PrefMargin( \
+ StaticPrefs::dom_image_lazy_loading_root_margin_##side_lower_(), \
+ StaticPrefs:: \
+ dom_image_lazy_loading_root_margin_##side_lower_##_percentage());
+ SET_MARGIN(Top, top);
+ SET_MARGIN(Right, right);
+ SET_MARGIN(Bottom, bottom);
+ SET_MARGIN(Left, left);
+#undef SET_MARGIN
+
+ return observer.forget();
+}
+
+already_AddRefed<DOMIntersectionObserver>
+DOMIntersectionObserver::CreateContentVisibilityObserver(Document& aDocument) {
+ RefPtr<DOMIntersectionObserver> observer =
+ new DOMIntersectionObserver(aDocument, ContentVisibilityCallback);
+
+ observer->mThresholds.AppendElement(0.0f);
+
+ auto margin = LengthPercentage::FromPercentage(
+ StaticPrefs::layout_css_content_visibility_relevant_content_margin() /
+ 100.0f);
+
+ observer->mRootMargin.Get(eSideTop) = margin;
+ observer->mRootMargin.Get(eSideRight) = margin;
+ observer->mRootMargin.Get(eSideBottom) = margin;
+ observer->mRootMargin.Get(eSideLeft) = margin;
+
+ return observer.forget();
+}
+
+bool DOMIntersectionObserver::SetRootMargin(const nsACString& aString) {
+ return Servo_IntersectionObserverRootMargin_Parse(&aString, &mRootMargin);
+}
+
+nsISupports* DOMIntersectionObserver::GetParentObject() const { return mOwner; }
+
+void DOMIntersectionObserver::GetRootMargin(nsACString& aRetVal) {
+ Servo_IntersectionObserverRootMargin_ToString(&mRootMargin, &aRetVal);
+}
+
+void DOMIntersectionObserver::GetThresholds(nsTArray<double>& aRetVal) {
+ aRetVal = mThresholds.Clone();
+}
+
+void DOMIntersectionObserver::Observe(Element& aTarget) {
+ if (!mObservationTargetSet.EnsureInserted(&aTarget)) {
+ return;
+ }
+ aTarget.RegisterIntersectionObserver(this);
+ mObservationTargets.AppendElement(&aTarget);
+
+ MOZ_ASSERT(mObservationTargets.Length() == mObservationTargetSet.Count());
+
+ Connect();
+ if (mDocument) {
+ if (nsPresContext* pc = mDocument->GetPresContext()) {
+ pc->RefreshDriver()->EnsureIntersectionObservationsUpdateHappens();
+ }
+ }
+}
+
+void DOMIntersectionObserver::Unobserve(Element& aTarget) {
+ if (!mObservationTargetSet.EnsureRemoved(&aTarget)) {
+ return;
+ }
+
+ mObservationTargets.RemoveElement(&aTarget);
+ aTarget.UnregisterIntersectionObserver(this);
+
+ MOZ_ASSERT(mObservationTargets.Length() == mObservationTargetSet.Count());
+
+ if (mObservationTargets.IsEmpty()) {
+ Disconnect();
+ }
+}
+
+void DOMIntersectionObserver::UnlinkTarget(Element& aTarget) {
+ mObservationTargets.RemoveElement(&aTarget);
+ mObservationTargetSet.Remove(&aTarget);
+ if (mObservationTargets.IsEmpty()) {
+ Disconnect();
+ }
+}
+
+void DOMIntersectionObserver::Connect() {
+ if (mConnected) {
+ return;
+ }
+
+ mConnected = true;
+ if (mDocument) {
+ mDocument->AddIntersectionObserver(this);
+ }
+}
+
+void DOMIntersectionObserver::Disconnect() {
+ if (!mConnected) {
+ return;
+ }
+
+ mConnected = false;
+ for (Element* target : mObservationTargets) {
+ target->UnregisterIntersectionObserver(this);
+ }
+ mObservationTargets.Clear();
+ mObservationTargetSet.Clear();
+ if (mDocument) {
+ mDocument->RemoveIntersectionObserver(this);
+ }
+}
+
+void DOMIntersectionObserver::TakeRecords(
+ nsTArray<RefPtr<DOMIntersectionObserverEntry>>& aRetVal) {
+ aRetVal = std::move(mQueuedEntries);
+}
+
+static Maybe<nsRect> EdgeInclusiveIntersection(const nsRect& aRect,
+ const nsRect& aOtherRect) {
+ nscoord left = std::max(aRect.x, aOtherRect.x);
+ nscoord top = std::max(aRect.y, aOtherRect.y);
+ nscoord right = std::min(aRect.XMost(), aOtherRect.XMost());
+ nscoord bottom = std::min(aRect.YMost(), aOtherRect.YMost());
+ if (left > right || top > bottom) {
+ return Nothing();
+ }
+ return Some(nsRect(left, top, right - left, bottom - top));
+}
+
+enum class BrowsingContextOrigin { Similar, Different };
+
+// NOTE(emilio): Checking docgroup as per discussion in:
+// https://github.com/w3c/IntersectionObserver/issues/161
+static BrowsingContextOrigin SimilarOrigin(const Element& aTarget,
+ const nsINode* aRoot) {
+ if (!aRoot) {
+ return BrowsingContextOrigin::Different;
+ }
+ return aTarget.OwnerDoc()->GetDocGroup() == aRoot->OwnerDoc()->GetDocGroup()
+ ? BrowsingContextOrigin::Similar
+ : BrowsingContextOrigin::Different;
+}
+
+// NOTE: This returns nullptr if |aDocument| is in another process from the top
+// level content document.
+static const Document* GetTopLevelContentDocumentInThisProcess(
+ const Document& aDocument) {
+ auto* wc = aDocument.GetTopLevelWindowContext();
+ return wc ? wc->GetExtantDoc() : nullptr;
+}
+
+// https://w3c.github.io/IntersectionObserver/#compute-the-intersection
+//
+// TODO(emilio): Proof of this being equivalent to the spec welcome, seems
+// reasonably close.
+//
+// Also, it's unclear to me why the spec talks about browsing context while
+// discarding observations of targets of different documents.
+//
+// Both aRootBounds and the return value are relative to
+// nsLayoutUtils::GetContainingBlockForClientRect(aRoot).
+//
+// In case of out-of-process document, aRemoteDocumentVisibleRect is a rectangle
+// in the out-of-process document's coordinate system.
+static Maybe<nsRect> ComputeTheIntersection(
+ nsIFrame* aTarget, nsIFrame* aRoot, const nsRect& aRootBounds,
+ const Maybe<nsRect>& aRemoteDocumentVisibleRect) {
+ nsIFrame* target = aTarget;
+ // 1. Let intersectionRect be the result of running the
+ // getBoundingClientRect() algorithm on the target.
+ //
+ // `intersectionRect` is kept relative to `target` during the loop.
+ Maybe<nsRect> intersectionRect = Some(nsLayoutUtils::GetAllInFlowRectsUnion(
+ target, target, nsLayoutUtils::RECTS_ACCOUNT_FOR_TRANSFORMS));
+
+ // 2. Let container be the containing block of the target.
+ // (We go through the parent chain and only look at scroll frames)
+ //
+ // FIXME(emilio): Spec uses containing blocks, we use scroll frames, but we
+ // only apply overflow-clipping, not clip-path, so it's ~fine. We do need to
+ // apply clip-path.
+ //
+ // 3. While container is not the intersection root:
+ nsIFrame* containerFrame =
+ nsLayoutUtils::GetCrossDocParentFrameInProcess(target);
+ while (containerFrame && containerFrame != aRoot) {
+ // FIXME(emilio): What about other scroll frames that inherit from
+ // nsHTMLScrollFrame but have a different type, like nsListControlFrame?
+ // This looks bogus in that case, but different bug.
+ if (nsIScrollableFrame* scrollFrame = do_QueryFrame(containerFrame)) {
+ if (containerFrame->GetParent() == aRoot && !aRoot->GetParent()) {
+ // This is subtle: if we're computing the intersection against the
+ // viewport (the root frame), and this is its scroll frame, we really
+ // want to skip this intersection (because we want to account for the
+ // root margin, which is already in aRootBounds).
+ break;
+ }
+ nsRect subFrameRect = scrollFrame->GetScrollPortRect();
+
+ // 3.1 Map intersectionRect to the coordinate space of container.
+ nsRect intersectionRectRelativeToContainer =
+ nsLayoutUtils::TransformFrameRectToAncestor(
+ target, intersectionRect.value(), containerFrame);
+
+ // 3.2 If container has overflow clipping or a css clip-path property,
+ // update intersectionRect by applying container's clip.
+ //
+ // 3.3 is handled, looks like, by this same clipping, given the root
+ // scroll-frame cannot escape the viewport, probably?
+ intersectionRect = EdgeInclusiveIntersection(
+ intersectionRectRelativeToContainer, subFrameRect);
+ if (!intersectionRect) {
+ return Nothing();
+ }
+ target = containerFrame;
+ } else {
+ const auto& disp = *containerFrame->StyleDisplay();
+ auto clipAxes = containerFrame->ShouldApplyOverflowClipping(&disp);
+ // 3.2 TODO: Apply clip-path.
+ if (clipAxes != PhysicalAxes::None) {
+ // 3.1 Map intersectionRect to the coordinate space of container.
+ const nsRect intersectionRectRelativeToContainer =
+ nsLayoutUtils::TransformFrameRectToAncestor(
+ target, intersectionRect.value(), containerFrame);
+ const nsRect clipRect = OverflowAreas::GetOverflowClipRect(
+ intersectionRectRelativeToContainer,
+ containerFrame->GetRectRelativeToSelf(), clipAxes,
+ containerFrame->OverflowClipMargin(clipAxes));
+ intersectionRect = EdgeInclusiveIntersection(
+ intersectionRectRelativeToContainer, clipRect);
+ if (!intersectionRect) {
+ return Nothing();
+ }
+ target = containerFrame;
+ }
+ }
+ containerFrame =
+ nsLayoutUtils::GetCrossDocParentFrameInProcess(containerFrame);
+ }
+ MOZ_ASSERT(intersectionRect);
+
+ // 4. Map intersectionRect to the coordinate space of the intersection root.
+ nsRect intersectionRectRelativeToRoot =
+ nsLayoutUtils::TransformFrameRectToAncestor(
+ target, intersectionRect.value(),
+ nsLayoutUtils::GetContainingBlockForClientRect(aRoot));
+
+ // 5.Update intersectionRect by intersecting it with the root intersection
+ // rectangle.
+ intersectionRect =
+ EdgeInclusiveIntersection(intersectionRectRelativeToRoot, aRootBounds);
+ if (intersectionRect.isNothing()) {
+ return Nothing();
+ }
+ // 6. Map intersectionRect to the coordinate space of the viewport of the
+ // Document containing the target.
+ //
+ // FIXME(emilio): I think this may not be correct if the root is explicit
+ // and in the same document, since then the rectangle may not be relative to
+ // the viewport already (but it's in the same document).
+ nsRect rect = intersectionRect.value();
+ if (aTarget->PresContext() != aRoot->PresContext()) {
+ if (nsIFrame* rootScrollFrame =
+ aTarget->PresShell()->GetRootScrollFrame()) {
+ nsLayoutUtils::TransformRect(aRoot, rootScrollFrame, rect);
+ }
+ }
+
+ // In out-of-process iframes we need to take an intersection with the remote
+ // document visible rect which was already clipped by ancestor document's
+ // viewports.
+ if (aRemoteDocumentVisibleRect) {
+ MOZ_ASSERT(aRoot->PresContext()->IsRootContentDocumentInProcess() &&
+ !aRoot->PresContext()->IsRootContentDocumentCrossProcess());
+
+ intersectionRect =
+ EdgeInclusiveIntersection(rect, *aRemoteDocumentVisibleRect);
+ if (intersectionRect.isNothing()) {
+ return Nothing();
+ }
+ rect = intersectionRect.value();
+ }
+
+ return Some(rect);
+}
+
+struct OopIframeMetrics {
+ nsIFrame* mInProcessRootFrame = nullptr;
+ nsRect mInProcessRootRect;
+ nsRect mRemoteDocumentVisibleRect;
+};
+
+static Maybe<OopIframeMetrics> GetOopIframeMetrics(
+ const Document& aDocument, const Document* aRootDocument) {
+ const Document* rootDoc =
+ nsContentUtils::GetInProcessSubtreeRootDocument(&aDocument);
+ MOZ_ASSERT(rootDoc);
+
+ if (rootDoc->IsTopLevelContentDocument()) {
+ return Nothing();
+ }
+
+ if (aRootDocument &&
+ rootDoc ==
+ nsContentUtils::GetInProcessSubtreeRootDocument(aRootDocument)) {
+ // aRootDoc, if non-null, is either the implicit root
+ // (top-level-content-document) or a same-origin document passed explicitly.
+ //
+ // In the former case, we should've returned above if there are no iframes
+ // in between. This condition handles the explicit, same-origin root
+ // document, when both are embedded in an OOP iframe.
+ return Nothing();
+ }
+
+ PresShell* rootPresShell = rootDoc->GetPresShell();
+ if (!rootPresShell || rootPresShell->IsDestroying()) {
+ return Some(OopIframeMetrics{});
+ }
+
+ nsIFrame* inProcessRootFrame = rootPresShell->GetRootFrame();
+ if (!inProcessRootFrame) {
+ return Some(OopIframeMetrics{});
+ }
+
+ BrowserChild* browserChild = BrowserChild::GetFrom(rootDoc->GetDocShell());
+ if (!browserChild) {
+ return Some(OopIframeMetrics{});
+ }
+
+ if (MOZ_UNLIKELY(browserChild->IsTopLevel())) {
+ // FIXME(bug 1772083): This can be hit, but it's unclear how... When can we
+ // have a top-level BrowserChild for a document that isn't a top-level
+ // content document?
+ MOZ_ASSERT_UNREACHABLE("Top level BrowserChild w/ non-top level Document?");
+ return Nothing();
+ }
+
+ nsRect inProcessRootRect;
+ if (nsIScrollableFrame* scrollFrame =
+ rootPresShell->GetRootScrollFrameAsScrollable()) {
+ inProcessRootRect = scrollFrame->GetScrollPortRect();
+ }
+
+ Maybe<LayoutDeviceRect> remoteDocumentVisibleRect =
+ browserChild->GetTopLevelViewportVisibleRectInSelfCoords();
+ if (!remoteDocumentVisibleRect) {
+ return Some(OopIframeMetrics{});
+ }
+
+ return Some(OopIframeMetrics{
+ inProcessRootFrame,
+ inProcessRootRect,
+ LayoutDeviceRect::ToAppUnits(
+ *remoteDocumentVisibleRect,
+ rootPresShell->GetPresContext()->AppUnitsPerDevPixel()),
+ });
+}
+
+// https://w3c.github.io/IntersectionObserver/#update-intersection-observations-algo
+// step 2.1
+IntersectionInput DOMIntersectionObserver::ComputeInput(
+ const Document& aDocument, const nsINode* aRoot,
+ const StyleRect<LengthPercentage>* aRootMargin) {
+ // 1 - Let rootBounds be observer's root intersection rectangle.
+ // ... but since the intersection rectangle depends on the target, we defer
+ // the inflation until later.
+ // NOTE: |rootRect| and |rootFrame| will be root in the same process. In
+ // out-of-process iframes, they are NOT root ones of the top level content
+ // document.
+ nsRect rootRect;
+ nsIFrame* rootFrame = nullptr;
+ const nsINode* root = aRoot;
+ const bool isImplicitRoot = !aRoot;
+ Maybe<nsRect> remoteDocumentVisibleRect;
+ if (aRoot && aRoot->IsElement()) {
+ if ((rootFrame = aRoot->AsElement()->GetPrimaryFrame())) {
+ nsRect rootRectRelativeToRootFrame;
+ if (nsIScrollableFrame* scrollFrame = do_QueryFrame(rootFrame)) {
+ // rootRectRelativeToRootFrame should be the content rect of rootFrame,
+ // not including the scrollbars.
+ rootRectRelativeToRootFrame = scrollFrame->GetScrollPortRect();
+ } else {
+ // rootRectRelativeToRootFrame should be the border rect of rootFrame.
+ rootRectRelativeToRootFrame = rootFrame->GetRectRelativeToSelf();
+ }
+ nsIFrame* containingBlock =
+ nsLayoutUtils::GetContainingBlockForClientRect(rootFrame);
+ rootRect = nsLayoutUtils::TransformFrameRectToAncestor(
+ rootFrame, rootRectRelativeToRootFrame, containingBlock);
+ }
+ } else {
+ MOZ_ASSERT(!aRoot || aRoot->IsDocument());
+ const Document* rootDocument =
+ aRoot ? aRoot->AsDocument()
+ : GetTopLevelContentDocumentInThisProcess(aDocument);
+ root = rootDocument;
+
+ if (rootDocument) {
+ // We're in the same process as the root document, though note that there
+ // could be an out-of-process iframe in between us and the root. Grab the
+ // root frame and the root rect.
+ //
+ // Note that the root rect is always good (we assume no DPI changes in
+ // between the two documents, and we don't need to convert coordinates).
+ //
+ // The root frame however we may need to tweak in the block below, if
+ // there's any OOP iframe in between `rootDocument` and `aDocument`, to
+ // handle the OOP iframe positions.
+ if (PresShell* presShell = rootDocument->GetPresShell()) {
+ rootFrame = presShell->GetRootFrame();
+ // We use the root scrollable frame's scroll port to account the
+ // scrollbars in rootRect, if needed.
+ if (nsIScrollableFrame* scrollFrame =
+ presShell->GetRootScrollFrameAsScrollable()) {
+ rootRect = scrollFrame->GetScrollPortRect();
+ } else if (rootFrame) {
+ rootRect = rootFrame->GetRectRelativeToSelf();
+ }
+ }
+ }
+
+ if (Maybe<OopIframeMetrics> metrics =
+ GetOopIframeMetrics(aDocument, rootDocument)) {
+ rootFrame = metrics->mInProcessRootFrame;
+ if (!rootDocument) {
+ rootRect = metrics->mInProcessRootRect;
+ }
+ remoteDocumentVisibleRect = Some(metrics->mRemoteDocumentVisibleRect);
+ }
+ }
+
+ nsMargin rootMargin; // This root margin is NOT applied in `implicit root`
+ // case, e.g. in out-of-process iframes.
+ if (aRootMargin) {
+ for (const auto side : mozilla::AllPhysicalSides()) {
+ nscoord basis = side == eSideTop || side == eSideBottom
+ ? rootRect.Height()
+ : rootRect.Width();
+ rootMargin.Side(side) = aRootMargin->Get(side).Resolve(
+ basis, static_cast<nscoord (*)(float)>(NSToCoordRoundWithClamp));
+ }
+ }
+ return {isImplicitRoot, root, rootFrame,
+ rootRect, rootMargin, remoteDocumentVisibleRect};
+}
+
+// https://w3c.github.io/IntersectionObserver/#update-intersection-observations-algo
+// (steps 2.1 - 2.5)
+IntersectionOutput DOMIntersectionObserver::Intersect(
+ const IntersectionInput& aInput, Element& aTarget,
+ IgnoreContentVisibility aIgnoreContentVisibility) {
+ const bool isSimilarOrigin = SimilarOrigin(aTarget, aInput.mRootNode) ==
+ BrowsingContextOrigin::Similar;
+ nsIFrame* targetFrame = aTarget.GetPrimaryFrame();
+ if (!targetFrame || !aInput.mRootFrame) {
+ return {isSimilarOrigin};
+ }
+
+ // "From the perspective of an IntersectionObserver, the skipped contents
+ // of an element are never intersecting the intersection root. This is
+ // true even if both the root and the target elements are in the skipped
+ // contents."
+ // https://drafts.csswg.org/css-contain/#cv-notes
+ //
+ // Skip the intersection if the element is hidden, unless this is the
+ // DOMIntersectionObserver used specifically to track the visibility of
+ // `content-visibility: auto` elements.
+ if (aIgnoreContentVisibility == IgnoreContentVisibility::No &&
+ targetFrame->IsHiddenByContentVisibilityOnAnyAncestor()) {
+ return {isSimilarOrigin};
+ }
+
+ // 2.2. If the intersection root is not the implicit root, and target is
+ // not in the same Document as the intersection root, skip to step 11.
+ if (!aInput.mIsImplicitRoot &&
+ aInput.mRootNode->OwnerDoc() != aTarget.OwnerDoc()) {
+ return {isSimilarOrigin};
+ }
+
+ // 2.3. If the intersection root is an element and target is not a descendant
+ // of the intersection root in the containing block chain, skip to step 11.
+ //
+ // NOTE(emilio): We also do this if target is the implicit root, pending
+ // clarification in
+ // https://github.com/w3c/IntersectionObserver/issues/456.
+ if (aInput.mRootFrame == targetFrame ||
+ !nsLayoutUtils::IsAncestorFrameCrossDocInProcess(aInput.mRootFrame,
+ targetFrame)) {
+ return {isSimilarOrigin};
+ }
+
+ nsRect rootBounds = aInput.mRootRect;
+ if (isSimilarOrigin) {
+ rootBounds.Inflate(aInput.mRootMargin);
+ }
+
+ // 2.4. Set targetRect to the DOMRectReadOnly obtained by running the
+ // getBoundingClientRect() algorithm on target.
+ nsRect targetRect = targetFrame->GetBoundingClientRect();
+
+ // 2.5. Let intersectionRect be the result of running the compute the
+ // intersection algorithm on target and observer’s intersection root.
+ Maybe<nsRect> intersectionRect =
+ ComputeTheIntersection(targetFrame, aInput.mRootFrame, rootBounds,
+ aInput.mRemoteDocumentVisibleRect);
+
+ return {isSimilarOrigin, rootBounds, targetRect, intersectionRect};
+}
+
+IntersectionOutput DOMIntersectionObserver::Intersect(
+ const IntersectionInput& aInput, const nsRect& aTargetRect) {
+ nsRect rootBounds = aInput.mRootRect;
+ rootBounds.Inflate(aInput.mRootMargin);
+ auto intersectionRect =
+ EdgeInclusiveIntersection(aInput.mRootRect, aTargetRect);
+ if (intersectionRect && aInput.mRemoteDocumentVisibleRect) {
+ intersectionRect = EdgeInclusiveIntersection(
+ *intersectionRect, *aInput.mRemoteDocumentVisibleRect);
+ }
+ return {true, rootBounds, aTargetRect, intersectionRect};
+}
+
+// https://w3c.github.io/IntersectionObserver/#update-intersection-observations-algo
+// (step 2)
+void DOMIntersectionObserver::Update(Document& aDocument,
+ DOMHighResTimeStamp time) {
+ auto input = ComputeInput(aDocument, mRoot, &mRootMargin);
+
+ // If this observer is used to determine content relevancy for
+ // `content-visiblity: auto` content, then do not skip intersection
+ // for content that is hidden by `content-visibility: auto`.
+ IgnoreContentVisibility ignoreContentVisibility =
+ aDocument.GetContentVisibilityObserver() == this
+ ? IgnoreContentVisibility::Yes
+ : IgnoreContentVisibility::No;
+
+ // 2. For each target in observer’s internal [[ObservationTargets]] slot,
+ // processed in the same order that observe() was called on each target:
+ for (Element* target : mObservationTargets) {
+ // 2.1 - 2.4.
+ IntersectionOutput output =
+ Intersect(input, *target, ignoreContentVisibility);
+
+ // 2.5. Let targetArea be targetRect’s area.
+ int64_t targetArea = (int64_t)output.mTargetRect.Width() *
+ (int64_t)output.mTargetRect.Height();
+
+ // 2.6. Let intersectionArea be intersectionRect’s area.
+ int64_t intersectionArea =
+ !output.mIntersectionRect
+ ? 0
+ : (int64_t)output.mIntersectionRect->Width() *
+ (int64_t)output.mIntersectionRect->Height();
+
+ // 2.7. Let isIntersecting be true if targetRect and rootBounds intersect or
+ // are edge-adjacent, even if the intersection has zero area (because
+ // rootBounds or targetRect have zero area); otherwise, let isIntersecting
+ // be false.
+ const bool isIntersecting = output.Intersects();
+
+ // 2.8. If targetArea is non-zero, let intersectionRatio be intersectionArea
+ // divided by targetArea. Otherwise, let intersectionRatio be 1 if
+ // isIntersecting is true, or 0 if isIntersecting is false.
+ double intersectionRatio;
+ if (targetArea > 0.0) {
+ intersectionRatio =
+ std::min((double)intersectionArea / (double)targetArea, 1.0);
+ } else {
+ intersectionRatio = isIntersecting ? 1.0 : 0.0;
+ }
+
+ // 2.9 Let thresholdIndex be the index of the first entry in
+ // observer.thresholds whose value is greater than intersectionRatio, or the
+ // length of observer.thresholds if intersectionRatio is greater than or
+ // equal to the last entry in observer.thresholds.
+ int32_t thresholdIndex = -1;
+
+ // If not intersecting, we can just shortcut, as we know that the thresholds
+ // are always between 0 and 1.
+ if (isIntersecting) {
+ thresholdIndex = mThresholds.IndexOfFirstElementGt(intersectionRatio);
+ if (thresholdIndex == 0) {
+ // Per the spec, we should leave threshold at 0 and distinguish between
+ // "less than all thresholds and intersecting" and "not intersecting"
+ // (queuing observer entries as both cases come to pass). However,
+ // neither Chrome nor the WPT tests expect this behavior, so treat these
+ // two cases as one.
+ //
+ // See https://github.com/w3c/IntersectionObserver/issues/432 about
+ // this.
+ thresholdIndex = -1;
+ }
+ }
+
+ // Steps 2.10 - 2.15.
+ if (target->UpdateIntersectionObservation(this, thresholdIndex)) {
+ // See https://github.com/w3c/IntersectionObserver/issues/432 about
+ // why we use thresholdIndex > 0 rather than isIntersecting for the
+ // entry's isIntersecting value.
+ QueueIntersectionObserverEntry(
+ target, time,
+ output.mIsSimilarOrigin ? Some(output.mRootBounds) : Nothing(),
+ output.mTargetRect, output.mIntersectionRect, thresholdIndex > 0,
+ intersectionRatio);
+ }
+ }
+}
+
+void DOMIntersectionObserver::QueueIntersectionObserverEntry(
+ Element* aTarget, DOMHighResTimeStamp time, const Maybe<nsRect>& aRootRect,
+ const nsRect& aTargetRect, const Maybe<nsRect>& aIntersectionRect,
+ bool aIsIntersecting, double aIntersectionRatio) {
+ RefPtr<DOMRect> rootBounds;
+ if (aRootRect.isSome()) {
+ rootBounds = new DOMRect(mOwner);
+ rootBounds->SetLayoutRect(aRootRect.value());
+ }
+ RefPtr<DOMRect> boundingClientRect = new DOMRect(mOwner);
+ boundingClientRect->SetLayoutRect(aTargetRect);
+ RefPtr<DOMRect> intersectionRect = new DOMRect(mOwner);
+ if (aIntersectionRect.isSome()) {
+ intersectionRect->SetLayoutRect(aIntersectionRect.value());
+ }
+ RefPtr<DOMIntersectionObserverEntry> entry = new DOMIntersectionObserverEntry(
+ mOwner, time, rootBounds.forget(), boundingClientRect.forget(),
+ intersectionRect.forget(), aIsIntersecting, aTarget, aIntersectionRatio);
+ mQueuedEntries.AppendElement(entry.forget());
+}
+
+void DOMIntersectionObserver::Notify() {
+ if (!mQueuedEntries.Length()) {
+ return;
+ }
+ Sequence<OwningNonNull<DOMIntersectionObserverEntry>> entries;
+ if (entries.SetCapacity(mQueuedEntries.Length(), mozilla::fallible)) {
+ for (size_t i = 0; i < mQueuedEntries.Length(); ++i) {
+ RefPtr<DOMIntersectionObserverEntry> next = mQueuedEntries[i];
+ *entries.AppendElement(mozilla::fallible) = next;
+ }
+ }
+ mQueuedEntries.Clear();
+
+ if (mCallback.is<RefPtr<dom::IntersectionCallback>>()) {
+ RefPtr<dom::IntersectionCallback> callback(
+ mCallback.as<RefPtr<dom::IntersectionCallback>>());
+ callback->Call(this, entries, *this);
+ } else {
+ mCallback.as<NativeCallback>()(entries);
+ }
+}
+
+} // namespace mozilla::dom