web: Only show file fetch error after fetch fails on file protocol

core/src/backend/navigator.rs

@@ -459,10 +459,7 @@
 
 /// This creates and returns the generic ErrorResponse for an invalid URL
 /// used in the NavigatorBackend fetch methods.
-pub fn create_fetch_error<ErrorType: Display>(
-    url: &str,
-    error: ErrorType,
-) -> Result<Box<dyn SuccessResponse>, ErrorResponse> {
+pub fn create_fetch_error<ErrorType: Display>(url: &str, error: ErrorType) -> ErrorResponse {
     create_specific_fetch_error("Invalid URL", url, error)
 }
 
@@ -472,17 +469,17 @@
     reason: &str,
     url: &str,
     error: ErrorType,
-) -> Result<Box<dyn SuccessResponse>, ErrorResponse> {
+) -> ErrorResponse {
     let message = if error.to_string() == "" {
         format!("{reason} {url}")
     } else {
         format!("{reason} {url}: {error}")
     };
     let error = Error::FetchError(message);
-    Err(ErrorResponse {
+    ErrorResponse {
         url: url.to_string(),
         error,
-    })
+    }
 }
 
 // Url doesn't implement from_file_path and to_file_path for WASM targets.
@@ -624,7 +621,7 @@
 
     let url = match navigator.resolve_url(url) {
         Ok(url) => url,
-        Err(e) => return async_return(create_fetch_error(url, e)),
+        Err(e) => return async_return(Err(create_fetch_error(url, e))),
     };
     let path = if url.scheme() == "file" {
         // Flash supports query parameters with local urls.
@@ -636,11 +633,11 @@
         match url_to_file_path(&filesystem_url) {
             Ok(path) => path,
             Err(_) => {
-                return async_return(create_specific_fetch_error(
+                return async_return(Err(create_specific_fetch_error(
                     "Unable to create path out of URL",
                     url.as_str(),
                     "",
-                ))
+                )))
             }
         }
     } else if let Some(base_path) = base_path {
@@ -654,11 +651,11 @@
         }
         path
     } else {
-        return async_return(create_specific_fetch_error(
+        return async_return(Err(create_specific_fetch_error(
             &format!("{navigator_name} can't fetch non-local URL"),
             url.as_str(),
             "",
-        ));
+        )));
     };
 
     Box::pin(async move {

frontend-utils/src/backends/navigator.rs

@@ -186,7 +186,7 @@ impl<F: FutureSpawner + 'static, I: NavigatorInterface> NavigatorBackend
         let mut processed_url = match self.resolve_url(request.url()) {
             Ok(url) => url,
             Err(e) => {
-                return async_return(create_fetch_error(request.url(), e));
+                return async_return(Err(create_fetch_error(request.url(), e)));
             }
         };
 

tests/framework/src/backends/navigator.rs

@@ -177,7 +177,7 @@ impl NavigatorBackend for TestNavigatorBackend {
 
         let url = match self.resolve_url(request.url()) {
             Ok(url) => url,
-            Err(e) => return async_return(create_fetch_error(request.url(), e)),
+            Err(e) => return async_return(Err(create_fetch_error(request.url(), e))),
         };
 
         let base_path = self.relative_base_path.clone();

web/src/navigator.rs

@@ -190,17 +190,7 @@ impl NavigatorBackend for WebNavigatorBackend {
         }
 
         let url = match self.resolve_url(url) {
-            Ok(url) => {
-                if url.scheme() == "file" {
-                    tracing::error!(
-                        "Can't open the local URL {} on WASM target",
-                        url.to_string()
-                    );
-                    return;
-                } else {
-                    url
-                }
-            }
+            Ok(url) => url,
             Err(e) => {
                 tracing::error!(
                     "Could not parse URL because of {}, the corrupt URL was: {}",
@@ -307,19 +297,9 @@ impl NavigatorBackend for WebNavigatorBackend {
 
     fn fetch(&self, request: Request) -> OwnedFuture<Box<dyn SuccessResponse>, ErrorResponse> {
         let url = match self.resolve_url(request.url()) {
-            Ok(url) => {
-                if url.scheme() == "file" {
-                    return async_return(create_specific_fetch_error(
-                        "WASM target can't fetch local URL",
-                        url.as_str(),
-                        "",
-                    ));
-                } else {
-                    url
-                }
-            }
+            Ok(url) => url,
             Err(e) => {
-                return async_return(create_fetch_error(request.url(), e));
+                return async_return(Err(create_fetch_error(request.url(), e)));
             }
         };
 
@@ -366,11 +346,11 @@ impl NavigatorBackend for WebNavigatorBackend {
             let web_request = match WebRequest::new_with_str_and_init(url.as_str(), &init) {
                 Ok(web_request) => web_request,
                 Err(_) => {
-                    return create_specific_fetch_error(
+                    return Err(create_specific_fetch_error(
                         "Unable to create request for",
                         url.as_str(),
                         "",
-                    );
+                    ));
                 }
             };
 
@@ -388,9 +368,19 @@ impl NavigatorBackend for WebNavigatorBackend {
             let window = web_sys::window().expect("window()");
             let fetchval = JsFuture::from(window.fetch_with_request(&web_request))
                 .await
-                .map_err(|_| ErrorResponse {
-                    url: url.to_string(),
-                    error: Error::FetchError("Got JS error".to_string()),
+                .map_err(|_| {
+                    if url.scheme() == "file" {
+                        create_specific_fetch_error(
+                            "WASM target can't fetch local URL",
+                            url.as_str(),
+                            "",
+                        )
+                    } else {
+                        ErrorResponse {
+                            url: url.to_string(),
+                            error: Error::FetchError("Got JS error".to_string()),
+                        }
+                    }
                 })?;
 
             let response: WebResponse = fetchval.dyn_into().map_err(|_| ErrorResponse {