From 3b5dc069ae338ebf373471e32874ea8f4ba3ade3 Mon Sep 17 00:00:00 2001 From: Martin Robinson Date: Fri, 25 Oct 2024 02:26:47 -0700 Subject: [PATCH] dom: Stub out the `IntersectionObserver` interface (#33989) This is the first step toward implementing the IntersectionObserver interface. It adds stubs which are exposed when a preference is turned on. This is enough to get some sites with `IntersectionObserver` to start working. Signed-off-by: Martin Robinson --- components/config/prefs.rs | 3 + components/script/dom/bindings/root.rs | 16 ++ components/script/dom/intersectionobserver.rs | 143 ++++++++++++++++++ .../script/dom/intersectionobserverentry.rs | 128 ++++++++++++++++ components/script/dom/mod.rs | 2 + .../dom/webidls/IntersectionObserver.webidl | 32 ++++ .../webidls/IntersectionObserverEntry.webidl | 29 ++++ resources/prefs.json | 1 + 8 files changed, 354 insertions(+) create mode 100644 components/script/dom/intersectionobserver.rs create mode 100644 components/script/dom/intersectionobserverentry.rs create mode 100644 components/script/dom/webidls/IntersectionObserver.webidl create mode 100644 components/script/dom/webidls/IntersectionObserverEntry.webidl diff --git a/components/config/prefs.rs b/components/config/prefs.rs index d8c005e9470..d3e37f25bd4 100644 --- a/components/config/prefs.rs +++ b/components/config/prefs.rs @@ -261,6 +261,9 @@ mod gen { imagebitmap: { enabled: bool, }, + intersection_observer: { + enabled: bool, + }, microdata: { testing: { enabled: bool, diff --git a/components/script/dom/bindings/root.rs b/components/script/dom/bindings/root.rs index 8f2685bd4fe..814ba48f593 100644 --- a/components/script/dom/bindings/root.rs +++ b/components/script/dom/bindings/root.rs @@ -190,6 +190,17 @@ impl DomRoot { pub fn from_ref(unrooted: &T) -> DomRoot { unsafe { DomRoot::new(Dom::from_ref(unrooted)) } } + + /// Create a traced version of this rooted object. + /// + /// # Safety + /// + /// This should never be used to create on-stack values. Instead these values should always + /// end up as members of other DOM objects. + #[allow(crown::unrooted_must_root)] + pub(crate) fn as_traced(&self) -> Dom { + Dom::from_ref(self) + } } impl MallocSizeOf for DomRoot @@ -360,6 +371,11 @@ impl Dom { ptr: ptr::NonNull::from(obj), } } + + /// Return a rooted version of this DOM object ([`DomRoot`]) suitable for use on the stack. + pub(crate) fn as_rooted(&self) -> DomRoot { + DomRoot::from_ref(self) + } } impl Deref for Dom { diff --git a/components/script/dom/intersectionobserver.rs b/components/script/dom/intersectionobserver.rs new file mode 100644 index 00000000000..3c02238f52f --- /dev/null +++ b/components/script/dom/intersectionobserver.rs @@ -0,0 +1,143 @@ +/* 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 https://mozilla.org/MPL/2.0/. */ + +use std::rc::Rc; + +use dom_struct::dom_struct; +use js::jsval::{JSVal, NullValue}; +use js::rust::HandleObject; + +use super::bindings::codegen::Bindings::IntersectionObserverBinding::{ + IntersectionObserverCallback, IntersectionObserverMethods, +}; +use super::bindings::codegen::UnionTypes::ElementOrDocument; +use super::types::{Element, IntersectionObserverEntry}; +use crate::dom::bindings::codegen::Bindings::IntersectionObserverBinding::IntersectionObserverInit; +use crate::dom::bindings::reflector::{reflect_dom_object_with_proto, Reflector}; +use crate::dom::bindings::root::DomRoot; +use crate::dom::bindings::str::DOMString; +use crate::dom::window::Window; +use crate::script_runtime::{CanGc, JSContext}; + +/// The Intersection Observer interface +/// +/// > The IntersectionObserver interface can be used to observe changes in the intersection +/// > of an intersection root and one or more target Elements. +/// +/// +#[dom_struct] +pub struct IntersectionObserver { + reflector_: Reflector, + + /// > This callback will be invoked when there are changes to a target’s intersection + /// > with the intersection root, as per the processing model. + /// + #[ignore_malloc_size_of = "Rc are hard"] + callback: Rc, +} + +impl IntersectionObserver { + pub fn new_inherited( + callback: Rc, + _init: &IntersectionObserverInit, + ) -> Self { + Self { + reflector_: Reflector::new(), + callback, + } + } + + fn new( + window: &Window, + proto: Option, + callback: Rc, + init: &IntersectionObserverInit, + can_gc: CanGc, + ) -> DomRoot { + let observer = Box::new(Self::new_inherited(callback, init)); + reflect_dom_object_with_proto(observer, window, proto, can_gc) + } +} + +impl IntersectionObserverMethods for IntersectionObserver { + /// > The root provided to the IntersectionObserver constructor, or null if none was provided. + /// + /// + fn GetRoot(&self) -> Option { + None + } + + /// > Offsets applied to the root intersection rectangle, effectively growing or + /// > shrinking the box that is used to calculate intersections. These offsets are only + /// > applied when handling same-origin-domain targets; for cross-origin-domain targets + /// > they are ignored. + /// + /// + fn RootMargin(&self) -> DOMString { + DOMString::new() + } + + /// > Offsets are applied to scrollports on the path from intersection root to target, + /// > effectively growing or shrinking the clip rects used to calculate intersections. + /// + /// + fn ScrollMargin(&self) -> DOMString { + DOMString::new() + } + + /// > A list of thresholds, sorted in increasing numeric order, where each threshold + /// > is a ratio of intersection area to bounding box area of an observed target. + /// > Notifications for a target are generated when any of the thresholds are crossed + /// > for that target. If no options.threshold was provided to the IntersectionObserver + /// > constructor, or the sequence is empty, the value of this attribute will be [0]. + /// + /// + fn Thresholds(&self, _context: JSContext) -> JSVal { + NullValue() + } + + /// > A number indicating the minimum delay in milliseconds between notifications from + /// > this observer for a given target. + /// + /// + fn Delay(&self) -> i32 { + 0 + } + + /// > A boolean indicating whether this IntersectionObserver will track changes in a target’s visibility. + /// + /// + fn TrackVisibility(&self) -> bool { + false + } + + /// > Run the observe a target Element algorithm, providing this and target. + /// + /// + fn Observe(&self, _target: &Element) {} + + /// > Run the unobserve a target Element algorithm, providing this and target. + /// + /// + fn Unobserve(&self, _target: &Element) {} + + /// + fn Disconnect(&self) {} + + /// + fn TakeRecords(&self) -> Vec> { + vec![] + } + + /// + fn Constructor( + window: &Window, + proto: Option, + can_gc: CanGc, + callback: Rc, + init: &IntersectionObserverInit, + ) -> DomRoot { + Self::new(window, proto, callback, init, can_gc) + } +} diff --git a/components/script/dom/intersectionobserverentry.rs b/components/script/dom/intersectionobserverentry.rs new file mode 100644 index 00000000000..08048c779fd --- /dev/null +++ b/components/script/dom/intersectionobserverentry.rs @@ -0,0 +1,128 @@ +/* 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 https://mozilla.org/MPL/2.0/. */ + +use dom_struct::dom_struct; +use js::rust::HandleObject; + +use super::bindings::codegen::Bindings::IntersectionObserverEntryBinding::{ + IntersectionObserverEntryInit, IntersectionObserverEntryMethods, +}; +use super::bindings::num::Finite; +use crate::dom::bindings::reflector::{reflect_dom_object_with_proto, DomObject, Reflector}; +use crate::dom::bindings::root::{Dom, DomRoot}; +use crate::dom::domrectreadonly::DOMRectReadOnly; +use crate::dom::element::Element; +use crate::dom::window::Window; +use crate::script_runtime::CanGc; + +/// An individual IntersectionObserver entry. +/// +/// +#[dom_struct] +pub struct IntersectionObserverEntry { + reflector_: Reflector, + target: Dom, +} + +impl IntersectionObserverEntry { + pub fn new_inherited(init: &IntersectionObserverEntryInit) -> Self { + Self { + reflector_: Reflector::new(), + target: init.target.as_traced(), + } + } + + fn new( + window: &Window, + proto: Option, + init: &IntersectionObserverEntryInit, + can_gc: CanGc, + ) -> DomRoot { + let observer = Box::new(Self::new_inherited(init)); + reflect_dom_object_with_proto(observer, window, proto, can_gc) + } +} + +impl IntersectionObserverEntryMethods for IntersectionObserverEntry { + /// > The attribute must return a DOMHighResTimeStamp that corresponds to the time the + /// > intersection was recorded, relative to the time origin of the global object + /// > associated with the IntersectionObserver instance that generated the notification. + /// + /// + fn Time(&self) -> Finite { + Finite::new(0.).unwrap() + } + + /// > For a same-origin-domain target, this will be the root intersection rectangle. + /// > Otherwise, this will be null. Note that if the target is in a different browsing + /// > context than the intersection root, this will be in a different coordinate system + /// > than boundingClientRect and intersectionRect. + /// + /// + fn GetRootBounds(&self) -> Option> { + None + } + + /// > A DOMRectReadOnly obtained by getting the bounding box for target. + /// + /// + fn BoundingClientRect(&self) -> DomRoot { + DOMRectReadOnly::new(&self.global(), None, 0., 0., 0., 0., CanGc::note()) + } + + /// > boundingClientRect, intersected by each of target's ancestors' clip rects (up to + /// > but not including root), intersected with the root intersection rectangle. This + /// > value represents the portion of target that intersects with the root intersection + /// > rectangle. + /// + /// + fn IntersectionRect(&self) -> DomRoot { + DOMRectReadOnly::new(&self.global(), None, 0., 0., 0., 0., CanGc::note()) + } + + /// > True if the target intersects with the root; false otherwise. This flag makes it + /// > possible to distinguish between an IntersectionObserverEntry signalling the + /// > transition from intersecting to not-intersecting; and an IntersectionObserverEntry + /// > signalling a transition from not-intersecting to intersecting with a zero-area + /// > intersection rect (as will happen with edge-adjacent intersections, or when the + /// > boundingClientRect has zero area). + /// + /// + fn IsIntersecting(&self) -> bool { + false + } + + /// > Contains the result of running the visibility algorithm on target. + /// + /// + fn IsVisible(&self) -> bool { + false + } + + /// > If the boundingClientRect has non-zero area, this will be the ratio of + /// > intersectionRect area to boundingClientRect area. Otherwise, this will be 1 if the + /// > isIntersecting is true, and 0 if not. + /// + /// + fn IntersectionRatio(&self) -> Finite { + Finite::new(0.).unwrap() + } + + /// > The Element whose intersection with the intersection root changed. + /// + /// + fn Target(&self) -> DomRoot { + self.target.as_rooted() + } + + /// + fn Constructor( + window: &Window, + proto: Option, + can_gc: CanGc, + init: &IntersectionObserverEntryInit, + ) -> DomRoot { + Self::new(window, proto, init, can_gc) + } +} diff --git a/components/script/dom/mod.rs b/components/script/dom/mod.rs index 059f706b373..ccb2970fd99 100644 --- a/components/script/dom/mod.rs +++ b/components/script/dom/mod.rs @@ -445,6 +445,8 @@ pub mod iirfilternode; pub mod imagebitmap; pub mod imagedata; pub mod inputevent; +pub mod intersectionobserver; +pub mod intersectionobserverentry; pub mod keyboardevent; pub mod location; pub mod mediadeviceinfo; diff --git a/components/script/dom/webidls/IntersectionObserver.webidl b/components/script/dom/webidls/IntersectionObserver.webidl new file mode 100644 index 00000000000..dc24a856363 --- /dev/null +++ b/components/script/dom/webidls/IntersectionObserver.webidl @@ -0,0 +1,32 @@ +/* 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 https://mozilla.org/MPL/2.0/. */ + +// https://w3c.github.io/IntersectionObserver/#intersection-observer-interface + +callback IntersectionObserverCallback = + undefined (sequence entries, IntersectionObserver observer); + +dictionary IntersectionObserverInit { + (Element or Document)? root = null; + DOMString rootMargin; + DOMString scrollMargin; + (double or sequence) threshold; + long delay; + boolean trackVisibility = false; +}; + +[Pref="dom.intersection_observer.enabled", Exposed=(Window)] +interface IntersectionObserver { + constructor(IntersectionObserverCallback callback, optional IntersectionObserverInit options = {}); + readonly attribute (Element or Document)? root; + readonly attribute DOMString rootMargin; + readonly attribute DOMString scrollMargin; + readonly attribute /* FrozenArray */ any thresholds; + readonly attribute long delay; + readonly attribute boolean trackVisibility; + undefined observe(Element target); + undefined unobserve(Element target); + undefined disconnect(); + sequence takeRecords(); +}; diff --git a/components/script/dom/webidls/IntersectionObserverEntry.webidl b/components/script/dom/webidls/IntersectionObserverEntry.webidl new file mode 100644 index 00000000000..108ad6636de --- /dev/null +++ b/components/script/dom/webidls/IntersectionObserverEntry.webidl @@ -0,0 +1,29 @@ +/* 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 https://mozilla.org/MPL/2.0/. */ + +// https://w3c.github.io/IntersectionObserver/#intersection-observer-entry + +[Pref="dom.intersection_observer.enabled", Exposed=(Window)] +interface IntersectionObserverEntry { + constructor(IntersectionObserverEntryInit intersectionObserverEntryInit); + readonly attribute DOMHighResTimeStamp time; + readonly attribute DOMRectReadOnly? rootBounds; + readonly attribute DOMRectReadOnly boundingClientRect; + readonly attribute DOMRectReadOnly intersectionRect; + readonly attribute boolean isIntersecting; + readonly attribute boolean isVisible; + readonly attribute double intersectionRatio; + readonly attribute Element target; +}; + +dictionary IntersectionObserverEntryInit { + required DOMHighResTimeStamp time; + required DOMRectInit rootBounds; + required DOMRectInit boundingClientRect; + required DOMRectInit intersectionRect; + required boolean isIntersecting; + required boolean isVisible; + required double intersectionRatio; + required Element target; +}; diff --git a/resources/prefs.json b/resources/prefs.json index c5d7daffca8..4a763c8cd6f 100644 --- a/resources/prefs.json +++ b/resources/prefs.json @@ -15,6 +15,7 @@ "dom.fullscreen.test": false, "dom.gamepad.enabled": true, "dom.imagebitmap.enabled": false, + "dom.intersection_observer.enabled": false, "dom.microdata.enabled": false, "dom.microdata.testing.enabled": false, "dom.mouseevent.which.enabled": false,