1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
use std::cell::RefCell;
use std::collections::VecDeque;
use dom_struct::dom_struct;
use js::rust::Runtime;
use js::context::JSContext;
use script_bindings::reflector::{Reflector, reflect_dom_object_with_cx};
use script_bindings::root::DomRoot;
use servo_base::generic_channel::{GenericCallback, GenericSend};
use servo_url::ServoUrl;
use storage_traits::cache_storage::{CacheStorageThreadMessage, CacheStorageThreadResponse};
use crate::dom::bindings::codegen::Bindings::CacheBinding::CacheMethods;
use crate::dom::bindings::codegen::GenericBindings::CacheBinding::CacheQueryOptions;
use crate::dom::bindings::codegen::UnionTypes::RequestOrUSVString;
use crate::dom::bindings::error::Error;
use crate::dom::bindings::refcounted::Trusted;
use crate::dom::bindings::reflector::DomGlobal;
use crate::dom::bindings::str::DOMString;
use crate::dom::fetch::request::Request;
use crate::dom::globalscope::GlobalScope;
use crate::dom::{Promise, RootedPromise, TracedPromise};
/// <https://w3c.github.io/ServiceWorker/#cache>
#[dom_struct]
pub(crate) struct Cache {
reflector_: Reflector,
/// The name used to identify
/// <https://w3c.github.io/ServiceWorker/#dfn-relevant-request-response-list>
name: DOMString,
#[no_trace]
#[ignore_malloc_size_of = "GenericCallback"]
callback: RefCell<Option<GenericCallback<CacheStorageThreadResponse>>>,
// Dequeue of pending promises for backend operations.
pending_promises: RefCell<VecDeque<TracedPromise>>,
}
impl Cache {
fn new_inherited(name: DOMString) -> Cache {
Cache {
reflector_: Reflector::new(),
name,
callback: Default::default(),
pending_promises: Default::default(),
}
}
pub(crate) fn new(cx: &mut JSContext, global: &GlobalScope, name: DOMString) -> DomRoot<Cache> {
reflect_dom_object_with_cx(Box::new(Cache::new_inherited(name)), global, cx)
}
/// Setup the callback to the backend service, if this hasn't been done already.
pub(crate) fn get_or_setup_callback(&self) -> GenericCallback<CacheStorageThreadResponse> {
if let Some(cb) = self.callback.borrow().as_ref() {
return cb.clone();
}
let global = self.global();
let response_listener = Trusted::new(self);
let task_source = global
.task_manager()
.dom_manipulation_task_source()
.to_sendable();
let callback = GenericCallback::new(move |message| {
let response_listener = response_listener.clone();
let response = match message {
Ok(inner) => Some(inner),
Err(err) => {
error!("Error in Cache callback {:?}.", err);
None
},
};
task_source.queue(task!(set_request_result_to_database: move |cx| {
let cache = response_listener.root();
cache.handle_response(cx, response)
}));
})
.expect("Could not create Cache callback");
*self.callback.borrow_mut() = Some(callback.clone());
callback
}
fn handle_response(&self, cx: &mut JSContext, response: Option<CacheStorageThreadResponse>) {
let response = match response {
Some(response) => response,
None => {
let Some(promise) = self
.pending_promises
.borrow_mut()
.pop_front()
.map(|promise| promise.root(cx))
else {
error!("No pending promise for Cache response.");
return;
};
promise.reject_error(
cx,
Error::Operation(Some("No response from Cache backend.".to_string())),
);
return;
},
};
match response {
// <https://w3c.github.io/ServiceWorker/#cache-keys>
CacheStorageThreadResponse::KeysResult(results) => {
// Step 5.4: Queue a task,
// on promise’s relevant settings object’s responsible event loop using the DOM manipulation task source,
// to perform the following steps:
// Note: we are inside the task.
// Step 5.4.1: Let requestList be a list.
let mut request_list: Vec<DomRoot<Request>> = Vec::new();
let Some(promise) = self
.pending_promises
.borrow_mut()
.pop_front()
.map(|promise| promise.root(cx))
else {
debug_assert!(false, "No pending promise for Cache KeysResult response.");
return;
};
// Step 5.4.2: For each request of requests:
// Step 5.4.2.1: Add a new Request object associated with request
// and a new associated Headers object whose guard is "immutable" to requestList.
for url in results.unwrap_or_default() {
let Ok(url) = ServoUrl::parse(&url) else {
promise.reject_error(cx, Error::Type(c"Invalid URL".to_owned()));
return;
};
let request = Request::new(cx, &self.global(), None, url);
// TODO: associate request with a header.
request_list.push(request);
}
// Step 5.4.3: Resolve promise with a frozen array created from requestList, in realm.
promise.resolve_native(cx, &request_list);
},
CacheStorageThreadResponse::DeleteCacheResult(_result) => debug_assert!(
false,
"Unexpected DeleteCacheResult response in Cache handle_response."
),
CacheStorageThreadResponse::HasCacheResult(_result) => debug_assert!(
false,
"Unexpected HasCacheResult response in Cache handle_response."
),
CacheStorageThreadResponse::OpenCacheResult { .. } => debug_assert!(
false,
"Unexpected OpenCacheResult response in Cache handle_response."
),
}
}
}
impl CacheMethods<crate::DomTypeHolder> for Cache {
/// <https://w3c.github.io/ServiceWorker/#dom-cache-keys>
// BAO patch (fork-maintained, 2026-09-28): terminal codegen passes no cx;
// take the thread's active context instead.
#[allow(unsafe_code)]
fn Keys(
&self,
request: Option<RequestOrUSVString>,
_options: &CacheQueryOptions,
) -> RootedPromise {
let mut cx = unsafe { JSContext::get_from_thread().expect("no active JS context") };
// Step 1: Let r be null.
let mut r: Option<DomRoot<Request>> = None;
// Step 3: Let realm be this’s relevant realm.
// Note: the global is used as the realm; step re-ordered to make it available in Step 2.
let global = self.global();
// Step 4: Let promise be a new promise.
// Note: step re-ordered to make it available in Step 2.
let promise = Promise::new(&mut cx, &global);
// Step 2: If the optional argument request is not omitted, then:
if let Some(request) = request {
// Step 2.1: If request is a Request object, then:
if let RequestOrUSVString::Request(request) = request {
// Step 2.1.1: Set r to request.
r = Some(request);
// Step 2.2: Else if request is a string, then:
} else if let RequestOrUSVString::USVString(request_string) = request {
// Step 2.2.1: Set r to the associated request of the result of
// invoking the initial value of Request as
// constructor with request as its argument.
let Ok(url) = ServoUrl::parse(&request_string) else {
// If this throws an exception, return a promise rejected with that exception.
// Note: only the url parse can error.
promise.reject_error(&mut cx, Error::Type(c"Invalid URL".to_owned()));
return promise;
};
let request = Request::new(&mut cx, &global, None, url);
r = Some(request);
}
}
// TODO: use r in the backend.
let _ = r;
// Step 5: Run these substeps in parallel:
let callback = self.get_or_setup_callback();
if global
.storage_threads()
.send(CacheStorageThreadMessage::Keys {
cache_name: self.name.to_string(),
callback,
origin: global.origin().immutable().clone(),
})
.is_err()
{
promise.reject_error(
&mut cx,
Error::Operation(Some("Could not run the parallel steps.".to_string())),
);
return promise;
}
self.pending_promises
.borrow_mut()
.push_back(promise.to_traced());
promise
}
}