Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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_promoting
conn.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_promo
conn.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.rs
index 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.rs
index 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 TestConte
install_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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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_state
diff --git a/moli-protocol/src/domains/runtime/tests/evaluate.rs b/moli-protocol/src/domains/runtime/tests/evaluate.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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
.tx
diff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rs
index 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();