Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
#[cfg(test)]
use std::path::PathBuf;
use std::{
future::IntoFuture,
net::SocketAddr,
sync::{Arc, atomic::AtomicU64},
time::Duration,
};
use anyhow::Result;
use anyhow::{Context, anyhow};
use axum::{
Router,
body::Body,
extract::State,
http::{HeaderValue, Request, header},
middleware::{self, Next},
response::{IntoResponse, Response},
routing::{MethodRouter, any, get, post, put},
serve::ListenerExt,
};
use moli_cookie_jar::StoredCookie;
use moli_core::{
LayoutConfiguration, LayoutPolicy, OptionalResourceFetchMask,
runtime::{NavigationRuntimeConfig, storage_partition::StoragePartitionState},
};
use moli_fetch::FetchConfig;
#[cfg(test)]
use moli_protocol::DEFAULT_CDP_TAB_TARGET_ID;
use moli_protocol::{CdpInitialStoragePartition, DEFAULT_CDP_PAGE_TARGET_ID};
#[cfg(test)]
use parking_lot::Mutex;
use tokio::net::TcpListener;
use tower::Layer;
use tracing::info;
#[cfg(test)]
use moli_cookie_cache as cookie_cache;
pub use crate::config::ServerConfig;
pub use instance_control::{BrowserInstanceControl, InstanceCommand};
mod cdp;
mod cdp_agent_host;
mod cdp_owner;
mod cdp_socket;
mod instance_control;
mod instance_shutdown;
mod protocol_local_executor;
mod tcp_options;
mod trailing_slash;
mod webdriver_bidi;
mod webdriver_classic;
mod webdriver_files;
use cdp_agent_host::SharedCdpAgentHostDirectory;
use cdp_owner::SharedCdpOwnerRegistry;
use webdriver_bidi::SharedBidiSessionRegistry;
use webdriver_classic::SharedClassicSessionRegistry;
const DEFAULT_BROWSER_ID: &str = "moli-browser";
const DEFAULT_TARGET_ID: &str = DEFAULT_CDP_PAGE_TARGET_ID;
#[cfg(test)]
const DEFAULT_TAB_TARGET_ID: &str = DEFAULT_CDP_TAB_TARGET_ID;
const DEFAULT_TARGET_URL: &str = "about:blank";
const JSON_DISCOVERY_PATH: &str = "/json";
#[derive(Debug, Clone)]
pub struct ProtocolServer {
config: ServerConfig,
storage_partition: Arc<StoragePartitionState>,
navigation_runtime_config: NavigationRuntimeConfig,
}
impl ProtocolServer {
pub fn new(config: ServerConfig) -> Self {
Self::new_with_initial_cookies(config, Vec::new())
}
pub fn new_with_initial_cookies(
config: ServerConfig,
initial_cookies: Vec<StoredCookie>,
) -> Self {
let storage_partition = Arc::new(
StoragePartitionState::open(None).expect("in-memory storage partition should open"),
);
storage_partition
.import_cookies(initial_cookies)
.expect("in-memory cookie import should succeed");
Self::new_with_storage_partition(config, storage_partition)
}
pub fn new_with_storage_partition(
config: ServerConfig,
storage_partition: Arc<StoragePartitionState>,
) -> Self {
Self::new_with_storage_partition_fetch_config_and_resource_loading(
config,
storage_partition,
FetchConfig::default(),
OptionalResourceFetchMask::NONE,
true,
)
}
pub fn new_with_storage_partition_fetch_config_and_resource_loading(
config: ServerConfig,
storage_partition: Arc<StoragePartitionState>,
fetch_config: FetchConfig,
optional_resource_fetch_mask: OptionalResourceFetchMask,
subframe_loading_enabled: bool,
) -> Self {
Self::new_with_storage_partition_and_runtime_config(
config,
storage_partition,
NavigationRuntimeConfig::new(
fetch_config,
optional_resource_fetch_mask,
subframe_loading_enabled,
LayoutPolicy::default(),
),
)
}
pub fn new_with_storage_partition_and_runtime_config(
config: ServerConfig,
storage_partition: Arc<StoragePartitionState>,
mut navigation_runtime_config: NavigationRuntimeConfig,
) -> Self {
if navigation_runtime_config
.fetch_config()
.http_cache_dir()
.is_none()
&& let Some(http_cache_root) = storage_partition.http_cache_root()
{
navigation_runtime_config
.fetch_config_mut()
.set_http_cache_dir(Some(http_cache_root.display().to_string()));
}
Self {
config,
storage_partition,
navigation_runtime_config,
}
}
pub async fn serve(&self) -> Result<()> {
self.serve_with_control(BrowserInstanceControl::new()).await
}
/// Serve one instance with a protocol-independent lifecycle control handle.
/// Use a fresh handle for each instance; shutdown requests are persistent.
pub async fn serve_with_control(&self, control: BrowserInstanceControl) -> Result<()> {
let listener = TcpListener::bind(self.config.bind_target())
.await
.with_context(|| {
anyhow!(
"failed to bind protocol server to {}:{}",
self.config.host,
self.config.port
)
})?;
let addr = listener
.local_addr()
.context("failed to read bound protocol socket address")?;
info!(%addr, "protocol server listening");
let app_state = AppState::new_with_storage_partition_and_runtime_config(
addr,
self.storage_partition.clone(),
self.navigation_runtime_config.clone(),
self.config.screencast_interval_ms,
control,
)?;
serve_listener(listener, app_state).await
}
}
/// Shared by the executable and instance-lifecycle integration tests.
async fn serve_listener(listener: TcpListener, app_state: AppState) -> Result<()> {
const SHUTDOWN_BUDGET: Duration = Duration::from_secs(5);
let control = app_state.control.clone();
let cdp_owner_registry = app_state.cdp_owner_registry.clone();
let classic_session_registry = app_state.classic_session_registry.clone();
let cookie_profile = app_state.cookie_profile.clone();
let listener =
listener.tap_io(|stream| tcp_options::configure_accepted_protocol_stream(stream));
let stop_accepting = control.clone();
let service = axum::ServiceExt::<Request<Body>>::into_make_service(build_router(app_state));
let serving = axum::serve(listener, service)
.with_graceful_shutdown(async move { stop_accepting.shutdown_requested().await })
.into_future();
tokio::pin!(serving);
let completed = tokio::select! {
result = &mut serving => Some(result),
_ = control.shutdown_requested() => None,
};
control.request(InstanceCommand::Shutdown);
tokio::time::timeout(SHUTDOWN_BUDGET, async {
let (_, result) = tokio::join!(cdp_owner_registry.shutdown(), async {
// Drain in-flight HTTP requests before taking the final Classic
// session set. New requests and upgraded sockets are rejected.
match completed {
Some(result) => result,
None => (&mut serving).await,
}
.context("protocol server failed")?;
classic_session_registry.shutdown(&cookie_profile).await?;
control.drained().await;
Ok(())
});
result
})
.await
.context("protocol server shutdown timed out; checkpoints may be incomplete")?
}
// Matchit accepts an empty final parameter when a literal slash follows it.
// Keep that legacy match without duplicating endpoint declarations.
trait ProtocolRoutes {
fn protocol_route(self, path: &str, route: MethodRouter<AppState>) -> Self;
}
impl ProtocolRoutes for Router<AppState> {
#[inline(never)]
fn protocol_route(self, path: &str, route: MethodRouter<AppState>) -> Self {
if path.ends_with('}') {
self.route(path, route.clone())
.route(&format!("{path}/"), route)
} else {
self.route(path, route)
}
}
}
fn build_router(app_state: AppState) -> trailing_slash::TrailingSlash<Router> {
let control = app_state.control.clone();
let router = Router::new()
.protocol_route("/status", get(webdriver_classic::webdriver_classic_status))
.protocol_route(JSON_DISCOVERY_PATH, any(cdp::json_list))
.protocol_route("/json/list", any(cdp::json_list))
.protocol_route("/json/version", get(cdp::json_version))
.protocol_route("/json/protocol", get(cdp::json_protocol))
.protocol_route("/json/new", put(cdp::json_new_target))
.protocol_route("/json/activate/{target_id}", get(cdp::json_activate_target))
.protocol_route("/json/close/{target_id}", get(cdp::json_close_target))
.protocol_route(
"/devtools/browser/{browser_id}",
get(cdp::ws_browser_upgrade_handler),
)
.protocol_route(
"/devtools/page/{target_id}",
get(cdp::ws_target_upgrade_handler),
)
.protocol_route(
"/session",
get(webdriver_bidi::ws_bidi_session_upgrade_handler)
.post(webdriver_classic::webdriver_classic_new_session),
)
.protocol_route(
"/session/{session_id}",
get(webdriver_bidi::ws_bidi_existing_session_upgrade_handler)
.delete(webdriver_classic::webdriver_classic_delete_session),
)
.protocol_route(
"/session/{session_id}/url",
get(webdriver_classic::webdriver_classic_get_url)
.post(webdriver_classic::webdriver_classic_navigate),
)
.protocol_route(
"/session/{session_id}/title",
get(webdriver_classic::webdriver_classic_get_title),
)
.protocol_route(
"/session/{session_id}/timeouts",
get(webdriver_classic::webdriver_classic_get_timeouts)
.post(webdriver_classic::webdriver_classic_set_timeouts),
)
.protocol_route(
"/session/{session_id}/source",
get(webdriver_classic::webdriver_classic_get_source),
)
.protocol_route(
"/session/{session_id}/screenshot",
get(webdriver_classic::webdriver_classic_take_screenshot),
)
.protocol_route(
"/session/{session_id}/print",
post(webdriver_classic::webdriver_classic_print_page),
)
.protocol_route(
"/session/{session_id}/file",
post(webdriver_classic::webdriver_classic_upload_file),
)
.protocol_route(
"/session/{session_id}/se/file",
post(webdriver_classic::webdriver_classic_upload_file),
)
.protocol_route(
"/session/{session_id}/se/files",
get(webdriver_classic::webdriver_classic_get_downloadable_files)
.post(webdriver_classic::webdriver_classic_download_file)
.delete(webdriver_classic::webdriver_classic_delete_downloadable_files),
)
.protocol_route(
"/session/{session_id}/moli/service-workers",
get(webdriver_classic::webdriver_classic_get_service_workers),
)
.protocol_route(
"/session/{session_id}/window",
get(webdriver_classic::webdriver_classic_get_window)
.post(webdriver_classic::webdriver_classic_switch_window)
.delete(webdriver_classic::webdriver_classic_close_window),
)
.protocol_route(
"/session/{session_id}/window/handles",
get(webdriver_classic::webdriver_classic_get_window_handles),
)
.protocol_route(
"/session/{session_id}/window/rect",
get(webdriver_classic::webdriver_classic_get_window_rect)
.post(webdriver_classic::webdriver_classic_set_window_rect),
)
.protocol_route(
"/session/{session_id}/window/maximize",
post(webdriver_classic::webdriver_classic_maximize_window),
)
.protocol_route(
"/session/{session_id}/window/minimize",
post(webdriver_classic::webdriver_classic_minimize_window),
)
.protocol_route(
"/session/{session_id}/window/fullscreen",
post(webdriver_classic::webdriver_classic_fullscreen_window),
)
.protocol_route(
"/session/{session_id}/window/new",
post(webdriver_classic::webdriver_classic_new_window),
)
.protocol_route(
"/session/{session_id}/frame",
post(webdriver_classic::webdriver_classic_switch_frame),
)
.protocol_route(
"/session/{session_id}/frame/parent",
post(webdriver_classic::webdriver_classic_switch_parent_frame),
)
.protocol_route(
"/session/{session_id}/alert/text",
get(webdriver_classic::webdriver_classic_get_alert_text)
.post(webdriver_classic::webdriver_classic_send_alert_text),
)
.protocol_route(
"/session/{session_id}/alert/accept",
post(webdriver_classic::webdriver_classic_accept_alert),
)
.protocol_route(
"/session/{session_id}/alert/dismiss",
post(webdriver_classic::webdriver_classic_dismiss_alert),
)
.protocol_route(
"/session/{session_id}/refresh",
post(webdriver_classic::webdriver_classic_refresh),
)
.protocol_route(
"/session/{session_id}/back",
post(webdriver_classic::webdriver_classic_back),
)
.protocol_route(
"/session/{session_id}/forward",
post(webdriver_classic::webdriver_classic_forward),
)
.protocol_route(
"/session/{session_id}/execute/sync",
post(webdriver_classic::webdriver_classic_execute_sync),
)
.protocol_route(
"/session/{session_id}/execute/async",
post(webdriver_classic::webdriver_classic_execute_async),
)
.protocol_route(
"/session/{session_id}/element",
post(webdriver_classic::webdriver_classic_find_element),
)
.protocol_route(
"/session/{session_id}/elements",
post(webdriver_classic::webdriver_classic_find_elements),
)
.protocol_route(
"/session/{session_id}/element/active",
get(webdriver_classic::webdriver_classic_get_active_element),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/element",
post(webdriver_classic::webdriver_classic_find_child_element),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/elements",
post(webdriver_classic::webdriver_classic_find_child_elements),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/shadow",
get(webdriver_classic::webdriver_classic_get_element_shadow_root),
)
.protocol_route(
"/session/{session_id}/shadow/{shadow_root_id}/element",
post(webdriver_classic::webdriver_classic_find_shadow_element),
)
.protocol_route(
"/session/{session_id}/shadow/{shadow_root_id}/elements",
post(webdriver_classic::webdriver_classic_find_shadow_elements),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/attribute/{name}",
get(webdriver_classic::webdriver_classic_get_element_attribute),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/text",
get(webdriver_classic::webdriver_classic_get_element_text),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/name",
get(webdriver_classic::webdriver_classic_get_element_tag_name),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/equals/{other_element_id}",
get(webdriver_classic::webdriver_classic_element_equals),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/enabled",
get(webdriver_classic::webdriver_classic_is_element_enabled),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/displayed",
get(webdriver_classic::webdriver_classic_is_element_displayed),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/selected",
get(webdriver_classic::webdriver_classic_is_element_selected),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/rect",
get(webdriver_classic::webdriver_classic_get_element_rect),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/screenshot",
get(webdriver_classic::webdriver_classic_take_element_screenshot),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/css/{property_name}",
get(webdriver_classic::webdriver_classic_get_element_css_value),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/computedlabel",
get(webdriver_classic::webdriver_classic_get_element_computed_label),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/computedrole",
get(webdriver_classic::webdriver_classic_get_element_computed_role),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/property/{name}",
get(webdriver_classic::webdriver_classic_get_element_property),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/clear",
post(webdriver_classic::webdriver_classic_clear_element),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/click",
post(webdriver_classic::webdriver_classic_click_element),
)
.protocol_route(
"/session/{session_id}/element/{element_id}/value",
post(webdriver_classic::webdriver_classic_send_keys_to_element),
)
.protocol_route(
"/session/{session_id}/actions",
post(webdriver_classic::webdriver_classic_perform_actions)
.delete(webdriver_classic::webdriver_classic_release_actions),
)
.protocol_route(
"/session/{session_id}/cookie",
get(webdriver_classic::webdriver_classic_get_cookies)
.post(webdriver_classic::webdriver_classic_add_cookie)
.delete(webdriver_classic::webdriver_classic_delete_all_cookies),
)
.protocol_route(
"/session/{session_id}/cookie/{name}",
get(webdriver_classic::webdriver_classic_get_named_cookie)
.delete(webdriver_classic::webdriver_classic_delete_cookie),
)
.with_state(app_state)
.layer(middleware::from_fn(
classic_webdriver_response_headers_middleware,
))
.layer(middleware::from_fn_with_state(control, instance_admission));
// The outer make-service wrapper bypasses Router's own eager finalization.
let router = router.with_state(());
trailing_slash::TrailingSlashLayer::new(&[JSON_DISCOVERY_PATH]).layer(router)
}
async fn instance_admission(
State(control): State<BrowserInstanceControl>,
request: Request<Body>,
next: Next,
) -> Response {
let Some(_connection) = control.connection() else {
return axum::http::StatusCode::SERVICE_UNAVAILABLE.into_response();
};
next.run(request).await
}
async fn classic_webdriver_response_headers_middleware(
request: Request<Body>,
next: Next,
) -> Response {
let should_apply = is_classic_webdriver_http_path(request.uri().path())
&& !is_websocket_upgrade_request(&request);
let mut response = next.run(request).await;
if should_apply && is_classic_webdriver_json_response(&response) {
let headers = response.headers_mut();
headers.insert(header::CACHE_CONTROL, HeaderValue::from_static("no-cache"));
headers.insert(
header::CONTENT_TYPE,
HeaderValue::from_static("application/json; charset=utf-8"),
);
}
response
}
fn is_classic_webdriver_json_response(response: &Response) -> bool {
response
.headers()
.get(header::CONTENT_TYPE)
.and_then(|value| value.to_str().ok())
.is_some_and(|value| {
value
.split_once(';')
.map_or(value, |(media_type, _)| media_type)
.trim()
.eq_ignore_ascii_case("application/json")
})
}
fn is_classic_webdriver_http_path(path: &str) -> bool {
path == "/status"
|| path == "/status/"
|| path == "/session"
|| path == "/session/"
|| path.starts_with("/session/")
}
fn is_websocket_upgrade_request(request: &Request<Body>) -> bool {
request
.headers()
.get(header::UPGRADE)
.is_some_and(|value| value.as_bytes().eq_ignore_ascii_case(b"websocket"))
}
#[derive(Clone)]
struct AppState {
control: BrowserInstanceControl,
debugger_enabled: bool,
browser_ws_url: String,
page_ws_url: String,
bidi_ws_url: String,
bidi_session_registry: SharedBidiSessionRegistry,
classic_session_registry: SharedClassicSessionRegistry,
cdp_agent_host_directory: SharedCdpAgentHostDirectory,
cdp_owner_registry: SharedCdpOwnerRegistry,
devtools_frontend_url: String,
cookie_profile: SharedCookieProfile,
storage_partition: Arc<StoragePartitionState>,
fetch_config: FetchConfig,
optional_resource_fetch_mask: OptionalResourceFetchMask,
subframe_loading_enabled: bool,
layout_configuration: LayoutConfiguration,
}
impl AppState {
#[cfg(test)]
fn new_with_storage_partition(
addr: SocketAddr,
storage_partition: Arc<StoragePartitionState>,
fetch_config: FetchConfig,
optional_resource_fetch_mask: OptionalResourceFetchMask,
subframe_loading_enabled: bool,
) -> anyhow::Result<Self> {
Self::new_with_storage_partition_and_runtime_config(
addr,
storage_partition,
NavigationRuntimeConfig::new(
fetch_config,
optional_resource_fetch_mask,
subframe_loading_enabled,
LayoutPolicy::default(),
),
crate::config::DEFAULT_SCREENCAST_INTERVAL_MS,
BrowserInstanceControl::new(),
)
}
fn new_with_storage_partition_and_runtime_config(
addr: SocketAddr,
storage_partition: Arc<StoragePartitionState>,
navigation_runtime_config: NavigationRuntimeConfig,
screencast_interval_ms: u32,
control: BrowserInstanceControl,
) -> anyhow::Result<Self> {
Ok(Self::from_parts(
addr,
SharedCookieProfile::from_storage_partition(storage_partition.clone()),
storage_partition,
navigation_runtime_config,
screencast_interval_ms,
control,
))
}
fn from_parts(
addr: SocketAddr,
cookie_profile: SharedCookieProfile,
storage_partition: Arc<StoragePartitionState>,
navigation_runtime_config: NavigationRuntimeConfig,
screencast_interval_ms: u32,
control: BrowserInstanceControl,
) -> Self {
let cdp_agent_host_directory = SharedCdpAgentHostDirectory::default();
let cdp_target_id_allocator = Arc::new(AtomicU64::new(0));
let cdp_tab_target_id_allocator = Arc::new(AtomicU64::new(0));
let cdp_owner_registry = SharedCdpOwnerRegistry::new(
cdp_agent_host_directory.clone(),
cdp_target_id_allocator,
cdp_tab_target_id_allocator,
cookie_profile.clone(),
storage_partition.clone(),
navigation_runtime_config.clone(),
screencast_interval_ms,
control.clone(),
);
Self {
control,
browser_ws_url: format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"),
debugger_enabled: navigation_runtime_config.debugger_enabled(),
page_ws_url: format!("ws://{addr}/devtools/page/{DEFAULT_TARGET_ID}"),
bidi_ws_url: format!("ws://{addr}/session"),
bidi_session_registry: SharedBidiSessionRegistry::default(),
classic_session_registry: SharedClassicSessionRegistry::default(),
cdp_agent_host_directory,
cdp_owner_registry,
devtools_frontend_url: format!(
"/devtools/inspector.html?ws={addr}/devtools/page/{DEFAULT_TARGET_ID}"
),
cookie_profile,
storage_partition,
fetch_config: navigation_runtime_config.fetch_config().clone(),
optional_resource_fetch_mask: navigation_runtime_config.optional_resource_fetch_mask(),
subframe_loading_enabled: navigation_runtime_config.subframe_loading_enabled(),
layout_configuration: navigation_runtime_config.layout_configuration(),
}
}
fn initial_storage_partition(
&self,
initial_cookies: Vec<StoredCookie>,
) -> CdpInitialStoragePartition {
CdpInitialStoragePartition::from_storage_partition(
initial_cookies,
self.storage_partition.as_ref(),
)
}
}
#[derive(Debug, Clone)]
struct SharedCookieProfile {
backing: SharedCookieProfileBacking,
}
#[derive(Debug, Clone)]
enum SharedCookieProfileBacking {
#[cfg(test)]
Legacy(Arc<Mutex<CookieProfile>>),
StoragePartition(Arc<StoragePartitionState>),
}
#[derive(Debug, Clone, Default)]
struct CookieProfileCommit {
initial_cookies: Vec<StoredCookie>,
final_cookies: Option<Vec<StoredCookie>>,
}
impl CookieProfileCommit {
fn new(initial_cookies: Vec<StoredCookie>, final_cookies: Vec<StoredCookie>) -> Self {
Self {
initial_cookies,
final_cookies: Some(final_cookies),
}
}
fn unchanged() -> Self {
Self {
initial_cookies: Vec::new(),
final_cookies: None,
}
}
fn from_optional_profile_backed_snapshot(
initial_cookies: Vec<StoredCookie>,
final_cookies: Option<Vec<StoredCookie>>,
) -> Self {
match final_cookies {
Some(final_cookies) => Self::new(initial_cookies, final_cookies),
None => Self::unchanged(),
}
}
fn is_unchanged(&self) -> bool {
self.final_cookies.is_none()
}
}
impl SharedCookieProfile {
#[cfg(test)]
fn new(initial_cookies: Vec<StoredCookie>, cache_paths: Vec<PathBuf>) -> Self {
Self {
backing: SharedCookieProfileBacking::Legacy(Arc::new(Mutex::new(CookieProfile {
cookies: initial_cookies,
cache_paths,
}))),
}
}
fn from_storage_partition(storage_partition: Arc<StoragePartitionState>) -> Self {
Self {
backing: SharedCookieProfileBacking::StoragePartition(storage_partition),
}
}
fn snapshot(&self) -> Vec<StoredCookie> {
match &self.backing {
#[cfg(test)]
SharedCookieProfileBacking::Legacy(inner) => inner.lock().cookies.clone(),
SharedCookieProfileBacking::StoragePartition(storage_partition) => storage_partition
.cookies()
.expect("storage partition cookie snapshot should succeed"),
}
}
fn commit_and_save(&self, commit: CookieProfileCommit) -> Result<()> {
if commit.is_unchanged() {
return Ok(());
}
match &self.backing {
#[cfg(test)]
SharedCookieProfileBacking::Legacy(inner) => {
let (cookies, cache_paths) = {
let mut profile = inner.lock();
commit_cookie_profile(&mut profile.cookies, commit);
(profile.cookies.clone(), profile.cache_paths.clone())
};
for path in cache_paths {
cookie_cache::save_cookie_cache(&path, cookies.clone()).with_context(|| {
anyhow!("failed to save cookie cache `{}`", path.display())
})?;
}
Ok(())
}
SharedCookieProfileBacking::StoragePartition(storage_partition) => {
storage_partition.commit_cookie_delta(&commit.initial_cookies, commit.final_cookies)
}
}
}
#[cfg(test)]
fn merge_and_save(&self, cookies: Vec<StoredCookie>) -> Result<()> {
self.commit_and_save(CookieProfileCommit::new(Vec::new(), cookies))
}
}
#[cfg(test)]
#[derive(Debug)]
struct CookieProfile {
cookies: Vec<StoredCookie>,
cache_paths: Vec<PathBuf>,
}
#[cfg(test)]
fn merge_cookie_profiles(base: &mut Vec<StoredCookie>, updates: Vec<StoredCookie>) {
for cookie in updates.into_iter().filter(|cookie| !cookie.is_expired()) {
if let Some(existing) = base
.iter_mut()
.find(|existing| same_cookie_key(existing, &cookie))
{
*existing = cookie;
} else {
base.push(cookie);
}
}
base.retain(|cookie| !cookie.is_expired());
}
#[cfg(test)]
fn commit_cookie_profile(base: &mut Vec<StoredCookie>, commit: CookieProfileCommit) {
let Some(final_cookies) = commit.final_cookies else {
return;
};
let final_cookies = final_cookies
.into_iter()
.filter(|cookie| !cookie.is_expired())
.collect::<Vec<_>>();
for initial in commit
.initial_cookies
.iter()
.filter(|cookie| !cookie.is_expired())
{
let cookie_still_exists_in_session = final_cookies
.iter()
.any(|cookie| same_cookie_key(cookie, initial));
if cookie_still_exists_in_session {
continue;
}
if let Some(position) = base
.iter()
.position(|cookie| same_cookie_key(cookie, initial) && cookie == initial)
{
base.remove(position);
}
}
merge_cookie_profiles(base, final_cookies);
}
#[cfg(test)]
fn same_cookie_key(left: &StoredCookie, right: &StoredCookie) -> bool {
left.name == right.name
&& left.domain == right.domain
&& left.path == right.path
&& left.partition_key == right.partition_key
}
#[cfg(test)]
mod tests;