prefer URL instead of std.Uri everywhere

nikneym · nikneym · commit b307473d80c5 · 2025-10-13T16:35:35.000+03:00
diff --git a/src/browser/html/document.zig b/src/browser/html/document.zig
@@ -85,7 +85,7 @@ pub const HTMLDocument = struct {
 
     pub fn get_cookie(_: *parser.DocumentHTML, page: *Page) ![]const u8 {
         var buf: std.ArrayListUnmanaged(u8) = .{};
-        try page.cookie_jar.forRequest(&page.url.uri, buf.writer(page.arena), .{
+        try page.cookie_jar.forRequest(page.url, buf.writer(page.arena), .{
             .is_http = false,
             .is_navigation = true,
         });
@@ -95,7 +95,7 @@ pub const HTMLDocument = struct {
     pub fn set_cookie(_: *parser.DocumentHTML, cookie_str: []const u8, page: *Page) ![]const u8 {
         // we use the cookie jar's allocator to parse the cookie because it
         // outlives the page's arena.
-        const c = try Cookie.parse(page.cookie_jar.allocator, &page.url.uri, cookie_str);
+        const c = try Cookie.parse(page.cookie_jar.allocator, page.url, cookie_str);
         errdefer c.deinit();
         if (c.http_only) {
             c.deinit();
diff --git a/src/browser/page.zig b/src/browser/page.zig
@@ -153,6 +153,7 @@ pub const Page = struct {
         }
     }
 
+    // FIXME: Deinit self.url.
     pub fn deinit(self: *Page) void {
         self.script_manager.shutdown = true;
 
@@ -229,7 +230,7 @@ pub const Page = struct {
 
         const doc = parser.documentHTMLToDocument(self.window.document);
 
-        // if the base si requested, add the base's node in the document's headers.
+        // if the base is requested, add the base's node in the document's headers.
         if (opts.with_base) {
             try self.addDOMTreeBase();
         }
@@ -515,10 +516,11 @@ pub const Page = struct {
         is_http: bool = true,
         is_navigation: bool = false,
     };
+
     pub fn requestCookie(self: *const Page, opts: RequestCookieOpts) Http.Client.RequestCookie {
         return .{
-            .jar = self.cookie_jar,
-            .origin = &self.url.uri,
+            .cookie_jar = self.cookie_jar,
+            .origin_url = self.url,
             .is_http = opts.is_http,
             .is_navigation = opts.is_navigation,
         };
@@ -849,7 +851,7 @@ pub const Page = struct {
         self.window.setStorageShelf(
             try self.session.storage_shed.getOrPut(try self.origin(self.arena)),
         );
-        try self.window.replaceLocation(.{ .url = try self.url.toWebApi(self.arena) });
+        //try self.window.replaceLocation(.{ .url = try self.url.toWebApi(self.arena) });
     }
 
     pub const MouseEvent = struct {
diff --git a/src/browser/storage/cookie.zig b/src/browser/storage/cookie.zig
diff --git a/src/browser/url/url.zig b/src/browser/url/url.zig
@@ -84,27 +84,45 @@ pub const URL = struct {
             break :blk ada.parse(url_str);
         };
 
-        // Prepare search_params.
-        const params: URLSearchParams = blk: {
-            const search = ada.getSearch(internal);
-            if (search.data == null) {
-                break :blk .{};
-            }
-
-            break :blk try .initFromString(page.arena, search.data[0..search.length]);
+        return .{
+            .internal = internal,
+            .search_params = try prepareSearchParams(page.arena, internal),
         };
-
-        // We're doing this since we track search params separately.
-        ada.clearSearch(internal);
-
-        return .{ .internal = internal, .search_params = params };
     }
 
     pub fn destructor(self: *const URL) void {
         // Not tracked by arena.
         return ada.free(self.internal);
     }
 
+    /// Initializes a `URL` from given `internal`.
+    /// Note that this copies the given `internal`; meaning 2 instances
+    /// of it has to be tracked separately.
+    pub fn constructFromInternal(arena: Allocator, internal: ada.URL) !URL {
+        const copy = ada.copy(internal);
+
+        return .{
+            .internal = copy,
+            .search_params = try prepareSearchParams(arena, copy),
+        };
+    }
+
+    /// Prepares a `URLSearchParams` from given `internal`.
+    /// Resets `search` of `internal`.
+    fn prepareSearchParams(arena: Allocator, internal: ada.URL) !URLSearchParams {
+        const search = ada.getSearch(internal);
+        // Empty.
+        if (search.data == null) return .{};
+
+        const slice = search.data[0..search.length];
+        const search_params = URLSearchParams.initFromString(arena, slice);
+        // After a call to this function, search params are tracked by
+        // `search_params`. So we reset the internal's search.
+        ada.clearSearch(internal);
+
+        return search_params;
+    }
+
     // Alias to get_href.
     pub fn _toString(self: *const URL, page: *Page) ![]const u8 {
         return self.get_href(page);
@@ -176,7 +194,13 @@ pub const URL = struct {
     }
 
     pub fn get_pathname(self: *const URL) []const u8 {
-        return ada.getPathname(self.internal);
+        const path = ada.getPathnameNullable(self.internal);
+        // Return a slash if path is null.
+        if (path.data == null) {
+            return "/";
+        }
+
+        return path.data[0..path.length];
     }
 
     // get_search depends on the current state of `search_params`.
diff --git a/src/cdp/domains/fetch.zig b/src/cdp/domains/fetch.zig
@@ -208,7 +208,7 @@ pub fn requestIntercept(arena: Allocator, bc: anytype, intercept: *const Notific
     log.debug(.cdp, "request intercept", .{
         .state = "paused",
         .id = transfer.id,
-        .url = transfer.uri,
+        .url = transfer.url,
     });
     // Await either continueRequest, failRequest or fulfillRequest
 
@@ -237,7 +237,7 @@ fn continueRequest(cmd: anytype) !void {
     log.debug(.cdp, "request intercept", .{
         .state = "continue",
         .id = transfer.id,
-        .url = transfer.uri,
+        .url = transfer.url,
         .new_url = params.url,
     });
 
@@ -342,7 +342,7 @@ fn fulfillRequest(cmd: anytype) !void {
     log.debug(.cdp, "request intercept", .{
         .state = "fulfilled",
         .id = transfer.id,
-        .url = transfer.uri,
+        .url = transfer.url,
         .status = params.responseCode,
         .body = params.body != null,
     });
@@ -376,7 +376,7 @@ fn failRequest(cmd: anytype) !void {
     log.info(.cdp, "request intercept", .{
         .state = "fail",
         .id = request_id,
-        .url = transfer.uri,
+        .url = transfer.url,
         .reason = params.errorReason,
     });
     return cmd.sendResult(null, .{});
@@ -420,7 +420,7 @@ pub fn requestAuthRequired(arena: Allocator, bc: anytype, intercept: *const Noti
     log.debug(.cdp, "request auth required", .{
         .state = "paused",
         .id = transfer.id,
-        .url = transfer.uri,
+        .url = transfer.url,
     });
     // Await continueWithAuth
 
diff --git a/src/cdp/domains/network.zig b/src/cdp/domains/network.zig
@@ -22,6 +22,7 @@ const Allocator = std.mem.Allocator;
 const CdpStorage = @import("storage.zig");
 const Transfer = @import("../../http/Client.zig").Transfer;
 const Notification = @import("../../notification.zig").Notification;
+const URL = @import("../../url.zig").URL;
 
 pub fn processMessage(cmd: anytype) !void {
     const action = std.meta.stringToEnum(enum {
@@ -117,22 +118,33 @@ fn deleteCookies(cmd: anytype) !void {
     const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
     const cookies = &bc.session.cookie_jar.cookies;
 
-    const uri = if (params.url) |url| std.Uri.parse(url) catch return error.InvalidParams else null;
-    const uri_ptr = if (uri) |u| &u else null;
+    const maybe_url: ?URL = blk: {
+        if (params.url) |url| {
+            break :blk URL.parse(url, null) catch return error.InvalidParams;
+        }
+
+        break :blk null;
+    };
 
     var index = cookies.items.len;
     while (index > 0) {
         index -= 1;
         const cookie = &cookies.items[index];
-        const domain = try Cookie.parseDomain(cmd.arena, uri_ptr, params.domain);
-        const path = try Cookie.parsePath(cmd.arena, uri_ptr, params.path);
+        const domain = try Cookie.parseDomain(cmd.arena, maybe_url, params.domain);
+        const path = try Cookie.parsePath(cmd.arena, maybe_url, params.path);
 
         // We do not want to use Cookie.appliesTo here. As a Cookie with a shorter path would match.
         // Similar to deduplicating with areCookiesEqual, except domain and path are optional.
         if (cookieMatches(cookie, params.name, domain, path)) {
             cookies.swapRemove(index).deinit();
         }
     }
+
+    // Deinit URL if we had.
+    if (maybe_url) |url| {
+        url.deinit();
+    }
+
     return cmd.sendResult(null, .{});
 }
 
@@ -177,13 +189,14 @@ fn getCookies(cmd: anytype) !void {
     const param_urls = params.urls orelse &[_][]const u8{page_url orelse return error.InvalidParams};
 
     var urls = try std.ArrayListUnmanaged(CdpStorage.PreparedUri).initCapacity(cmd.arena, param_urls.len);
-    for (param_urls) |url| {
-        const uri = std.Uri.parse(url) catch return error.InvalidParams;
+    for (param_urls) |url_str| {
+        const url = URL.parse(url_str, null) catch return error.InvalidParams;
+        defer url.deinit();
 
         urls.appendAssumeCapacity(.{
-            .host = try Cookie.parseDomain(cmd.arena, &uri, null),
-            .path = try Cookie.parsePath(cmd.arena, &uri, null),
-            .secure = std.mem.eql(u8, uri.scheme, "https"),
+            .host = try Cookie.parseDomain(cmd.arena, url, null),
+            .path = try Cookie.parsePath(cmd.arena, url, null),
+            .secure = url.isSecure(),
         });
     }
 
@@ -247,7 +260,7 @@ pub fn httpRequestStart(arena: Allocator, bc: anytype, msg: *const Notification.
         .requestId = try std.fmt.allocPrint(arena, "REQ-{d}", .{transfer.id}),
         .frameId = target_id,
         .loaderId = bc.loader_id,
-        .documentUrl = DocumentUrlWriter.init(&page.url.uri),
+        .documentUrl = DocumentUrlWriter.init(page.url),
         .request = TransferAsRequestWriter.init(transfer),
         .initiator = .{ .type = "other" },
     }, .{ .session_id = session_id });
@@ -300,23 +313,17 @@ pub const TransferAsRequestWriter = struct {
             try jws.objectField("url");
             try jws.beginWriteRaw();
             try writer.writeByte('\"');
-            try transfer.uri.writeToStream(writer, .{
-                .scheme = true,
-                .authentication = true,
-                .authority = true,
-                .path = true,
-                .query = true,
-            });
+            try transfer.url.writeToStream(writer);
             try writer.writeByte('\"');
             jws.endWriteRaw();
         }
 
         {
-            if (transfer.uri.fragment) |frag| {
+            if (transfer.url.getFragment()) |frag| {
                 try jws.objectField("urlFragment");
                 try jws.beginWriteRaw();
                 try writer.writeAll("\"#");
-                try writer.writeAll(frag.percent_encoded);
+                try writer.writeAll(frag);
                 try writer.writeByte('\"');
                 jws.endWriteRaw();
             }
@@ -370,13 +377,7 @@ const TransferAsResponseWriter = struct {
             try jws.objectField("url");
             try jws.beginWriteRaw();
             try writer.writeByte('\"');
-            try transfer.uri.writeToStream(writer, .{
-                .scheme = true,
-                .authentication = true,
-                .authority = true,
-                .path = true,
-                .query = true,
-            });
+            try transfer.url.writeToStream(writer);
             try writer.writeByte('\"');
             jws.endWriteRaw();
         }
@@ -417,29 +418,22 @@ const TransferAsResponseWriter = struct {
 };
 
 const DocumentUrlWriter = struct {
-    uri: *std.Uri,
+    url: URL,
 
-    fn init(uri: *std.Uri) DocumentUrlWriter {
-        return .{
-            .uri = uri,
-        };
+    fn init(url: URL) DocumentUrlWriter {
+        return .{ .url = url };
     }
 
     pub fn jsonStringify(self: *const DocumentUrlWriter, jws: anytype) !void {
         self._jsonStringify(jws) catch return error.WriteFailed;
     }
+
     fn _jsonStringify(self: *const DocumentUrlWriter, jws: anytype) !void {
         const writer = jws.writer;
 
         try jws.beginWriteRaw();
         try writer.writeByte('\"');
-        try self.uri.writeToStream(writer, .{
-            .scheme = true,
-            .authentication = true,
-            .authority = true,
-            .path = true,
-            .query = true,
-        });
+        try self.url.writeToStream(writer);
         try writer.writeByte('\"');
         jws.endWriteRaw();
     }
diff --git a/src/cdp/domains/storage.zig b/src/cdp/domains/storage.zig
@@ -21,6 +21,7 @@ const std = @import("std");
 const log = @import("../../log.zig");
 const Cookie = @import("../../browser/storage/storage.zig").Cookie;
 const CookieJar = @import("../../browser/storage/storage.zig").CookieJar;
+const URL = @import("../../url.zig").URL;
 pub const PreparedUri = @import("../../browser/storage/cookie.zig").PreparedUri;
 
 pub fn processMessage(cmd: anytype) !void {
@@ -136,12 +137,25 @@ pub fn setCdpCookie(cookie_jar: *CookieJar, param: CdpCookie) !void {
     const a = arena.allocator();
 
     // NOTE: The param.url can affect the default domain, (NOT path), secure, source port, and source scheme.
-    const uri = if (param.url) |url| std.Uri.parse(url) catch return error.InvalidParams else null;
-    const uri_ptr = if (uri) |*u| u else null;
-    const domain = try Cookie.parseDomain(a, uri_ptr, param.domain);
+    const maybe_url: ?URL = blk: {
+        if (param.url) |url| {
+            break :blk URL.parse(url, null) catch return error.InvalidParams;
+        }
+
+        break :blk null;
+    };
+
+    const domain = try Cookie.parseDomain(a, maybe_url, param.domain);
     const path = if (param.path == null) "/" else try Cookie.parsePath(a, null, param.path);
 
-    const secure = if (param.secure) |s| s else if (uri) |uri_| std.mem.eql(u8, uri_.scheme, "https") else false;
+    const secure: bool = blk: {
+        // Check if params indicate security.
+        if (param.secure) |s| break :blk s;
+        // Check if protocol is secure.
+        if (maybe_url) |url| break :blk url.isSecure();
+        // If all fails, insecure.
+        break :blk false;
+    };
 
     const cookie = Cookie{
         .arena = arena,
@@ -158,6 +172,12 @@ pub fn setCdpCookie(cookie_jar: *CookieJar, param: CdpCookie) !void {
             .None => .none,
         },
     };
+
+    // Free if we had.
+    if (maybe_url) |url| {
+        url.deinit();
+    }
+
     try cookie_jar.add(cookie, std.time.timestamp());
 }
 
diff --git a/src/http/Client.zig b/src/http/Client.zig
diff --git a/src/url.zig b/src/url.zig
