Implement basics of link preloading

These changes allow a minimal set of checks for font-src
CSP checks to pass.

Part of servo#4577
Part of servo#35035

Signed-off-by: Tim van der Lippe <[email protected]>

Author: TimvdLippe

components/net/lib.rs

@@ -16,7 +16,6 @@ pub mod http_cache;
 pub mod http_loader;
 pub mod image_cache;
 pub mod local_directory_listing;
-pub mod mime_classifier;
 pub mod protocols;
 pub mod request_interceptor;
 pub mod resource_thread;

components/net/tests/main.rs

@@ -14,7 +14,6 @@ mod filemanager_thread;
 mod hsts;
 mod http_cache;
 mod http_loader;
-mod mime_classifier;
 mod resource_thread;
 mod subresource_integrity;
 

components/script/dom/htmllinkelement.rs

@@ -5,13 +5,16 @@
 use std::borrow::{Borrow, ToOwned};
 use std::cell::Cell;
 use std::default::Default;
+use std::str::FromStr;
 
 use base::id::WebViewId;
 use content_security_policy as csp;
 use dom_struct::dom_struct;
 use embedder_traits::EmbedderMsg;
 use html5ever::{LocalName, Prefix, local_name, ns};
 use js::rust::HandleObject;
+use mime::Mime;
+use net_traits::mime_classifier::{MediaType, MimeClassifier};
 use net_traits::policy_container::PolicyContainer;
 use net_traits::request::{
     CorsSettings, Destination, Initiator, InsecureRequestsPolicy, Referrer, RequestBuilder,
@@ -22,7 +25,7 @@ use net_traits::{
     ResourceTimingType,
 };
 use servo_arc::Arc;
-use servo_url::ServoUrl;
+use servo_url::{ImmutableOrigin, ServoUrl};
 use style::attr::AttrValue;
 use style::stylesheets::Stylesheet;
 use stylo_atoms::Atom;
@@ -78,6 +81,7 @@ struct LinkProcessingOptions {
     policy_container: PolicyContainer,
     source_set: Option<()>,
     base_url: ServoUrl,
+    origin: ImmutableOrigin,
     insecure_requests_policy: InsecureRequestsPolicy,
     has_trustworthy_ancestor_origin: bool,
     // Some fields that we don't need yet are missing
@@ -257,6 +261,10 @@ impl VirtualMethods for HTMLLinkElement {
                 if self.relations.get().contains(LinkRelations::PREFETCH) {
                     self.fetch_and_process_prefetch_link(&attr.value());
                 }
+
+                if self.relations.get().contains(LinkRelations::PRELOAD) {
+                    self.handle_preload_url();
+                }
             },
             local_name!("sizes") if self.relations.get().contains(LinkRelations::ICON) => {
                 if let Some(ref href) = get_attr(self.upcast(), &local_name!("href")) {
@@ -307,6 +315,10 @@ impl VirtualMethods for HTMLLinkElement {
                 if relations.contains(LinkRelations::PREFETCH) {
                     self.fetch_and_process_prefetch_link(&href);
                 }
+
+                if relations.contains(LinkRelations::PRELOAD) {
+                    self.handle_preload_url();
+                }
             }
         }
     }
@@ -348,6 +360,7 @@ impl HTMLLinkElement {
             referrer_policy: referrer_policy_for_element(element),
             policy_container: document.policy_container().to_owned(),
             source_set: None, // FIXME
+            origin: document.borrow().origin().immutable().to_owned(),
             base_url: document.borrow().base_url(),
             insecure_requests_policy: document.insecure_requests_policy(),
             has_trustworthy_ancestor_origin: document.has_trustworthy_ancestor_or_current_origin(),
@@ -494,6 +507,99 @@ impl HTMLLinkElement {
             Err(e) => debug!("Parsing url {} failed: {}", href, e),
         }
     }
+
+    /// <https://html.spec.whatwg.org/multipage/links.html#link-type-preload:fetch-and-process-the-linked-resource-2>
+    fn handle_preload_url(&self) {
+        // Step 1. Update the source set for el.
+        // TODO
+        // Step 2. Let options be the result of creating link options from el.
+        let options = self.processing_options();
+        // Step 3. Preload options, with the following steps given a response response:
+        // Step 3.1 If response is a network error, fire an event named error at el. Otherwise, fire an event named load at el.
+        self.preload(options);
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/links.html#preload>
+    fn preload(&self, options: LinkProcessingOptions) {
+        // Step 1. If options's type doesn't match options's destination, then return.
+        if !HTMLLinkElement::type_matches_destination(&options.link_type, options.destination) {
+            return;
+        }
+        // Step 2. If options's destination is "image" and options's source set is not null,
+        // then set options's href to the result of selecting an image source from options's source set.
+        // TODO
+        // Step 3. Let request be the result of creating a link request given options.
+        let url = options.base_url.clone();
+        let Some(mut request) = options.create_link_request(self.owner_window().webview_id())
+        else {
+            // Step 4. If request is null, then return.
+            return;
+        };
+        let document = self.upcast::<Node>().owner_doc();
+        // Step 5. Let unsafeEndTime be 0.
+        // TODO
+        // Step 6. Let entry be a new preload entry whose integrity metadata is options's integrity.
+        // TODO
+        // Step 7. Let key be the result of creating a preload key given request.
+        // TODO
+        // Step 8. If options's document is "pending", then set request's initiator type to "early hint".
+        if document.has_pending_parsing_blocking_script() {
+            request = request.initiator(Initiator::EarlyHint);
+        }
+        // Step 9. Let controller be null.
+        // Step 10. Let reportTiming given a Document document be to report timing for controller given document's relevant global object.
+        // Step 11. Set controller to the result of fetching request, with processResponseConsumeBody
+        // set to the following steps given a response response and null, failure, or a byte sequence bodyBytes:
+        let fetch_context = PreloadContext {
+            url,
+            link: Trusted::new(self),
+            resource_timing: ResourceFetchTiming::new(ResourceTimingType::Resource),
+        };
+        document.fetch_background(request.clone(), fetch_context);
+    }
+
+    fn type_matches_destination(mime_type: &str, destination: Option<Destination>) -> bool {
+        // Step 1. If type is an empty string, then return true.
+        if mime_type.is_empty() {
+            return true;
+        }
+        let Some(destination) = destination else {
+            return false;
+        };
+        // Step 2. If destination is "fetch", then return true.
+        // TODO
+        // Step 3. Let mimeTypeRecord be the result of parsing type.
+        let Ok(mime_type_record) = Mime::from_str(mime_type) else {
+            // Step 4. If mimeTypeRecord is failure, then return false.
+            return false;
+        };
+        // Step 5. If mimeTypeRecord is not supported by the user agent, then return false.
+        let Some(mime_type) = MimeClassifier::get_media_type(&mime_type_record) else {
+            return false;
+        };
+        // Step 6. If any of the following are true:
+        if
+        // destination is "audio" or "video", and mimeTypeRecord is an audio or video MIME type;
+        ((destination == Destination::Audio || destination == Destination::Video) &&
+            mime_type == MediaType::AudioVideo)
+            // destination is a script-like destination and mimeTypeRecord is a JavaScript MIME type;
+            || (destination.is_script_like() && mime_type == MediaType::Script)
+            // destination is "image" and mimeTypeRecord is an image MIME type;
+            || (destination == Destination::Image && mime_type == MediaType::Image)
+        // destination is "font" and mimeTypeRecord is a font MIME type;
+        // TODO
+        // destination is "json" and mimeTypeRecord is a JSON MIME type;
+        // TODO
+        // destination is "style" and mimeTypeRecord's essence is text/css; or
+        // TODO
+        // destination is "track" and mimeTypeRecord's essence is text/vtt,
+        // TODO
+        {
+            return true;
+        }
+        // Step 7. Return false.
+        false
+    }
 }
 
 impl StylesheetOwner for HTMLLinkElement {
@@ -552,6 +658,18 @@ impl HTMLLinkElementMethods<crate::DomTypeHolder> for HTMLLinkElement {
             .set_tokenlist_attribute(&local_name!("rel"), rel, can_gc);
     }
 
+    // https://html.spec.whatwg.org/multipage/#dom-link-as
+    make_enumerated_getter!(
+        As,
+        "as",
+        "fetch" | "font" | "image" | "script" | "track",
+        missing => "",
+        invalid => ""
+    );
+
+    // https://html.spec.whatwg.org/multipage/#dom-link-as
+    make_setter!(SetAs, "as");
+
     // https://html.spec.whatwg.org/multipage/#dom-link-media
     make_getter!(Media, "media");
 
@@ -689,6 +807,7 @@ impl LinkProcessingOptions {
             self.has_trustworthy_ancestor_origin,
             self.policy_container,
         )
+        .origin(self.origin)
         .integrity_metadata(self.integrity)
         .cryptographic_nonce_metadata(self.cryptographic_nonce_metadata)
         .referrer_policy(self.referrer_policy);
@@ -795,3 +914,89 @@ impl PreInvoke for PrefetchContext {
         true
     }
 }
+
+struct PreloadContext {
+    /// The `<link>` element that caused this prefetch operation
+    link: Trusted<HTMLLinkElement>,
+
+    resource_timing: ResourceFetchTiming,
+
+    /// The url being prefetched
+    url: ServoUrl,
+}
+
+impl FetchResponseListener for PreloadContext {
+    fn process_request_body(&mut self, _: RequestId) {}
+
+    fn process_request_eof(&mut self, _: RequestId) {}
+
+    fn process_response(
+        &mut self,
+        _: RequestId,
+        fetch_metadata: Result<FetchMetadata, NetworkError>,
+    ) {
+        _ = fetch_metadata;
+    }
+
+    fn process_response_chunk(&mut self, _: RequestId, chunk: Vec<u8>) {
+        _ = chunk;
+    }
+
+    // Step 3.1 of https://html.spec.whatwg.org/multipage/links.html#link-type-preload:fetch-and-process-the-linked-resource-2
+    fn process_response_eof(
+        &mut self,
+        _: RequestId,
+        response: Result<ResourceFetchTiming, NetworkError>,
+    ) {
+        if response.is_err() {
+            // Step 1. If response is a network error, fire an event named error at el.
+            self.link
+                .root()
+                .upcast::<EventTarget>()
+                .fire_event(atom!("error"), CanGc::note());
+        } else {
+            // Step 2. Otherwise, fire an event named load at el.
+            self.link
+                .root()
+                .upcast::<EventTarget>()
+                .fire_event(atom!("load"), CanGc::note());
+        }
+    }
+
+    fn resource_timing_mut(&mut self) -> &mut ResourceFetchTiming {
+        &mut self.resource_timing
+    }
+
+    fn resource_timing(&self) -> &ResourceFetchTiming {
+        &self.resource_timing
+    }
+
+    fn submit_resource_timing(&mut self) {
+        submit_timing(self, CanGc::note())
+    }
+
+    fn process_csp_violations(&mut self, _request_id: RequestId, violations: Vec<csp::Violation>) {
+        let global = &self.resource_timing_global();
+        global.report_csp_violations(violations, None);
+    }
+}
+
+impl ResourceTimingListener for PreloadContext {
+    fn resource_timing_information(&self) -> (InitiatorType, ServoUrl) {
+        (
+            InitiatorType::LocalName("preload".to_string()),
+            self.url.clone(),
+        )
+    }
+
+    fn resource_timing_global(&self) -> DomRoot<GlobalScope> {
+        self.link.root().upcast::<Node>().owner_doc().global()
+    }
+}
+
+impl PreInvoke for PreloadContext {
+    fn should_invoke(&self) -> bool {
+        // Preload requests are never aborted.
+        true
+    }
+}

components/script_bindings/webidls/HTMLLinkElement.webidl

@@ -13,7 +13,7 @@ interface HTMLLinkElement : HTMLElement {
            attribute DOMString? crossOrigin;
   [CEReactions]
            attribute DOMString rel;
-  // [CEReactions] attribute DOMString as;
+  [CEReactions] attribute DOMString as;
   [SameObject, PutForwards=value] readonly attribute DOMTokenList relList;
   [CEReactions]
            attribute DOMString media;

components/shared/net/lib.rs

@@ -40,6 +40,7 @@ pub mod blob_url_store;
 pub mod filemanager_thread;
 pub mod http_status;
 pub mod image_cache;
+pub mod mime_classifier;
 pub mod policy_container;
 pub mod pub_domains;
 pub mod quality;

components/net/mime_classifier.rs renamed to components/shared/net/mime_classifier.rs

@@ -3,7 +3,8 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 use mime::{self, Mime};
-use net_traits::LoadContext;
+
+use crate::LoadContext;
 
 pub struct MimeClassifier {
     image_classifier: GroupedClassifier,
@@ -16,11 +17,13 @@ pub struct MimeClassifier {
     font_classifier: GroupedClassifier,
 }
 
+#[derive(PartialEq)]
 pub enum MediaType {
     Xml,
     Html,
     AudioVideo,
     Image,
+    Script,
 }
 
 pub enum ApacheBugFlag {
@@ -99,7 +102,9 @@ impl MimeClassifier {
                                         Some(MediaType::AudioVideo) => {
                                             self.audio_video_classifier.classify(data)
                                         },
-                                        Some(MediaType::Xml) | None => None,
+                                        Some(MediaType::Script) | Some(MediaType::Xml) | None => {
+                                            None
+                                        },
                                     }
                                     .unwrap_or(supplied_type.clone())
                                 },
@@ -241,7 +246,11 @@ impl MimeClassifier {
             mt.type_() == mime::STAR && mt.subtype() == mime::STAR
     }
 
-    fn get_media_type(mime: &Mime) -> Option<MediaType> {
+    fn is_script(mt: &Mime) -> bool {
+        mt.type_() == mime::JAVASCRIPT
+    }
+
+    pub fn get_media_type(mime: &Mime) -> Option<MediaType> {
         if MimeClassifier::is_xml(mime) {
             Some(MediaType::Xml)
         } else if MimeClassifier::is_html(mime) {
@@ -250,6 +259,8 @@ impl MimeClassifier {
             Some(MediaType::Image)
         } else if MimeClassifier::is_audio_video(mime) {
             Some(MediaType::AudioVideo)
+        } else if MimeClassifier::is_script(mime) {
+            Some(MediaType::Script)
         } else {
             None
         }

components/shared/net/request.rs

@@ -39,6 +39,7 @@ pub enum Initiator {
     XSLT,
     Prefetch,
     Link,
+    EarlyHint,
 }
 
 /// A request [destination](https://fetch.spec.whatwg.org/#concept-request-destination)

components/net/tests/mime_classifier.rs renamed to components/shared/net/tests/mime_classifier.rs

@@ -8,8 +8,8 @@ use std::io::{self, Read};
 use std::path::{self, PathBuf};
 
 use mime::{self, Mime};
-use net::mime_classifier::{ApacheBugFlag, MimeClassifier, Mp4Matcher, NoSniffFlag};
 use net_traits::LoadContext;
+use net_traits::mime_classifier::{ApacheBugFlag, MimeClassifier, Mp4Matcher, NoSniffFlag};
 
 fn read_file(path: &path::Path) -> io::Result<Vec<u8>> {
     let mut file = File::open(path)?;