Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(cdp): aggregate target policy by session
ldm042ca2882d26d
diff --git a/moli-core/src/page/settings_support.rs b/moli-core/src/page/settings_support.rsindex 55df1010f..512693560 100644--- a/moli-core/src/page/settings_support.rs+++ b/moli-core/src/page/settings_support.rs@@ -127,6 +127,49 @@ impl Page {)}+ pub async fn set_network_request_policy_async(+ &mut self,+ extra_http_headers: &[(String, String)],+ bypass_service_worker: bool,+ cache_disabled: bool,+ ) -> Result<()> {+ self.dispatch_unit_page_command_async(+ RendererPageCommand::SetNetworkRequestPolicy {+ extra_http_headers: extra_http_headers.to_vec(),+ bypass_service_worker,+ cache_disabled,+ },+ "set network request policy",+ )+ .await+ }++ pub fn start_set_network_request_policy(+ &self,+ extra_http_headers: &[(String, String)],+ bypass_service_worker: bool,+ cache_disabled: bool,+ ) -> Result<PendingPageCommand> {+ self.start_page_command(RendererPageCommand::SetNetworkRequestPolicy {+ extra_http_headers: extra_http_headers.to_vec(),+ bypass_service_worker,+ cache_disabled,+ })+ }++ pub fn finish_set_network_request_policy(+ &mut self,+ completion: CompletedPageCommand,+ ) -> Result<()> {+ let reply = self.finish_page_command(completion);+ expect_page_reply!(+ reply,+ "set network request policy",+ "a unit reply",+ RendererPageReply::Unit => Ok(()),+ )+ }+pub async fn set_permission_overrides_async(&mut self,overrides: &[PermissionOverrideRegistration],diff --git a/moli-core/src/runtime/navigation_engine.rs b/moli-core/src/runtime/navigation_engine.rsindex c570373a0..88e8743cf 100644--- a/moli-core/src/runtime/navigation_engine.rs+++ b/moli-core/src/runtime/navigation_engine.rs@@ -709,6 +709,10 @@ impl NavigationEngine {self.page_network_policy.set_bypass_service_worker(bypass);}+ pub fn set_cache_disabled(&mut self, disabled: bool) {+ self.page_network_policy.set_cache_disabled(disabled);+ }+fn ensure_resource_runtime(&mut self,cookie_store: SharedBrowserCookieStore,diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rsindex 751d67540..570947270 100644--- a/moli-protocol/src/conn.rs+++ b/moli-protocol/src/conn.rs@@ -554,10 +554,10 @@ pub(crate) use state::{BrowserContextStoragePartitionHandles, CommittedRendererAgentAttachment,CommittedRendererDocumentBinding, CompletedDownloadBody, CompletedDownloadBodyArtifact,DedicatedWorkerMainScriptOutcome, DedicatedWorkerMainScriptSnapshot,- DedicatedWorkerTargetState, DevToolsConsoleOutputSessionState, DevToolsLogViolationThreshold,- DocumentNavigationToken, DuplicatePendingRendererCommand, EmulatedNetworkConditions,- EmulatedViewportSurface, InspectorCommandDispatch, NETWORK_ERROR_PAGE_URL,- NavigationResultProjection, NavigationSourceDocumentSecurityContext,+ DedicatedWorkerTargetState, DevToolsBrowserIdentityOverride, DevToolsConsoleOutputSessionState,+ DevToolsLogViolationThreshold, DocumentNavigationToken, DuplicatePendingRendererCommand,+ EmulatedNetworkConditions, EmulatedViewportSurface, InspectorCommandDispatch,+ NETWORK_ERROR_PAGE_URL, NavigationResultProjection, NavigationSourceDocumentSecurityContext,NetworkErrorPageNavigation, PageScreencastConfig, PageScreencastFormat, ParkedTargetOwnerState,PendingBidiChannelListener, PendingInspectorAwait, PendingRendererCommandKey,PerformanceTimeDomain, PreparedRendererCallDispatch, ProfilerAction, ProfilerInspectorCommand,diff --git a/moli-protocol/src/conn/browser_context/emulation_owner.rs b/moli-protocol/src/conn/browser_context/emulation_owner.rsindex ff86fdc58..bad8932be 100644--- a/moli-protocol/src/conn/browser_context/emulation_owner.rs+++ b/moli-protocol/src/conn/browser_context/emulation_owner.rs@@ -1,17 +1,11 @@use super::target_session_owner::{TargetSessionOwnerMut, TargetSessionOwnerRef};use super::*;-use crate::conn::state::TargetSessionOverrideStack;use crate::conn::{EmulatedDeviceMetrics, EmulatedGeolocationOverrideState, EmulatedMediaOverrides,EmulatedNetworkConditions,};pub(crate) struct TargetEmulationSessionStateMut<'a> {- session_id: Option<String>,- pub(crate) locale_override: &'a mut Option<String>,- pub(crate) timezone_override: &'a mut Option<String>,- locale_overrides: &'a mut TargetSessionOverrideStack<String>,- timezone_overrides: &'a mut TargetSessionOverrideStack<String>,pub(crate) network_conditions: &'a mut Option<EmulatedNetworkConditions>,pub(crate) geolocation_override: &'a mut Option<EmulatedGeolocationOverrideState>,pub(crate) emulated_media: &'a mut EmulatedMediaOverrides,@@ -23,20 +17,6 @@ pub(crate) struct TargetEmulationSessionStateMut<'a> {pub(crate) script_execution_disabled: &'a mut bool,}-impl TargetEmulationSessionStateMut<'_> {- pub(crate) fn set_locale_override(&mut self, locale: Option<String>) {- self.locale_overrides- .replace(self.session_id.as_deref(), locale);- *self.locale_override = self.locale_overrides.effective().cloned();- }-- pub(crate) fn set_timezone_override(&mut self, timezone: Option<String>) {- self.timezone_overrides- .replace(self.session_id.as_deref(), timezone);- *self.timezone_override = self.timezone_overrides.effective().cloned();- }-}-impl TargetSessionOwnerMut<'_> {fn mutate_emulation_session_state(mut self,@@ -44,17 +24,10 @@ impl TargetSessionOwnerMut<'_> {) -> bool {match &mut self {Self::ActiveTarget {- browser_context,- session_id,- ..+ browser_context, ..} => {let state = browser_context.active_page_state_mut();f(Some(TargetEmulationSessionStateMut {- session_id: session_id.clone(),- locale_override: &mut state.locale_override,- timezone_override: &mut state.timezone_override,- locale_overrides: &mut state.locale_overrides,- timezone_overrides: &mut state.timezone_overrides,network_conditions: &mut state.network_conditions,geolocation_override: &mut state.geolocation_override,emulated_media: &mut state.emulated_media,@@ -69,15 +42,9 @@ impl TargetSessionOwnerMut<'_> {Self::PageTargetHost {browser_context,target_id,- session_id,..} => browser_context.mutate_parked_page_session_state(target_id, |state| {f(Some(TargetEmulationSessionStateMut {- session_id: session_id.clone(),- locale_override: &mut state.locale_override,- timezone_override: &mut state.timezone_override,- locale_overrides: &mut state.locale_overrides,- timezone_overrides: &mut state.timezone_overrides,network_conditions: &mut state.network_conditions,geolocation_override: &mut state.geolocation_override,emulated_media: &mut state.emulated_media,@@ -96,6 +63,48 @@ impl TargetSessionOwnerMut<'_> {}true}++ fn set_devtools_locale_override(+ &mut self,+ locale_override: Option<String>,+ ) -> Result<(), &'static str> {+ self.mutate_page_state(|state, is_auxiliary_target_session, session_id| {+ state.set_devtools_locale_override(+ is_auxiliary_target_session,+ session_id,+ locale_override,+ )+ })+ .unwrap_or(Err("BrowserContextNotLoaded"))+ }++ fn set_devtools_timezone_override(+ &mut self,+ timezone_override: Option<String>,+ ) -> Result<(), &'static str> {+ self.mutate_page_state(|state, is_auxiliary_target_session, session_id| {+ state.set_devtools_timezone_override(+ is_auxiliary_target_session,+ session_id,+ timezone_override,+ )+ })+ .unwrap_or(Err("BrowserContextNotLoaded"))+ }++ fn set_base_locale_override(&mut self, locale_override: Option<String>) -> bool {+ self.mutate_page_state(|state, _is_auxiliary_target_session, _session_id| {+ state.set_base_locale_override(locale_override);+ })+ .is_some()+ }++ fn set_base_timezone_override(&mut self, timezone_override: Option<String>) -> bool {+ self.mutate_page_state(|state, _is_auxiliary_target_session, _session_id| {+ state.set_base_timezone_override(timezone_override);+ })+ .is_some()+ }}impl TargetSessionOwnerRef<'_> {@@ -128,6 +137,44 @@ impl CdpConnection {.unwrap_or(false)}+ pub(crate) fn set_devtools_locale_override_for_session_owner(+ &mut self,+ session_id: Option<&str>,+ locale_override: Option<String>,+ ) -> Result<(), &'static str> {+ self.target_session_owner_mut(session_id)+ .ok_or("BrowserContextNotLoaded")?+ .set_devtools_locale_override(locale_override)+ }++ pub(crate) fn set_devtools_timezone_override_for_session_owner(+ &mut self,+ session_id: Option<&str>,+ timezone_override: Option<String>,+ ) -> Result<(), &'static str> {+ self.target_session_owner_mut(session_id)+ .ok_or("BrowserContextNotLoaded")?+ .set_devtools_timezone_override(timezone_override)+ }++ pub(crate) fn set_base_locale_override_for_session_owner(+ &mut self,+ session_id: Option<&str>,+ locale_override: Option<String>,+ ) -> bool {+ self.target_session_owner_mut(session_id)+ .is_some_and(|mut owner| owner.set_base_locale_override(locale_override))+ }++ pub(crate) fn set_base_timezone_override_for_session_owner(+ &mut self,+ session_id: Option<&str>,+ timezone_override: Option<String>,+ ) -> bool {+ self.target_session_owner_mut(session_id)+ .is_some_and(|mut owner| owner.set_base_timezone_override(timezone_override))+ }+pub(crate) fn emit_touch_events_for_mouse_for_session_owner(&self,session_id: Option<&str>,diff --git a/moli-protocol/src/conn/browser_context/network_owner.rs b/moli-protocol/src/conn/browser_context/network_owner.rsindex f6718a7ea..728818ab0 100644--- a/moli-protocol/src/conn/browser_context/network_owner.rs+++ b/moli-protocol/src/conn/browser_context/network_owner.rs@@ -11,18 +11,6 @@ use crate::domains::network::{use moli_core::page::PendingPageCommand;impl TargetSessionStateMut<'_> {- fn set_cache_disabled(mut self, cache_disabled: bool) {- if let Some(network_policy) = self.network_policy_mut() {- network_policy.set_cache_disabled(cache_disabled);- }- }-- fn set_bypass_service_worker(mut self, bypass_service_worker: bool) {- if let Some(network_policy) = self.network_policy_mut() {- network_policy.set_bypass_service_worker(bypass_service_worker);- }- }-fn set_blocked_url_patterns(mut self,blocked_url_patterns: Vec<String>,@@ -31,47 +19,6 @@ impl TargetSessionStateMut<'_> {Some(network_policy.replace_blocked_url_patterns(blocked_url_patterns))}- fn set_extra_http_headers(- mut self,- extra_headers: Vec<(String, String)>,- ) -> Option<Vec<(String, String)>> {- let session_id = match &self {- Self::Active { session_id, .. } | Self::Parked { session_id, .. } => session_id.clone(),- Self::NoLoaded => None,- };- let network_policy = self.network_policy_mut()?;- Some(network_policy.replace_extra_headers_for_session(session_id.as_deref(), extra_headers))- }-- #[cfg(test)]- fn set_user_agent_override(mut self, user_agent: Option<String>) -> bool {- let should_refresh_active_engine = matches!(self, Self::Active { .. });- if let Some(network_policy) = self.network_policy_mut() {- if let Some(user_agent) = user_agent {- network_policy.set_user_agent_override(user_agent);- } else {- network_policy.clear_browser_identity_override();- }- }- should_refresh_active_engine- }-- fn set_browser_identity_override(- mut self,- browser_identity: Option<moli_browser_profile::BrowserIdentityProfile>,- ) -> bool {- let should_refresh_active_engine = matches!(self, Self::Active { .. });- let session_id = match &self {- Self::Active { session_id, .. } | Self::Parked { session_id, .. } => session_id.clone(),- Self::NoLoaded => None,- };- if let Some(network_policy) = self.network_policy_mut() {- network_policy- .set_browser_identity_override_for_session(session_id.as_deref(), browser_identity);- }- should_refresh_active_engine- }-fn set_tls_verify_host_override(mut self, enabled: bool) -> bool {let should_refresh_active_engine = matches!(self, Self::Active { .. });if let Some(tls_verify_host_override) = self.tls_verify_host_override_mut() {@@ -137,12 +84,24 @@ impl<'a> TargetSessionOwnerMut<'a> {}}- fn enable_listener(self, session_id: Option<&str>) -> bool {+ fn enable_listener(mut self, session_id: Option<&str>) -> bool {+ if self+ .mutate_network_policy_session_state(|state| state.network_enabled = true)+ .is_none()+ {+ return false;+ }self.into_network_listener_owner().enable_listener(session_id)}- fn disable_listener(self, session_id: Option<&str>) -> bool {+ fn disable_listener(mut self, session_id: Option<&str>) -> bool {+ if self+ .mutate_network_policy_session_state(|state| *state = Default::default())+ .is_none()+ {+ return false;+ }self.into_network_listener_owner().disable_listener(session_id)}@@ -383,14 +342,67 @@ impl TargetNetworkListenerOwnerMut<'_> {}impl TargetSessionOwnerMut<'_> {- fn set_cache_disabled(self, cache_disabled: bool) -> bool {+ fn mutate_network_policy_session_state<T>(+ &mut self,+ f: impl FnOnce(&mut crate::conn::state::DevToolsNetworkSessionState) -> T,+ ) -> Option<T> {+ fn mutate<T>(+ page_state: &mut crate::conn::state::TargetPageState,+ session_id: Option<&str>,+ is_auxiliary_target_session: bool,+ f: impl FnOnce(&mut crate::conn::state::DevToolsNetworkSessionState) -> T,+ ) -> T {+ page_state.mutate_devtools_network_session_state(+ is_auxiliary_target_session,+ session_id,+ f,+ )+ }+match self {- Self::NoLoadedBrowserContext => false,- owner => {- owner.mutate_session_state(|state| state.set_cache_disabled(cache_disabled));- true- }+ Self::ActiveTarget {+ browser_context,+ session_id,+ is_auxiliary_target_session,+ ..+ } => Some(mutate(+ browser_context.active_page_state_mut(),+ session_id.as_deref(),+ *is_auxiliary_target_session,+ f,+ )),+ Self::PageTargetHost {+ browser_context,+ target_id,+ session_id,+ is_auxiliary_target_session,+ } => Some(+ browser_context.mutate_parked_page_session_state(target_id, |page_state| {+ mutate(+ page_state,+ session_id.as_deref(),+ *is_auxiliary_target_session,+ f,+ )+ }),+ ),+ Self::NoLoadedBrowserContext => None,+ }+ }++ fn start_set_cache_disabled(+ mut self,+ cache_disabled: bool,+ ) -> Result<Option<PendingPageCommand>, String> {+ if self+ .mutate_network_policy_session_state(|state| {+ state.cache_disabled = cache_disabled;+ })+ .is_none()+ {+ return Err("BrowserContextNotLoaded".to_owned());}+ self.start_replay_effective_network_request_policy()}fn start_set_bypass_service_worker(@@ -400,16 +412,23 @@ impl TargetSessionOwnerMut<'_> {if matches!(self, Self::NoLoadedBrowserContext) {return Err("BrowserContextNotLoaded".to_owned());}- self.mutate_session_state_ref(|state| {- state.set_bypass_service_worker(bypass_service_worker);+ self.mutate_network_policy_session_state(|state| {+ state.bypass_service_worker = bypass_service_worker;});+ let effective_bypass = self+ .mutate_session_state_ref(|mut state| {+ state+ .network_policy_mut()+ .map(|policy| policy.bypass_service_worker())+ })+ .unwrap_or(bypass_service_worker);let Some(page) = self.runtime_slot_mut().and_then(|runtime_slot| runtime_slot.loaded_page_mut())else {return Ok(None);};- page.start_set_bypass_service_worker(bypass_service_worker)+ page.start_set_bypass_service_worker(effective_bypass).map(Some).map_err(|error| format!("failed to update page service worker bypass: {error}"))}@@ -444,11 +463,47 @@ impl TargetSessionOwnerMut<'_> {if matches!(self, Self::NoLoadedBrowserContext) {return Err("BrowserContextNotLoaded".to_owned());}- let Some(headers) =- self.mutate_session_state_ref(|state| state.set_extra_http_headers(extra_headers))+ if self+ .mutate_network_policy_session_state(|state| {+ state.extra_headers = extra_headers;+ })+ .is_none()+ {+ return Ok(None);+ }+ let headers = self+ .mutate_session_state_ref(|mut state| {+ state+ .network_policy_mut()+ .map(|policy| policy.extra_headers().to_vec())+ })+ .unwrap_or_default();+ let effective_headers = self.effective_extra_headers_for_target_policy(headers);+ let Some(page) = self+ .runtime_slot_mut()+ .and_then(|runtime_slot| runtime_slot.loaded_page_mut())else {return Ok(None);};+ page.start_set_extra_http_headers(&effective_headers)+ .map(Some)+ .map_err(|error| format!("failed to update page extra HTTP headers: {error}"))+ }++ fn start_set_target_extra_http_headers(+ mut self,+ extra_headers: Vec<(String, String)>,+ ) -> Result<Option<PendingPageCommand>, String> {+ if matches!(self, Self::NoLoadedBrowserContext) {+ return Err("BrowserContextNotLoaded".to_owned());+ }+ let headers = self+ .mutate_session_state_ref(|mut state| {+ state+ .network_policy_mut()+ .map(|policy| policy.replace_base_extra_headers(extra_headers))+ })+ .unwrap_or_default();let effective_headers = self.effective_extra_headers_for_target_policy(headers);let Some(page) = self.runtime_slot_mut()@@ -461,21 +516,81 @@ impl TargetSessionOwnerMut<'_> {.map_err(|error| format!("failed to update page extra HTTP headers: {error}"))}- fn set_browser_identity_override(- mut self,+ fn start_replay_effective_network_request_policy(+ &mut self,+ ) -> Result<Option<PendingPageCommand>, String> {+ if matches!(self, Self::NoLoadedBrowserContext) {+ return Err("BrowserContextNotLoaded".to_owned());+ }+ let (headers, bypass_service_worker, cache_disabled) = self+ .mutate_session_state_ref(|mut state| {+ state.network_policy_mut().map(|policy| {+ (+ policy.extra_headers().to_vec(),+ policy.bypass_service_worker(),+ policy.cache_disabled(),+ )+ })+ })+ .unwrap_or_default();+ let effective_headers = self.effective_extra_headers_for_target_policy(headers);+ let Some(page) = self+ .runtime_slot_mut()+ .and_then(|runtime_slot| runtime_slot.loaded_page_mut())+ else {+ return Ok(None);+ };+ page.start_set_network_request_policy(+ &effective_headers,+ bypass_service_worker,+ cache_disabled,+ )+ .map(Some)+ .map_err(|error| format!("failed to replay page network request policy: {error}"))+ }++ fn set_devtools_browser_identity_override(+ &mut self,+ browser_identity: Option<crate::conn::DevToolsBrowserIdentityOverride>,+ ) -> Option<bool> {+ let refresh_active_engine = matches!(+ self,+ Self::ActiveTarget {+ is_current_active_browser_context: true,+ ..+ }+ );+ self.mutate_page_state(|state, is_auxiliary_target_session, session_id| {+ state.set_devtools_browser_identity_override(+ is_auxiliary_target_session,+ session_id,+ browser_identity,+ );+ })?;+ Some(refresh_active_engine)+ }++ fn set_base_browser_identity_override(+ &mut self,browser_identity: Option<moli_browser_profile::BrowserIdentityProfile>,) -> Option<bool> {- self.mutate_session_state_ref(|state| {- state.set_browser_identity_override(browser_identity);- });- match self {+ let refresh_active_engine = matches!(+ self,Self::ActiveTarget {- is_current_active_browser_context,+ is_current_active_browser_context: true,..- } => Some(is_current_active_browser_context),- Self::PageTargetHost { .. } => Some(false),- Self::NoLoadedBrowserContext => None,- }+ }+ );+ self.mutate_page_state(|state, _is_auxiliary_target_session, _session_id| {+ if let Some(browser_identity) = browser_identity {+ state+ .network_policy+ .set_browser_identity_override(browser_identity);+ } else {+ state.network_policy.clear_browser_identity_override();+ }+ })?;+ Some(refresh_active_engine)}fn set_tls_verify_host_override(mut self, enabled: bool) -> Option<bool> {@@ -780,11 +895,15 @@ impl CdpConnection {pub(crate) fn set_global_cache_disabled(&mut self, cache_disabled: bool) {self.global_cache_disabled = cache_disabled;- if let Some(browser_context) = self.browser_context.as_mut() {- browser_context.global_cache_disabled = cache_disabled;- }- for browser_context in &mut self.inactive_browser_contexts {+ for browser_context in self+ .browser_context+ .iter_mut()+ .chain(self.inactive_browser_contexts.iter_mut())+ {browser_context.global_cache_disabled = cache_disabled;+ for target in browser_context.page_targets.iter_mut() {+ target.set_base_cache_disabled(cache_disabled);+ }}}@@ -816,15 +935,15 @@ impl CdpConnection {.unwrap_or(false)}- pub(crate) fn set_cache_disabled_for_session_owner(+ pub(crate) fn start_set_cache_disabled_for_session_owner(&mut self,session_id: Option<&str>,cache_disabled: bool,- ) -> bool {- self.with_target_session_owner_mut(session_id, |owner| {- owner.set_cache_disabled(cache_disabled)- })- .unwrap_or(false)+ ) -> Result<Option<PendingPageCommand>, String> {+ let Some(owner) = self.target_session_owner_mut(session_id) else {+ return Err("BrowserContextNotLoaded".to_owned());+ };+ owner.start_set_cache_disabled(cache_disabled)}pub(crate) fn set_cache_disabled_for_target(@@ -832,13 +951,17 @@ impl CdpConnection {target_id: &str,cache_disabled: bool,) -> bool {- let Some(route) = self.target_session_route_for_target_id(target_id) else {- return false;- };- let mut route_scope = self.scoped_none_session_owner_route_override(route);- route_scope- .conn_mut()- .set_cache_disabled_for_session_owner(None, cache_disabled)+ for browser_context in self+ .browser_context+ .iter_mut()+ .chain(self.inactive_browser_contexts.iter_mut())+ {+ if let Some(target) = browser_context.page_target_mut(target_id) {+ target.set_base_cache_disabled(cache_disabled);+ return true;+ }+ }+ false}pub(crate) fn start_set_bypass_service_worker_for_session_owner(@@ -874,7 +997,38 @@ impl CdpConnection {owner.start_set_extra_http_headers(extra_headers)}- pub(crate) fn start_set_user_agent_override_for_session_owner(+ pub(crate) fn start_set_target_extra_http_headers_for_session_owner(+ &mut self,+ session_id: Option<&str>,+ extra_headers: Vec<(String, String)>,+ ) -> Result<Option<PendingPageCommand>, String> {+ let Some(owner) = self.target_session_owner_mut(session_id) else {+ return Err("BrowserContextNotLoaded".to_owned());+ };+ owner.start_set_target_extra_http_headers(extra_headers)+ }++ pub(crate) fn start_replay_effective_network_request_policy_for_session_owner(+ &mut self,+ session_id: Option<&str>,+ ) -> Result<Option<PendingPageCommand>, String> {+ if matches!(+ self.session_route(session_id),+ Some(+ CdpSessionRoute::DedicatedWorkerTarget { .. }+ | CdpSessionRoute::SharedWorkerTarget { .. }+ | CdpSessionRoute::ServiceWorkerTarget { .. }+ )+ ) {+ return Ok(None);+ }+ let Some(mut owner) = self.target_session_owner_mut(session_id) else {+ return Err("BrowserContextNotLoaded".to_owned());+ };+ owner.start_replay_effective_network_request_policy()+ }++ pub(crate) fn start_set_base_user_agent_override_for_session_owner(&mut self,session_id: Option<&str>,user_agent: Option<String>,@@ -885,47 +1039,91 @@ impl CdpConnection {self.base_browser_identity.accept_language(),)});- self.start_set_browser_identity_override_for_session_owner(session_id, browser_identity)+ self.start_set_base_browser_identity_override_for_session_owner(+ session_id,+ browser_identity,+ )}- pub(crate) fn start_set_browser_identity_override_for_session_owner(+ fn start_set_non_page_browser_identity_override(&mut self,session_id: Option<&str>,browser_identity: Option<moli_browser_profile::BrowserIdentityProfile>,- ) -> Result<Option<PendingPageCommand>, String> {- if matches!(+ ) -> Option<Result<Option<PendingPageCommand>, String>> {+ let is_browser_session = matches!(self.session_route(session_id),Some(CdpSessionRoute::Browser)- ) {- if let Some(browser_context) = self.browser_context.as_mut() {- if let Some(browser_identity) = browser_identity.clone() {- browser_context- .network_policy- .set_browser_identity_override(browser_identity);- } else {- browser_context- .network_policy- .clear_browser_identity_override();- }+ );+ let is_pre_context_root = session_id.is_none()+ && self.none_session_owner_route_override().is_none()+ && self.browser_context.is_none();+ if !is_browser_session && !is_pre_context_root {+ return None;+ }++ if is_browser_session && let Some(browser_context) = self.browser_context.as_mut() {+ if let Some(browser_identity) = browser_identity {+ browser_context+ .network_policy+ .set_browser_identity_override(browser_identity);} else {- self.global_browser_identity_override = browser_identity.clone();+ browser_context+ .network_policy+ .clear_browser_identity_override();}- self.apply_active_engine_fetch_overrides();- return self.start_rebuild_resource_runtime_for_session_owner(session_id);+ } else {+ self.global_browser_identity_override = browser_identity;}- if session_id.is_none()- && self.none_session_owner_route_override().is_none()- && self.browser_context.is_none()+ self.apply_active_engine_fetch_overrides();+ Some(self.start_rebuild_resource_runtime_for_session_owner(session_id))+ }++ pub(crate) fn start_set_devtools_browser_identity_override_for_session_owner(+ &mut self,+ session_id: Option<&str>,+ browser_identity: Option<crate::conn::DevToolsBrowserIdentityOverride>,+ ) -> Result<Option<PendingPageCommand>, String> {+ let non_page_identity = browser_identity+ .as_ref()+ .map(crate::conn::DevToolsBrowserIdentityOverride::to_browser_identity);+ if let Some(result) =+ self.start_set_non_page_browser_identity_override(session_id, non_page_identity){- self.global_browser_identity_override = browser_identity.clone();+ return result;+ }++ let Some(owner) = self.target_session_owner_mut(session_id) else {+ return Err("BrowserContextNotLoaded".to_owned());+ };+ let mut owner = owner;+ let Some(refresh_active_engine) =+ owner.set_devtools_browser_identity_override(browser_identity)+ else {+ return Err("BrowserContextNotLoaded".to_owned());+ };+ if refresh_active_engine {self.apply_active_engine_fetch_overrides();return self.start_rebuild_resource_runtime_for_session_owner(session_id);}+ Ok(None)+ }- let Some(owner) = self.target_session_owner_mut(session_id) else {+ pub(crate) fn start_set_base_browser_identity_override_for_session_owner(+ &mut self,+ session_id: Option<&str>,+ browser_identity: Option<moli_browser_profile::BrowserIdentityProfile>,+ ) -> Result<Option<PendingPageCommand>, String> {+ if let Some(result) =+ self.start_set_non_page_browser_identity_override(session_id, browser_identity.clone())+ {+ return result;+ }++ let Some(mut owner) = self.target_session_owner_mut(session_id) else {return Err("BrowserContextNotLoaded".to_owned());};- let Some(refresh_active_engine) = owner.set_browser_identity_override(browser_identity)+ let Some(refresh_active_engine) =+ owner.set_base_browser_identity_override(browser_identity)else {return Err("BrowserContextNotLoaded".to_owned());};@@ -1048,7 +1246,6 @@ mod tests {fn active_session_state_mut(browser_context: &mut BrowserContext) -> TargetSessionStateMut<'_> {let state = browser_context.active_page_state_mut();TargetSessionStateMut::Active {- session_id: None,devtools_session_state: &mut state.devtools_sessions[moli_page_types::DevToolsSessionKey::Primary],network_policy: &mut state.network_policy,@@ -1058,7 +1255,6 @@ mod tests {fn parked_session_state_mut(state: &mut TargetPageState) -> TargetSessionStateMut<'_> {TargetSessionStateMut::Parked {- session_id: None,devtools_session_state: &mut state.devtools_sessions[moli_page_types::DevToolsSessionKey::Primary],network_policy: &mut state.network_policy,@@ -1124,14 +1320,16 @@ mod tests {#[test]fn target_session_state_mut_applies_active_and_parked_network_fields() {let mut active = BrowserContext::new("BID-active".to_owned());- active_session_state_mut(&mut active).set_cache_disabled(true);- active_session_state_mut(&mut active).set_bypass_service_worker(true);+ {+ let network = &mut active.devtools_sessions.primary_mut().network_session_state;+ network.network_enabled = true;+ network.cache_disabled = true;+ network.bypass_service_worker = true;+ network.extra_headers = vec![("X-Test".to_owned(), "active".to_owned())];+ }+ active.refresh_devtools_network_policy();let active_blocked = active_session_state_mut(&mut active).set_blocked_url_patterns(vec!["*://blocked.test/*".to_owned()]);- let active_headers_should_apply = active_session_state_mut(&mut active)- .set_extra_http_headers(vec![("X-Test".to_owned(), "active".to_owned())]);- let active_user_agent_should_refresh = active_session_state_mut(&mut active)- .set_user_agent_override(Some("Moli/Active".to_owned()));let active_offline = active_session_state_mut(&mut active).set_emulated_network_conditions(true,25.0,@@ -1147,19 +1345,10 @@ mod tests {active.network_policy.blocked_url_patterns(),vec!["*://blocked.test/*"]);- assert_eq!(- active_headers_should_apply,- Some(vec![("X-Test".to_owned(), "active".to_owned())])- );assert_eq!(active.network_policy.extra_headers(),vec![("X-Test".to_owned(), "active".to_owned())]);- assert_eq!(- active.network_policy.user_agent_override(),- Some("Moli/Active")- );- assert!(active_user_agent_should_refresh);assert_eq!(active_offline, Some(true));assert!(active.network_policy.network_offline());assert_eq!(active.network_policy.emulated_network_latency(), 25.0);@@ -1171,14 +1360,16 @@ mod tests {);let mut parked = TargetPageState::default();- parked_session_state_mut(&mut parked).set_cache_disabled(true);- parked_session_state_mut(&mut parked).set_bypass_service_worker(true);+ {+ let network = &mut parked.devtools_sessions.primary_mut().network_session_state;+ network.network_enabled = true;+ network.cache_disabled = true;+ network.bypass_service_worker = true;+ network.extra_headers = vec![("X-Test".to_owned(), "parked".to_owned())];+ }+ parked.refresh_devtools_network_policy();let parked_blocked = parked_session_state_mut(&mut parked).set_blocked_url_patterns(vec!["*://parked-blocked.test/*".to_owned()]);- let parked_headers_should_apply = parked_session_state_mut(&mut parked)- .set_extra_http_headers(vec![("X-Test".to_owned(), "parked".to_owned())]);- let parked_user_agent_should_refresh = parked_session_state_mut(&mut parked)- .set_user_agent_override(Some("Moli/Parked".to_owned()));let parked_offline = parked_session_state_mut(&mut parked).set_emulated_network_conditions(true,50.0,@@ -1197,19 +1388,10 @@ mod tests {parked.network_policy.blocked_url_patterns(),vec!["*://parked-blocked.test/*"]);- assert_eq!(- parked_headers_should_apply,- Some(vec![("X-Test".to_owned(), "parked".to_owned())])- );assert_eq!(parked.network_policy.extra_headers(),vec![("X-Test".to_owned(), "parked".to_owned())]);- assert_eq!(- parked.network_policy.user_agent_override(),- Some("Moli/Parked")- );- assert!(!parked_user_agent_should_refresh);assert_eq!(parked_offline, Some(true));assert!(parked.network_policy.network_offline());assert_eq!(parked.network_policy.emulated_network_latency(), 50.0);diff --git a/moli-protocol/src/conn/browser_context/page_owner.rs b/moli-protocol/src/conn/browser_context/page_owner.rsindex 66d938230..f8ff48ea9 100644--- a/moli-protocol/src/conn/browser_context/page_owner.rs+++ b/moli-protocol/src/conn/browser_context/page_owner.rs@@ -1010,7 +1010,6 @@ mod tests {fn active_session_state_mut(browser_context: &mut BrowserContext) -> TargetSessionStateMut<'_> {let state = browser_context.active_page_state_mut();TargetSessionStateMut::Active {- session_id: None,devtools_session_state: &mut state.devtools_sessions[moli_page_types::DevToolsSessionKey::Primary],network_policy: &mut state.network_policy,@@ -1020,7 +1019,6 @@ mod tests {fn parked_session_state_mut(state: &mut TargetPageState) -> TargetSessionStateMut<'_> {TargetSessionStateMut::Parked {- session_id: None,devtools_session_state: &mut state.devtools_sessions[moli_page_types::DevToolsSessionKey::Primary],network_policy: &mut state.network_policy,diff --git a/moli-protocol/src/conn/browser_context/target_session_owner.rs b/moli-protocol/src/conn/browser_context/target_session_owner.rsindex e5acffe78..7cdf1baf1 100644--- a/moli-protocol/src/conn/browser_context/target_session_owner.rs+++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs@@ -4,7 +4,7 @@ use crate::conn::state::{BrowserContextPageStorageHandles, BrowserContextResourceStorageHandles, DevToolsSessionState,PageNavigationHistoryEntry, RendererMainDocumentCommitSeed, TargetFetchConfig,TargetNetworkPolicyState, TargetOwnerState, TargetPageAbsenceReason,- TargetPageResidenceIdentity, TargetRuntimeSessionState, TargetRuntimeSlot,+ TargetPageResidenceIdentity, TargetPageState, TargetRuntimeSessionState, TargetRuntimeSlot,};use crate::conn::{BackgroundProtocolEvent, ConnectionNetworkRequestIdAllocator, DocumentStartScript,@@ -104,13 +104,11 @@ impl ClosedPageTarget {pub(super) enum TargetSessionStateMut<'a> {Active {- session_id: Option<String>,devtools_session_state: &'a mut DevToolsSessionState,network_policy: &'a mut TargetNetworkPolicyState,tls_verify_host_override: &'a mut Option<bool>,},Parked {- session_id: Option<String>,devtools_session_state: &'a mut DevToolsSessionState,network_policy: &'a mut TargetNetworkPolicyState,tls_verify_host_override: &'a mut Option<bool>,@@ -196,6 +194,7 @@ pub(crate) struct TargetNavigationLoadInputs {pub(crate) viewport_surface: Option<moli_core::page::ViewportSurface>,pub(crate) network_offline: bool,pub(crate) bypass_service_worker: bool,+ pub(crate) cache_disabled: bool,pub(crate) blocked_url_patterns: Vec<String>,pub(crate) fetch_subresource_interception:(bool, Option<moli_core::page::SubresourceResourceType>),@@ -303,6 +302,7 @@ impl TargetNavigationLoadInputs {network_offline: browser_context.network_policy.network_offline()|| browser_context.effective_active_network_offline(),bypass_service_worker: browser_context.network_policy.bypass_service_worker(),+ cache_disabled: browser_context.network_policy.cache_disabled(),blocked_url_patterns: browser_context.network_policy.blocked_url_patterns()@@ -370,6 +370,7 @@ impl TargetNavigationLoadInputs {viewport_surface: None,network_offline: false,bypass_service_worker: false,+ cache_disabled: false,blocked_url_patterns: Vec::new(),fetch_subresource_interception: (false, None),permission_overrides: Vec::new(),@@ -823,6 +824,7 @@ impl<'a> TargetSessionOwnerRef<'a> {network_offline: page_state.network_policy.network_offline()|| browser_context.effective_parked_network_offline(target_id),bypass_service_worker: page_state.network_policy.bypass_service_worker(),+ cache_disabled: page_state.network_policy.cache_disabled(),blocked_url_patterns: page_state.network_policy.blocked_url_patterns().to_vec(),fetch_subresource_interception: page_state.fetch_owner@@ -954,7 +956,6 @@ impl<'a> TargetSessionOwnerMut<'a> {.devtools_sessions.routed_mut_or_insert(*is_auxiliary_target_session, session_id.as_deref());f(TargetSessionStateMut::Active {- session_id: session_id.clone(),devtools_session_state,network_policy: &mut state.network_policy,tls_verify_host_override: &mut state.tls_verify_host_override,@@ -971,7 +972,6 @@ impl<'a> TargetSessionOwnerMut<'a> {.devtools_sessions.routed_mut_or_insert(*is_auxiliary_target_session, session_id.as_deref());f(TargetSessionStateMut::Parked {- session_id: session_id.clone(),devtools_session_state,network_policy: &mut state.network_policy,tls_verify_host_override: &mut state.tls_verify_host_override,@@ -981,6 +981,36 @@ impl<'a> TargetSessionOwnerMut<'a> {}}+ pub(super) fn mutate_page_state<T>(+ &mut self,+ f: impl FnOnce(&mut TargetPageState, bool, Option<&str>) -> T,+ ) -> Option<T> {+ match self {+ Self::ActiveTarget {+ browser_context,+ session_id,+ is_auxiliary_target_session,+ ..+ } => Some(f(+ browser_context.active_page_state_mut(),+ *is_auxiliary_target_session,+ session_id.as_deref(),+ )),+ Self::PageTargetHost {+ browser_context,+ target_id,+ session_id,+ is_auxiliary_target_session,+ ..+ } => Some(+ browser_context.mutate_parked_page_session_state(target_id, |state| {+ f(state, *is_auxiliary_target_session, session_id.as_deref())+ }),+ ),+ Self::NoLoadedBrowserContext => None,+ }+ }+pub(super) fn mutate_session_state<T>(mut self,f: impl FnOnce(TargetSessionStateMut<'_>) -> T,@@ -4112,8 +4142,8 @@ mod tests {"https://parked.example/start".to_owned(),));parked.mutate_parked_page_session_state("TID-parked", |state| {- state.locale_override = Some("fr-FR".to_owned());- state.timezone_override = Some("Europe/Paris".to_owned());+ state.set_base_locale_override(Some("fr-FR".to_owned()));+ state.set_base_timezone_override(Some("Europe/Paris".to_owned()));state.http_proxy_override = Some("http://proxy.example:8080".to_owned());state.http_no_proxy_override = Some("localhost,127.0.0.1".to_owned());state.tls_verify_host_override = Some(false);diff --git a/moli-protocol/src/conn/downloads.rs b/moli-protocol/src/conn/downloads.rsindex a94886cb7..b6a1f76d6 100644--- a/moli-protocol/src/conn/downloads.rs+++ b/moli-protocol/src/conn/downloads.rs@@ -416,7 +416,9 @@ impl CdpConnection {let mut request = Request::get(&activation.url).map_err(|error| format!("invalid download url: {error}"))?;request.request_headers = owner.request_headers;- request = request.with_top_level_navigation_cookie_context();+ request = request+ .with_top_level_navigation_cookie_context()+ .with_page_network_policy();if let Some(ref initiator_url) = owner.initiator_url {request = request.with_initiator_url(initiator_url);}diff --git a/moli-protocol/src/conn/page_state/fetch_state.rs b/moli-protocol/src/conn/page_state/fetch_state.rsindex 68249b3ab..c24ff7f62 100644--- a/moli-protocol/src/conn/page_state/fetch_state.rs+++ b/moli-protocol/src/conn/page_state/fetch_state.rs@@ -59,8 +59,7 @@ impl BrowserContext {}pub(crate) fn insert_page_target_host(&mut self, mut host: PageTargetHost) -> bool {- host.network_policy- .set_cache_disabled(self.global_cache_disabled);+ host.set_base_cache_disabled(self.global_cache_disabled);if let Some(config) = self.page_navigation_runtime_config.clone() {let engine = self.new_page_navigation_engine(config);let replaced = host.replace_navigation_engine(engine);diff --git a/moli-protocol/src/conn/page_state/parked.rs b/moli-protocol/src/conn/page_state/parked.rsindex ddfafa601..372034068 100644--- a/moli-protocol/src/conn/page_state/parked.rs+++ b/moli-protocol/src/conn/page_state/parked.rs@@ -4,7 +4,6 @@ use super::super::{ParkedTargetOwnerState, ServiceWorkerTargetState, SharedWorkerTargetState, TargetIdentityState,TargetInitialEmptyDocumentCreator,};-use crate::conn::state::{DevToolsSessionState, TargetNetworkPolicyState};use crate::devtools_runtime::{DevToolsBrowserContextId, DevToolsTargetId, DevToolsTargetInfo, DevToolsTargetKind,};@@ -285,13 +284,13 @@ impl BrowserContext {target_id: &str,session_id: String,) -> bool {- if self.is_active_target(target_id) || self.background_target(target_id).is_some() {- self.auxiliary_target_sessions- .insert(session_id, target_id.to_owned());- true- } else {- false- }+ let Some(target) = self.page_target_mut(target_id) else {+ return false;+ };+ target.devtools_sessions.ensure_attached(&session_id);+ self.auxiliary_target_sessions+ .insert(session_id, target_id.to_owned());+ true}pub(crate) fn auxiliary_target_id_for_session(&self, session_id: &str) -> Option<&str> {@@ -331,23 +330,17 @@ impl BrowserContext {pub(crate) fn remove_auxiliary_session(&mut self, session_id: &str) -> Option<String> {let target_id = self.auxiliary_target_sessions.remove(session_id)?;- if self.is_active_target(&target_id) {- self.active_target- .runtime_slot- .remove_auxiliary_network_session(session_id);- self.active_target- .fetch_owner- .remove_fetch_session(Some(session_id));- self.devtools_sessions.remove_attached(session_id);- } else if let Some(target) = self.background_target_mut(&target_id) {+ if let Some(target) = self.page_target_mut(&target_id) {target.runtime_slot.remove_auxiliary_network_session(session_id);- target.devtools_sessions.remove_attached(session_id);target.fetch_owner.remove_fetch_session(Some(session_id));target.runtime_slot.remove_network_session_observation_cursor(Some(session_id));+ target.devtools_sessions.remove_attached(session_id);+ target.refresh_devtools_network_policy();+ target.refresh_devtools_emulation_policy();}Some(target_id)}@@ -372,68 +365,67 @@ impl BrowserContext {return Ok(false);};- let (browser_identity_changed, extra_headers_changed, locale_changed, timezone_changed) =- if self.is_active_target(&target_id) {- let (browser_identity_changed, extra_headers_changed) =- self.network_policy.remove_session_overrides(session_id);- let locale_changed = self.locale_overrides.remove_session(session_id);- let timezone_changed = self.timezone_overrides.remove_session(session_id);- if locale_changed {- self.locale_override = self.locale_overrides.effective().cloned();- }- if timezone_changed {- self.timezone_override = self.timezone_overrides.effective().cloned();- }- (- browser_identity_changed,- extra_headers_changed,- locale_changed,- timezone_changed,- )- } else {- self.mutate_parked_page_session_state(&target_id, |state| {- let (browser_identity_changed, extra_headers_changed) =- state.network_policy.remove_session_overrides(session_id);- let locale_changed = state.locale_overrides.remove_session(session_id);- let timezone_changed = state.timezone_overrides.remove_session(session_id);- if locale_changed {- state.locale_override = state.locale_overrides.effective().cloned();- }- if timezone_changed {- state.timezone_override = state.timezone_overrides.effective().cloned();- }- (- browser_identity_changed,- extra_headers_changed,- locale_changed,- timezone_changed,- )- })- };-- if !extra_headers_changed && !locale_changed && !timezone_changed {+ let is_auxiliary = self.auxiliary_target_id_for_session(session_id) == Some(&target_id);+ let Some(target) = self.page_target_mut(&target_id) else {+ return Ok(false);+ };+ let state = target.state_mut();+ let previous_headers = state.network_policy.extra_headers().to_vec();+ let previous_bypass = state.network_policy.bypass_service_worker();+ let previous_cache_disabled = state.network_policy.cache_disabled();+ let previous_browser_identity = state.network_policy.browser_identity_override_owned();+ let previous_locale = state.locale_override.clone();+ let previous_timezone = state.timezone_override.clone();+ let routed_session_id = is_auxiliary.then_some(session_id);+ state.clear_devtools_network_state(is_auxiliary, routed_session_id);+ state.clear_devtools_emulation_state(is_auxiliary, routed_session_id);+ let extra_headers_changed = previous_headers != state.network_policy.extra_headers();+ let bypass_service_worker_changed =+ previous_bypass != state.network_policy.bypass_service_worker();+ let cache_disabled_changed =+ previous_cache_disabled != state.network_policy.cache_disabled();+ let browser_identity_changed =+ previous_browser_identity != state.network_policy.browser_identity_override_owned();+ let locale_changed = previous_locale != state.locale_override;+ let timezone_changed = previous_timezone != state.timezone_override;++ if !extra_headers_changed+ && !bypass_service_worker_changed+ && !cache_disabled_changed+ && !locale_changed+ && !timezone_changed+ {return Ok(browser_identity_changed);}- let (effective_headers, effective_locale, effective_timezone) =- if self.is_active_target(&target_id) {- (- self.effective_extra_headers(),- self.effective_active_locale_override_owned(),- self.effective_active_timezone_override_owned(),- )- } else {- let page_state = self.parked_page_session_state(&target_id);- (- self.effective_parked_extra_headers(&target_id),- page_state- .and_then(|state| state.locale_override.clone())- .or_else(|| self.default_locale_override.clone()),- page_state- .and_then(|state| state.timezone_override.clone())- .or_else(|| self.default_timezone_override.clone()),- )- };+ let (+ effective_headers,+ effective_bypass,+ effective_cache_disabled,+ effective_locale,+ effective_timezone,+ ) = if self.is_active_target(&target_id) {+ (+ self.effective_extra_headers(),+ self.network_policy.bypass_service_worker(),+ self.network_policy.cache_disabled(),+ self.effective_active_locale_override_owned(),+ self.effective_active_timezone_override_owned(),+ )+ } else {+ let page_state = self.parked_page_session_state(&target_id);+ (+ self.effective_parked_extra_headers(&target_id),+ page_state.is_some_and(|state| state.network_policy.bypass_service_worker()),+ page_state.is_some_and(|state| state.network_policy.cache_disabled()),+ page_state+ .and_then(|state| state.locale_override.clone())+ .or_else(|| self.default_locale_override.clone()),+ page_state+ .and_then(|state| state.timezone_override.clone())+ .or_else(|| self.default_timezone_override.clone()),+ )+ };let page = if self.is_active_target(&target_id) {self.active_target.runtime_slot.loaded_page_mut()} else {@@ -443,12 +435,16 @@ impl BrowserContext {let Some(page) = page else {return Ok(browser_identity_changed);};- if extra_headers_changed {- page.set_extra_http_headers_async(&effective_headers)- .await- .map_err(|error| {- format!("failed to restore detached session extra headers: {error}")- })?;+ if extra_headers_changed || bypass_service_worker_changed || cache_disabled_changed {+ page.set_network_request_policy_async(+ &effective_headers,+ effective_bypass,+ effective_cache_disabled,+ )+ .await+ .map_err(|error| {+ format!("failed to restore detached session network request policy: {error}")+ })?;}if locale_changed {page.set_locale_override_async(effective_locale.as_deref())@@ -514,19 +510,28 @@ impl BrowserContext {.runtime_slot.remove_network_session_observation_cursor(Some(session_id));+ let effective_headers = self.effective_parked_extra_headers(&target_id);+ let effective_bypass = self+ .parked_page_session_state(&target_id)+ .is_some_and(|state| state.network_policy.bypass_service_worker());+ let cache_disabled = self+ .parked_page_session_state(&target_id)+ .is_some_and(|state| state.network_policy.cache_disabled());+if let Some(page) = self.background_target_mut(&target_id).and_then(|target| target.runtime_slot.loaded_page_mut()){- page.set_extra_http_headers_async(&[])- .await- .map_err(|error| format!("failed to clear page extra headers: {error}"))?;+ page.set_network_request_policy_async(+ &effective_headers,+ effective_bypass,+ cache_disabled,+ )+ .await+ .map_err(|error| format!("failed to clear page network request policy: {error}"))?;page.set_network_offline_async(false).await.map_err(|error| format!("failed to clear page offline state: {error}"))?;- page.set_bypass_service_worker_async(false)- .await- .map_err(|error| format!("failed to clear page service worker bypass: {error}"))?;page.set_blocked_url_patterns_async(&[]).await.map_err(|error| format!("failed to clear page blocked URLs: {error}"))?;@@ -568,9 +573,11 @@ impl BrowserContext {target_id})?;self.mutate_parked_page_session_state(&target_id, |state| {- *state.devtools_sessions.primary_mut() = DevToolsSessionState::default();+ state.devtools_sessions.reset(true);state.runtime_slot.disable_primary_network_events();- state.network_policy = TargetNetworkPolicyState::default();+ state.network_policy.clear_session_scoped_state();+ state.refresh_devtools_network_policy();+ state.refresh_devtools_emulation_policy();state.fetch_owner.reset_config();});self.background_target_mut(&target_id)diff --git a/moli-protocol/src/conn/resource_runtime_support.rs b/moli-protocol/src/conn/resource_runtime_support.rsindex c7c60978a..201a3f2e6 100644--- a/moli-protocol/src/conn/resource_runtime_support.rs+++ b/moli-protocol/src/conn/resource_runtime_support.rs@@ -83,6 +83,7 @@ impl CdpConnection {engine.set_http_no_proxy_override(http_no_proxy);engine.set_tls_verify_host(tls_verify_host);engine.set_bypass_service_worker(load_inputs.bypass_service_worker);+ engine.set_cache_disabled(load_inputs.cache_disabled);Some(engine)}diff --git a/moli-protocol/src/conn/runtime_load.rs b/moli-protocol/src/conn/runtime_load.rsindex 3cec5bcf9..91e27c6c6 100644--- a/moli-protocol/src/conn/runtime_load.rs+++ b/moli-protocol/src/conn/runtime_load.rs@@ -2536,6 +2536,7 @@ impl CdpConnection {engine.reset_resource_runtime_without_loaded_page();}engine.set_bypass_service_worker(load_inputs.bypass_service_worker);+ engine.set_cache_disabled(load_inputs.cache_disabled);// The engine may publish lifecycle or resource activity before the// DCL-bound navigation result is adopted into a target slot. Bind its// scheduler sender at construction time so that early tail work queues@@ -3041,6 +3042,7 @@ impl CdpConnection {.navigation_engine_for_load_inputs_mut(&load_inputs).ok_or_else(|| "navigation Page engine unavailable".to_owned())?;engine.set_bypass_service_worker(load_inputs.bypass_service_worker);+ engine.set_cache_disabled(load_inputs.cache_disabled);engine.fetch_navigation_response_with_storage_async(resource_storage.into_navigation_storage(),@@ -3079,6 +3081,7 @@ impl CdpConnection {let mut request = Request::new_bytes(method, raw_url, body, request_headers).map_err(|error| format!("failed to build request for `{raw_url}`: {error}"))?.with_top_level_navigation_cookie_context()+ .with_page_network_policy().with_browser_navigation_kind(load_inputs.browser_navigation_kind);if !load_inputs.infer_navigation_referrer {request = request.without_inferred_referrer();@@ -3159,6 +3162,7 @@ impl CdpConnection {let mut request = Request::new_bytes(method, raw_url, body, request_headers).map_err(|error| format!("failed to build request for `{raw_url}`: {error}"))?.with_top_level_navigation_cookie_context()+ .with_page_network_policy().with_browser_navigation_kind(load_inputs.browser_navigation_kind);if !load_inputs.infer_navigation_referrer {request = request.without_inferred_referrer();diff --git a/moli-protocol/src/conn/state/devtools_session.rs b/moli-protocol/src/conn/state/devtools_session.rsindex 75cf08962..32c8ddab5 100644--- a/moli-protocol/src/conn/state/devtools_session.rs+++ b/moli-protocol/src/conn/state/devtools_session.rs@@ -25,11 +25,10 @@ use moli_page_types::{RendererDomDebuggerXhrBreakpoint,};-/// CDP session-owned state for DevTools domains that are backed by a renderer-/// inspector session.+/// CDP domain-handler state owned by one DevTools session.///-/// This is the protocol-side state object we can share across page and worker-/// targets while the renderer-side V8 inspector backend is still target-shaped.+/// Browser-side policy and renderer-inspector state live together here so+/// attachment, replay, and disposal all address the same session object.#[derive(Clone, Debug, Default, PartialEq)]pub(crate) struct DevToolsSessionState {pub(crate) dom_session_state: DevToolsDomSessionState,@@ -40,7 +39,8 @@ pub(crate) struct DevToolsSessionState {pub(crate) runtime_session_state: TargetRuntimeSessionState,pub(crate) console_output_session_state: DevToolsConsoleOutputSessionState,pub(crate) dom_storage_session_state: DevToolsDomStorageSessionState,- pub(crate) network_output_session_state: DevToolsNetworkOutputSessionState,+ pub(crate) network_session_state: DevToolsNetworkSessionState,+ pub(crate) emulation_session_state: DevToolsEmulationSessionState,pub(crate) runtime_bindings: Vec<RuntimeBindingDefinition>,pub(crate) runtime_binding_replay_pending: BTreeSet<(String, Option<String>)>,pub(crate) runtime_remote_object_ids: HashSet<String>,@@ -61,6 +61,7 @@ pub(crate) struct DevToolsSessionState {#[derive(Clone, Debug, PartialEq)]pub(crate) struct DevToolsSessionRegistry {states: BTreeMap<DevToolsSessionKey, DevToolsSessionState>,+ attached_order: Vec<String>,}impl Default for DevToolsSessionRegistry {@@ -70,6 +71,7 @@ impl Default for DevToolsSessionRegistry {DevToolsSessionKey::Primary,DevToolsSessionState::default(),)]),+ attached_order: Vec::new(),}}}@@ -120,19 +122,31 @@ impl DevToolsSessionRegistry {}pub(crate) fn ensure_attached(&mut self, session_id: &str) -> &mut DevToolsSessionState {+ if !self+ .states+ .contains_key(&DevToolsSessionKey::Attached(session_id.to_owned()))+ {+ self.attached_order.push(session_id.to_owned());+ }self.states.entry(DevToolsSessionKey::Attached(session_id.to_owned())).or_default()}pub(crate) fn remove_attached(&mut self, session_id: &str) -> Option<DevToolsSessionState> {- self.states- .remove(&DevToolsSessionKey::Attached(session_id.to_owned()))+ let key = DevToolsSessionKey::Attached(session_id.to_owned());+ let removed = self.states.remove(&key);+ if removed.is_some() {+ self.attached_order+ .retain(|attached| attached != session_id);+ }+ removed}pub(crate) fn clear_attached(&mut self) {self.states.retain(|key, _state| matches!(key, DevToolsSessionKey::Primary));+ self.attached_order.clear();}pub(crate) fn attached_len(&self) -> usize {@@ -158,6 +172,178 @@ impl DevToolsSessionRegistry {self.states.values()}+ /// Iterates browser-side domain handlers in attachment order: the implicit+ /// primary session first, then flattened sessions in attach order. Network+ /// header merging and Emulation identity precedence expose this order.+ pub(crate) fn states_in_attachment_order(&self) -> impl Iterator<Item = &DevToolsSessionState> {+ std::iter::once(self.primary()).chain(+ self.attached_order+ .iter()+ .filter_map(|session_id| self.attached(session_id)),+ )+ }++ pub(crate) fn effective_network_policy(&self) -> DevToolsNetworkPolicyAggregate {+ let mut aggregate = DevToolsNetworkPolicyAggregate::default();+ for state in self.states_in_attachment_order() {+ let network = &state.network_session_state;+ if !network.network_enabled {+ continue;+ }+ aggregate.cache_disabled |= network.cache_disabled;+ aggregate.bypass_service_worker |= network.bypass_service_worker;+ for (name, value) in &network.extra_headers {+ if let Some(index) = aggregate+ .extra_headers+ .iter()+ .position(|(existing, _)| existing.eq_ignore_ascii_case(name))+ {+ aggregate.extra_headers[index] = (name.clone(), value.clone());+ } else {+ aggregate.extra_headers.push((name.clone(), value.clone()));+ }+ }+ }+ aggregate+ }++ pub(crate) fn effective_browser_identity_override(+ &self,+ ) -> Option<moli_browser_profile::BrowserIdentityProfile> {+ let mut identity_base = None;+ let mut user_agent = None;+ let mut accept_language = None;+ let mut navigator_platform = None;+ for contribution in self.states_in_attachment_order().filter_map(|state| {+ state+ .emulation_session_state+ .browser_identity_override+ .as_ref()+ }) {+ identity_base = Some(&contribution.base);+ if contribution.user_agent.is_some() {+ user_agent = Some(contribution);+ }+ if contribution.accept_language.is_some() {+ accept_language = Some(contribution);+ }+ if contribution.navigator_platform.is_some() {+ navigator_platform = Some(contribution);+ }+ }+ identity_base.map(|base| {+ moli_browser_profile::BrowserIdentityProfile::from_devtools_override(+ base,+ user_agent+ .and_then(|contribution| contribution.user_agent.clone())+ .unwrap_or_default(),+ accept_language.and_then(|contribution| contribution.accept_language.clone()),+ navigator_platform.and_then(|contribution| contribution.navigator_platform.clone()),+ user_agent.and_then(|contribution| contribution.user_agent_metadata.clone()),+ )+ })+ }++ fn routed_key(is_attached_session: bool, session_id: Option<&str>) -> DevToolsSessionKey {+ if is_attached_session && let Some(session_id) = session_id {+ return DevToolsSessionKey::Attached(session_id.to_owned());+ }+ DevToolsSessionKey::Primary+ }++ pub(crate) fn set_browser_identity_override(+ &mut self,+ is_attached_session: bool,+ session_id: Option<&str>,+ browser_identity_override: Option<DevToolsBrowserIdentityOverride>,+ ) {+ let state = self.routed_mut_or_insert(is_attached_session, session_id);+ state.emulation_session_state.browser_identity_override = browser_identity_override;+ }++ pub(crate) fn set_locale_override(+ &mut self,+ is_attached_session: bool,+ session_id: Option<&str>,+ locale_override: Option<String>,+ ) -> Result<(), &'static str> {+ let key = Self::routed_key(is_attached_session, session_id);+ let current_session_owns_override = self+ .states+ .get(&key)+ .is_some_and(|state| state.emulation_session_state.locale_override.is_some());+ let another_session_owns_override = self.states.iter().any(|(candidate, state)| {+ candidate != &key && state.emulation_session_state.locale_override.is_some()+ });+ if !current_session_owns_override && another_session_owns_override {+ return Err("Another locale override is already in effect");+ }+ self.routed_mut_or_insert(is_attached_session, session_id)+ .emulation_session_state+ .locale_override = locale_override;+ Ok(())+ }++ pub(crate) fn set_timezone_override(+ &mut self,+ is_attached_session: bool,+ session_id: Option<&str>,+ timezone_override: Option<String>,+ ) -> Result<(), &'static str> {+ let key = Self::routed_key(is_attached_session, session_id);+ let current_session_owns_override = self+ .states+ .get(&key)+ .is_some_and(|state| state.emulation_session_state.timezone_override.is_some());+ let another_session_owns_override = self.states.iter().any(|(candidate, state)| {+ candidate != &key && state.emulation_session_state.timezone_override.is_some()+ });+ if timezone_override.is_some()+ && !current_session_owns_override+ && another_session_owns_override+ {+ return Err("Timezone override is already in effect");+ }+ self.routed_mut_or_insert(is_attached_session, session_id)+ .emulation_session_state+ .timezone_override = timezone_override;+ Ok(())+ }++ pub(crate) fn effective_locale_override(&self) -> Option<&str> {+ self.states+ .values()+ .find_map(|state| state.emulation_session_state.locale_override.as_deref())+ }++ pub(crate) fn effective_timezone_override(&self) -> Option<&str> {+ self.states+ .values()+ .find_map(|state| state.emulation_session_state.timezone_override.as_deref())+ }++ pub(crate) fn clear_routed_network_state(+ &mut self,+ is_attached_session: bool,+ session_id: Option<&str>,+ ) {+ let key = Self::routed_key(is_attached_session, session_id);+ if let Some(state) = self.states.get_mut(&key) {+ state.network_session_state = DevToolsNetworkSessionState::default();+ }+ }++ pub(crate) fn clear_routed_emulation_state(+ &mut self,+ is_attached_session: bool,+ session_id: Option<&str>,+ ) {+ let key = Self::routed_key(is_attached_session, session_id);+ if let Some(state) = self.states.get_mut(&key) {+ state.emulation_session_state = DevToolsEmulationSessionState::default();+ }+ }+pub(crate) fn states_mut(&mut self) -> impl Iterator<Item = &mut DevToolsSessionState> {self.states.values_mut()}@@ -426,11 +612,75 @@ pub(crate) struct DevToolsDomStorageSessionState {}#[derive(Clone, Debug, Default, PartialEq)]-pub(crate) struct DevToolsNetworkOutputSessionState {+pub(crate) struct DevToolsNetworkSessionState {pub(crate) network_enabled: bool,+ pub(crate) cache_disabled: bool,+ pub(crate) bypass_service_worker: bool,+ pub(crate) extra_headers: Vec<(String, String)>,pub(crate) service_worker_fetch_diagnostic_entries: usize,}+#[derive(Clone, Debug, Default, PartialEq)]+pub(crate) struct DevToolsEmulationSessionState {+ // UA, Accept-Language, and platform are independent handler contributions.+ pub(crate) browser_identity_override: Option<DevToolsBrowserIdentityOverride>,+ // Locale and timezone are exclusive controller claims, unlike UA fields.+ pub(crate) locale_override: Option<String>,+ pub(crate) timezone_override: Option<String>,+}++#[derive(Clone, Debug, PartialEq)]+pub(crate) struct DevToolsBrowserIdentityOverride {+ // Keep individual command contributions instead of a flattened profile:+ // Chromium lets different sessions win UA, Accept-Language, and+ // navigator.platform independently in attachment order.+ base: moli_browser_profile::BrowserIdentityProfile,+ user_agent: Option<String>,+ accept_language: Option<String>,+ navigator_platform: Option<String>,+ user_agent_metadata: Option<moli_browser_profile::BrowserUserAgentMetadataOverride>,+}++impl DevToolsBrowserIdentityOverride {+ pub(crate) fn from_command(+ base: &moli_browser_profile::BrowserIdentityProfile,+ user_agent: String,+ accept_language: Option<String>,+ navigator_platform: Option<String>,+ user_agent_metadata: Option<moli_browser_profile::BrowserUserAgentMetadataOverride>,+ ) -> Option<Self> {+ let user_agent = (!user_agent.is_empty()).then_some(user_agent);+ let accept_language = accept_language.filter(|value| !value.is_empty());+ let navigator_platform = navigator_platform.filter(|value| !value.is_empty());+ (user_agent.is_some() || accept_language.is_some() || navigator_platform.is_some()).then(+ || Self {+ base: base.clone(),+ user_agent,+ accept_language,+ navigator_platform,+ user_agent_metadata,+ },+ )+ }++ pub(crate) fn to_browser_identity(&self) -> moli_browser_profile::BrowserIdentityProfile {+ moli_browser_profile::BrowserIdentityProfile::from_devtools_override(+ &self.base,+ self.user_agent.clone().unwrap_or_default(),+ self.accept_language.clone(),+ self.navigator_platform.clone(),+ self.user_agent_metadata.clone(),+ )+ }+}++#[derive(Clone, Debug, Default, PartialEq, Eq)]+pub(crate) struct DevToolsNetworkPolicyAggregate {+ pub(crate) cache_disabled: bool,+ pub(crate) bypass_service_worker: bool,+ pub(crate) extra_headers: Vec<(String, String)>,+}+#[derive(Clone, Debug, Default, PartialEq)]pub(crate) struct DevToolsConsoleOutputSessionState {pub(crate) console_enabled: bool,@@ -860,6 +1110,28 @@ mod tests {}}+ fn identity_override(+ user_agent: &str,+ accept_language: Option<&str>,+ navigator_platform: Option<&str>,+ ) -> Option<DevToolsBrowserIdentityOverride> {+ DevToolsBrowserIdentityOverride::from_command(+ &moli_browser_profile::BrowserIdentityProfile::default(),+ user_agent.to_owned(),+ accept_language.map(str::to_owned),+ navigator_platform.map(str::to_owned),+ None,+ )+ }++ fn effective_identity(+ sessions: &DevToolsSessionRegistry,+ ) -> moli_browser_profile::BrowserIdentityProfile {+ sessions+ .effective_browser_identity_override()+ .expect("browser identity contribution should be effective")+ }+#[test]fn registry_owns_primary_and_attached_sessions_in_stable_order() {let mut sessions = DevToolsSessionRegistry::default();@@ -881,6 +1153,159 @@ mod tests {assert_eq!(sessions.primary(), &DevToolsSessionState::default());}+ #[test]+ fn network_policy_uses_attachment_order_and_domain_specific_aggregation() {+ let mut sessions = DevToolsSessionRegistry::default();+ let primary = &mut sessions.primary_mut().network_session_state;+ primary.network_enabled = true;+ primary.cache_disabled = true;+ primary.extra_headers = vec![+ ("X-Primary".to_owned(), "primary".to_owned()),+ ("X-Shared".to_owned(), "primary".to_owned()),+ ];++ let attached_b = &mut sessions.ensure_attached("SID-b").network_session_state;+ attached_b.network_enabled = true;+ attached_b.bypass_service_worker = true;+ attached_b.extra_headers = vec![+ ("X-B".to_owned(), "b".to_owned()),+ ("x-shared".to_owned(), "b".to_owned()),+ ];++ let attached_a = &mut sessions.ensure_attached("SID-a").network_session_state;+ attached_a.network_enabled = false;+ attached_a.cache_disabled = true;+ attached_a.extra_headers = vec![("X-Ignored".to_owned(), "a".to_owned())];++ let policy = sessions.effective_network_policy();+ assert!(policy.cache_disabled);+ assert!(policy.bypass_service_worker);+ assert_eq!(+ policy.extra_headers,+ vec![+ ("X-Primary".to_owned(), "primary".to_owned()),+ ("x-shared".to_owned(), "b".to_owned()),+ ("X-B".to_owned(), "b".to_owned()),+ ]+ );++ sessions.remove_attached("SID-b");+ let policy = sessions.effective_network_policy();+ assert!(policy.cache_disabled);+ assert!(!policy.bypass_service_worker);+ assert_eq!(+ policy.extra_headers,+ vec![+ ("X-Primary".to_owned(), "primary".to_owned()),+ ("X-Shared".to_owned(), "primary".to_owned()),+ ]+ );+ }++ #[test]+ fn browser_identity_override_uses_attachment_order_not_setter_order() {+ let mut sessions = DevToolsSessionRegistry::default();+ sessions.ensure_attached("SID-later");+ sessions.set_browser_identity_override(+ true,+ Some("SID-later"),+ identity_override("Moli/Later-1", None, None),+ );+ sessions.set_browser_identity_override(+ false,+ None,+ identity_override("Moli/Primary-1", None, None),+ );+ assert_eq!(effective_identity(&sessions).user_agent(), "Moli/Later-1");++ sessions.set_browser_identity_override(+ false,+ None,+ identity_override("Moli/Primary-2", None, None),+ );+ assert_eq!(+ effective_identity(&sessions).user_agent(),+ "Moli/Later-1",+ "a later setter must not outrank a later-attached session"+ );++ sessions.set_browser_identity_override(true, Some("SID-later"), None);+ assert_eq!(effective_identity(&sessions).user_agent(), "Moli/Primary-2");++ sessions.set_browser_identity_override(+ true,+ Some("SID-later"),+ identity_override("Moli/Later-2", None, None),+ );+ assert_eq!(effective_identity(&sessions).user_agent(), "Moli/Later-2");++ sessions.remove_attached("SID-later");+ assert_eq!(effective_identity(&sessions).user_agent(), "Moli/Primary-2");++ sessions.ensure_attached("SID-later");+ sessions.set_browser_identity_override(+ true,+ Some("SID-later"),+ identity_override("", Some("fr-FR"), Some("AuxPlatform")),+ );+ let identity = effective_identity(&sessions);+ assert_eq!(identity.user_agent(), "Moli/Primary-2");+ assert_eq!(identity.accept_language(), "fr-FR");+ assert_eq!(identity.navigator_platform(), "AuxPlatform");+ }++ #[test]+ fn locale_and_timezone_follow_their_distinct_exclusive_claim_rules() {+ let mut sessions = DevToolsSessionRegistry::default();+ sessions.ensure_attached("SID-a");+ sessions.ensure_attached("SID-b");++ sessions+ .set_locale_override(true, Some("SID-a"), Some("fr-FR".to_owned()))+ .unwrap();+ assert_eq!(+ sessions+ .set_locale_override(true, Some("SID-b"), Some("de-DE".to_owned()))+ .unwrap_err(),+ "Another locale override is already in effect"+ );+ assert_eq!(+ sessions+ .set_locale_override(true, Some("SID-b"), None)+ .unwrap_err(),+ "Another locale override is already in effect",+ "Chromium treats a non-owner locale clear as a new claim"+ );+ sessions+ .set_locale_override(true, Some("SID-a"), Some("it-IT".to_owned()))+ .unwrap();+ assert_eq!(sessions.effective_locale_override(), Some("it-IT"));++ sessions+ .set_timezone_override(true, Some("SID-a"), Some("Europe/Paris".to_owned()))+ .unwrap();+ assert_eq!(+ sessions+ .set_timezone_override(true, Some("SID-b"), Some("America/New_York".to_owned()),)+ .unwrap_err(),+ "Timezone override is already in effect"+ );+ sessions+ .set_timezone_override(true, Some("SID-b"), None)+ .expect("Chromium accepts a non-owner timezone clear as a no-op");+ assert_eq!(sessions.effective_timezone_override(), Some("Europe/Paris"));++ sessions.remove_attached("SID-a");+ assert_eq!(sessions.effective_locale_override(), None);+ assert_eq!(sessions.effective_timezone_override(), None);+ sessions+ .set_locale_override(true, Some("SID-b"), Some("de-DE".to_owned()))+ .unwrap();+ sessions+ .set_timezone_override(true, Some("SID-b"), Some("America/New_York".to_owned()))+ .unwrap();+ }+#[test]fn registry_aggregates_renderer_configuration_by_session_identity() {let mut sessions = DevToolsSessionRegistry::default();diff --git a/moli-protocol/src/conn/state/mod.rs b/moli-protocol/src/conn/state/mod.rsindex 55ffdc7ee..6f8c17733 100644--- a/moli-protocol/src/conn/state/mod.rs+++ b/moli-protocol/src/conn/state/mod.rs@@ -48,7 +48,8 @@ pub(crate) use dedicated_worker_target::{DedicatedWorkerMainScriptOutcome, DedicatedWorkerMainScriptSnapshot, DedicatedWorkerTargetState,};pub(crate) use devtools_session::{- DevToolsConsoleOutputSessionState, DevToolsLogViolationThreshold, DevToolsSessionState,+ DevToolsBrowserIdentityOverride, DevToolsConsoleOutputSessionState,+ DevToolsLogViolationThreshold, DevToolsNetworkSessionState, DevToolsSessionState,PreparedRendererCallReplacements, SessionRendererCallReplay, SessionRendererCallTermination,};pub(crate) use document_lifecycle_observer::{@@ -100,7 +101,7 @@ pub(crate) use service_worker_target::{pub(crate) use session::TargetPerformanceSessionState;pub(crate) use session::{PageScreencastConfig, PageScreencastFormat, PerformanceTimeDomain, TargetNetworkPolicyState,- TargetPageSessionState, TargetRuntimeSessionState, TargetSessionOverrideStack,+ TargetPageSessionState, TargetRuntimeSessionState,};pub(crate) use session_storage::TargetSessionStorageNamespace;pub(crate) use shared_worker_attachment::{diff --git a/moli-protocol/src/conn/state/page_target_host.rs b/moli-protocol/src/conn/state/page_target_host.rsindex e3b93934b..3254c5c2d 100644--- a/moli-protocol/src/conn/state/page_target_host.rs+++ b/moli-protocol/src/conn/state/page_target_host.rs@@ -145,11 +145,21 @@ impl PageTargetHost {pub(crate) fn replace_navigation_engine(&mut self,- engine: NavigationEngine,+ mut engine: NavigationEngine,) -> Option<NavigationEngine> {+ engine.set_bypass_service_worker(self.network_policy.bypass_service_worker());+ engine.set_cache_disabled(self.network_policy.cache_disabled());self.navigation_engine.replace(engine)}+ pub(crate) fn set_base_cache_disabled(&mut self, disabled: bool) {+ self.network_policy.set_base_cache_disabled(disabled);+ let effective = self.network_policy.cache_disabled();+ if let Some(engine) = self.navigation_engine.as_mut() {+ engine.set_cache_disabled(effective);+ }+ }+pub(crate) fn navigation_engine_and_runtime_slot_mut(&mut self,) -> Option<(&mut NavigationEngine, &mut TargetRuntimeSlot)> {diff --git a/moli-protocol/src/conn/state/service_worker_target.rs b/moli-protocol/src/conn/state/service_worker_target.rsindex 40166ba6b..80515b1e3 100644--- a/moli-protocol/src/conn/state/service_worker_target.rs+++ b/moli-protocol/src/conn/state/service_worker_target.rs@@ -716,11 +716,18 @@ impl ServiceWorkerTargetState {let Some(state) = self.session_state_mut(session_id) else {return false;};- let was_enabled = state.network_output_session_state.network_enabled;- state.network_output_session_state.network_enabled = enabled;- if !enabled || !was_enabled {+ let was_enabled = state.network_session_state.network_enabled;+ if enabled {+ state.network_session_state.network_enabled = true;+ if !was_enabled {+ state+ .network_session_state+ .service_worker_fetch_diagnostic_entries = diagnostic_len;+ }+ } else {+ state.network_session_state = Default::default();state- .network_output_session_state+ .network_session_state.service_worker_fetch_diagnostic_entries = diagnostic_len;}true@@ -728,7 +735,7 @@ impl ServiceWorkerTargetState {pub(crate) fn network_enabled(&self, session_id: &str) -> bool {self.session_state(session_id)- .is_some_and(|state| state.network_output_session_state.network_enabled)+ .is_some_and(|state| state.network_session_state.network_enabled)}pub(crate) fn clear_console_messages(&mut self, session_id: &str) {@@ -859,11 +866,11 @@ impl ServiceWorkerTargetState {let Some(state) = self.session_state(session_id) else {return &[];};- if !state.network_output_session_state.network_enabled {+ if !state.network_session_state.network_enabled {return &[];}&self.fetch_diagnostics[state- .network_output_session_state+ .network_session_state.service_worker_fetch_diagnostic_entries.min(self.fetch_diagnostics.len())..]}@@ -901,7 +908,7 @@ impl ServiceWorkerTargetState {let diagnostic_len = self.fetch_diagnostics.len();if let Some(state) = self.session_state_mut(session_id) {state- .network_output_session_state+ .network_session_state.service_worker_fetch_diagnostic_entries = diagnostic_end.min(diagnostic_len);}}diff --git a/moli-protocol/src/conn/state/session.rs b/moli-protocol/src/conn/state/session.rsindex bb97766c9..1a1f98b89 100644--- a/moli-protocol/src/conn/state/session.rs+++ b/moli-protocol/src/conn/state/session.rs@@ -1,6 +1,8 @@use std::collections::HashMap;-use super::devtools_session::DevToolsSessionRegistry;+use super::devtools_session::{+ DevToolsNetworkPolicyAggregate, DevToolsNetworkSessionState, DevToolsSessionRegistry,+};use super::emulation::{EmulatedDeviceMetrics, EmulatedGeolocationOverrideState, EmulatedMediaOverrides,EmulatedNetworkConditions,@@ -90,10 +92,13 @@ pub struct TargetPageState {pub(crate) http_proxy_override: Option<String>,pub(crate) http_no_proxy_override: Option<String>,pub(crate) tls_verify_host_override: Option<bool>,+ // Target-scoped non-CDP policy (for example WebDriver BiDi). CDP session+ // contributions temporarily shadow this layer and reveal it on detach.+ pub(crate) base_locale_override: Option<String>,+ pub(crate) base_timezone_override: Option<String>,+ // Materialized values consumed by navigation and the renderer.pub(crate) locale_override: Option<String>,pub(crate) timezone_override: Option<String>,- pub(crate) locale_overrides: TargetSessionOverrideStack<String>,- pub(crate) timezone_overrides: TargetSessionOverrideStack<String>,pub(crate) network_conditions: Option<EmulatedNetworkConditions>,pub(crate) geolocation_override: Option<EmulatedGeolocationOverrideState>,pub(crate) emulated_media: EmulatedMediaOverrides,@@ -120,10 +125,10 @@ impl Default for TargetPageState {http_proxy_override: None,http_no_proxy_override: None,tls_verify_host_override: None,+ base_locale_override: None,+ base_timezone_override: None,locale_override: None,timezone_override: None,- locale_overrides: TargetSessionOverrideStack::default(),- timezone_overrides: TargetSessionOverrideStack::default(),network_conditions: None,geolocation_override: None,emulated_media: EmulatedMediaOverrides::default(),@@ -144,6 +149,116 @@ impl Default for TargetPageState {}impl TargetPageState {+ pub(crate) fn mutate_devtools_network_session_state<T>(+ &mut self,+ is_attached_session: bool,+ session_id: Option<&str>,+ f: impl FnOnce(&mut DevToolsNetworkSessionState) -> T,+ ) -> T {+ let result = {+ let session = self+ .devtools_sessions+ .routed_mut_or_insert(is_attached_session, session_id);+ f(&mut session.network_session_state)+ };+ self.refresh_devtools_network_policy();+ result+ }++ pub(crate) fn refresh_devtools_network_policy(&mut self) {+ self.network_policy+ .apply_devtools_network_policy(self.devtools_sessions.effective_network_policy());+ }++ pub(crate) fn set_devtools_browser_identity_override(+ &mut self,+ is_attached_session: bool,+ session_id: Option<&str>,+ browser_identity_override: Option<super::DevToolsBrowserIdentityOverride>,+ ) {+ self.devtools_sessions.set_browser_identity_override(+ is_attached_session,+ session_id,+ browser_identity_override,+ );+ self.refresh_devtools_emulation_policy();+ }++ pub(crate) fn set_devtools_locale_override(+ &mut self,+ is_attached_session: bool,+ session_id: Option<&str>,+ locale_override: Option<String>,+ ) -> Result<(), &'static str> {+ self.devtools_sessions.set_locale_override(+ is_attached_session,+ session_id,+ locale_override,+ )?;+ self.refresh_devtools_emulation_policy();+ Ok(())+ }++ pub(crate) fn set_devtools_timezone_override(+ &mut self,+ is_attached_session: bool,+ session_id: Option<&str>,+ timezone_override: Option<String>,+ ) -> Result<(), &'static str> {+ self.devtools_sessions.set_timezone_override(+ is_attached_session,+ session_id,+ timezone_override,+ )?;+ self.refresh_devtools_emulation_policy();+ Ok(())+ }++ pub(crate) fn set_base_locale_override(&mut self, locale_override: Option<String>) {+ self.base_locale_override = locale_override;+ self.refresh_devtools_emulation_policy();+ }++ pub(crate) fn set_base_timezone_override(&mut self, timezone_override: Option<String>) {+ self.base_timezone_override = timezone_override;+ self.refresh_devtools_emulation_policy();+ }++ pub(crate) fn refresh_devtools_emulation_policy(&mut self) {+ self.network_policy.devtools_browser_identity_override =+ self.devtools_sessions.effective_browser_identity_override();+ self.locale_override = self+ .devtools_sessions+ .effective_locale_override()+ .map(str::to_owned)+ .or_else(|| self.base_locale_override.clone());+ self.timezone_override = self+ .devtools_sessions+ .effective_timezone_override()+ .map(str::to_owned)+ .or_else(|| self.base_timezone_override.clone());+ }++ pub(crate) fn clear_devtools_network_state(+ &mut self,+ is_attached_session: bool,+ session_id: Option<&str>,+ ) {+ self.devtools_sessions+ .clear_routed_network_state(is_attached_session, session_id);+ self.refresh_devtools_network_policy();+ }++ pub(crate) fn clear_devtools_emulation_state(+ &mut self,+ is_attached_session: bool,+ session_id: Option<&str>,+ ) {+ self.devtools_sessions+ .clear_routed_emulation_state(is_attached_session, session_id);+ self.refresh_devtools_emulation_policy();+ }+pub(crate) fn has_pending_javascript_dialog(&self) -> bool {self.devtools_sessions.states().any(|session| {!session@@ -165,8 +280,6 @@ impl TargetPageState {|| self.tls_verify_host_override.is_some()|| self.locale_override.is_some()|| self.timezone_override.is_some()- || self.locale_overrides != TargetSessionOverrideStack::default()- || self.timezone_overrides != TargetSessionOverrideStack::default()|| self.network_conditions.is_some()|| self.geolocation_override.is_some()|| self.emulated_media != EmulatedMediaOverrides::default()@@ -192,14 +305,12 @@ impl TargetPageState {self.active_target.runtime_slot.disable_primary_network_events();- self.network_policy = TargetNetworkPolicyState::default();+ self.network_policy.clear_session_scoped_state();+ self.refresh_devtools_network_policy();+ self.refresh_devtools_emulation_policy();self.http_proxy_override = None;self.http_no_proxy_override = None;self.tls_verify_host_override = None;- self.locale_override = None;- self.timezone_override = None;- self.locale_overrides.clear();- self.timezone_overrides.clear();self.network_conditions = None;self.geolocation_override = None;self.emulated_media = EmulatedMediaOverrides::default();@@ -492,50 +603,12 @@ pub(crate) struct InspectorSessionState {pub(crate) v8_state: Option<V8InspectorSessionState>,}-#[derive(Debug, Clone, PartialEq)]-pub(crate) struct TargetSessionOverrideStack<T> {- entries: Vec<(Option<String>, T)>,-}--impl<T> Default for TargetSessionOverrideStack<T> {- fn default() -> Self {- Self {- entries: Vec::new(),- }- }-}--impl<T> TargetSessionOverrideStack<T> {- pub(crate) fn effective(&self) -> Option<&T> {- self.entries.last().map(|(_session_id, value)| value)- }-- pub(crate) fn replace(&mut self, session_id: Option<&str>, value: Option<T>) {- self.entries- .retain(|(owner, _value)| owner.as_deref() != session_id);- if let Some(value) = value {- self.entries.push((session_id.map(str::to_owned), value));- }- }-- pub(crate) fn remove_session(&mut self, session_id: &str) -> bool {- let effective_changed = self- .entries- .last()- .is_some_and(|(owner, _value)| owner.as_deref() == Some(session_id));- self.entries- .retain(|(owner, _value)| owner.as_deref() != Some(session_id));- effective_changed- }-- pub(crate) fn clear(&mut self) {- self.entries.clear();- }-}-#[derive(Debug, Clone, PartialEq)]pub(crate) struct TargetNetworkPolicyState {- cache_disabled: bool,+ // Target-wide policy contributed by WebDriver BiDi or connection defaults.+ base_cache_disabled: bool,+ // OR of cache-disabled contributions from enabled CDP Network handlers.+ devtools_cache_disabled: bool,bypass_service_worker: bool,network_offline: bool,blocked_url_patterns: Vec<String>,@@ -543,15 +616,22 @@ pub(crate) struct TargetNetworkPolicyState {emulated_download_throughput: f64,emulated_upload_throughput: f64,emulated_connection_type: Option<String>,- browser_identity_overrides:- TargetSessionOverrideStack<moli_browser_profile::BrowserIdentityProfile>,- extra_header_overrides: TargetSessionOverrideStack<Vec<(String, String)>>,+ base_browser_identity_override: Option<moli_browser_profile::BrowserIdentityProfile>,+ devtools_browser_identity_override: Option<moli_browser_profile::BrowserIdentityProfile>,+ // Target-scoped headers contributed by WebDriver BiDi.+ base_extra_headers: Vec<(String, String)>,+ // Headers aggregated from enabled CDP Network handlers.+ devtools_extra_headers: Vec<(String, String)>,+ // Materialized target-local result. Keeping this derived projection lets+ // request snapshots borrow the effective headers without allocating.+ extra_headers: Vec<(String, String)>,}impl Default for TargetNetworkPolicyState {fn default() -> Self {Self {- cache_disabled: false,+ base_cache_disabled: false,+ devtools_cache_disabled: false,bypass_service_worker: false,network_offline: false,blocked_url_patterns: Vec::new(),@@ -559,30 +639,54 @@ impl Default for TargetNetworkPolicyState {emulated_download_throughput: -1.0,emulated_upload_throughput: -1.0,emulated_connection_type: None,- browser_identity_overrides: TargetSessionOverrideStack::default(),- extra_header_overrides: TargetSessionOverrideStack::default(),+ base_browser_identity_override: None,+ devtools_browser_identity_override: None,+ base_extra_headers: Vec::new(),+ devtools_extra_headers: Vec::new(),+ extra_headers: Vec::new(),}}}impl TargetNetworkPolicyState {- #[cfg(test)]pub(crate) fn cache_disabled(&self) -> bool {- self.cache_disabled+ self.base_cache_disabled || self.devtools_cache_disabled}- pub(crate) fn set_cache_disabled(&mut self, cache_disabled: bool) {- self.cache_disabled = cache_disabled;+ pub(crate) fn set_base_cache_disabled(&mut self, cache_disabled: bool) {+ self.base_cache_disabled = cache_disabled;+ }++ pub(crate) fn clear_session_scoped_state(&mut self) {+ let base_cache_disabled = self.base_cache_disabled;+ let base_extra_headers = std::mem::take(&mut self.base_extra_headers);+ let base_browser_identity_override = self.base_browser_identity_override.take();+ *self = Self::default();+ self.base_cache_disabled = base_cache_disabled;+ self.base_extra_headers = base_extra_headers;+ self.base_browser_identity_override = base_browser_identity_override;+ self.refresh_extra_headers();}pub(crate) fn bypass_service_worker(&self) -> bool {self.bypass_service_worker}+ #[cfg(test)]pub(crate) fn set_bypass_service_worker(&mut self, bypass_service_worker: bool) {self.bypass_service_worker = bypass_service_worker;}+ pub(crate) fn apply_devtools_network_policy(+ &mut self,+ aggregate: DevToolsNetworkPolicyAggregate,+ ) {+ self.devtools_cache_disabled = aggregate.cache_disabled;+ self.bypass_service_worker = aggregate.bypass_service_worker;+ self.devtools_extra_headers = aggregate.extra_headers;+ self.refresh_extra_headers();+ }+pub(crate) fn network_offline(&self) -> bool {self.network_offline}@@ -610,34 +714,44 @@ impl TargetNetworkPolicyState {}pub(crate) fn extra_headers(&self) -> &[(String, String)] {- self.extra_header_overrides- .effective()- .map(Vec::as_slice)- .unwrap_or(&[])+ &self.extra_headers}- pub(crate) fn replace_extra_headers_for_session(+ pub(crate) fn replace_base_extra_headers(&mut self,- session_id: Option<&str>,extra_headers: Vec<(String, String)>,) -> Vec<(String, String)> {- let override_value = (!extra_headers.is_empty()).then_some(extra_headers);- self.extra_header_overrides- .replace(session_id, override_value);- self.extra_headers().to_vec()+ self.base_extra_headers = extra_headers;+ self.refresh_extra_headers();+ self.extra_headers.clone()+ }++ fn refresh_extra_headers(&mut self) {+ let mut effective = Vec::new();+ for layer in [&self.base_extra_headers, &self.devtools_extra_headers] {+ for (name, value) in layer {+ effective.retain(|(existing, _): &(String, String)| {+ !existing.eq_ignore_ascii_case(name)+ });+ effective.push((name.clone(), value.clone()));+ }+ }+ self.extra_headers = effective;}#[cfg(test)]pub(crate) fn push_extra_header(&mut self, header: (String, String)) {- let mut headers = self.extra_headers().to_vec();+ let mut headers = self.base_extra_headers.clone();headers.push(header);- self.replace_extra_headers_for_session(None, headers);+ self.replace_base_extra_headers(headers);}pub(crate) fn browser_identity_override(&self,) -> Option<&moli_browser_profile::BrowserIdentityProfile> {- self.browser_identity_overrides.effective()+ self.devtools_browser_identity_override+ .as_ref()+ .or(self.base_browser_identity_override.as_ref())}#[cfg(test)]@@ -664,26 +778,11 @@ impl TargetNetworkPolicyState {&mut self,browser_identity: moli_browser_profile::BrowserIdentityProfile,) {- self.set_browser_identity_override_for_session(None, Some(browser_identity));+ self.base_browser_identity_override = Some(browser_identity);}pub(crate) fn clear_browser_identity_override(&mut self) {- self.set_browser_identity_override_for_session(None, None);- }-- pub(crate) fn set_browser_identity_override_for_session(- &mut self,- session_id: Option<&str>,- browser_identity: Option<moli_browser_profile::BrowserIdentityProfile>,- ) {- self.browser_identity_overrides- .replace(session_id, browser_identity);- }-- pub(crate) fn remove_session_overrides(&mut self, session_id: &str) -> (bool, bool) {- let browser_identity_changed = self.browser_identity_overrides.remove_session(session_id);- let extra_headers_changed = self.extra_header_overrides.remove_session(session_id);- (browser_identity_changed, extra_headers_changed)+ self.base_browser_identity_override = None;}#[cfg(test)]@@ -726,55 +825,47 @@ impl TargetNetworkPolicyState {#[cfg(test)]mod tests {use super::{- PageScreencastConfig, PageScreencastFormat, PageScreencastSessionState,- TargetNetworkPolicyState, TargetSessionOverrideStack,+ PageScreencastConfig, PageScreencastFormat, PageScreencastSessionState, TargetPageState,};#[test]- fn detached_session_network_overrides_restore_the_previous_session() {- let mut policy = TargetNetworkPolicyState::default();- policy.replace_extra_headers_for_session(- Some("session-a"),- vec![("X-Test".to_owned(), "A".to_owned())],+ fn devtools_emulation_overrides_reveal_target_base_state_when_cleared() {+ let mut state = TargetPageState::default();+ state.set_base_locale_override(Some("en-GB".to_owned()));+ state.set_base_timezone_override(Some("Europe/London".to_owned()));+ state.network_policy.set_browser_identity_override(+ moli_browser_profile::BrowserIdentityProfile::new("Moli/Base", "en-GB"),);- policy.set_browser_identity_override_for_session(- Some("session-a"),- Some(moli_browser_profile::BrowserIdentityProfile::new(- "Moli/A", "fr-FR",- )),- );- policy.replace_extra_headers_for_session(- Some("session-b"),- vec![("X-Test".to_owned(), "B".to_owned())],++ state+ .set_devtools_locale_override(false, None, Some("fr-FR".to_owned()))+ .unwrap();+ state+ .set_devtools_timezone_override(false, None, Some("Europe/Paris".to_owned()))+ .unwrap();+ state.set_devtools_browser_identity_override(+ false,+ None,+ crate::conn::DevToolsBrowserIdentityOverride::from_command(+ &moli_browser_profile::BrowserIdentityProfile::default(),+ "Moli/CDP".to_owned(),+ Some("fr-FR".to_owned()),+ None,+ None,+ ),);- policy.set_browser_identity_override_for_session(- Some("session-b"),- Some(moli_browser_profile::BrowserIdentityProfile::new(- "Moli/B", "ja-JP",- )),+ assert_eq!(state.locale_override.as_deref(), Some("fr-FR"));+ assert_eq!(state.timezone_override.as_deref(), Some("Europe/Paris"));+ assert_eq!(state.network_policy.user_agent_override(), Some("Moli/CDP"));++ state.clear_devtools_network_state(false, None);+ state.clear_devtools_emulation_state(false, None);+ assert_eq!(state.locale_override.as_deref(), Some("en-GB"));+ assert_eq!(state.timezone_override.as_deref(), Some("Europe/London"));+ assert_eq!(+ state.network_policy.user_agent_override(),+ Some("Moli/Base"));-- assert_eq!(policy.extra_headers()[0].1, "B");- assert_eq!(policy.user_agent_override(), Some("Moli/B"));- assert_eq!(policy.remove_session_overrides("session-b"), (true, true));- assert_eq!(policy.extra_headers()[0].1, "A");- assert_eq!(policy.user_agent_override(), Some("Moli/A"));- assert_eq!(policy.remove_session_overrides("session-a"), (true, true));- assert!(policy.extra_headers().is_empty());- assert_eq!(policy.user_agent_override(), None);- }-- #[test]- fn detached_session_emulation_override_restores_the_previous_session() {- let mut overrides = TargetSessionOverrideStack::default();- overrides.replace(Some("session-a"), Some("fr-FR".to_owned()));- overrides.replace(Some("session-b"), Some("ja-JP".to_owned()));- assert_eq!(overrides.effective().map(String::as_str), Some("ja-JP"));-- assert!(overrides.remove_session("session-b"));- assert_eq!(overrides.effective().map(String::as_str), Some("fr-FR"));- overrides.replace(Some("session-a"), None);- assert!(overrides.effective().is_none());}fn jpeg_config() -> PageScreencastConfig {diff --git a/moli-protocol/src/conn/state/shared_worker_target.rs b/moli-protocol/src/conn/state/shared_worker_target.rsindex 2247c712f..2141d067c 100644--- a/moli-protocol/src/conn/state/shared_worker_target.rs+++ b/moli-protocol/src/conn/state/shared_worker_target.rs@@ -490,13 +490,17 @@ impl SharedWorkerTargetState {let Some(state) = self.session_state_mut(session_id) else {return false;};- state.network_output_session_state.network_enabled = enabled;+ if enabled {+ state.network_session_state.network_enabled = true;+ } else {+ state.network_session_state = Default::default();+ }true}pub(crate) fn network_enabled(&self, session_id: &str) -> bool {self.session_state(session_id)- .is_some_and(|state| state.network_output_session_state.network_enabled)+ .is_some_and(|state| state.network_session_state.network_enabled)}pub(crate) fn set_console_enabled(&mut self, session_id: &str, enabled: bool) {diff --git a/moli-protocol/src/conn/tests/resource_runtime.rs b/moli-protocol/src/conn/tests/resource_runtime.rsindex 8f968cf22..1a63d92cc 100644--- a/moli-protocol/src/conn/tests/resource_runtime.rs+++ b/moli-protocol/src/conn/tests/resource_runtime.rs@@ -3167,6 +3167,7 @@ async fn direct_network_policy_routes_to_inactive_active_owner_without_promotingconn.inactive_browser_contexts.push(inactive);for raw in [+ r#"{"id":0,"method":"Network.enable","sessionId":"SID-B"}"#,r#"{"id":1,"method":"Network.setCacheDisabled","sessionId":"SID-B","params":{"cacheDisabled":true}}"#,r#"{"id":2,"method":"Network.setBypassServiceWorker","sessionId":"SID-B","params":{"bypass":true}}"#,r#"{"id":3,"method":"Network.setBlockedURLs","sessionId":"SID-B","params":{"urls":["*://blocked.test/*"]}}"#,@@ -3281,6 +3282,7 @@ async fn direct_network_policy_routes_to_inactive_background_owner_without_promoconn.inactive_browser_contexts.push(inactive);for raw in [+ r#"{"id":0,"method":"Network.enable","sessionId":"SID-background"}"#,r#"{"id":1,"method":"Network.setCacheDisabled","sessionId":"SID-background","params":{"cacheDisabled":true}}"#,r#"{"id":2,"method":"Network.setBypassServiceWorker","sessionId":"SID-background","params":{"bypass":true}}"#,r#"{"id":3,"method":"Network.setBlockedURLs","sessionId":"SID-background","params":{"urls":["*://blocked-background.test/*"]}}"#,diff --git a/moli-protocol/src/domains/emulation.rs b/moli-protocol/src/domains/emulation.rsindex 5f30f3017..350eca88e 100644--- a/moli-protocol/src/domains/emulation.rs+++ b/moli-protocol/src/domains/emulation.rs@@ -457,15 +457,15 @@ fn start_locale_override_command(return EmulationCommandTaskStep::Complete(CommandOutputPlan::result(json!({})));}let locale_override = params.locale.clone().filter(|value| !value.is_empty());- if !conn.mutate_emulation_session_state_for_session_owner(cmd.session_id, |state| {- if let Some(mut state) = state {- state.set_locale_override(locale_override.clone());- }- }) {- return EmulationCommandTaskStep::Complete(CommandOutputPlan::error(- -31998,- "BrowserContextNotLoaded",- ));+ if let Err(message) =+ conn.set_devtools_locale_override_for_session_owner(cmd.session_id, locale_override.clone())+ {+ let code = if message == "BrowserContextNotLoaded" {+ -31998+ } else {+ -32000+ };+ return EmulationCommandTaskStep::Complete(CommandOutputPlan::error(code, message));}let pending = if emulation_command_is_context_wide(conn, cmd.session_id) {match start_context_locale_override_page_commands(conn) {@@ -571,15 +571,15 @@ fn start_timezone_override_command(let trimmed = params.timezone_id.trim();(!trimmed.is_empty()).then(|| trimmed.to_owned())};- if !conn.mutate_emulation_session_state_for_session_owner(cmd.session_id, |state| {- if let Some(mut state) = state {- state.set_timezone_override(timezone_override.clone());- }- }) {- return EmulationCommandTaskStep::Complete(CommandOutputPlan::error(- -31998,- "BrowserContextNotLoaded",- ));+ if let Err(message) = conn+ .set_devtools_timezone_override_for_session_owner(cmd.session_id, timezone_override.clone())+ {+ let code = if message == "BrowserContextNotLoaded" {+ -31998+ } else {+ -32000+ };+ return EmulationCommandTaskStep::Complete(CommandOutputPlan::error(code, message));}let owner_scope = CommandOwnerScope::capture(conn, cmd.session_id);let Some(page) = loaded_page_mut_for_session(conn, cmd.session_id) else {@@ -753,9 +753,9 @@ fn start_user_agent_override_command(Err(plan) => return EmulationCommandTaskStep::Complete(plan),};let owner_scope = CommandOwnerScope::capture(conn, cmd.session_id);- match conn.start_set_browser_identity_override_for_session_owner(+ match conn.start_set_devtools_browser_identity_override_for_session_owner(cmd.session_id,- Some(browser_identity),+ browser_identity,) {Ok(Some(pending)) => EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {command_id: cmd.id,@@ -1401,7 +1401,7 @@ fn start_extra_headers_for_current_route() -> Result<Vec<PendingEmulationPageCommand>, DevToolsError> {let target = pending_emulation_target_for_route(route)?;let pending = conn- .start_set_extra_http_headers_for_session_owner(None, headers)+ .start_set_target_extra_http_headers_for_session_owner(None, headers).map_err(devtools_emulation_owner_error)?;Ok(pending.map(|pending| {@@ -1657,7 +1657,7 @@ fn start_user_agent_override_for_current_route() -> Result<Option<PendingEmulationPageCommand>, DevToolsError> {let target = pending_emulation_target_for_route(route)?;let pending = conn- .start_set_user_agent_override_for_session_owner(None, user_agent)+ .start_set_base_user_agent_override_for_session_owner(None, user_agent).map_err(devtools_emulation_owner_error)?;if let Some(pending) = pending {return Ok(Some(PendingEmulationPageCommand {@@ -1771,11 +1771,7 @@ fn start_locale_override_for_current_route(route: &CdpSessionRoute,locale: Option<String>,) -> Result<Vec<PendingEmulationPageCommand>, DevToolsError> {- if !conn.mutate_emulation_session_state_for_session_owner(None, |state| {- if let Some(mut state) = state {- state.set_locale_override(locale.clone());- }- }) {+ if !conn.set_base_locale_override_for_session_owner(None, locale) {return Err(devtools_emulation_owner_error("BrowserContextNotLoaded".to_owned(),));@@ -1880,11 +1876,7 @@ fn start_timezone_override_for_current_route(route: &CdpSessionRoute,timezone: Option<String>,) -> Result<Option<PendingEmulationPageCommand>, DevToolsError> {- if !conn.mutate_emulation_session_state_for_session_owner(None, |state| {- if let Some(mut state) = state {- state.set_timezone_override(timezone.clone());- }- }) {+ if !conn.set_base_timezone_override_for_session_owner(None, timezone) {return Err(devtools_emulation_owner_error("BrowserContextNotLoaded".to_owned(),));diff --git a/moli-protocol/src/domains/emulation/tests.rs b/moli-protocol/src/domains/emulation/tests.rsindex 35bd55335..7c0f30f19 100644--- a/moli-protocol/src/domains/emulation/tests.rs+++ b/moli-protocol/src/domains/emulation/tests.rs@@ -54,6 +54,49 @@ async fn load_session_page_for_pending_emulation_test_at_url(ctx: &mut TestConteinstall_session_page_for_emulation_test(ctx, bc, url).await;}+fn install_multi_session_page_state(ctx: &mut TestContext) {+ let mut browser_context = BrowserContext::new("BID-1".into());+ browser_context.set_active_target_id("TID-1");+ browser_context.attach_active_session("SID-primary");+ assert!(browser_context.assign_auxiliary_session_to_target("TID-1", "SID-aux".to_owned()));+ ctx.conn.browser_context = Some(browser_context);+}++async fn expect_session_command_result(+ ctx: &mut TestContext,+ id: u64,+ session_id: &str,+ method: &str,+ params: serde_json::Value,+) {+ ctx.process_async(json!({+ "id": id,+ "method": method,+ "sessionId": session_id,+ "params": params,+ }))+ .await;+ ctx.expect_result(id, json!({}), Some(session_id));+}++async fn expect_session_command_error(+ ctx: &mut TestContext,+ id: u64,+ session_id: &str,+ method: &str,+ params: serde_json::Value,+ message: &str,+) {+ ctx.process_async(json!({+ "id": id,+ "method": method,+ "sessionId": session_id,+ "params": params,+ }))+ .await;+ ctx.expect_error(id, -32000, message);+}+async fn install_session_page_for_emulation_test(ctx: &mut TestContext,bc: BrowserContext,@@ -768,6 +811,181 @@ async fn set_timezone_override_without_loaded_browser_context_errors() {ctx.expect_error(7, -31998, "BrowserContextNotLoaded");}+#[tokio::test(flavor = "multi_thread")]+async fn multi_session_locale_and_timezone_claims_match_chromium() {+ const LOCALE: &str = "Emulation.setLocaleOverride";+ const TIMEZONE: &str = "Emulation.setTimezoneOverride";+ let mut ctx = TestContext::new();+ install_multi_session_page_state(&mut ctx);++ expect_session_command_result(+ &mut ctx,+ 70_001,+ "SID-primary",+ LOCALE,+ json!({+ "locale": "fr-FR"+ }),+ )+ .await;+ expect_session_command_error(+ &mut ctx,+ 70_002,+ "SID-aux",+ LOCALE,+ json!({ "locale": "de-DE" }),+ "Another locale override is already in effect",+ )+ .await;+ expect_session_command_result(+ &mut ctx,+ 70_003,+ "SID-primary",+ TIMEZONE,+ json!({+ "timezoneId": "Europe/Paris"+ }),+ )+ .await;+ expect_session_command_error(+ &mut ctx,+ 70_004,+ "SID-aux",+ TIMEZONE,+ json!({ "timezoneId": "America/New_York" }),+ "Timezone override is already in effect",+ )+ .await;+ expect_session_command_result(+ &mut ctx,+ 70_005,+ "SID-aux",+ TIMEZONE,+ json!({ "timezoneId": "" }),+ )+ .await;++ let page_state = ctx+ .conn+ .browser_context+ .as_ref()+ .expect("browser context")+ .active_page_state();+ assert_eq!(page_state.locale_override.as_deref(), Some("fr-FR"));+ assert_eq!(+ page_state.timezone_override.as_deref(),+ Some("Europe/Paris")+ );+}++#[tokio::test(flavor = "multi_thread")]+async fn multi_session_browser_identity_uses_attachment_order_and_field_contributions() {+ const EMULATION_UA: &str = "Emulation.setUserAgentOverride";+ const NETWORK_UA: &str = "Network.setUserAgentOverride";+ let mut ctx = TestContext::new();+ install_multi_session_page_state(&mut ctx);++ for (id, method, session_id, user_agent) in [+ (71_001, EMULATION_UA, "SID-aux", "Moli/Aux-1"),+ (71_002, NETWORK_UA, "SID-primary", "Moli/Primary-1"),+ (71_003, EMULATION_UA, "SID-primary", "Moli/Primary-2"),+ ] {+ expect_session_command_result(+ &mut ctx,+ id,+ session_id,+ method,+ json!({ "userAgent": user_agent }),+ )+ .await;+ }+ assert_eq!(+ ctx.conn+ .browser_context+ .as_ref()+ .expect("browser context")+ .network_policy+ .user_agent_override(),+ Some("Moli/Aux-1")+ );++ expect_session_command_result(+ &mut ctx,+ 71_004,+ "SID-aux",+ NETWORK_UA,+ json!({ "userAgent": "" }),+ )+ .await;+ assert_eq!(+ ctx.conn+ .browser_context+ .as_ref()+ .expect("browser context")+ .network_policy+ .user_agent_override(),+ Some("Moli/Primary-2")+ );++ expect_session_command_result(+ &mut ctx,+ 71_005,+ "SID-aux",+ EMULATION_UA,+ json!({+ "userAgent": "",+ "acceptLanguage": "fr-FR",+ "platform": "AuxPlatform"+ }),+ )+ .await;+ let identity = ctx+ .conn+ .browser_context+ .as_ref()+ .expect("browser context")+ .network_policy+ .browser_identity_override()+ .expect("UA and per-field contributions should compose an identity");+ assert_eq!(identity.user_agent(), "Moli/Primary-2");+ assert_eq!(identity.accept_language(), "fr-FR");+ assert_eq!(identity.navigator_platform(), "AuxPlatform");++ expect_session_command_result(+ &mut ctx,+ 71_006,+ "SID-aux",+ NETWORK_UA,+ json!({ "userAgent": "Moli/Aux-2" }),+ )+ .await;+ expect_session_command_result(&mut ctx, 71_007, "SID-aux", "Network.disable", json!({})).await;+ assert_eq!(+ ctx.conn+ .browser_context+ .as_ref()+ .expect("browser context")+ .network_policy+ .user_agent_override(),+ Some("Moli/Aux-2"),+ "Network.disable must not dispose the shared Emulation agent state"+ );++ ctx.conn+ .clear_target_session_overrides_async("SID-aux")+ .await+ .expect("detaching the auxiliary session should restore the previous UA");+ assert_eq!(+ ctx.conn+ .browser_context+ .as_ref()+ .expect("browser context")+ .network_policy+ .user_agent_override(),+ Some("Moli/Primary-2")+ );+}+#[tokio::test(flavor = "multi_thread")]async fn async_emulation_device_state_updates_browser_context() {let mut ctx = TestContext::new();diff --git a/moli-protocol/src/domains/network.rs b/moli-protocol/src/domains/network.rsindex 9fca28945..aca37a6a0 100644--- a/moli-protocol/src/domains/network.rs+++ b/moli-protocol/src/domains/network.rs@@ -150,6 +150,9 @@ pub(crate) enum NetworkCommandTaskStep {}enum PendingNetworkCommandKind {+ Enable,+ Disable,+ SetCacheDisabled,SetExtraHttpHeaders,SetBlockedUrls,SetBypassServiceWorker,@@ -213,15 +216,15 @@ pub(crate) fn start_network_domain_command_dispatch());};match action {- NetworkAction::Enable => {- NetworkDomainCommandTaskStep::Complete(settings::enable_command_output_plan(conn, cmd))- }- NetworkAction::Disable => {- NetworkDomainCommandTaskStep::Complete(settings::disable_command_output_plan(conn, cmd))- }- NetworkAction::SetCacheDisabled => NetworkDomainCommandTaskStep::Complete(- settings::set_cache_disabled_command_output_plan(conn, cmd),+ NetworkAction::Enable => NetworkDomainCommandTaskStep::Network(+ start_set_network_domain_enabled_command(conn, cmd, true),),+ NetworkAction::Disable => NetworkDomainCommandTaskStep::Network(+ start_set_network_domain_enabled_command(conn, cmd, false),+ ),+ NetworkAction::SetCacheDisabled => {+ NetworkDomainCommandTaskStep::Network(start_set_cache_disabled_command(conn, cmd))+ }NetworkAction::SetBypassServiceWorker => NetworkDomainCommandTaskStep::Network(start_set_bypass_service_worker_command(conn, cmd),),@@ -466,6 +469,44 @@ fn pending_network_page_command_step(}}+fn start_set_network_domain_enabled_command(+ conn: &mut CdpConnection,+ cmd: &Cmd<'_>,+ enabled: bool,+) -> NetworkCommandTaskStep {+ let updated = if enabled {+ conn.enable_network_listener_for_session_owner(cmd.session_id)+ } else {+ conn.disable_network_listener_for_session_owner(cmd.session_id)+ };+ if !updated {+ return NetworkCommandTaskStep::Complete(CommandOutputPlan::error(+ -31998,+ "BrowserContextNotLoaded",+ ));+ }++ let kind = if enabled {+ PendingNetworkCommandKind::Enable+ } else {+ PendingNetworkCommandKind::Disable+ };+ match conn.start_replay_effective_network_request_policy_for_session_owner(cmd.session_id) {+ Ok(Some(pending)) => NetworkCommandTaskStep::Pending(PendingNetworkCommandDispatch {+ command_id: cmd.id,+ session_id: cmd.session_id.map(str::to_owned),+ kind,+ pending: PendingNetworkCommandWork::Page(pending),+ }),+ Ok(None) => NetworkCommandTaskStep::Complete(if enabled {+ settings::enabled_command_output_plan(conn, cmd.session_id)+ } else {+ CommandOutputPlan::success()+ }),+ Err(error) => NetworkCommandTaskStep::Complete(CommandOutputPlan::error(-32000, error)),+ }+}+fn start_set_extra_http_headers_command(conn: &mut CdpConnection,cmd: &Cmd<'_>,@@ -482,6 +523,22 @@ fn start_set_extra_http_headers_command()}+fn start_set_cache_disabled_command(+ conn: &mut CdpConnection,+ cmd: &Cmd<'_>,+) -> NetworkCommandTaskStep {+ let cache_disabled = match settings::cache_disabled_for_command(cmd) {+ Ok(cache_disabled) => cache_disabled,+ Err(plan) => return NetworkCommandTaskStep::Complete(plan),+ };+ pending_network_page_command_step(+ cmd.id,+ cmd.session_id,+ PendingNetworkCommandKind::SetCacheDisabled,+ conn.start_set_cache_disabled_for_session_owner(cmd.session_id, cache_disabled),+ )+}+fn start_set_blocked_urls_command(conn: &mut CdpConnection,cmd: &Cmd<'_>,@@ -550,9 +607,9 @@ fn start_set_user_agent_override_command(cmd.id,cmd.session_id,PendingNetworkCommandKind::SetUserAgentOverride,- conn.start_set_browser_identity_override_for_session_owner(+ conn.start_set_devtools_browser_identity_override_for_session_owner(cmd.session_id,- Some(browser_identity),+ browser_identity,),)}@@ -562,6 +619,15 @@ pub(crate) fn complete_pending_network_command(completed: CompletedNetworkCommandDispatch,) -> NetworkCommandTaskStep {match completed.kind {+ PendingNetworkCommandKind::Enable => {+ NetworkCommandTaskStep::Complete(complete_network_policy_refresh(conn, completed, true))+ }+ PendingNetworkCommandKind::Disable => NetworkCommandTaskStep::Complete(+ complete_network_policy_refresh(conn, completed, false),+ ),+ PendingNetworkCommandKind::SetCacheDisabled => NetworkCommandTaskStep::Complete(+ complete_network_policy_refresh(conn, completed, false),+ ),PendingNetworkCommandKind::SetExtraHttpHeaders => {NetworkCommandTaskStep::Complete(complete_unit_page_network_command(conn,@@ -602,6 +668,7 @@ pub(crate) fn complete_pending_network_command(}}+#[derive(Clone, Copy)]enum NetworkPageCommandFinish {ExtraHttpHeaders,BlockedUrls,@@ -609,6 +676,41 @@ enum NetworkPageCommandFinish {NetworkOffline,}+fn complete_network_policy_refresh(+ conn: &mut CdpConnection,+ completed: CompletedNetworkCommandDispatch,+ enabled: bool,+) -> CommandOutputPlan {+ let completion = match completed.completed {+ CompletedNetworkCommandWork::Page(Ok(completion)) => *completion,+ CompletedNetworkCommandWork::Page(Err(error)) => {+ return CommandOutputPlan::error(-32000, error);+ }+ CompletedNetworkCommandWork::Resource(_) => {+ return CommandOutputPlan::error(-32000, "InvalidNetworkCommandCompletion");+ }+ };+ let page = match conn.loaded_page_mut_for_protocol_access(completed.session_id.as_deref()) {+ Ok(page) => page,+ Err(message) if message == "NoDocumentLoaded" => {+ return if enabled {+ settings::enabled_command_output_plan(conn, completed.session_id.as_deref())+ } else {+ CommandOutputPlan::success()+ };+ }+ Err(message) => return CommandOutputPlan::error(-32000, message),+ };+ if let Err(error) = page.finish_set_network_request_policy(completion) {+ return CommandOutputPlan::error(-32000, error.to_string());+ }+ if enabled {+ settings::enabled_command_output_plan(conn, completed.session_id.as_deref())+ } else {+ CommandOutputPlan::success()+ }+}+fn complete_unit_page_network_command(conn: &mut CdpConnection,completed: CompletedNetworkCommandDispatch,diff --git a/moli-protocol/src/domains/network/settings.rs b/moli-protocol/src/domains/network/settings.rsindex eba5711b8..ee6d7e496 100644--- a/moli-protocol/src/domains/network/settings.rs+++ b/moli-protocol/src/domains/network/settings.rs@@ -1,4 +1,4 @@-use crate::conn::{CdpConnection, Cmd};+use crate::conn::{CdpConnection, Cmd, DevToolsBrowserIdentityOverride};use crate::domains::command_output::CommandOutputPlan;#[allow(deprecated)]use chromiumoxide_cdp::cdp::browser_protocol::{@@ -24,15 +24,12 @@ pub(super) struct EmulatedNetworkConditionsForCommand {pub(super) connection_type: Option<String>,}-pub(super) fn enable_command_output_plan(+pub(super) fn enabled_command_output_plan(conn: &mut CdpConnection,- cmd: &Cmd<'_>,+ session_id: Option<&str>,) -> CommandOutputPlan {- if !conn.enable_network_listener_for_session_owner(cmd.session_id) {- return CommandOutputPlan::error(-31998, "BrowserContextNotLoaded");- }let mut plan = CommandOutputPlan::success();- if let Some(session_id) = cmd.session_id {+ if let Some(session_id) = session_id {plan.extend_background_events(super::super::target::dedicated_worker_main_script_network_replay_for_session(conn, session_id,@@ -42,16 +39,6 @@ pub(super) fn enable_command_output_plan(plan}-pub(super) fn disable_command_output_plan(- conn: &mut CdpConnection,- cmd: &Cmd<'_>,-) -> CommandOutputPlan {- bool_result_plan(- conn.disable_network_listener_for_session_owner(cmd.session_id),- "BrowserContextNotLoaded",- )-}-pub(super) fn clear_browser_cache_command_output_plan(conn: &mut CdpConnection,cmd: &Cmd<'_>,@@ -70,18 +57,12 @@ pub(super) fn clear_browser_cache_command_output_plan(CommandOutputPlan::success()}-pub(super) fn set_cache_disabled_command_output_plan(- conn: &mut CdpConnection,- cmd: &Cmd<'_>,-) -> CommandOutputPlan {+pub(super) fn cache_disabled_for_command(cmd: &Cmd<'_>) -> Result<bool, CommandOutputPlan> {let params: SetCacheDisabledParams = match cmd.get_params() {Ok(Some(params)) => params,- _ => return CommandOutputPlan::error(-32602, "InvalidParams"),+ _ => return Err(CommandOutputPlan::error(-32602, "InvalidParams")),};- bool_result_plan(- conn.set_cache_disabled_for_session_owner(cmd.session_id, params.cache_disabled),- "BrowserContextNotLoaded",- )+ Ok(params.cache_disabled)}pub(super) fn bypass_service_worker_for_command(cmd: &Cmd<'_>) -> Result<bool, CommandOutputPlan> {@@ -135,7 +116,7 @@ pub(super) fn extra_http_headers_for_command(pub(crate) fn user_agent_override_for_command(cmd: &Cmd<'_>,base: &moli_browser_profile::BrowserIdentityProfile,-) -> Result<moli_browser_profile::BrowserIdentityProfile, CommandOutputPlan> {+) -> Result<Option<DevToolsBrowserIdentityOverride>, CommandOutputPlan> {let params: SetUserAgentOverrideParams = match cmd.get_params() {Ok(Some(params)) => params,_ => return Err(CommandOutputPlan::error(-32602, "InvalidParams")),@@ -220,15 +201,13 @@ pub(crate) fn user_agent_override_for_command(form_factors: metadata.form_factors,}});- Ok(- moli_browser_profile::BrowserIdentityProfile::from_devtools_override(- base,- params.user_agent,- params.accept_language,- params.platform,- metadata,- ),- )+ Ok(DevToolsBrowserIdentityOverride::from_command(+ base,+ params.user_agent,+ params.accept_language,+ params.platform,+ metadata,+ ))}fn is_valid_chromium_header_value(value: &str) -> bool {@@ -262,14 +241,6 @@ fn validate_client_hint_brand_list(Ok(())}-fn bool_result_plan(success: bool, failure_message: &str) -> CommandOutputPlan {- if success {- CommandOutputPlan::success()- } else {- CommandOutputPlan::error(-31998, failure_message)- }-}-fn extra_http_headers_from_params(params: SetExtraHttpHeadersParams,) -> Option<Vec<(String, String)>> {diff --git a/moli-protocol/src/domains/network/tests/blocked_urls.rs b/moli-protocol/src/domains/network/tests/blocked_urls.rsindex 7ee9c3cd6..665467719 100644--- a/moli-protocol/src/domains/network/tests/blocked_urls.rs+++ b/moli-protocol/src/domains/network/tests/blocked_urls.rs@@ -354,11 +354,16 @@ async fn set_blocked_urls_worker_fetch_emits_loading_failed() {let mut bc = BrowserContext::new("BID-1".into());bc.set_active_target_id("TID-1");bc.attach_active_session("SID-1");- bc.active_target- .runtime_slot- .enable_primary_network_events();ctx.conn.browser_context = Some(bc);+ ctx.process_async(json!({+ "id": 28_101,+ "method": "Network.enable",+ "sessionId": "SID-1"+ }))+ .await;+ ctx.expect_result(28_101, json!({}), Some("SID-1"));+ctx.process_async(json!({"id": 2811,"method": "Page.navigate",@@ -493,11 +498,16 @@ async fn set_blocked_urls_worker_xhr_emits_loading_failed() {let mut bc = BrowserContext::new("BID-1".into());bc.set_active_target_id("TID-1");bc.attach_active_session("SID-1");- bc.active_target- .runtime_slot- .enable_primary_network_events();ctx.conn.browser_context = Some(bc);+ ctx.process_async(json!({+ "id": 28_102,+ "method": "Network.enable",+ "sessionId": "SID-1"+ }))+ .await;+ ctx.expect_result(28_102, json!({}), Some("SID-1"));+ctx.process_async(json!({"id": 2816,"method": "Page.navigate",@@ -628,11 +638,16 @@ async fn set_blocked_urls_worker_websocket_emits_loading_failed() {let mut bc = BrowserContext::new("BID-1".into());bc.set_active_target_id("TID-1");bc.attach_active_session("SID-1");- bc.active_target- .runtime_slot- .enable_primary_network_events();ctx.conn.browser_context = Some(bc);+ ctx.process_async(json!({+ "id": 28_103,+ "method": "Network.enable",+ "sessionId": "SID-1"+ }))+ .await;+ ctx.expect_result(28_103, json!({}), Some("SID-1"));+ctx.process_async(json!({"id": 2822,"method": "Page.navigate",diff --git a/moli-protocol/src/domains/network/tests/cache.rs b/moli-protocol/src/domains/network/tests/cache.rsindex b9db94bc0..5041acefc 100644--- a/moli-protocol/src/domains/network/tests/cache.rs+++ b/moli-protocol/src/domains/network/tests/cache.rs@@ -173,6 +173,71 @@ async fn cached_subresource_reload_emits_served_from_cache_before_response() {"immutable reload should not contact the origin again");+ ctx.process_async(json!({+ "id": 76,+ "method": "Network.setCacheDisabled",+ "sessionId": "SID-1",+ "params": {"cacheDisabled": true}+ }))+ .await;+ ctx.expect_result(76, json!({}), Some("SID-1"));+ ctx.sent.clear();++ ctx.process_async(json!({+ "id": 77,+ "method": "Page.reload",+ "sessionId": "SID-1",+ "params": {}+ }))+ .await;+ flush_until_subresource_finished(+ &mut ctx,+ "Script",+ 1,+ "cache-disabled immutable script network completion",+ )+ .await;+ assert_eq!(+ asset_hits.load(Ordering::SeqCst),+ 2,+ "cache-disabled reload must contact the origin"+ );+ assert!(+ !ctx.sent.iter().any(|message| {+ message["method"] == json!("Network.requestServedFromCache")+ && message["sessionId"] == json!("SID-1")+ }),+ "cache-disabled requests must not be reported as cache hits"+ );++ ctx.process_async(json!({+ "id": 78,+ "method": "Network.setCacheDisabled",+ "sessionId": "SID-1",+ "params": {"cacheDisabled": false}+ }))+ .await;+ ctx.expect_result(78, json!({}), Some("SID-1"));+ ctx.sent.clear();++ ctx.process_async(json!({+ "id": 79,+ "method": "Page.reload",+ "sessionId": "SID-1",+ "params": {}+ }))+ .await;+ wait_until_cached_request_finished(+ &mut ctx,+ "cache re-enabled immutable script network completion",+ )+ .await;+ assert_eq!(+ asset_hits.load(Ordering::SeqCst),+ 2,+ "re-enabled cache should reuse the response stored by the bypass load"+ );+server.abort();let _ = fs::remove_dir_all(cache_dir);}@@ -281,6 +346,87 @@ async fn cached_main_document_navigation_emits_served_from_cache_before_response"the cached second navigation must not contact the origin");+ ctx.process_async(json!({+ "id": 80,+ "method": "Network.setCacheDisabled",+ "sessionId": "SID-1",+ "params": {"cacheDisabled": true}+ }))+ .await;+ ctx.expect_result(80, json!({}), Some("SID-1"));+ ctx.sent.clear();++ ctx.process_async(json!({+ "id": 81,+ "method": "Page.navigate",+ "sessionId": "SID-1",+ "params": {"url": url}+ }))+ .await;+ wait_until_messages(+ &mut ctx,+ Some("SID-1"),+ "cache-disabled main document network completion",+ |messages| {+ let Some(request_id) = messages.iter().find_map(|message| {+ if message["method"] == json!("Network.requestWillBeSent")+ && message["params"]["type"] == json!("Document")+ {+ message["params"]["requestId"].as_str()+ } else {+ None+ }+ }) else {+ return false;+ };+ messages.iter().any(|message| {+ message["method"] == json!("Network.loadingFinished")+ && message["params"]["requestId"] == json!(request_id)+ })+ },+ )+ .await;+ assert_eq!(+ document_hits.load(Ordering::SeqCst),+ 2,+ "cache-disabled navigation must contact the origin"+ );+ assert!(+ !ctx.sent.iter().any(|message| {+ message["method"] == json!("Network.requestServedFromCache")+ && message["sessionId"] == json!("SID-1")+ }),+ "cache-disabled navigation must not be reported as a cache hit"+ );++ ctx.process_async(json!({+ "id": 82,+ "method": "Network.setCacheDisabled",+ "sessionId": "SID-1",+ "params": {"cacheDisabled": false}+ }))+ .await;+ ctx.expect_result(82, json!({}), Some("SID-1"));+ ctx.sent.clear();++ ctx.process_async(json!({+ "id": 83,+ "method": "Page.navigate",+ "sessionId": "SID-1",+ "params": {"url": url}+ }))+ .await;+ wait_until_cached_request_finished(+ &mut ctx,+ "cache re-enabled main document network completion",+ )+ .await;+ assert_eq!(+ document_hits.load(Ordering::SeqCst),+ 2,+ "re-enabled cache should reuse the response stored by the bypass navigation"+ );+server.abort();let _ = fs::remove_dir_all(cache_dir);}@@ -578,6 +724,13 @@ async fn set_cache_disabled_updates_browser_context_state() {let mut ctx = TestContext::new();ctx.conn.browser_context = Some(BrowserContext::new("BID-1".into()));+ ctx.process_async(json!({+ "id": 219,+ "method": "Network.enable"+ }))+ .await;+ ctx.expect_result(219, json!({}), None);+ctx.process_async(json!({"id": 22,"method": "Network.setCacheDisabled",@@ -807,6 +960,13 @@ async fn set_bypass_service_worker_updates_browser_context_state() {let mut ctx = TestContext::new();ctx.conn.browser_context = Some(BrowserContext::new("BID-1".into()));+ ctx.process_async(json!({+ "id": 239,+ "method": "Network.enable"+ }))+ .await;+ ctx.expect_result(239, json!({}), None);+ctx.process_async(json!({"id": 26,"method": "Network.setBypassServiceWorker",diff --git a/moli-protocol/src/domains/network/tests/cookies.rs b/moli-protocol/src/domains/network/tests/cookies.rsindex ea8a9e99d..9ddc978d8 100644--- a/moli-protocol/src/domains/network/tests/cookies.rs+++ b/moli-protocol/src/domains/network/tests/cookies.rs@@ -66,6 +66,10 @@ async fn set_extra_http_headers_replaces_previous_headers() {let mut ctx = TestContext::new();ctx.conn.browser_context = Some(BrowserContext::new("NID-A".into()));+ ctx.process_async(json!({"id": 2, "method": "Network.enable"}))+ .await;+ ctx.expect_result(2, json!({}), None);+ctx.process_async(json!({"id": 3, "method": "Network.setExtraHTTPHeaders", "params": { "headers": { "foo": "bar" }}})).await;ctx.expect_result(3, json!({}), None);diff --git a/moli-protocol/src/domains/network/tests/service_worker.rs b/moli-protocol/src/domains/network/tests/service_worker.rsindex 45e2a846a..88b73dd0b 100644--- a/moli-protocol/src/domains/network/tests/service_worker.rs+++ b/moli-protocol/src/domains/network/tests/service_worker.rs@@ -51,6 +51,14 @@ self.addEventListener("fetch", event => {browser_context.attach_active_session("SID-1");ctx.conn.browser_context = Some(browser_context);+ ctx.process_async(json!({+ "id": 80_000,+ "method": "Network.enable",+ "sessionId": "SID-1"+ }))+ .await;+ ctx.expect_result(80_000, json!({}), Some("SID-1"));+ctx.process_async(json!({"id": 80_001,"method": "Page.navigate",diff --git a/moli-protocol/src/domains/network/tests/session.rs b/moli-protocol/src/domains/network/tests/session.rsindex 65412ab08..f44a505e7 100644--- a/moli-protocol/src/domains/network/tests/session.rs+++ b/moli-protocol/src/domains/network/tests/session.rs@@ -56,6 +56,125 @@ async fn auxiliary_network_enable_does_not_enable_primary_session() {vec![Some("SID-aux".to_owned())]);}++#[tokio::test(flavor = "multi_thread")]+async fn page_network_policy_aggregates_enabled_sessions_like_chromium_handlers() {+ let mut ctx = TestContext::new();+ let mut bc = BrowserContext::new("BID-1".into());+ bc.set_active_target_id("TID-1".to_owned());+ bc.attach_active_session("SID-primary".to_owned());+ assert!(bc.assign_auxiliary_session_to_target("TID-1", "SID-aux".to_owned()));+ ctx.conn.browser_context = Some(bc);++ for (id, session_id) in [(20_001, "SID-primary"), (20_002, "SID-aux")] {+ ctx.process_async(json!({+ "id": id,+ "method": "Network.enable",+ "sessionId": session_id,+ }))+ .await;+ ctx.expect_result(id, json!({}), Some(session_id));+ }++ for (id, session_id, method, params) in [+ (+ 20_003,+ "SID-primary",+ "Network.setCacheDisabled",+ json!({"cacheDisabled": true}),+ ),+ (+ 20_004,+ "SID-primary",+ "Network.setBypassServiceWorker",+ json!({"bypass": true}),+ ),+ (+ 20_005,+ "SID-primary",+ "Network.setExtraHTTPHeaders",+ json!({"headers": {"X-Primary": "primary", "X-Shared": "primary"}}),+ ),+ (+ 20_006,+ "SID-aux",+ "Network.setCacheDisabled",+ json!({"cacheDisabled": false}),+ ),+ (+ 20_007,+ "SID-aux",+ "Network.setBypassServiceWorker",+ json!({"bypass": false}),+ ),+ (+ 20_008,+ "SID-aux",+ "Network.setExtraHTTPHeaders",+ json!({"headers": {"X-Aux": "aux", "x-shared": "aux"}}),+ ),+ ] {+ ctx.process_async(json!({+ "id": id,+ "method": method,+ "sessionId": session_id,+ "params": params,+ }))+ .await;+ ctx.expect_result(id, json!({}), Some(session_id));+ }++ let policy = &ctx.conn.browser_context.as_ref().unwrap().network_policy;+ assert!(policy.cache_disabled());+ assert!(policy.bypass_service_worker());+ assert_eq!(+ policy.extra_headers(),+ [+ ("X-Primary".to_owned(), "primary".to_owned()),+ ("x-shared".to_owned(), "aux".to_owned()),+ ("X-Aux".to_owned(), "aux".to_owned()),+ ]+ );++ ctx.process_async(json!({+ "id": 20_009,+ "method": "Network.disable",+ "sessionId": "SID-primary",+ }))+ .await;+ ctx.expect_result(20_009, json!({}), Some("SID-primary"));++ let policy = &ctx.conn.browser_context.as_ref().unwrap().network_policy;+ assert!(!policy.cache_disabled());+ assert!(!policy.bypass_service_worker());+ assert_eq!(+ policy.extra_headers(),+ [+ ("X-Aux".to_owned(), "aux".to_owned()),+ ("x-shared".to_owned(), "aux".to_owned()),+ ]+ );++ ctx.process_async(json!({+ "id": 20_010,+ "method": "Network.enable",+ "sessionId": "SID-primary",+ }))+ .await;+ ctx.expect_result(20_010, json!({}), Some("SID-primary"));++ let policy = &ctx.conn.browser_context.as_ref().unwrap().network_policy;+ assert!(!policy.cache_disabled());+ assert!(!policy.bypass_service_worker());+ assert_eq!(+ policy.extra_headers(),+ [+ ("X-Aux".to_owned(), "aux".to_owned()),+ ("x-shared".to_owned(), "aux".to_owned()),+ ],+ "Network.disable must clear the disabled session's policy state"+ );+}#[tokio::test(flavor = "multi_thread")]async fn enable_after_page_load_does_not_replay_historical_subresource_events() {async fn page() -> impl IntoResponse {diff --git a/moli-protocol/src/domains/network/tests/subresource.rs b/moli-protocol/src/domains/network/tests/subresource.rsindex 6b9ca9fe4..a3a947034 100644--- a/moli-protocol/src/domains/network/tests/subresource.rs+++ b/moli-protocol/src/domains/network/tests/subresource.rs@@ -266,6 +266,162 @@ fetch('/api')server.abort();}++#[tokio::test(flavor = "multi_thread")]+async fn enabling_and_disabling_sessions_replays_aggregated_headers_to_loaded_page() {+ async fn page() -> impl IntoResponse {+ (+ [(CONTENT_TYPE.as_str(), "text/html")],+ "<!doctype html><body>ready</body>",+ )+ }++ async fn api(headers: axum::http::HeaderMap) -> impl IntoResponse {+ headers+ .get("x-shared")+ .and_then(|value| value.to_str().ok())+ .unwrap_or("")+ .to_owned()+ }++ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ let server = tokio::spawn(async move {+ axum::serve(+ listener,+ Router::new()+ .route("/page", get(page))+ .route("/api", get(api)),+ )+ .await+ .unwrap();+ });++ let page_url = format!("http://{addr}/page");+ let api_url = format!("http://{addr}/api");+ let mut ctx = TestContext::new();+ let mut bc = BrowserContext::new("BID-1".into());+ bc.set_active_target_id("TID-1");+ bc.attach_active_session("SID-1");+ assert!(bc.assign_auxiliary_session_to_target("TID-1", "SID-aux".to_owned()));+ ctx.conn.browser_context = Some(bc);++ ctx.process_async(json!({+ "id": 50_001,+ "method": "Page.navigate",+ "sessionId": "SID-1",+ "params": {"url": page_url},+ }))+ .await;+ ctx.expect_result(+ 50_001,+ json!({"frameId": "TID-1", "loaderId": LOADER_ID}),+ Some("SID-1"),+ );++ for (id, session_id, value) in [(50_002, "SID-1", "primary"), (50_003, "SID-aux", "aux")] {+ ctx.process_async(json!({+ "id": id,+ "method": "Network.setExtraHTTPHeaders",+ "sessionId": session_id,+ "params": {"headers": {"X-Shared": value}},+ }))+ .await;+ ctx.expect_result(id, json!({}), Some(session_id));+ }++ async fn fetch_header(ctx: &mut TestContext, id: u64, api_url: &str, expected: &str) {+ ctx.process_async(json!({+ "id": id,+ "method": "Runtime.evaluate",+ "sessionId": "SID-1",+ "params": {+ "expression": format!("fetch({api_url:?}).then(response => response.text())"),+ "awaitPromise": true,+ "returnByValue": true,+ },+ }))+ .await;+ wait_until_messages(+ ctx,+ Some("SID-1"),+ "network policy fetch response",+ |messages| messages.iter().any(|message| message["id"] == json!(id)),+ )+ .await;+ ctx.expect_result(+ id,+ json!({"result": {"type": "string", "value": expected}}),+ Some("SID-1"),+ );+ ctx.sent.clear();+ }++ fetch_header(&mut ctx, 50_004, &api_url, "").await;++ ctx.process_async(json!({+ "id": 50_005,+ "method": "Network.enable",+ "sessionId": "SID-1",+ }))+ .await;+ ctx.expect_result(50_005, json!({}), Some("SID-1"));+ fetch_header(&mut ctx, 50_006, &api_url, "primary").await;++ ctx.process_async(json!({+ "id": 50_007,+ "method": "Network.enable",+ "sessionId": "SID-aux",+ }))+ .await;+ ctx.expect_result(50_007, json!({}), Some("SID-aux"));+ fetch_header(&mut ctx, 50_008, &api_url, "aux").await;++ ctx.process_async(json!({+ "id": 50_009,+ "method": "Network.disable",+ "sessionId": "SID-aux",+ }))+ .await;+ ctx.expect_result(50_009, json!({}), Some("SID-aux"));+ fetch_header(&mut ctx, 50_010, &api_url, "primary").await;++ ctx.process_async(json!({+ "id": 50_011,+ "method": "Network.enable",+ "sessionId": "SID-aux",+ }))+ .await;+ ctx.expect_result(50_011, json!({}), Some("SID-aux"));+ fetch_header(&mut ctx, 50_012, &api_url, "primary").await;++ ctx.process_async(json!({+ "id": 50_013,+ "method": "Network.setExtraHTTPHeaders",+ "sessionId": "SID-aux",+ "params": {"headers": {"X-Shared": "aux-after-enable"}},+ }))+ .await;+ ctx.expect_result(50_013, json!({}), Some("SID-aux"));+ fetch_header(&mut ctx, 50_014, &api_url, "aux-after-enable").await;++ ctx.conn+ .clear_target_session_overrides_async("SID-aux")+ .await+ .expect("detaching the auxiliary session should restore effective request policy");+ assert_eq!(+ ctx.conn+ .browser_context+ .as_mut()+ .unwrap()+ .remove_auxiliary_session("SID-aux")+ .as_deref(),+ Some("TID-1")+ );+ fetch_header(&mut ctx, 50_015, &api_url, "primary").await;++ server.abort();+}#[tokio::test(flavor = "multi_thread")]async fn page_fetch_response_clone_preserves_binary_body_source() {async fn page() -> impl IntoResponse {@@ -1625,6 +1781,14 @@ async fn parser_external_script_applies_extra_http_headers() {bc.attach_active_session("SID-1");ctx.conn.browser_context = Some(bc);+ ctx.process_async(json!({+ "id": 70_000,+ "method": "Network.enable",+ "sessionId": "SID-1"+ }))+ .await;+ ctx.expect_result(70_000, json!({}), Some("SID-1"));+ctx.process_async(json!({"id": 70_001,"method": "Network.setExtraHTTPHeaders",@@ -2115,6 +2279,14 @@ worker.onmessage = event => {bc.attach_active_session("SID-1");ctx.conn.browser_context = Some(bc);+ ctx.process_async(json!({+ "id": 70_019,+ "method": "Network.enable",+ "sessionId": "SID-1"+ }))+ .await;+ ctx.expect_result(70_019, json!({}), Some("SID-1"));+ctx.process_async(json!({"id": 70_020,"method": "Network.setExtraHTTPHeaders",diff --git a/moli-protocol/src/domains/page/tests/lifecycle.rs b/moli-protocol/src/domains/page/tests/lifecycle.rsindex 5f9d6c498..ae440e2c1 100644--- a/moli-protocol/src/domains/page/tests/lifecycle.rs+++ b/moli-protocol/src/domains/page/tests/lifecycle.rs@@ -2944,8 +2944,12 @@ async fn close_clears_loaded_page_state_and_emits_detached_events() {bc.active_target.runtime_slot.enable_primary_network_events();- bc.network_policy.set_cache_disabled(true);- bc.network_policy.set_bypass_service_worker(true);+ bc.mutate_devtools_network_session_state(false, None, |network| {+ network.network_enabled = true;+ network.cache_disabled = true;+ network.bypass_service_worker = true;+ network.extra_headers = vec![("X-Test".into(), "1".into())];+ });bc.css_enabled = true;bc.active_target.fetch_owner.configure(None,@@ -2956,8 +2960,6 @@ async fn close_clears_loaded_page_state_and_emits_detached_events() {request_stage: FetchRequestStage::Response,}],);- bc.network_policy- .push_extra_header(("X-Test".into(), "1".into()));bc.active_target.owner_state.target_crash_statediff --git a/moli-protocol/src/domains/runtime/tests/evaluate.rs b/moli-protocol/src/domains/runtime/tests/evaluate.rsindex f7fbb9bee..69dcbecea 100644--- a/moli-protocol/src/domains/runtime/tests/evaluate.rs+++ b/moli-protocol/src/domains/runtime/tests/evaluate.rs@@ -4446,6 +4446,13 @@ async fn runtime_evaluate_fetch_applies_extra_http_headers() {let api_url = format!("http://{addr}/api");let mut ctx = TestContext::new();with_loaded_http_document_async(&mut ctx, &page_url, "SID-1", "TID-1").await;+ ctx.process_async(json!({+ "id": 489,+ "method": "Network.enable",+ "sessionId": "SID-1"+ }))+ .await;+ let _ = take_response_by_id(&mut ctx, 489);let _ = enable_runtime_and_take_execution_context_id_async(&mut ctx, 490).await;ctx.process_async(json!({"id": 491,@@ -4667,6 +4674,13 @@ async fn runtime_evaluate_xhr_applies_extra_http_headers() {let xhr_url = format!("http://{addr}/xhr");let mut ctx = TestContext::new();with_loaded_http_document_async(&mut ctx, &page_url, "SID-1", "TID-1").await;+ ctx.process_async(json!({+ "id": 493,+ "method": "Network.enable",+ "sessionId": "SID-1"+ }))+ .await;+ let _ = take_response_by_id(&mut ctx, 493);let _ = enable_runtime_and_take_execution_context_id_async(&mut ctx, 494).await;ctx.process_async(json!({"id": 495,diff --git a/moli-protocol/src/domains/target/tests/tests_background_staging.rs b/moli-protocol/src/domains/target/tests/tests_background_staging.rsindex 9378b2ee1..ccc2af0b2 100644--- a/moli-protocol/src/domains/target/tests/tests_background_staging.rs+++ b/moli-protocol/src/domains/target/tests/tests_background_staging.rs@@ -1955,6 +1955,14 @@ async fn same_context_background_session_can_stage_its_own_extra_headers_before_.await;ctx.expect_result(10419460, json!({}), None);+ ctx.process_async(json!({+ "id": 104194601,+ "method": "Network.enable",+ "sessionId": "SID-active"+ }))+ .await;+ ctx.expect_result(104194601, json!({}), Some("SID-active"));+ctx.process_async(json!({"id": 10419461,"method": "Network.setExtraHTTPHeaders",@@ -1989,6 +1997,14 @@ async fn same_context_background_session_can_stage_its_own_extra_headers_before_.to_owned();ctx.expect_result(10419462, json!({ "targetId": second_target_id }), None);+ ctx.process_async(json!({+ "id": 104194602,+ "method": "Network.enable",+ "sessionId": second_session_id+ }))+ .await;+ ctx.expect_result(104194602, json!({}), Some(&second_session_id));+ctx.process_async(json!({"id": 10419463,"method": "Network.setExtraHTTPHeaders",@@ -2135,6 +2151,14 @@ async fn same_context_background_session_can_clear_its_own_extra_headers_before_.await;ctx.expect_result(104194661, json!({}), None);+ ctx.process_async(json!({+ "id": 1041946611,+ "method": "Network.enable",+ "sessionId": "SID-active"+ }))+ .await;+ ctx.expect_result(1041946611, json!({}), Some("SID-active"));+ctx.process_async(json!({"id": 104194662,"method": "Network.setExtraHTTPHeaders",@@ -2169,6 +2193,14 @@ async fn same_context_background_session_can_clear_its_own_extra_headers_before_.to_owned();ctx.expect_result(104194663, json!({ "targetId": second_target_id }), None);+ ctx.process_async(json!({+ "id": 1041946631,+ "method": "Network.enable",+ "sessionId": second_session_id+ }))+ .await;+ ctx.expect_result(1041946631, json!({}), Some(&second_session_id));+ctx.process_async(json!({"id": 104194664,"method": "Network.setExtraHTTPHeaders",@@ -2201,12 +2233,10 @@ async fn same_context_background_session_can_clear_its_own_extra_headers_before_active.network_policy.extra_headers(),vec![("X-Target".into(), "A".into())]);- assert!(- active- .parked_page_session_state(&second_target_id)- .is_none(),- "clearing staged headers back to default should fold away the parked state entry"- );+ let staged = active+ .parked_page_session_state(&second_target_id)+ .expect("enabled background session should retain its target-owned state");+ assert!(staged.network_policy.extra_headers().is_empty());}let url_a = format!("http://{addr}/page-a");diff --git a/moli-protocol/src/domains/target/tests/tests_same_context_overrides.rs b/moli-protocol/src/domains/target/tests/tests_same_context_overrides.rsindex 759f54350..4233f4368 100644--- a/moli-protocol/src/domains/target/tests/tests_same_context_overrides.rs+++ b/moli-protocol/src/domains/target/tests/tests_same_context_overrides.rs@@ -16,6 +16,14 @@ async fn same_context_targets_restore_their_own_page_session_overrides_after_swi.unwrap().attach_active_session("SID-active");+ ctx.process_async(json!({+ "id": 104158,+ "method": "Network.enable",+ "sessionId": "SID-active"+ }))+ .await;+ ctx.expect_result(104158, json!({}), Some("SID-active"));+ctx.process_async(json!({"id": 104159,"method": "Network.setExtraHTTPHeaders",@@ -64,6 +72,14 @@ async fn same_context_targets_restore_their_own_page_session_overrides_after_swi.to_owned();ctx.expect_event("Target.attachedToTarget", None);+ ctx.process_async(json!({+ "id": 1041621,+ "method": "Network.enable",+ "sessionId": second_session_id+ }))+ .await;+ ctx.expect_result(1041621, json!({}), Some(&second_session_id));+ctx.process_async(json!({"id": 104163,"method": "Page.navigate",diff --git a/moli-protocol/src/domains/target/tests/tests_target_attachment.rs b/moli-protocol/src/domains/target/tests/tests_target_attachment.rsindex 4a8da9ab3..56b4c29f0 100644--- a/moli-protocol/src/domains/target/tests/tests_target_attachment.rs+++ b/moli-protocol/src/domains/target/tests/tests_target_attachment.rs@@ -1548,8 +1548,12 @@ async fn detach_from_target() {bc.active_target.runtime_slot.enable_primary_network_events();- bc.network_policy.set_cache_disabled(true);- bc.network_policy.set_bypass_service_worker(true);+ bc.mutate_devtools_network_session_state(false, None, |network| {+ network.network_enabled = true;+ network.cache_disabled = true;+ network.bypass_service_worker = true;+ network.extra_headers = vec![("X-Test".into(), "1".into())];+ });bc.css_enabled = true;bc.active_target.fetch_owner.configure(None,@@ -1560,8 +1564,6 @@ async fn detach_from_target() {request_stage: crate::conn::FetchRequestStage::Request,}],);- bc.network_policy- .push_extra_header(("X-Test".into(), "1".into()));ctx.process_async(json!({"id": 12, "method": "Target.detachFromTarget","params": {"targetId": tid}}))@@ -2197,8 +2199,12 @@ async fn set_auto_attach_false_detaches_existing_target() {bc.active_target.runtime_slot.enable_primary_network_events();- bc.network_policy.set_cache_disabled(true);- bc.network_policy.set_bypass_service_worker(true);+ bc.mutate_devtools_network_session_state(false, None, |network| {+ network.network_enabled = true;+ network.cache_disabled = true;+ network.bypass_service_worker = true;+ network.extra_headers = vec![("X-Test".into(), "1".into())];+ });bc.css_enabled = true;bc.active_target.fetch_owner.configure(None,@@ -2209,8 +2215,6 @@ async fn set_auto_attach_false_detaches_existing_target() {request_stage: crate::conn::FetchRequestStage::Request,}],);- bc.network_policy- .push_extra_header(("X-Test".into(), "1".into()));ctx.conn.auto_attach = true;ctx.process_async(json!({diff --git a/moli-protocol/src/domains/target/tests/tests_target_management.rs b/moli-protocol/src/domains/target/tests/tests_target_management.rsindex 5626715c5..5381a94c4 100644--- a/moli-protocol/src/domains/target/tests/tests_target_management.rs+++ b/moli-protocol/src/domains/target/tests/tests_target_management.rs@@ -50,8 +50,12 @@ async fn close_target_success() {bc.active_target.runtime_slot.enable_primary_network_events();- bc.network_policy.set_cache_disabled(true);- bc.network_policy.set_bypass_service_worker(true);+ bc.mutate_devtools_network_session_state(false, None, |network| {+ network.network_enabled = true;+ network.cache_disabled = true;+ network.bypass_service_worker = true;+ network.extra_headers = vec![("X-Test".into(), "1".into())];+ });bc.css_enabled = true;bc.active_target.fetch_owner.configure(None,@@ -62,8 +66,6 @@ async fn close_target_success() {request_stage: crate::conn::FetchRequestStage::Response,}],);- bc.network_policy- .push_extra_header(("X-Test".into(), "1".into()));bc.set_target_security_origin("https://old.example".into());bc.set_target_secure_context_type("InsecureScheme".into());bc.set_next_network_request_sequence_for_test(41);diff --git a/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs b/moli-renderer-v8/src/native_bridge/context_host/host_environment.rsindex 45855e192..f4a190462 100644--- a/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs@@ -2450,6 +2450,19 @@ impl JsContextHost {}}+ pub(crate) fn set_cache_disabled(&mut self, disabled: bool) {+ if let Some(resource_loader) = self.current_main_document_resource_loader() {+ resource_loader+ .request_client()+ .set_cache_disabled(disabled);+ }+ for worker in self.workers.values() {+ if let super::workers::WorkerExecutionState::Running { handle } = &worker.execution {+ handle.set_cache_disabled(disabled);+ }+ }+ }+pub(crate) fn set_blocked_url_patterns(&mut self, patterns: &[String]) {self.blocked_url_patterns = patterns.to_vec();if let Some(resource_loader) = self.current_main_document_resource_loader() {diff --git a/moli-renderer-v8/src/network/navigation/loader.rs b/moli-renderer-v8/src/network/navigation/loader.rsindex 37ba14da5..ea822787b 100644--- a/moli-renderer-v8/src/network/navigation/loader.rs+++ b/moli-renderer-v8/src/network/navigation/loader.rs@@ -173,7 +173,10 @@ impl NavigationResourceLoader {self.begin_fetch()?;match self.request_client- .fetch_with_cancel(request, self.inner.cancel.clone())+ .fetch_with_cancel(+ request.with_page_network_policy(),+ self.inner.cancel.clone(),+ ).await{Ok(response) => {@@ -194,7 +197,10 @@ impl NavigationResourceLoader {self.begin_fetch()?;match self.request_client- .fetch_text_stream_with_cancel_and_network_metadata(request, self.inner.cancel.clone())+ .fetch_text_stream_with_cancel_and_network_metadata(+ request.with_page_network_policy(),+ self.inner.cancel.clone(),+ ).await{Ok(response) => {@@ -212,7 +218,10 @@ impl NavigationResourceLoader {self.begin_fetch()?;match self.request_client- .fetch_raw_stream_with_cancel(request, self.inner.cancel.clone())+ .fetch_raw_stream_with_cancel(+ request.with_page_network_policy(),+ self.inner.cancel.clone(),+ ).await{Ok(mut response) => {@@ -248,7 +257,10 @@ impl NavigationResourceLoader {self.begin_fetch()?;match self.request_client- .fetch_raw_stream_with_cancel_and_network_metadata(request, self.inner.cancel.clone())+ .fetch_raw_stream_with_cancel_and_network_metadata(+ request.with_page_network_policy(),+ self.inner.cancel.clone(),+ ).await{Ok(response) => {diff --git a/moli-renderer-v8/src/network/policy.rs b/moli-renderer-v8/src/network/policy.rsindex d95549ae5..fbec5659c 100644--- a/moli-renderer-v8/src/network/policy.rs+++ b/moli-renderer-v8/src/network/policy.rs@@ -3,7 +3,7 @@ use std::sync::Arc;use anyhow::{Result, anyhow};use http::HeaderName;use indexmap::IndexMap;-use moli_fetch::{Request, url_pattern_matches};+use moli_fetch::{Request, RequestCacheMode, url_pattern_matches};use parking_lot::Mutex;use crate::{protocol_types::OptionalResourceFetchMask, types::SubresourceResourceType};@@ -21,6 +21,7 @@ struct PageNetworkPolicyState {optional_resource_fetch_mask: OptionalResourceFetchMask,subframe_loading_enabled: bool,bypass_service_worker: bool,+ cache_disabled: bool,}impl PageNetworkPolicyState {@@ -41,6 +42,7 @@ impl Default for PageNetworkPolicyState {optional_resource_fetch_mask: OptionalResourceFetchMask::NONE,subframe_loading_enabled: true,bypass_service_worker: false,+ cache_disabled: false,}}}@@ -118,6 +120,7 @@ impl PageNetworkPolicy {optional_resource_fetch_mask: snapshot.optional_resource_fetch_mask,subframe_loading_enabled: snapshot.subframe_loading_enabled,bypass_service_worker: snapshot.bypass_service_worker,+ cache_disabled: snapshot.cache_disabled,})),network_conditions: Arc::new(Mutex::new(PageNetworkConditionsState {revision: snapshot.network_conditions_revision,@@ -143,6 +146,7 @@ impl PageNetworkPolicy {optional_resource_fetch_mask: snapshot.optional_resource_fetch_mask,subframe_loading_enabled: snapshot.subframe_loading_enabled,bypass_service_worker: snapshot.bypass_service_worker,+ cache_disabled: snapshot.cache_disabled,})),network_conditions: Arc::clone(&self.network_conditions),}@@ -171,6 +175,7 @@ impl PageNetworkPolicy {optional_resource_fetch_mask: state.optional_resource_fetch_mask,subframe_loading_enabled: state.subframe_loading_enabled,bypass_service_worker: state.bypass_service_worker,+ cache_disabled: state.cache_disabled,}}@@ -281,6 +286,19 @@ impl PageNetworkPolicy {pub fn bypass_service_worker(&self) -> bool {self.state.lock().bypass_service_worker}++ pub fn set_cache_disabled(&self, disabled: bool) {+ let mut state = self.state.lock();+ if state.cache_disabled == disabled {+ return;+ }+ state.cache_disabled = disabled;+ state.advance_revision();+ }++ pub fn cache_disabled(&self) -> bool {+ self.state.lock().cache_disabled+ }}/// Immutable request-time view of one Page's network policy.@@ -297,6 +315,7 @@ pub struct PageNetworkPolicySnapshot {optional_resource_fetch_mask: OptionalResourceFetchMask,subframe_loading_enabled: bool,bypass_service_worker: bool,+ cache_disabled: bool,}impl PageNetworkPolicySnapshot {@@ -321,6 +340,10 @@ impl PageNetworkPolicySnapshot {self.bypass_service_worker}+ pub fn cache_disabled(&self) -> bool {+ self.cache_disabled+ }+pub(crate) fn blocks_url(&self, url: &url::Url) -> bool {self.blocked_url_patterns.iter()@@ -339,6 +362,10 @@ impl PageNetworkPolicySnapshot {return Err(anyhow!(BLOCKED_BY_CLIENT_ERROR_TEXT));}+ if self.cache_disabled {+ request = request.with_cache_mode(RequestCacheMode::Bypass);+ }+if !self.extra_http_headers.is_empty() {request.request_headers = merge_page_network_policy_headers(&self.extra_http_headers,@@ -432,6 +459,26 @@ mod tests {assert!(policy.revision() > snapshot.revision());}+ #[test]+ fn cache_disabled_forces_page_requests_to_bypass_cache() {+ let policy = PageNetworkPolicy::default();+ let before = policy.revision();+ policy.set_cache_disabled(true);++ let request = policy+ .snapshot()+ .apply_to_request(+ Request::get("https://example.test/cache")+ .unwrap()+ .with_page_network_policy(),+ )+ .unwrap();++ assert_eq!(request.cache_mode(), RequestCacheMode::Bypass);+ assert!(policy.cache_disabled());+ assert!(policy.revision() > before);+ }+#[test]fn frozen_request_view_keeps_configuration_but_observes_live_network_conditions() {let policy = PageNetworkPolicy::default();diff --git a/moli-renderer-v8/src/network/request_client.rs b/moli-renderer-v8/src/network/request_client.rsindex 07786b7cf..d9d515c6f 100644--- a/moli-renderer-v8/src/network/request_client.rs+++ b/moli-renderer-v8/src/network/request_client.rs@@ -1001,6 +1001,10 @@ impl ResourceRequestClient {self.page_network_policy.bypass_service_worker()}+ pub fn set_cache_disabled(&self, disabled: bool) {+ self.page_network_policy.set_cache_disabled(disabled);+ }+fn apply_network_policy(&self, mut request: Request) -> Result<Request> {if let Some(browser_site_context) = self.browser_site_context.as_deref() {request = request.with_browser_site_context(browser_site_context.clone());diff --git a/moli-renderer-v8/src/runtime/page_commands.rs b/moli-renderer-v8/src/runtime/page_commands.rsindex 126fc1fa3..b3c3b46fc 100644--- a/moli-renderer-v8/src/runtime/page_commands.rs+++ b/moli-renderer-v8/src/runtime/page_commands.rs@@ -1089,6 +1089,16 @@ impl PageVm {self.set_extra_http_headers(&headers);Ok(RendererPageReply::Unit)}+ RendererPageCommand::SetNetworkRequestPolicy {+ extra_http_headers,+ bypass_service_worker,+ cache_disabled,+ } => {+ self.set_extra_http_headers(&extra_http_headers);+ self.set_bypass_service_worker(bypass_service_worker);+ self.set_cache_disabled(cache_disabled);+ Ok(RendererPageReply::Unit)+ }RendererPageCommand::SetPermissionOverrides(overrides) => {self.set_permission_overrides(&overrides);Ok(RendererPageReply::Unit)diff --git a/moli-renderer-v8/src/runtime/page_network.rs b/moli-renderer-v8/src/runtime/page_network.rsindex b2b516001..6a6015e6d 100644--- a/moli-renderer-v8/src/runtime/page_network.rs+++ b/moli-renderer-v8/src/runtime/page_network.rs@@ -207,6 +207,10 @@ impl PageVm {self.vm_mut().set_bypass_service_worker(bypass);}+ pub(crate) fn set_cache_disabled(&mut self, disabled: bool) {+ self.vm_mut().set_cache_disabled(disabled);+ }+pub(crate) fn set_blocked_url_patterns(&mut self, patterns: &[String]) {self.blocked_url_patterns = patterns.to_vec();self.vm_mut().set_blocked_url_patterns(patterns);diff --git a/moli-renderer-v8/src/runtime/page_surface.rs b/moli-renderer-v8/src/runtime/page_surface.rsindex ff1470777..62bfbdcd7 100644--- a/moli-renderer-v8/src/runtime/page_surface.rs+++ b/moli-renderer-v8/src/runtime/page_surface.rs@@ -5216,6 +5216,11 @@ pub enum RendererPageCommand {PrepareAppManifestLoad,PublishAppManifestLoad(Box<crate::RendererAppManifestLoadPublication>),SetExtraHttpHeaders(Vec<(String, String)>),+ SetNetworkRequestPolicy {+ extra_http_headers: Vec<(String, String)>,+ bypass_service_worker: bool,+ cache_disabled: bool,+ },SetPermissionOverrides(Vec<crate::protocol_types::PermissionOverrideRegistration>),SetIdleOverride(Option<crate::protocol_types::EmulatedIdleOverride>),SetLocaleOverride(Option<String>),diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rsindex 6e65aa8c8..01b2e46d8 100644--- a/moli-renderer-v8/src/script_vm.rs+++ b/moli-renderer-v8/src/script_vm.rs@@ -5175,6 +5175,10 @@ impl ScriptVm {.set_bypass_service_worker(bypass);}+ pub(super) fn set_cache_disabled(&mut self, disabled: bool) {+ self._context_host.borrow_mut().set_cache_disabled(disabled);+ }+pub(super) fn set_blocked_url_patterns(&mut self, patterns: &[String]) {self._context_host.borrow_mut()diff --git a/moli-renderer-v8/src/worker/handle.rs b/moli-renderer-v8/src/worker/handle.rsindex e6c74a8dd..53e883c4b 100644--- a/moli-renderer-v8/src/worker/handle.rs+++ b/moli-renderer-v8/src/worker/handle.rs@@ -155,6 +155,8 @@ pub(crate) enum WorkerMessage {SetExtraHttpHeaders(Vec<(String, String)>),/// Update the Network.emulateNetworkConditions offline state visible to worker-owned fetch/XHR.SetNetworkOffline(bool),+ /// Update the effective Network.setCacheDisabled state visible to worker-owned fetch/XHR.+ SetCacheDisabled(bool),/// Update the Network.setBlockedURLs state visible to worker-owned fetch/XHR.SetBlockedUrlPatterns(Vec<String>),/// Update Fetch domain subresource interception visible to worker-owned fetch/XHR.@@ -893,6 +895,10 @@ impl WorkerHandle {let _ = self.tx.send(WorkerMessage::SetNetworkOffline(offline));}+ pub(crate) fn set_cache_disabled(&self, disabled: bool) {+ let _ = self.tx.send(WorkerMessage::SetCacheDisabled(disabled));+ }+pub(crate) fn set_blocked_url_patterns(&self, patterns: &[String]) {let _ = self.txdiff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rsindex 9a89c645a..141f79645 100644--- a/moli-renderer-v8/src/worker/thread/mod.rs+++ b/moli-renderer-v8/src/worker/thread/mod.rs@@ -1046,6 +1046,13 @@ async fn run_worker_pre_bootstrap_debugger_pause(};loader.request_client().set_network_offline(offline);}+ Some(WorkerMessage::SetCacheDisabled(disabled)) => {+ state+ .borrow()+ .loader+ .request_client()+ .set_cache_disabled(disabled);+ }Some(WorkerMessage::SetBlockedUrlPatterns(patterns)) => {let (loader, patterns_for_loader) = {let mut state = state.borrow_mut();@@ -2711,6 +2718,13 @@ async fn worker_main(};loader.request_client().set_network_offline(offline);}+ WorkerLoopWake::Message(Some(WorkerMessage::SetCacheDisabled(disabled))) => {+ state+ .borrow()+ .loader+ .request_client()+ .set_cache_disabled(disabled);+ }WorkerLoopWake::Message(Some(WorkerMessage::SetBlockedUrlPatterns(patterns))) => {let (loader, patterns_for_loader) = {let mut state = state.borrow_mut();