script/
navigation.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
5//! The listener that encapsulates all state for an in-progress document request.
6//! Any redirects that are encountered are followed. Whenever a non-redirect
7//! response is received, it is forwarded to the appropriate script thread.
8
9use std::cell::Cell;
10
11use content_security_policy::sandboxing_directive::SandboxingFlagSet;
12use crossbeam_channel::Sender;
13use embedder_traits::user_contents::UserContentManagerId;
14use embedder_traits::{Theme, ViewportDetails, WebDriverLoadStatus};
15use http::header;
16use js::context::JSContext;
17use net_traits::blob_url_store::UrlWithBlobClaim;
18use net_traits::policy_container::RequestPolicyContainer;
19use net_traits::request::{
20    CredentialsMode, InsecureRequestsPolicy, Origin, PreloadedResources, RedirectMode,
21    RequestBuilder, RequestClient, RequestMode,
22};
23use net_traits::response::ResponseInit;
24use net_traits::{
25    BoxedFetchCallback, CoreResourceThread, DOCUMENT_ACCEPT_HEADER_VALUE, FetchResponseMsg,
26    Metadata, ReferrerPolicy, fetch_async, set_default_accept_language,
27};
28use script_bindings::inheritance::Castable;
29use script_traits::{DocumentActivity, NewPipelineInfo};
30use servo_base::cross_process_instant::CrossProcessInstant;
31use servo_base::id::{BrowsingContextId, PipelineId, WebViewId};
32use servo_constellation_traits::{
33    LoadData, LoadOrigin, NavigationHistoryBehavior, ScriptToConstellationMessage,
34    TargetSnapshotParams,
35};
36use servo_url::{ImmutableOrigin, MutableOrigin, ServoUrl};
37use url::Position;
38
39use crate::dom::bindings::codegen::Bindings::HTMLIFrameElementBinding::HTMLIFrameElementMethods;
40use crate::dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
41use crate::dom::bindings::refcounted::Trusted;
42use crate::dom::element::Element;
43use crate::dom::html::htmliframeelement::HTMLIFrameElement;
44use crate::dom::node::node::NodeTraits;
45use crate::dom::window::Window;
46use crate::dom::windowproxy::WindowProxy;
47use crate::fetch::FetchCanceller;
48use crate::messaging::MainThreadScriptMsg;
49use crate::script_runtime::CanGc;
50use crate::script_thread::ScriptThread;
51
52#[derive(Clone)]
53pub struct NavigationListener {
54    request_builder: RequestBuilder,
55    main_thread_sender: Sender<MainThreadScriptMsg>,
56    // Whether or not results are sent to the main thread. After a redirect results are no longer sent,
57    // as the main thread has already started a new request.
58    send_results_to_main_thread: Cell<bool>,
59}
60
61impl NavigationListener {
62    pub(crate) fn into_callback(self) -> BoxedFetchCallback {
63        Box::new(move |response_msg| self.notify_fetch(response_msg))
64    }
65
66    pub fn new(
67        request_builder: RequestBuilder,
68        main_thread_sender: Sender<MainThreadScriptMsg>,
69    ) -> NavigationListener {
70        NavigationListener {
71            request_builder,
72            main_thread_sender,
73            send_results_to_main_thread: Cell::new(true),
74        }
75    }
76
77    pub fn initiate_fetch(
78        self,
79        core_resource_thread: &CoreResourceThread,
80        response_init: Option<ResponseInit>,
81    ) {
82        fetch_async(
83            core_resource_thread,
84            self.request_builder.clone(),
85            response_init,
86            self.into_callback(),
87        );
88    }
89
90    fn notify_fetch(&self, message: FetchResponseMsg) {
91        // If we've already asked the main thread to redirect the response, then stop sending results
92        // for this fetch. The main thread has already replaced it.
93        if !self.send_results_to_main_thread.get() {
94            return;
95        }
96
97        // If this is a redirect, don't send any more message after this one.
98        if Self::http_redirect_metadata(&message).is_some() {
99            self.send_results_to_main_thread.set(false);
100        }
101
102        let pipeline_id = self
103            .request_builder
104            .pipeline_id
105            .expect("Navigation should always have an associated Pipeline");
106        let result = self
107            .main_thread_sender
108            .send(MainThreadScriptMsg::NavigationResponse {
109                pipeline_id,
110                message: Box::new(message),
111            });
112
113        if let Err(error) = result {
114            warn!(
115                "Failed to send network message to pipeline {:?}: {error:?}",
116                pipeline_id
117            );
118        }
119    }
120
121    pub(crate) fn http_redirect_metadata(message: &FetchResponseMsg) -> Option<&Metadata> {
122        let FetchResponseMsg::ProcessResponse(_, Ok(metadata)) = message else {
123            return None;
124        };
125
126        // Don't allow redirects for non HTTP(S) URLs.
127        let metadata = metadata.metadata();
128        if !matches!(
129            metadata.location_url,
130            Some(Ok(ref location_url)) if matches!(location_url.scheme(), "http" | "https")
131        ) {
132            return None;
133        }
134
135        Some(metadata)
136    }
137}
138
139/// A document load that is in the process of fetching the requested resource. Contains
140/// data that will need to be present when the document and frame tree entry are created,
141/// but is only easily available at initiation of the load and on a push basis (so some
142/// data will be updated according to future resize events, viewport changes, etc.)
143#[derive(JSTraceable)]
144pub(crate) struct InProgressLoad {
145    /// The pipeline which requested this load.
146    #[no_trace]
147    pub(crate) pipeline_id: PipelineId,
148    /// The browsing context being loaded into.
149    #[no_trace]
150    pub(crate) browsing_context_id: BrowsingContextId,
151    /// The top level ancestor browsing context.
152    #[no_trace]
153    pub(crate) webview_id: WebViewId,
154    /// The parent pipeline and frame type associated with this load, if any.
155    #[no_trace]
156    pub(crate) parent_info: Option<PipelineId>,
157    /// The opener, if this is an auxiliary.
158    #[no_trace]
159    pub(crate) opener: Option<BrowsingContextId>,
160    /// The current window size associated with this pipeline.
161    #[no_trace]
162    pub(crate) viewport_details: ViewportDetails,
163    /// The activity level of the document (inactive, active or fully active).
164    #[no_trace]
165    pub(crate) activity: DocumentActivity,
166    /// Window is throttled, running timers at a heavily limited rate.
167    pub(crate) throttled: bool,
168    /// Timestamp reporting the time when the browser started this load.
169    #[no_trace]
170    pub(crate) navigation_start: CrossProcessInstant,
171    /// For cancelling the fetch
172    pub(crate) canceller: FetchCanceller,
173    /// The [`LoadData`] associated with this load.
174    #[no_trace]
175    pub(crate) load_data: LoadData,
176    /// A list of URL to keep track of all the redirects that have happened during
177    /// this load.
178    #[no_trace]
179    pub(crate) url_list: Vec<ServoUrl>,
180    #[no_trace]
181    /// The [`UserContentManagerId`] associated with this load's `WebView`.
182    pub(crate) user_content_manager_id: Option<UserContentManagerId>,
183    /// The [`Theme`] to use for this page, once it loads.
184    #[no_trace]
185    pub(crate) theme: Theme,
186    /// The [`TargetSnapshotParams`] to use when creating this document.
187    #[no_trace]
188    pub(crate) target_snapshot_params: TargetSnapshotParams,
189}
190
191impl InProgressLoad {
192    /// Create a new InProgressLoad object.
193    pub(crate) fn new(new_pipeline_info: NewPipelineInfo) -> InProgressLoad {
194        let url = new_pipeline_info.load_data.url.clone();
195        InProgressLoad {
196            pipeline_id: new_pipeline_info.new_pipeline_id,
197            browsing_context_id: new_pipeline_info.browsing_context_id,
198            webview_id: new_pipeline_info.webview_id,
199            parent_info: new_pipeline_info.parent_info,
200            opener: new_pipeline_info.opener,
201            viewport_details: new_pipeline_info.viewport_details,
202            activity: DocumentActivity::FullyActive,
203            throttled: false,
204            navigation_start: CrossProcessInstant::now(),
205            canceller: Default::default(),
206            load_data: new_pipeline_info.load_data,
207            url_list: vec![url],
208            user_content_manager_id: new_pipeline_info.user_content_manager_id,
209            theme: new_pipeline_info.theme,
210            target_snapshot_params: new_pipeline_info.target_snapshot_params,
211        }
212    }
213
214    pub(crate) fn request_builder(&mut self) -> RequestBuilder {
215        let client_origin = match self.load_data.load_origin {
216            LoadOrigin::Script(ref initiator_origin) => initiator_origin.immutable().clone(),
217            _ => ImmutableOrigin::new_opaque(),
218        };
219
220        let id = self.pipeline_id;
221        let webview_id = self.webview_id;
222
223        let insecure_requests_policy = self
224            .load_data
225            .inherited_insecure_requests_policy
226            .unwrap_or(InsecureRequestsPolicy::DoNotUpgrade);
227
228        let request_client = RequestClient {
229            preloaded_resources: PreloadedResources::default(),
230            policy_container: RequestPolicyContainer::PolicyContainer(
231                self.load_data.policy_container.clone().unwrap_or_default(),
232            ),
233            origin: Origin::Origin(client_origin),
234            is_nested_browsing_context: self.parent_info.is_some(),
235            insecure_requests_policy,
236        };
237
238        let mut request_builder = RequestBuilder::new(
239            Some(webview_id),
240            UrlWithBlobClaim::from_url_without_having_claimed_blob(self.load_data.url.clone()),
241            self.load_data.referrer.clone(),
242        )
243        .method(self.load_data.method.clone())
244        .destination(self.load_data.destination)
245        .mode(RequestMode::Navigate)
246        .credentials_mode(CredentialsMode::Include)
247        .use_url_credentials(true)
248        .pipeline_id(Some(id))
249        .referrer_policy(self.load_data.referrer_policy)
250        .policy_container(self.load_data.policy_container.clone().unwrap_or_default())
251        .insecure_requests_policy(insecure_requests_policy)
252        .has_trustworthy_ancestor_origin(self.load_data.has_trustworthy_ancestor_origin)
253        .headers(self.load_data.headers.clone())
254        .body(self.load_data.data.clone())
255        .redirect_mode(RedirectMode::Manual)
256        .crash(self.load_data.crash.clone())
257        .client(request_client)
258        .url_list(self.url_list.clone());
259
260        if !request_builder.headers.contains_key(header::ACCEPT) {
261            request_builder
262                .headers
263                .insert(header::ACCEPT, DOCUMENT_ACCEPT_HEADER_VALUE);
264        }
265        set_default_accept_language(&mut request_builder.headers);
266
267        request_builder
268    }
269}
270
271/// <https://html.spec.whatwg.org/multipage/#determining-the-origin>
272pub(crate) fn determine_the_origin(
273    url: Option<&ServoUrl>,
274    sandbox_flags: SandboxingFlagSet,
275    source_origin: Option<MutableOrigin>,
276) -> MutableOrigin {
277    // Step 1. If sandboxFlags has its sandboxed origin browsing context flag set, then return a new opaque origin.
278    let is_sandboxed =
279        sandbox_flags.contains(SandboxingFlagSet::SANDBOXED_ORIGIN_BROWSING_CONTEXT_FLAG);
280    if is_sandboxed {
281        return MutableOrigin::new(ImmutableOrigin::new_opaque());
282    }
283
284    // Step 2. If url is null, then return a new opaque origin.
285    let Some(url) = url else {
286        return MutableOrigin::new(ImmutableOrigin::new_opaque());
287    };
288
289    // Step 3. If url is about:srcdoc, then:
290    if url.as_str() == "about:srcdoc" {
291        // Step 3.1 Assert: sourceOrigin is non-null.
292        let source_origin =
293            source_origin.expect("Can't have a null source origin for about:srcdoc");
294        // Step 3.2 Return sourceOrigin
295        return source_origin;
296    }
297
298    // Step 4. If url matches about:blank and sourceOrigin is non-null, then return sourceOrigin.
299    if url.as_str() == "about:blank" {
300        if let Some(source_origin) = source_origin {
301            return source_origin;
302        }
303    }
304
305    // Step 5. Return url's origin.
306    MutableOrigin::new(url.origin())
307}
308
309/// <https://html.spec.whatwg.org/multipage/#navigate-fragid>
310fn navigate_to_fragment(
311    cx: &mut JSContext,
312    window: &Window,
313    url: &ServoUrl,
314    history_handling: NavigationHistoryBehavior,
315) {
316    let doc = window.Document();
317    // Step 1. Let navigation be navigable's active window's navigation API.
318    // TODO
319    // Step 2. Let destinationNavigationAPIState be navigable's active session history entry's navigation API state.
320    // TODO
321    // Step 3. If navigationAPIState is not null, then set destinationNavigationAPIState to navigationAPIState.
322    // TODO
323
324    // Step 4. Let continue be the result of firing a push/replace/reload navigate event
325    // at navigation with navigationType set to historyHandling, isSameDocument set to true,
326    // userInvolvement set to userInvolvement, sourceElement set to sourceElement,
327    // destinationURL set to url, and navigationAPIState set to destinationNavigationAPIState.
328    // TODO
329    // Step 5. If continue is false, then return.
330    // TODO
331
332    // Step 6. Let historyEntry be a new session history entry, with
333    // Step 7. Let entryToReplace be navigable's active session history entry if historyHandling is "replace", otherwise null.
334    // Step 8. Let history be navigable's active document's history object.
335    // Step 9. Let scriptHistoryIndex be history's index.
336    // Step 10. Let scriptHistoryLength be history's length.
337    // Step 11. If historyHandling is "push", then:
338    // Step 13. Set navigable's active session history entry to historyEntry.
339    window.send_to_constellation(ScriptToConstellationMessage::NavigatedToFragment(
340        url.clone(),
341        history_handling,
342    ));
343    // Step 12. Set navigable's active document's URL to url.
344    let old_url = doc.url();
345    doc.set_url(url.clone());
346    // Step 14. Update document for history step application given navigable's active document,
347    // historyEntry, true, scriptHistoryIndex, scriptHistoryLength, and historyHandling.
348    doc.update_document_for_history_step_application(&old_url, url);
349    // Step 15. Scroll to the fragment given navigable's active document.
350    let Some(fragment) = url.fragment() else {
351        unreachable!("Must always have a fragment");
352    };
353    doc.scroll_to_the_fragment(fragment, CanGc::from_cx(cx));
354    // Step 16. Let traversable be navigable's traversable navigable.
355    // TODO
356    // Step 17. Append the following session history synchronous navigation steps involving navigable to traversable:
357    // TODO
358}
359
360/// <https://html.spec.whatwg.org/multipage/#navigate>
361pub(crate) fn navigate(
362    cx: &mut JSContext,
363    window: &Window,
364    history_handling: NavigationHistoryBehavior,
365    force_reload: bool,
366    load_data: LoadData,
367) {
368    let doc = window.Document();
369
370    // Step 3. Let initiatorOriginSnapshot be sourceDocument's origin.
371    let initiator_origin_snapshot = &load_data.load_origin;
372
373    // TODO: Important re security. See https://github.com/servo/servo/issues/23373
374    // Step 5. check that the source browsing-context is "allowed to navigate" this window.
375
376    // Step 4 and 5
377    let pipeline_id = window.pipeline_id();
378    let window_proxy = window.window_proxy();
379    if let Some(active) = window_proxy.currently_active() {
380        if pipeline_id == active && doc.is_prompting_or_unloading() {
381            return;
382        }
383    }
384
385    // Step 12. If historyHandling is "auto", then:
386    let history_handling = if history_handling == NavigationHistoryBehavior::Auto {
387        // Step 12.1. If url equals navigable's active document's URL, and
388        // initiatorOriginSnapshot is same origin with targetNavigable's active document's
389        // origin, then set historyHandling to "replace".
390        //
391        // Note: `targetNavigable` is not actually defined in the spec, "active document" is
392        // assumed to be the correct reference based on WPT results
393        if let LoadOrigin::Script(initiator_origin) = initiator_origin_snapshot {
394            if load_data.url == doc.url() && initiator_origin.same_origin(&*doc.origin()) {
395                NavigationHistoryBehavior::Replace
396            } else {
397                // Step 12.2. Otherwise, set historyHandling to "push".
398                NavigationHistoryBehavior::Push
399            }
400        } else {
401            // Step 12.2. Otherwise, set historyHandling to "push".
402            NavigationHistoryBehavior::Push
403        }
404    } else {
405        history_handling
406    };
407
408    // Step 13. If the navigation must be a replace given url and navigable's active
409    // document, then set historyHandling to "replace".
410    //
411    // Inlines implementation of https://html.spec.whatwg.org/multipage/#the-navigation-must-be-a-replace
412    let history_handling = if load_data.url.scheme() == "javascript" || doc.is_initial_about_blank()
413    {
414        NavigationHistoryBehavior::Replace
415    } else {
416        history_handling
417    };
418
419    // Step 14. If all of the following are true:
420    // > documentResource is null;
421    // > response is null;
422    if !force_reload
423        // > url equals navigable's active session history entry's URL with exclude fragments set to true; and
424        && load_data.url.as_url()[..Position::AfterQuery] ==
425            doc.url().as_url()[..Position::AfterQuery]
426        // > url's fragment is non-null,
427        && load_data.url.fragment().is_some()
428    {
429        // Step 14.1. Navigate to a fragment given navigable, url, historyHandling,
430        // userInvolvement, sourceElement, navigationAPIState, and navigationId.
431        let webdriver_sender = window.webdriver_load_status_sender();
432        if let Some(ref sender) = webdriver_sender {
433            let _ = sender.send(WebDriverLoadStatus::NavigationStart);
434        }
435        navigate_to_fragment(cx, window, &load_data.url, history_handling);
436        // Step 14.2. Return.
437        if let Some(sender) = webdriver_sender {
438            let _ = sender.send(WebDriverLoadStatus::NavigationStop);
439        }
440        return;
441    }
442
443    // Step 15. If navigable's parent is non-null, then set navigable's is delaying load events to true.
444    let window_proxy = window.window_proxy();
445    if window_proxy.parent().is_some() {
446        window_proxy.start_delaying_load_events_mode();
447    }
448
449    // Step 16. Let targetSnapshotParams be the result of snapshotting target
450    // snapshot params given navigable.
451    let target_snapshot_params = snapshot_target_snapshot_params(&window_proxy);
452
453    // Step 17. Invoke WebDriver BiDi navigation started with navigable
454    // and a new WebDriver BiDi navigation status whose id is navigationId,
455    // status is "pending", and url is url.
456    // TODO
457    if let Some(sender) = window.webdriver_load_status_sender() {
458        let _ = sender.send(WebDriverLoadStatus::NavigationStart);
459    }
460
461    // Step 18. If navigable's ongoing navigation is "traversal", then:
462    // TODO
463    // Step 19. Set the ongoing navigation for navigable to navigationId.
464    // TODO
465
466    // Step 20. If url's scheme is "javascript", then:
467    if load_data.url.scheme() == "javascript" {
468        // Step 20.1. Queue a global task on the navigation and traversal task source given
469        // navigable's active window to navigate to a javascript: URL given navigable, url,
470        // historyHandling, sourceSnapshotParams, initiatorOriginSnapshot, userInvolvement,
471        // cspNavigationType, initialInsertion, and navigationId.
472        let global = window.as_global_scope();
473        let trusted_window = Trusted::new(window);
474        let sender = global.script_to_constellation_chan().clone();
475        let mut load_data = load_data;
476        load_data.about_base_url = window.Document().about_base_url();
477        let task = task!(navigate_javascript: move |cx| {
478            // Important re security. See https://github.com/servo/servo/issues/23373
479            let window = trusted_window.root();
480            let global = window.as_global_scope();
481            if ScriptThread::navigate_to_javascript_url(cx, global, global, &mut load_data, None, None) {
482                sender
483                    .send(ScriptToConstellationMessage::LoadUrl(load_data, history_handling, target_snapshot_params))
484                    .unwrap();
485            }
486        });
487        global
488            .task_manager()
489            .navigation_and_traversal_task_source()
490            .queue(task);
491        // Step 20.2. Return.
492        return;
493    }
494
495    // Step 23. In parallel, run these steps:
496    //
497    // TODO: in parallel
498
499    // Step 23.1. Let unloadPromptCanceled be the result of checking if unloading
500    // is canceled for navigable's active document's inclusive descendant navigables.
501    let unload_prompt_canceled = doc.check_if_unloading_is_cancelled(false, CanGc::from_cx(cx));
502    // Step 23.2. If unloadPromptCanceled is not "continue",
503    // or navigable's ongoing navigation is no longer navigationId:
504    //
505    // TODO: Check for ongoing navigation
506    if !unload_prompt_canceled {
507        // Step 23.2.1. Invoke WebDriver BiDi navigation failed with navigable
508        // and a new WebDriver BiDi navigation status whose id is navigationId,
509        // status is "canceled", and url is url.
510        // TODO
511        // Step 23.2.2. Abort these steps.
512        return;
513    }
514
515    // Step 23.9. Attempt to populate the history entry's document for historyEntry,
516    // given navigable, "navigate", sourceSnapshotParams, targetSnapshotParams,
517    // userInvolvement, navigationId, navigationParams, cspNavigationType,
518    // with allowPOST set to true and completionSteps set to the following step:
519    window.send_to_constellation(ScriptToConstellationMessage::LoadUrl(
520        load_data,
521        history_handling,
522        target_snapshot_params,
523    ));
524}
525
526/// <https://html.spec.whatwg.org/multipage/#determining-the-creation-sandboxing-flags>
527pub(crate) fn determine_creation_sandboxing_flags(
528    browsing_context: Option<&WindowProxy>,
529    element: Option<&Element>,
530) -> SandboxingFlagSet {
531    // To determine the creation sandboxing flags for a browsing context
532    // browsing context, given null or an element embedder, return the union
533    // of the flags that are present in the following sandboxing flag sets:
534    match element {
535        // If embedder is null, then: the flags set on browsing context's
536        // popup sandboxing flag set.
537        None => browsing_context
538            .and_then(|browsing_context| browsing_context.document())
539            .map(|document| document.active_sandboxing_flag_set())
540            .unwrap_or(SandboxingFlagSet::empty()),
541        Some(element) => {
542            // If embedder is an element, then: the flags set on embedder's
543            // iframe sandboxing flag set.
544            // If embedder is an element, then: the flags set on embedder's
545            // node document's active sandboxing flag set.
546            element
547                .downcast::<HTMLIFrameElement>()
548                .map(|iframe| iframe.sandboxing_flag_set())
549                .unwrap_or(SandboxingFlagSet::empty())
550                .union(element.owner_document().active_sandboxing_flag_set())
551        },
552    }
553}
554
555/// <https://html.spec.whatwg.org/multipage/#determining-the-iframe-element-referrer-policy>
556pub(crate) fn determine_iframe_element_referrer_policy(
557    element: Option<&Element>,
558) -> ReferrerPolicy {
559    // Step 1. If embedder is an iframe element, then return embedder's referrerpolicy
560    // attribute's state's corresponding keyword.
561    element
562        .and_then(|element| element.downcast::<HTMLIFrameElement>())
563        .map(|iframe| {
564            let token = iframe.ReferrerPolicy();
565            ReferrerPolicy::from(&*token.str())
566        })
567        // Step 2. Return the empty string.
568        .unwrap_or(ReferrerPolicy::EmptyString)
569}
570
571/// <https://html.spec.whatwg.org/multipage/#snapshotting-target-snapshot-params>
572pub(crate) fn snapshot_target_snapshot_params(navigable: &WindowProxy) -> TargetSnapshotParams {
573    // TODO(jdm): This doesn't work for cross-origin parent frames.
574    let container = navigable.frame_element();
575    // the result of determining the creation sandboxing flags given targetNavigable's
576    // active browsing context and targetNavigable's container
577    let sandboxing_flags = determine_creation_sandboxing_flags(Some(navigable), container);
578    // the result of determining the iframe element referrer policy given
579    // targetNavigable's container
580    let iframe_element_referrer_policy = determine_iframe_element_referrer_policy(container);
581    TargetSnapshotParams {
582        sandboxing_flags,
583        iframe_element_referrer_policy,
584    }
585}
script/navigation.rs

script/
navigation.rs
