prefer Scheduler.ScheduleInterface instead of callbacks

Commit before introduces `Scheduler.ScheduleInterface` which allow consumers to pass types that contain `action` and `finalize` callbacks.

src/browser/Page.zig

@@ -380,16 +380,16 @@ fn registerBackgroundTasks(self: *Page) !void {
     const Browser = @import("Browser.zig");
 
     return self.scheduler.after(
-        .{ .name = "runMessageLoop", .priority = .high },
+        .{ .name = "runMessageLoop", .prio = .high },
         Browser,
         self._session.browser,
         250,
         struct {
-            fn runMessageLoop(_: *Scheduler, browser: *Browser) !Scheduler.AfterAction {
+            pub fn action(_: *Scheduler, browser: *Browser) !Scheduler.AfterAction {
                 browser.runMessageLoop();
                 return .repeat(250);
             }
-        }.runMessageLoop,
+        },
     );
 }
 
@@ -1268,11 +1268,11 @@ pub fn notifyPerformanceObservers(self: *Page, entry: *Performance.Entry) !void
     self._performance_delivery_scheduled = true;
 
     return self.scheduler.once(
-        .{ .priority = .low },
+        .{ .prio = .low },
         Page,
         self,
         struct {
-            fn run(_: *Scheduler, page: *Page) !void {
+            pub fn action(_: *Scheduler, page: *Page) !void {
                 page._performance_delivery_scheduled = false;
 
                 // Dispatch performance observers.
@@ -1282,7 +1282,7 @@ pub fn notifyPerformanceObservers(self: *Page, entry: *Performance.Entry) !void
                     }
                 }
             }
-        }.run,
+        },
     );
 }
 

src/browser/webapi/AbortSignal.zig

@@ -100,16 +100,12 @@ pub fn createTimeout(delay: u32, page: *Page) !*AbortSignal {
         .signal = try init(page),
     };
 
-    //try page.scheduler.add(callback, TimeoutCallback.run, delay, .{
-    //    .name = "AbortSignal.timeout",
-    //});
-
     try page.scheduler.after(
-        .{ .name = "AbortSignal.timeout", .priority = .high },
+        .{ .name = "AbortSignal.timeout", .prio = .high },
         TimeoutCallback,
         callback,
         delay,
-        TimeoutCallback.run,
+        TimeoutCallback,
     );
 
     return callback.signal;
@@ -143,7 +139,7 @@ const TimeoutCallback = struct {
     page: *Page,
     signal: *AbortSignal,
 
-    fn run(_: *Scheduler, self: *TimeoutCallback) !Scheduler.AfterAction {
+    pub fn action(_: *Scheduler, self: *TimeoutCallback) !Scheduler.AfterAction {
         var ls: js.Local.Scope = undefined;
         self.page.js.localScope(&ls);
         defer ls.deinit();

src/browser/webapi/MessagePort.zig

@@ -67,10 +67,10 @@ pub fn postMessage(self: *MessagePort, message: js.Value.Global, page: *Page) !v
     });
 
     try page.scheduler.once(
-        .{ .name = "MessagePort.postMessage", .priority = .high },
+        .{ .name = "MessagePort.postMessage", .prio = .high },
         PostMessageCallback,
         callback,
-        PostMessageCallback.run,
+        PostMessageCallback,
     );
 }
 
@@ -116,7 +116,7 @@ const PostMessageCallback = struct {
         self.page._factory.destroy(self);
     }
 
-    fn run(_: *Scheduler, self: *PostMessageCallback) !void {
+    pub fn action(_: *Scheduler, self: *PostMessageCallback) !void {
         defer self.deinit();
         const page = self.page;
 

src/browser/webapi/Window.zig

@@ -368,17 +368,11 @@ pub fn postMessage(self: *Window, message: js.Value.Global, target_origin: ?[]co
         .origin = try arena.dupe(u8, origin),
     };
 
-    //try page.scheduler.add(callback, PostMessageCallback.run, 0, .{
-    //    .name = "postMessage",
-    //    .low_priority = false,
-    //    .finalizer = PostMessageCallback.cancelled,
-    //});
-
     return page.scheduler.once(
-        .{ .name = "postMessage", .priority = .high },
+        .{ .name = "postMessage", .prio = .high },
         PostMessageCallback,
         callback,
-        PostMessageCallback.run,
+        PostMessageCallback,
     );
 }
 
@@ -457,11 +451,11 @@ pub fn scrollTo(self: *Window, opts: ScrollToOpts, y: ?i32, page: *Page) !void {
     // We dispatch scroll event asynchronously after 10ms. So we can throttle
     // them.
     try page.scheduler.once(
-        .{ .priority = .low },
+        .{ .prio = .low },
         Page,
         page,
         struct {
-            fn dispatch(_: *Scheduler, p: *Page) !void {
+            pub fn action(_: *Scheduler, p: *Page) !void {
                 const pos = &p.window._scroll_pos;
                 // If the state isn't scroll, we can ignore safely to throttle
                 // the events.
@@ -476,17 +470,17 @@ pub fn scrollTo(self: *Window, opts: ScrollToOpts, y: ?i32, page: *Page) !void {
 
                 return;
             }
-        }.dispatch,
+        },
     );
 
     // We dispatch scrollend event asynchronously after 20ms.
     try page.scheduler.after(
-        .{ .priority = .low },
+        .{ .prio = .low },
         Page,
         page,
         20,
         struct {
-            fn dispatch(_: *Scheduler, p: *Page) !Scheduler.AfterAction {
+            pub fn action(_: *Scheduler, p: *Page) !Scheduler.AfterAction {
                 const pos = &p.window._scroll_pos;
                 // Dispatch only if the state is .end.
                 // If a scroll is pending, retry in 10ms.
@@ -504,7 +498,7 @@ pub fn scrollTo(self: *Window, opts: ScrollToOpts, y: ?i32, page: *Page) !void {
 
                 return .dont_repeat;
             }
-        }.dispatch,
+        },
     );
 }
 
@@ -561,11 +555,11 @@ fn scheduleCallback(self: *Window, cb: js.Function.Temp, delay_ms: u32, opts: Sc
     //});
 
     try page.scheduler.after(
-        .{ .priority = .high },
+        .{ .prio = .high },
         ScheduleCallback,
         callback,
         delay_ms,
-        ScheduleCallback.run,
+        ScheduleCallback,
     );
 
     return timer_id;
@@ -595,11 +589,6 @@ const ScheduleCallback = struct {
         animation_frame,
     };
 
-    fn cancelled(ctx: *anyopaque) void {
-        var self: *ScheduleCallback = @ptrCast(@alignCast(ctx));
-        self.deinit();
-    }
-
     fn deinit(self: *ScheduleCallback) void {
         self.page.js.release(self.cb);
         for (self.params) |param| {
@@ -608,7 +597,11 @@ const ScheduleCallback = struct {
         self.page.releaseArena(self.arena);
     }
 
-    fn run(_: *Scheduler, self: *ScheduleCallback) !Scheduler.AfterAction {
+    pub fn finalize(self: *ScheduleCallback) void {
+        self.deinit();
+    }
+
+    pub fn action(_: *Scheduler, self: *ScheduleCallback) !Scheduler.AfterAction {
         const page = self.page;
         const window = page.window;
 
@@ -660,12 +653,11 @@ const PostMessageCallback = struct {
         self.page.releaseArena(self.arena);
     }
 
-    fn cancelled(ctx: *anyopaque) void {
-        const self: *PostMessageCallback = @ptrCast(@alignCast(ctx));
+    pub fn finalize(self: *PostMessageCallback) void {
         self.page.releaseArena(self.arena);
     }
 
-    fn run(_: *Scheduler, self: *PostMessageCallback) !void {
+    pub fn action(_: *Scheduler, self: *PostMessageCallback) !void {
         defer self.deinit();
 
         const page = self.page;