fix(xhr): share intercepted request header handling

This commit is contained in:
ldm0
2026-11-15 15:02:05 +08:00
committed by Donough Liu
parent fcaba165e5
commit d8fe34fe93
10 changed files with 625 additions and 26 deletions
+6
View File
@@ -50,6 +50,12 @@ XHR retains its original raw-byte capture for Network consumers while the
Window/Worker JS boundary materializes a response. Memory-allocation identity,
disk extent lifetime, non-UTF-8 bytes and release are checked by Rust regressions.
The default `fetch-headers` group compares fetch, asynchronous XHR and synchronous
XHR using real redirect and echo endpoints. It checks replayed upload headers,
no-op method/body edits, fresh Content-Type values, generated Origin visibility,
and Authorization scoped to one redirect origin. Each request must retain its
Network identity and emit exactly one terminal event.
The default `fetch-media` group drives real audio, video and text-track element
loads. Eleven scenarios cover single Media filters, mixed Image/Media/Font
patterns, continue/fulfill/fail/disable and response-stage body reading. Valid
+20 -1
View File
@@ -585,7 +585,13 @@ class FixtureServer:
self._dispatch()
def do_OPTIONS(self) -> None:
if urllib.parse.urlparse(self.path).path.startswith("/fetch-dispatch/network/"):
if urllib.parse.urlparse(self.path).path.startswith("/fetch-headers/"):
self._send_common(HTTPStatus.NO_CONTENT, "text/plain", b"", {
"Access-Control-Allow-Origin": "*",
"Access-Control-Allow-Methods": "GET, POST",
"Access-Control-Allow-Headers": "authorization, content-type, x-author, user-agent",
})
elif urllib.parse.urlparse(self.path).path.startswith("/fetch-dispatch/network/"):
self._send_common(HTTPStatus.NO_CONTENT, "text/plain", b"", {
"Access-Control-Allow-Origin": "*",
"Access-Control-Allow-Methods": "GET, POST",
@@ -600,6 +606,19 @@ class FixtureServer:
query = urllib.parse.parse_qs(parsed.query)
_body = self._read_body()
if route.startswith("/fetch-headers/"):
outer._record_resource_request(self.path, self.headers)
if route == "/fetch-headers/redirect":
self._send_common(HTTPStatus(int(query.get("status", ["302"])[0])),
"text/plain", b"", {"Location": query["to"][0],
"Access-Control-Allow-Origin": "*"})
else:
self._send_json({"method": self.command,
"headers": {name.lower(): value for name, value in self.headers.items()},
"body": _body.decode("utf-8")},
headers={"Access-Control-Allow-Origin": "*"})
return
if route == "/ws-echo" and self.headers.get("Upgrade", "").lower() == "websocket":
self._handle_websocket()
return
@@ -0,0 +1,163 @@
from __future__ import annotations
import asyncio
import json
from typing import Any
from urllib.parse import parse_qs, urlencode, urlsplit
from ..assertions import assert_equal, record_contract, wait_until
from ..diagnostics import new_cdp_session
from ..fixture import FixtureServer
from ..helpers import attach_cdp_event_collector
def _url(origin: str, route: str, case: str, *, hop: str = "final", target: str = "", status: int = 302) -> str:
return origin + "/fetch-headers/" + route + "?" + urlencode({"case": case, "hop": hop, "to": target, "status": status})
async def run_fetch_headers_group(browser: Any, fixture: str, results: list[dict[str, Any]]) -> None:
peer, escape = FixtureServer(), FixtureServer()
peer.start()
escape.start()
try:
cases = [(f"replay-{status}", status) for status in (301, 302, 303, 307, 308)]
cases += [(case, 302) for case in ("noop-method", "empty-postdata", "new-content-type", "chain-replay",
"drop-then-replay", "fresh-then-replay", "origin-echo", "authorization")]
for api in ("fetch", "xhr", "sync-xhr"):
for case, status in cases:
await _case(browser, fixture, peer, escape.url, api, case, status, results)
finally:
peer.stop()
escape.stop()
async def _case(browser: Any, source: str, peer: FixtureServer, escape: str,
api: str, case: str, status: int, results: list[dict[str, Any]]) -> None:
label = f"{api}-{case}"
context = await browser.new_context()
operation = None
pending_pause = None
try:
page = await context.new_page()
await page.goto(source + "/plain", wait_until="load", timeout=10_000)
cdp = await new_cdp_session(context, page)
await cdp.send("Network.enable")
await cdp.send("Fetch.enable", {"patterns": [
{"urlPattern": "*fetch-headers/*", "resourceType": resource}
for resource in ("Fetch", "XHR")
]})
queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue()
cdp.on("Fetch.requestPaused", queue.put_nowait)
pauses = []
preflights = []
original = None
target = _url(source, "echo", label)
next_url = target
if case in ("chain-replay", "drop-then-replay", "fresh-then-replay"):
next_url = _url(source, "redirect", label, hop="middle", target=target)
peer_url = _url(peer.url, "redirect", label, hop="authorized", target=_url(escape, "echo", label))
url = _url(source, "redirect", label, hop="source", target=next_url, status=status)
if case == "origin-echo":
url = _url(peer.url, "echo", label)
elif case == "authorization":
url = _url(source, "redirect", label, hop="source", target=peer_url)
method = "GET" if case == "authorization" else "POST"
author_headers = {"Authorization": "author-secret"} if case == "authorization" else {"Content-Type": "text/plain", "X-Author": "kept"}
body = "undefined" if method == "GET" else json.dumps("abc")
if api == "fetch":
script = f"fetch({json.dumps(url)},{{method:{json.dumps(method)},headers:{json.dumps(author_headers)},body:{body}}}).then(r=>r.text())"
else:
script = f"""new Promise((resolve,reject)=>{{const x=new XMLHttpRequest();
x.open({json.dumps(method)},{json.dumps(url)},{str(api != 'sync-xhr').lower()});
for(const [k,v] of Object.entries({json.dumps(author_headers)}))x.setRequestHeader(k,v);
x.onload=()=>resolve(x.responseText);x.onerror=()=>reject(new Error('XHR failed'));x.send({body});}})"""
with attach_cdp_event_collector(cdp, ["Network.requestWillBeSent", "Network.responseReceived",
"Network.loadingFinished", "Network.loadingFailed"]) as events:
operation = asyncio.create_task(page.evaluate(script))
async with asyncio.timeout(10):
while True:
pending_pause = asyncio.create_task(queue.get())
done, _ = await asyncio.wait((operation, pending_pause), return_when=asyncio.FIRST_COMPLETED)
if operation in done:
pending_pause.cancel()
await asyncio.gather(pending_pause, return_exceptions=True)
break
pause = pending_pause.result()
pending_pause = None
if pause["request"]["method"] == "OPTIONS":
# Chromium also labels intercepted preflights as XHR.
# They have independent Network IDs, outside this chain.
preflights.append(pause)
await cdp.send("Fetch.continueRequest", {"requestId": pause["requestId"]})
continue
pauses.append(pause)
query = parse_qs(urlsplit(pause["request"]["url"]).query)
hop = query["hop"][0]
headers = None
params = {"requestId": pause["requestId"]}
if hop == "source" and case != "authorization":
original = dict(pause["request"]["headers"])
elif case == "origin-echo":
headers = dict(pause["request"]["headers"])
origin = next((value for name, value in headers.items() if name.lower() == "origin"), None)
assert_equal(origin, source, label + " visible generated Origin")
elif case == "authorization":
if hop == "authorized":
headers = {"Authorization": "interceptor-secret"}
else:
headers = dict(original)
if case == "noop-method":
params["method"] = pause["request"]["method"]
if case == "empty-postdata":
params["postData"] = ""
if case == "new-content-type" or (case == "fresh-then-replay" and hop == "middle"):
headers = {name: value for name, value in headers.items() if name.lower() != "content-type"}
headers["Content-Type"] = "application/x-new"
if case == "drop-then-replay" and hop == "middle":
headers = None
if headers is not None:
params["headers"] = [{"name": name, "value": value} for name, value in headers.items()]
await cdp.send("Fetch.continueRequest", params)
value = json.loads(await operation)
wire = value["headers"]
keep_body = status in (307, 308) or case == "origin-echo"
expected_type = "text/plain" if keep_body or case in ("drop-then-replay", "fresh-then-replay") else None
if case == "new-content-type":
expected_type = "application/x-new"
assert_equal(value["method"], "POST" if keep_body else "GET", label + " wire method")
assert_equal(value["body"], "abc" if keep_body else "", label + " wire body")
assert_equal(wire.get("content-type"), expected_type, label + " wire Content-Type")
assert_equal(wire.get("content-length"), "3" if keep_body else None, label + " wire Content-Length")
if case == "authorization":
peer_path = urlsplit(peer_url).path + "?" + urlsplit(peer_url).query
assert_equal(peer.resource_request_headers(peer_path).get("authorization"), "interceptor-secret",
label + " explicit second-hop Authorization")
assert_equal(wire.get("authorization"), None, label + " third origin has no Authorization")
else:
assert_equal(wire.get("x-author"), "kept", label + " retained custom header")
if not keep_body:
assert_equal(wire.get("origin"), None, label + " no replayed POST Origin")
ids = {pause.get("networkId") for pause in pauses}
assert_equal(len(ids), 1, label + " stable Network identity")
request_id = next(iter(ids))
if not request_id:
raise AssertionError(label + " missing Network identity")
await wait_until(lambda: any(event["method"] in ("Network.loadingFinished", "Network.loadingFailed")
and event["params"].get("requestId") == request_id for event in events),
label + " Network terminal")
terminals = [event["method"] for event in events
if event["method"] in ("Network.loadingFinished", "Network.loadingFailed")
and event["params"].get("requestId") == request_id]
assert_equal(terminals, ["Network.loadingFinished"], label + " one terminal")
record_contract(results, "intercepted_headers_" + label,
contract="A redirect removes replayed upload headers, preserves fresh overrides and scopes explicit Authorization.",
source="Executable Chromium CDP oracle",
commands=["Fetch.enable", "Fetch.continueRequest"],
observed={"api": api, "case": case, "method": value["method"], "contentType": expected_type,
"pauses": len(pauses), "preflightPauses": len(preflights), "terminals": terminals})
finally:
for task in (pending_pause, operation):
if task is not None and not task.done():
task.cancel()
await asyncio.gather(task, return_exceptions=True)
await context.close()
+7
View File
@@ -43,6 +43,7 @@ from .groups.emulation_storage import run_emulation_storage_group
from .groups.error_document import run_error_document_group
from .groups.fetch_runtime_teardown import run_fetch_runtime_teardown_group
from .groups.fetch_font import run_fetch_font_group
from .groups.fetch_headers import run_fetch_headers_group
from .groups.fetch_media import run_fetch_media_group
from .groups.fetch_resource_dispatch import run_fetch_resource_dispatch_group
from .groups.history_worlds import run_history_worlds_group
@@ -405,6 +406,12 @@ PAGE_GROUPS: tuple[SmokeGroup, ...] = (
)
BROWSER_GROUPS: tuple[SmokeGroup, ...] = (
SmokeGroup(
"fetch-headers",
"Fetch and native XHR header overrides, redirect uploads, CORS and scoped Authorization.",
"browser",
run_fetch_headers_group,
),
SmokeGroup(
"text-input",
"Native legacy TextEvent order, cancellation, payload, focus and target lifetime.",
@@ -36,6 +36,7 @@ class GroupSelectionTests(unittest.TestCase):
self.assertIn("navigation-outcomes", DEFAULT_GROUP_NAMES)
self.assertIn("font-face", DEFAULT_GROUP_NAMES)
self.assertIn("fetch-font", DEFAULT_GROUP_NAMES)
self.assertIn("fetch-headers", DEFAULT_GROUP_NAMES)
self.assertIn("fetch-media", DEFAULT_GROUP_NAMES)
self.assertIn("fetch-resource-dispatch", DEFAULT_GROUP_NAMES)
self.assertIn("media-error", DEFAULT_GROUP_NAMES)
@@ -1,4 +1,5 @@
use super::*;
mod intercepted_headers;
mod native_xhr;
mod navigation_disable;
use crate::automation::{
@@ -0,0 +1,405 @@
use super::native_xhr::run_cdp_command_with_network_decisions;
use super::*;
use axum::{body::Bytes, http::Uri};
use parking_lot::Mutex;
#[derive(Clone, Copy, Debug)]
enum Api {
Fetch,
AsyncXhr,
SyncXhr,
}
impl Api {
fn resource_type(self) -> &'static str {
if matches!(self, Self::Fetch) {
"Fetch"
} else {
"XHR"
}
}
fn expression(self, url: &str, method: &str, headers: Value) -> String {
let body = if method == "POST" {
"'abc'"
} else {
"undefined"
};
match self {
Self::Fetch => format!(
"fetch({url:?},{{method:{method:?},headers:{headers},body:{body}}}).then(r=>r.text()).catch(e=>'ERROR:'+e.name)"
),
Self::AsyncXhr | Self::SyncXhr => format!(
"new Promise(resolve=>{{const x=new XMLHttpRequest();x.open({method:?},{url:?},{asynchronous});for(const [k,v] of Object.entries({headers}))x.setRequestHeader(k,v);x.onload=()=>resolve(x.responseText);x.onerror=()=>resolve('ERROR:NetworkError');try{{x.send({body});}}catch(e){{resolve('ERROR:'+e.name);}}}})",
asynchronous = matches!(self, Self::AsyncXhr)
),
}
}
}
const APIS: [Api; 3] = [Api::Fetch, Api::AsyncXhr, Api::SyncXhr];
struct Fixture {
origin: String,
peer: String,
requests: Arc<Mutex<Vec<Value>>>,
servers: Vec<tokio::task::JoinHandle<()>>,
}
impl Drop for Fixture {
fn drop(&mut self) {
for server in &self.servers {
server.abort();
}
}
}
impl Fixture {
async fn new() -> Self {
let mut listeners = Vec::new();
for _ in 0..3 {
listeners.push(TcpListener::bind("127.0.0.1:0").await.unwrap());
}
let origins = listeners
.iter()
.map(|listener| format!("http://{}", listener.local_addr().unwrap()))
.collect::<Vec<_>>();
let requests = Arc::new(Mutex::new(Vec::new()));
let recorded = requests.clone();
let peer = origins[1].clone();
let last = origins[2].clone();
let app = Router::new().fallback(any(move |method: Method, uri: Uri, headers: HeaderMap, body: Bytes| {
let recorded = recorded.clone();
let peer = peer.clone();
let last = last.clone();
async move {
let header = |name| headers.get(name).and_then(|value| value.to_str().ok());
let record = json!({"path":uri.path(),"method":method.as_str(),"contentType":header("content-type"),"contentLength":header("content-length"),"origin":header("origin"),"authorization":header("authorization"),"keep":header("x-keep"),"preflight":header("access-control-request-headers"),"body":String::from_utf8_lossy(&body)});
recorded.lock().push(record.clone());
let mut response = if method == Method::OPTIONS {
StatusCode::NO_CONTENT.into_response()
} else if uri.path() == "/page" {
axum::response::Html("<!doctype html>ready").into_response()
} else if let Some(status) = uri.path().strip_prefix("/start/") {
(StatusCode::from_u16(status.parse().unwrap()).unwrap(), [("location", "/target")], "").into_response()
} else if uri.path() == "/auth-start" {
(StatusCode::FOUND, [("location", format!("{peer}/auth-next"))], "").into_response()
} else if uri.path() == "/auth-next" {
(StatusCode::FOUND, [("location", format!("{last}/target"))], "").into_response()
} else {
axum::Json(record).into_response()
};
for (name,value) in [("access-control-allow-origin","*"),("access-control-allow-methods","GET, POST"),("access-control-allow-headers","authorization, content-type, x-keep")] {
response.headers_mut().insert(name,value.parse().unwrap());
}
response
}
}));
let servers = listeners
.into_iter()
.map(|listener| {
let app = app.clone();
tokio::spawn(async move {
axum::serve(listener, app).await.unwrap();
})
})
.collect();
Self {
origin: origins[0].clone(),
peer: origins[1].clone(),
requests,
servers,
}
}
async fn context(&self, api: Api) -> TestContext {
let mut ctx = TestContext::new();
with_loaded_http_document(&mut ctx, &format!("{}/page", self.origin), "SID-1", "TID-1")
.await;
enable_runtime_async(&mut ctx, "SID-1", 47000).await;
ctx.process_async(json!({"id":47001,"sessionId":"SID-1","method":"Fetch.enable","params":{"patterns":[{"urlPattern":"*","resourceType":api.resource_type()}]}})).await;
ctx.expect_result(47001, json!({}), Some("SID-1"));
self.requests.lock().clear();
ctx
}
}
fn continue_request(pause: &Value, headers: Option<Vec<Value>>, method: Option<&str>) -> Value {
let mut params = json!({"requestId":pause["params"]["requestId"]});
if let Some(headers) = headers {
params["headers"] = json!(headers);
}
if let Some(method) = method {
params["method"] = json!(method);
}
json!({"id":47003,"sessionId":"SID-1","method":"Fetch.continueRequest","params":params})
}
fn echo_headers(pause: &Value) -> Vec<Value> {
pause["params"]["request"]["headers"]
.as_object()
.unwrap()
.iter()
.map(|(name, value)| json!({"name":name,"value":value}))
.collect()
}
async fn request(
ctx: &mut TestContext,
expression: String,
decide: impl FnMut(&Value) -> Value,
) -> (Value, Vec<Value>) {
let pauses=run_cdp_command_with_network_decisions(ctx,json!({"id":47002,"sessionId":"SID-1","method":"Runtime.evaluate","params":{"expression":expression,"awaitPromise":true,"returnByValue":true}}),decide).await;
let result = take_response_by_id(ctx, 47002);
assert!(
result.get("error").is_none() && result["result"].get("exceptionDetails").is_none(),
"{result}"
);
(result["result"]["result"]["value"].clone(), pauses)
}
async fn assert_terminal(ctx: &mut TestContext, pauses: &[Value], terminal: &str) {
let id = pauses[0]["params"]["networkId"].clone();
assert!(id.as_str().is_some_and(|id| !id.is_empty()));
for pause in pauses {
assert_eq!(pause["params"]["networkId"], id);
}
wait_until_scheduler_message(ctx, "intercepted request terminal", |message| {
matches!(
message["method"].as_str(),
Some("Network.loadingFailed" | "Network.loadingFinished")
) && message["params"]["requestId"] == id
})
.await;
let terminals = ctx
.sent
.iter()
.filter(|message| {
matches!(
message["method"].as_str(),
Some("Network.loadingFailed" | "Network.loadingFinished")
) && message["params"]["requestId"] == id
})
.collect::<Vec<_>>();
assert_eq!(terminals.len(), 1, "{terminals:?}");
assert_eq!(terminals[0]["method"], terminal);
}
#[tokio::test(flavor = "multi_thread")]
async fn replayed_upload_headers_follow_the_same_rules_for_fetch_and_native_xhr() {
let fixture = Fixture::new().await;
for api in APIS {
for status in [301, 302, 303, 307, 308] {
for repeat_method in [false, true] {
let mut ctx = fixture.context(api).await;
let mut original = None;
let (result, pauses) = request(
&mut ctx,
api.expression(
&format!("{}/start/{status}", fixture.origin),
"POST",
json!({"Content-Type":"text/plain","X-Keep":"yes"}),
),
|pause| {
if pause["params"]["request"]["url"]
.as_str()
.unwrap()
.contains("/start/")
{
original = Some(echo_headers(pause));
continue_request(pause, None, None)
} else {
continue_request(
pause,
original.clone(),
repeat_method.then(|| {
pause["params"]["request"]["method"].as_str().unwrap()
}),
)
}
},
)
.await;
assert_eq!(pauses.len(), 2, "{api:?} {status}");
let result: Value = serde_json::from_str(result.as_str().unwrap()).unwrap();
let keep_body = matches!(status, 307 | 308);
assert_eq!(
result["method"],
if keep_body { "POST" } else { "GET" },
"{api:?} {status}"
);
assert_eq!(
result["contentType"],
if keep_body {
json!("text/plain")
} else {
Value::Null
},
"{api:?} {status}"
);
assert_eq!(
result["contentLength"],
if keep_body { json!("3") } else { Value::Null },
"{api:?} {status}"
);
assert_eq!(result["body"], if keep_body { "abc" } else { "" });
assert_eq!(result["keep"], "yes");
assert_eq!(
result["origin"],
if keep_body {
json!(fixture.origin)
} else {
Value::Null
}
);
assert_terminal(&mut ctx, &pauses, "Network.loadingFinished").await;
}
}
}
}
#[tokio::test(flavor = "multi_thread")]
async fn redirected_fetch_and_xhr_accept_explicit_new_content_type() {
let fixture = Fixture::new().await;
for api in APIS {
let mut ctx = fixture.context(api).await;
let (result, pauses) = request(
&mut ctx,
api.expression(
&format!("{}/start/302", fixture.origin),
"POST",
json!({"Content-Type":"text/plain"}),
),
|pause| {
let redirected = pause["params"]["request"]["method"] == "GET";
continue_request(
pause,
redirected
.then(|| vec![json!({"name":"Content-Type","value":"application/x-new"})]),
None,
)
},
)
.await;
let result: Value = serde_json::from_str(result.as_str().unwrap()).unwrap();
assert_eq!(result["method"], "GET", "{api:?}");
assert_eq!(result["contentType"], "application/x-new", "{api:?}");
assert_eq!(result["body"], "");
assert_terminal(&mut ctx, &pauses, "Network.loadingFinished").await;
}
}
#[tokio::test(flavor = "multi_thread")]
async fn fetch_and_native_xhr_project_origin_without_granting_forbidden_preflight_headers() {
let fixture = Fixture::new().await;
for api in APIS {
for denied in [false, true] {
let mut ctx = fixture.context(api).await;
let mut headers = json!({"Content-Type":"text/plain","X-Keep":"yes"});
if denied {
headers["X-Denied"] = json!("no");
}
let (result, pauses) = request(
&mut ctx,
api.expression(&format!("{}/target", fixture.peer), "POST", headers),
|pause| {
assert!(
pause["params"]["request"]["headers"]
.as_object()
.unwrap()
.iter()
.any(|(name, value)| name.eq_ignore_ascii_case("origin")
&& value == &fixture.origin),
"{api:?}: {pause}"
);
continue_request(pause, Some(echo_headers(pause)), None)
},
)
.await;
assert_eq!(pauses.len(), 1);
let records = fixture.requests.lock().clone();
let preflight = records
.iter()
.find(|r| r["method"] == "OPTIONS")
.expect("author X-Keep requires preflight");
let names = preflight["preflight"]
.as_str()
.unwrap()
.split(',')
.map(str::trim)
.collect::<Vec<_>>();
assert!(names.contains(&"x-keep"));
assert!(!names.contains(&"origin"), "{preflight}");
if denied {
assert!(
result.as_str().unwrap().starts_with("ERROR:"),
"{api:?}: {result}"
);
assert!(!records.iter().any(|r| r["method"] == "POST"));
} else {
let result: Value = serde_json::from_str(result.as_str().unwrap()).unwrap();
assert_eq!(result["origin"], fixture.origin, "{api:?}");
assert_eq!(result["body"], "abc");
}
assert_terminal(
&mut ctx,
&pauses,
if denied {
"Network.loadingFailed"
} else {
"Network.loadingFinished"
},
)
.await;
}
}
}
#[tokio::test(flavor = "multi_thread")]
async fn fetch_and_native_xhr_authorization_override_stays_with_its_redirect_hop() {
let fixture = Fixture::new().await;
for api in APIS {
let mut ctx = fixture.context(api).await;
let (result, pauses) = request(
&mut ctx,
api.expression(
&format!("{}/auth-start", fixture.origin),
"GET",
json!({"Authorization":"author-secret"}),
),
|pause| {
let redirected =
pause["params"]["request"]["url"] == format!("{}/auth-next", fixture.peer);
continue_request(
pause,
redirected.then(|| {
vec![json!({"name":"Authorization","value":"interceptor-secret"})]
}),
None,
)
},
)
.await;
assert_eq!(pauses.len(), 3);
let result: Value = serde_json::from_str(result.as_str().unwrap()).unwrap();
assert_eq!(result["authorization"], Value::Null, "{api:?}");
let actual = {
let records = fixture.requests.lock();
records
.iter()
.filter(|r| r["method"] != "OPTIONS")
.map(|r| r["authorization"].clone())
.collect::<Vec<_>>()
};
assert_eq!(
actual,
[
json!("author-secret"),
json!("interceptor-secret"),
Value::Null
],
"{api:?}"
);
assert_terminal(&mut ctx, &pauses, "Network.loadingFinished").await;
}
}
@@ -29,14 +29,7 @@ pub(crate) async fn fetch_intercepted_window_hop(
cancel_handle: Option<FetchCancelHandle>,
) -> Result<NetworkFetchResult<Response>, String> {
let mode = request.redirect_mode();
// DevTools can echo generated fields (Origin, Host, Content-Length,
// Sec-*). Those are not author CORS headers requiring preflight permission.
let preflight_headers = request
.request_headers
.to_byte_strings()
.into_iter()
.filter(|(name, _)| !moli_fetch::is_forbidden_request_header_name(name))
.collect();
let preflight_headers = request.request_headers.to_byte_strings();
let cancel = cancel_handle.unwrap_or_default();
let response_cancel = cancel.child_for_subrequest();
let observed = fetch_subresource_hop(
@@ -157,6 +150,12 @@ pub(super) async fn fetch_subresource_hop(
preflight_headers: Vec<(String, String)>,
observer: Option<&CorsPreflightNetworkObserver>,
) -> Result<NetworkFetchResult<super::loaded_response::LoadedResponse>, String> {
// Both intercepted fetch and native XHR can echo browser-generated fields.
// Origin, Host, Content-Length and Sec-* are not author CORS permissions.
let preflight_headers: Vec<_> = preflight_headers
.into_iter()
.filter(|(name, _)| !moli_fetch::is_forbidden_request_header_name(name))
.collect();
run_cors_preflight_if_needed(
loader,
&request,
@@ -216,7 +216,7 @@ impl ControlledResourceLoad {
fn sync_info(&mut self) {
self.info.url = self.request.url.clone();
self.info.method = self.request.method.clone();
self.info.request_headers = self.request.request_headers.clone();
self.info.request_headers = self.request.interception_request_headers();
self.info.request_body_bytes = self.request.body.clone();
self.info.request_body = self
.request
@@ -225,6 +225,15 @@ impl ControlledResourceLoad {
.map(|body| String::from_utf8_lossy(body).into_owned());
}
fn apply_request_overrides(&mut self, overrides: moli_fetch::RequestOverrides) {
let headers_changed = overrides.headers.is_some();
overrides.apply(&mut self.request);
if headers_changed {
self.preflight_headers = self.request.request_headers.to_byte_strings();
}
self.sync_info();
}
fn check_request(&self) -> Result<(), String> {
let redirect_status = if self.request.redirect_count() == 0 {
crate::content_security_policy::ContentSecurityPolicyRedirectStatus::NoRedirect
@@ -327,20 +336,14 @@ impl ControlledResourceLoad {
intercept_response: response,
handle_auth_requests: auth,
} => {
let headers_changed = headers.is_some();
moli_fetch::RequestOverrides {
self.apply_request_overrides(moli_fetch::RequestOverrides {
url,
method,
body,
headers,
}
.apply(&mut self.request);
if headers_changed {
self.preflight_headers = self.request.request_headers.to_byte_strings();
}
});
intercept_response = response;
handle_auth_requests = auth;
self.sync_info();
}
D::Fail(error) => return Err(error),
D::Fulfill {
@@ -350,13 +353,7 @@ impl ControlledResourceLoad {
body,
} => {
if let Some(overrides) = request_overrides {
let headers_changed = overrides.headers.is_some();
overrides.apply(&mut self.request);
if headers_changed {
self.preflight_headers =
self.request.request_headers.to_byte_strings();
}
self.sync_info();
self.apply_request_overrides(*overrides);
}
synthetic = Some(self.synthetic_response(status, headers, body));
intercept_response = false;
@@ -34,11 +34,12 @@ impl ControlledXhrContext {
pub(crate) fn load(
self,
request: moli_fetch::Request,
info: PendingSubresourceFetchInfo,
mut info: PendingSubresourceFetchInfo,
load: ResourceLoadLease,
cancel: moli_fetch::FetchCancelHandle,
preflight_headers: Vec<(String, String)>,
) -> super::ControlledResourceLoad {
info.request_headers = request.interception_request_headers();
super::ControlledResourceLoad {
request,
info,