Lightpanda: the headless browser designed for AI and automation
perf: improve ResizeObserver performance
Karl Seguin122a4f1001d7
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zigindex 827aa3a3c..de726838c 100644--- a/src/browser/Frame.zig+++ b/src/browser/Frame.zig@@ -1956,7 +1956,7 @@ pub fn domChanged(self: *Frame) void {// A DOM change is our "rendering opportunity": re-evaluate the layout// observers. Both are no-ops unless something they track actually changed.observers.scheduleIntersectionChecks(self);- observers.scheduleResizeDelivery(self);+ observers.scheduleResizeChecks(self);}const ElementIdMaps = struct { lookup: *std.StringHashMapUnmanaged(*Element), removed_ids: *std.StringHashMapUnmanaged(void) };diff --git a/src/browser/StyleManager.zig b/src/browser/StyleManager.zigindex 868545c19..0001991dc 100644--- a/src/browser/StyleManager.zig+++ b/src/browser/StyleManager.zig@@ -511,10 +511,12 @@ fn addRawRule(self: *StyleManager, build_arena: Allocator, selector_text: []conspub fn sheetRemoved(self: *StyleManager) void {self.dirty = true;+ Frame.observers.scheduleResizeDelivery(self.frame);}pub fn sheetModified(self: *StyleManager) void {self.dirty = true;+ Frame.observers.scheduleResizeDelivery(self.frame);}/// Rebuilds the rule list from all document stylesheets.diff --git a/src/browser/frame/observers.zig b/src/browser/frame/observers.zigindex b0b42bd43..8fadf65be 100644--- a/src/browser/frame/observers.zig+++ b/src/browser/frame/observers.zig@@ -16,10 +16,11 @@// You should have received a copy of the GNU Affero General Public License// along with this program. If not, see <https://www.gnu.org/licenses/>.-// Per-frame MutationObserver and IntersectionObserver bookkeeping: registration,-// the scheduling of the microtask deliveries, and broadcasting DOM mutations to-// the registered observers. The state lives on the Frame (frame._mutation /-// frame._intersection); these functions operate on it.+// Per-frame MutationObserver, IntersectionObserver and ResizeObserver+// bookkeeping: registration, the scheduling of the microtask deliveries, and+// broadcasting DOM mutations to the registered observers. The state lives on+// the Frame (frame._mutation / frame._intersection / frame._resize); these+// functions operate on it.const std = @import("std");const lp = @import("lightpanda");@@ -57,6 +58,7 @@ pub const Intersection = struct {pub const Resize = struct {// List of active ResizeObservers (i.e. those with >= 1 observation)observers: std.ArrayList(*ResizeObserver) = .empty,+ check_scheduled: bool = false,delivery_scheduled: bool = false,delivery_depth: u32 = 0,};@@ -171,6 +173,81 @@ pub fn scheduleResizeDelivery(frame: *Frame) void {};}+// Called on every DOM change, a full delivery is too expensive to call here.+// What we can do is schedule a check.+pub fn scheduleResizeChecks(frame: *Frame) void {+ if (frame._resize.observers.items.len == 0) {+ return;+ }+ if (frame._resize.check_scheduled or frame._resize.delivery_scheduled) {+ // check is already scheduled OR delivery is already scheduled+ return;+ }+ frame._resize.check_scheduled = true;+ frame.js.queueResizeChecks() catch |err| {+ frame._resize.check_scheduled = false;+ log.err(.frame, "frame.scheduleResizeChecks", .{ .err = err, .type = frame._type, .url = frame.url });+ };+}++pub fn performScheduledResizeChecks(frame: *Frame) void {+ if (!frame._resize.check_scheduled) {+ return;+ }++ frame._resize.check_scheduled = false;+ if (frame._resize.delivery_scheduled) {+ return;+ }++ // Check if we should schedule a delivery. If you're wondering why we're+ // scheduling within a schedule, it's because this can be expensive and we+ // want to coalesce as many of these into a single call as possible.+ for (frame._resize.observers.items) |observer| {+ if (observer.connectivityChanged()) {+ scheduleResizeDelivery(frame);+ return;+ }+ }+}++// Only these attributes can change an element's size or visibility in our+// styling model (StyleManager.isHidden + Element.getElementDimensions), and+// only for the element itself and its descendants — so a delivery is only+// scheduled when an observed element is in the changed element's subtree.+fn resizeAttributeChanged(frame: *Frame, element: *Element, name: String) void {+ if (frame._resize.observers.items.len == 0) {+ return;+ }+ if (frame._resize.delivery_scheduled) {+ return;+ }++ // This has proven to be on the hot path+ switch (name.len) {+ 2 => if (!name.eqlWithSameLen(comptime .wrap("id"))) {+ return;+ },+ 4 => if (!name.eqlWithSameLen(comptime .wrap("type")) and !name.eqlWithSameLen(comptime .wrap("open"))) {+ return;+ },+ 5 => if (!name.eqlWithSameLen(comptime .wrap("style")) and !name.eqlWithSameLen(comptime .wrap("class")) and !name.eqlWithSameLen(comptime .wrap("width"))) {+ return;+ },+ 6 => if (!name.eqlWithSameLen(comptime .wrap("hidden")) and !name.eqlWithSameLen(comptime .wrap("height"))) {+ return;+ },+ else => return,+ }++ for (frame._resize.observers.items) |observer| {+ if (observer.observesWithin(element)) {+ scheduleResizeDelivery(frame);+ return;+ }+ }+}+pub fn deliverResizes(frame: *Frame) void {if (!frame._resize.delivery_scheduled) {return;@@ -183,7 +260,7 @@ pub fn deliverResizes(frame: *Frame) void {defer if (!frame._resize.delivery_scheduled) {frame._resize.delivery_depth = 0;};- if (frame._resize.delivery_depth > 50) {+ if (frame._resize.delivery_depth > 16) {log.warn(.frame, "frame.ResizeLimit", .{ .type = frame._type, .url = frame.url });frame._resize.delivery_depth = 0;return;@@ -242,7 +319,7 @@ pub fn deliverMutations(frame: *Frame) void {frame._mutation.delivery_depth = 0;};- if (frame._mutation.delivery_depth > 50) {+ if (frame._mutation.delivery_depth > 16) {log.err(.frame, "frame.MutationLimit", .{ .type = frame._type, .url = frame.url });frame._mutation.delivery_depth = 0;return;@@ -292,9 +369,10 @@ pub fn deliverMutations(frame: *Frame) void {}}-// Broadcast an attribute change to every registered MutationObserver. The-// caller (Frame.attributeChange / attributeRemove) handles the non-observer-// side effects (build hooks, custom-element callbacks, slot/popover updates).+// Broadcast an attribute change to every registered MutationObserver and to+// the resize bookkeeping. The caller (Frame.attributeChange / attributeRemove)+// handles the non-observer side effects (build hooks, custom-element+// callbacks, slot/popover updates).pub fn notifyAttributeChange(frame: *Frame, element: *Element, name: String, old_value: ?String) void {var it: ?*std.DoublyLinkedList.Node = frame._mutation.observers.first;while (it) |node| : (it = node.next) {@@ -303,6 +381,7 @@ pub fn notifyAttributeChange(frame: *Frame, element: *Element, name: String, oldlog.err(.frame, "attributeChange.notifyObserver", .{ .err = err, .type = frame._type, .url = frame.url });};}+ resizeAttributeChanged(frame, element, name);}pub fn notifyCharacterDataChange(frame: *Frame, target: *Node, old_value: String) void {diff --git a/src/browser/js/Context.zig b/src/browser/js/Context.zigindex f8c5163e8..0641a06ab 100644--- a/src/browser/js/Context.zig+++ b/src/browser/js/Context.zig@@ -1093,6 +1093,17 @@ pub fn queueIntersectionDelivery(self: *Context) !void {}.run);}+pub fn queueResizeChecks(self: *Context) !void {+ self.enqueueMicrotask(struct {+ fn run(ctx: *Context) void {+ switch (ctx.global) {+ .frame => |frame| Frame.observers.performScheduledResizeChecks(frame),+ .worker => unreachable,+ }+ }+ }.run);+}+pub fn queueResizeDelivery(self: *Context) !void {self.enqueueMicrotask(struct {fn run(ctx: *Context) void {diff --git a/src/browser/webapi/ResizeObserver.zig b/src/browser/webapi/ResizeObserver.zigindex 0029ca2a0..6dac4a385 100644--- a/src/browser/webapi/ResizeObserver.zig+++ b/src/browser/webapi/ResizeObserver.zig@@ -52,6 +52,7 @@ _observations: std.ArrayList(Observation) = .empty,const Observation = struct {target: *Element,+ connected: bool = false,last_width: f64 = 0,last_height: f64 = 0,};@@ -123,18 +124,50 @@ pub fn disconnect(self: *ResizeObserver, frame: *Frame) void {Frame.observers.unregisterResizeObserver(frame, self);}+// True if any observed element's connectedness changed since the last+// delivery. Runs on every DOM change (via Frame.observers), so it must stay+// pointer walks only — no style lookups.+pub fn connectivityChanged(self: *const ResizeObserver) bool {+ for (self._observations.items) |obs| {+ if (obs.target.asNode().isConnected() != obs.connected) {+ return true;+ }+ }+ return false;+}++// True if any observed element is `ancestor` or one of its descendants. Walks+// the same parentElement chain StyleManager.isHidden resolves visibility+// through.+pub fn observesWithin(self: *const ResizeObserver, ancestor: *Element) bool {+ for (self._observations.items) |obs| {+ var current: ?*Element = obs.target;+ while (current) |el| : (current = el.parentElement()) {+ if (el == ancestor) {+ return true;+ }+ }+ }+ return false;+}+// Gather the observations whose size changed since the last delivery and, if// any, invoke the callback.pub fn deliverEntries(self: *ResizeObserver, frame: *Frame) !void {var entries: std.ArrayList(*ResizeObserverEntry) = .empty;+ // Observed elements share ancestors, so one cache serves the whole pass.+ var visibility_cache: Element.VisibilityCache = .empty;for (self._observations.items) |*obs| {const target = obs.target;+ const connected = target.asNode().isConnected();+ obs.connected = connected;const width, const height = blk: {- if (obs.target.asNode().isConnected() == false) {+ if (!connected or !target.checkVisibilityCached(&visibility_cache, frame)) {break :blk .{ 0, 0 };}- break :blk .{ target.getClientWidth(frame), target.getClientHeight(frame) };+ const dims = target.getElementDimensions(frame);+ break :blk .{ dims.width, dims.height };};if (width == obs.last_width and height == obs.last_height) {diff --git a/src/string.zig b/src/string.zigindex 384031e26..437133ebf 100644--- a/src/string.zig+++ b/src/string.zig@@ -179,16 +179,24 @@ pub const String = packed struct {return false;}- const len = a.len;- if (len < 0 or b.len < 0) {+ if (a.len < 0 or b.len < 0) {return false;}+ return eqlWithSameLen(a, b);+ }+ // Dangerous. Use this only when you have to (and, obviously, when you know+ // a.len == b.len)+ pub fn eqlWithSameLen(a: String, b: String) bool {+ if (comptime IS_DEBUG) {+ std.debug.assert(a.len == b.len);+ }++ const len = a.len;if (len <= 12) {return a.payload.content == b.payload.content;}- // a.len == b.len at this pointconst al: usize = @intCast(len);const bl: usize = @intCast(len);const ap: [*]const u8 = @ptrFromInt(a.payload.heap.ptr);