script/dom/
serviceworkercontainer.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5use std::default::Default;
6use std::rc::Rc;
7
8use base::generic_channel::GenericCallback;
9use constellation_traits::{
10    Job, JobError, JobResult, JobResultValue, JobType, ScriptToConstellationMessage,
11};
12use dom_struct::dom_struct;
13
14use crate::dom::bindings::codegen::Bindings::ServiceWorkerContainerBinding::{
15    RegistrationOptions, ServiceWorkerContainerMethods,
16};
17use crate::dom::bindings::error::Error;
18use crate::dom::bindings::refcounted::TrustedPromise;
19use crate::dom::bindings::reflector::{DomGlobal, reflect_dom_object};
20use crate::dom::bindings::root::{Dom, DomRoot, MutNullableDom};
21use crate::dom::bindings::str::USVString;
22use crate::dom::client::Client;
23use crate::dom::eventtarget::EventTarget;
24use crate::dom::globalscope::GlobalScope;
25use crate::dom::promise::Promise;
26use crate::dom::serviceworker::ServiceWorker;
27use crate::dom::serviceworkerregistration::ServiceWorkerRegistration;
28use crate::realms::{InRealm, enter_realm};
29use crate::script_runtime::CanGc;
30use crate::task_source::SendableTaskSource;
31
32#[dom_struct]
33pub(crate) struct ServiceWorkerContainer {
34    eventtarget: EventTarget,
35    controller: MutNullableDom<ServiceWorker>,
36    client: Dom<Client>,
37}
38
39impl ServiceWorkerContainer {
40    fn new_inherited(client: &Client) -> ServiceWorkerContainer {
41        ServiceWorkerContainer {
42            eventtarget: EventTarget::new_inherited(),
43            controller: Default::default(),
44            client: Dom::from_ref(client),
45        }
46    }
47
48    #[cfg_attr(crown, allow(crown::unrooted_must_root))]
49    pub(crate) fn new(global: &GlobalScope, can_gc: CanGc) -> DomRoot<ServiceWorkerContainer> {
50        let client = Client::new(global.as_window(), can_gc);
51        let container = ServiceWorkerContainer::new_inherited(&client);
52        reflect_dom_object(Box::new(container), global, can_gc)
53    }
54}
55
56impl ServiceWorkerContainerMethods<crate::DomTypeHolder> for ServiceWorkerContainer {
57    // https://w3c.github.io/ServiceWorker/#service-worker-container-controller-attribute
58    fn GetController(&self) -> Option<DomRoot<ServiceWorker>> {
59        self.client.get_controller()
60    }
61
62    /// <https://w3c.github.io/ServiceWorker/#dom-serviceworkercontainer-register> - A
63    /// and <https://w3c.github.io/ServiceWorker/#start-register> - B
64    fn Register(
65        &self,
66        script_url: USVString,
67        options: &RegistrationOptions,
68        comp: InRealm,
69        can_gc: CanGc,
70    ) -> Rc<Promise> {
71        // A: Step 2.
72        let global = self.client.global();
73
74        // A: Step 1
75        let promise = Promise::new_in_current_realm(comp, can_gc);
76        let USVString(ref script_url) = script_url;
77
78        // A: Step 3
79        let api_base_url = global.api_base_url();
80        let script_url = match api_base_url.join(script_url) {
81            Ok(url) => url,
82            Err(_) => {
83                // B: Step 1
84                promise.reject_error(Error::Type("Invalid script URL".to_owned()), can_gc);
85                return promise;
86            },
87        };
88
89        // A: Step 4-5
90        let scope = match options.scope {
91            Some(ref scope) => {
92                let USVString(inner_scope) = scope;
93                match api_base_url.join(inner_scope) {
94                    Ok(url) => url,
95                    Err(_) => {
96                        promise.reject_error(Error::Type("Invalid scope URL".to_owned()), can_gc);
97                        return promise;
98                    },
99                }
100            },
101            None => script_url.join("./").unwrap(),
102        };
103
104        // A: Step 6 -> invoke B.
105
106        // B: Step 3
107        match script_url.scheme() {
108            "https" | "http" => {},
109            _ => {
110                promise.reject_error(
111                    Error::Type("Only secure origins are allowed".to_owned()),
112                    can_gc,
113                );
114                return promise;
115            },
116        }
117        // B: Step 4
118        if script_url.path().to_ascii_lowercase().contains("%2f") ||
119            script_url.path().to_ascii_lowercase().contains("%5c")
120        {
121            promise.reject_error(
122                Error::Type("Script URL contains forbidden characters".to_owned()),
123                can_gc,
124            );
125            return promise;
126        }
127
128        // B: Step 6
129        match scope.scheme() {
130            "https" | "http" => {},
131            _ => {
132                promise.reject_error(
133                    Error::Type("Only secure origins are allowed".to_owned()),
134                    can_gc,
135                );
136                return promise;
137            },
138        }
139        // B: Step 7
140        if scope.path().to_ascii_lowercase().contains("%2f") ||
141            scope.path().to_ascii_lowercase().contains("%5c")
142        {
143            promise.reject_error(
144                Error::Type("Scope URL contains forbidden characters".to_owned()),
145                can_gc,
146            );
147            return promise;
148        }
149
150        // Setup the callback for reject/resolve of the promise,
151        // from steps running "in-parallel" from here in the serviceworker manager.
152        let mut handler = RegisterJobResultHandler {
153            trusted_promise: Some(TrustedPromise::new(promise.clone())),
154            task_source: global.task_manager().dom_manipulation_task_source().into(),
155        };
156
157        let result_handler = GenericCallback::new(move |message| match message {
158            Ok(msg) => handler.handle(msg),
159            Err(err) => warn!("Error receiving a JobResult: {:?}", err),
160        })
161        .expect("Failed to create callback");
162
163        let scope_things =
164            ServiceWorkerRegistration::create_scope_things(&global, script_url.clone());
165
166        // B: Step 8 - 13
167        let job = Job::create_job(
168            JobType::Register,
169            scope,
170            script_url,
171            result_handler,
172            self.client.creation_url(),
173            Some(scope_things),
174        );
175
176        // B: Step 14: schedule job.
177        let _ = global
178            .script_to_constellation_chan()
179            .send(ScriptToConstellationMessage::ScheduleJob(job));
180
181        // A: Step 7
182        promise
183    }
184}
185
186/// Callback for resolve/reject job promise for Register.
187/// <https://w3c.github.io/ServiceWorker/#register>
188struct RegisterJobResultHandler {
189    trusted_promise: Option<TrustedPromise>,
190    task_source: SendableTaskSource,
191}
192
193impl RegisterJobResultHandler {
194    /// <https://w3c.github.io/ServiceWorker/#reject-job-promise>
195    /// <https://w3c.github.io/ServiceWorker/#resolve-job-promise>
196    /// Handle a result to either resolve or reject the register job promise.
197    pub(crate) fn handle(&mut self, result: JobResult) {
198        match result {
199            JobResult::RejectPromise(error) => {
200                let promise = self
201                    .trusted_promise
202                    .take()
203                    .expect("No promise to resolve for SW Register job.");
204
205                // Step 1
206                self.task_source
207                    .queue(task!(reject_promise_with_security_error: move || {
208                        let promise = promise.root();
209                        let _ac = enter_realm(&*promise.global());
210                        match error {
211                            JobError::TypeError => {
212                                promise.reject_error(
213                                    Error::Type("Failed to register a ServiceWorker".to_string()),
214                                    CanGc::note(),
215                                );
216                            },
217                            JobError::SecurityError => {
218                                promise.reject_error(Error::Security, CanGc::note());
219                            },
220                        }
221
222                    }));
223
224                // TODO: step 2, handle equivalent jobs.
225            },
226            JobResult::ResolvePromise(job, value) => {
227                let promise = self
228                    .trusted_promise
229                    .take()
230                    .expect("No promise to resolve for SW Register job.");
231
232                // Step 1
233                self.task_source.queue(task!(resolve_promise: move || {
234                    let promise = promise.root();
235                    let global = promise.global();
236                    let _ac = enter_realm(&*global);
237
238                    // Step 1.1
239                    let JobResultValue::Registration {
240                        id,
241                        installing_worker,
242                        waiting_worker,
243                        active_worker,
244                    } = value;
245
246                    // Step 1.2 (Job type is "register").
247                    let registration = global.get_serviceworker_registration(
248                        &job.script_url,
249                        &job.scope_url,
250                        id,
251                        installing_worker,
252                        waiting_worker,
253                        active_worker,
254                        CanGc::note()
255                    );
256
257                    // Step 1.4
258                    promise.resolve_native(&*registration, CanGc::note());
259                }));
260
261                // TODO: step 2, handle equivalent jobs.
262            },
263        }
264    }
265}
script/dom/serviceworkercontainer.rs

script/dom/
serviceworkercontainer.rs
