constellation: crash to a new “sad tab” error page (#30290)

* constellation: crash to a new “sad tab” page

* check in resources/crash.html

* use a separate enum variant instead of keying on reason

* fmt + tidy

* rename Resource::Crash to Resource::CrashHTML

* clean up crash page and add details (reason + backtrace)

* avoid repeating crash errors in script::script_thread warn log

* make new LoadData init more idiomatic

* clarify comments and new fields

* fix doc comment style

components/script/dom/servoparser/mod.rs

@@ -774,28 +774,29 @@ impl FetchResponseListener for ParserContext {
     fn process_request_eof(&mut self) {}
 
     fn process_response(&mut self, meta_result: Result<FetchMetadata, NetworkError>) {
-        let mut ssl_error = None;
-        let mut network_error = None;
-        let metadata = match meta_result {
-            Ok(meta) => Some(match meta {
-                FetchMetadata::Unfiltered(m) => m,
-                FetchMetadata::Filtered { unsafe_, .. } => unsafe_,
-            }),
-            Err(NetworkError::SslValidation(reason, cert_bytes)) => {
-                ssl_error = Some((reason, cert_bytes));
-                let mut meta = Metadata::default(self.url.clone());
-                let mime: Option<Mime> = "text/html".parse().ok();
-                meta.set_content_type(mime.as_ref());
-                Some(meta)
-            },
-            Err(NetworkError::Internal(reason)) => {
-                network_error = Some(reason);
-                let mut meta = Metadata::default(self.url.clone());
-                let mime: Option<Mime> = "text/html".parse().ok();
-                meta.set_content_type(mime.as_ref());
-                Some(meta)
-            },
-            Err(_) => None,
+        let (metadata, error) = match meta_result {
+            Ok(meta) => (
+                Some(match meta {
+                    FetchMetadata::Unfiltered(m) => m,
+                    FetchMetadata::Filtered { unsafe_, .. } => unsafe_,
+                }),
+                None,
+            ),
+            Err(error) => (
+                // Check variant without moving
+                match &error {
+                    NetworkError::SslValidation(..) |
+                    NetworkError::Internal(..) |
+                    NetworkError::Crash(..) => {
+                        let mut meta = Metadata::default(self.url.clone());
+                        let mime: Option<Mime> = "text/html".parse().ok();
+                        meta.set_content_type(mime.as_ref());
+                        Some(meta)
+                    },
+                    _ => None,
+                },
+                Some(error),
+            ),
         };
         let content_type: Option<Mime> = metadata
             .clone()
@@ -876,8 +877,8 @@ impl FetchResponseListener for ParserContext {
                 parser.parse_sync();
                 parser.tokenizer.borrow_mut().set_plaintext_state();
             },
-            (mime::TEXT, mime::HTML, _) => {
-                if let Some((reason, bytes)) = ssl_error {
+            (mime::TEXT, mime::HTML, _) => match error {
+                Some(NetworkError::SslValidation(reason, bytes)) => {
                     self.is_synthesized_document = true;
                     let page = resources::read_string(Resource::BadCertHTML);
                     let page = page.replace("${reason}", &reason);
@@ -887,14 +888,23 @@ impl FetchResponseListener for ParserContext {
                         page.replace("${secret}", &net_traits::PRIVILEGED_SECRET.to_string());
                     parser.push_string_input_chunk(page);
                     parser.parse_sync();
-                }
-                if let Some(reason) = network_error {
+                },
+                Some(NetworkError::Internal(reason)) => {
                     self.is_synthesized_document = true;
                     let page = resources::read_string(Resource::NetErrorHTML);
                     let page = page.replace("${reason}", &reason);
                     parser.push_string_input_chunk(page);
                     parser.parse_sync();
-                }
+                },
+                Some(NetworkError::Crash(details)) => {
+                    self.is_synthesized_document = true;
+                    let page = resources::read_string(Resource::CrashHTML);
+                    let page = page.replace("${details}", &details);
+                    parser.push_string_input_chunk(page);
+                    parser.parse_sync();
+                },
+                Some(_) => {},
+                None => {},
             },
             (mime::TEXT, mime::XML, _) |
             (mime::APPLICATION, mime::XML, _) |

components/script/fetch.rs

@@ -129,6 +129,7 @@ fn request_init_from_request(request: NetTraitsRequest) -> RequestBuilder {
         csp_list: None,
         https_state: request.https_state,
         response_tainting: request.response_tainting,
+        crash: None,
     }
 }
 

components/script/script_thread.rs

@@ -3843,7 +3843,8 @@ impl ScriptThread {
             .headers(load_data.headers)
             .body(load_data.data)
             .redirect_mode(RedirectMode::Manual)
-            .origin(incomplete.origin.immutable().clone());
+            .origin(incomplete.origin.immutable().clone())
+            .crash(load_data.crash);
 
         let context = ParserContext::new(id, load_data.url);
         self.incomplete_parser_contexts
@@ -3869,6 +3870,7 @@ impl ScriptThread {
     ) {
         match fetch_metadata {
             Ok(_) => (),
+            Err(NetworkError::Crash(..)) => (),
             Err(ref e) => {
                 warn!("Network error: {:?}", e);
             },