net: Set Response::cache_state appropriately. (servo#40277)

`Response::cache_state` is populated upon fetch.

Testing: Net tests have been added.
Fixes: servo#40236

Signed-off-by: Mark Buer <[email protected]>

Author: mark-buer

components/net/http_loader.rs

@@ -53,7 +53,7 @@ use net_traits::request::{
     is_cors_non_wildcard_request_header_name, is_cors_safelisted_method,
     is_cors_safelisted_request_header,
 };
-use net_traits::response::{HttpsState, Response, ResponseBody, ResponseType};
+use net_traits::response::{CacheState, HttpsState, Response, ResponseBody, ResponseType};
 use net_traits::{
     CookieSource, DOCUMENT_ACCEPT_HEADER_VALUE, FetchMetadata, NetworkError, RedirectEndValue,
     RedirectStartValue, ReferrerPolicy, ResourceAttribute, ResourceFetchTiming, ResourceTimeValue,
@@ -1573,6 +1573,9 @@ async fn http_network_or_cache_fetch(
                 } else {
                     // Substep 6
                     response = cached_response;
+                    if let Some(response) = &mut response {
+                        response.cache_state = CacheState::Local;
+                    }
                 }
                 if response.is_none() {
                     // Ensure the done chan is not set if we're not using the cached response,
@@ -1690,6 +1693,9 @@ async fn http_network_or_cache_fetch(
                 response = http_cache.refresh(http_request, forward_response.clone(), done_chan);
             }
             wait_for_cached_response(done_chan, &mut response).await;
+            if let Some(response) = &mut response {
+                response.cache_state = CacheState::Validated;
+            }
         }
 
         // Step 10.5 If response is null, then:

components/net/tests/fetch.rs

@@ -7,6 +7,7 @@
 use std::fs;
 use std::iter::FromIterator;
 use std::path::Path;
+use std::str::FromStr;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex, Weak};
 use std::time::{Duration, SystemTime};
@@ -18,8 +19,8 @@ use crossbeam_channel::{Sender, unbounded};
 use devtools_traits::{HttpRequest as DevtoolsHttpRequest, HttpResponse as DevtoolsHttpResponse};
 use headers::{
     AccessControlAllowCredentials, AccessControlAllowHeaders, AccessControlAllowMethods,
-    AccessControlAllowOrigin, AccessControlMaxAge, CacheControl, ContentLength, ContentType,
-    Expires, HeaderMapExt, LastModified, Pragma, StrictTransportSecurity, UserAgent,
+    AccessControlAllowOrigin, AccessControlMaxAge, CacheControl, ContentLength, ContentType, ETag,
+    Expires, HeaderMapExt, IfNoneMatch, LastModified, Pragma, StrictTransportSecurity, UserAgent,
 };
 use http::header::{self, HeaderMap, HeaderName, HeaderValue};
 use http::{Method, StatusCode};
@@ -1260,6 +1261,83 @@ fn test_fetch_async_returns_complete_response() {
     assert_eq!(response_is_done(&fetch_response), true);
 }
 
+#[test]
+fn test_response_cache_status_is_local() {
+    static MESSAGE: &'static [u8] = b"cacheable content";
+    let handler =
+        move |_: HyperRequest<Incoming>,
+              response: &mut HyperResponse<BoxBody<Bytes, hyper::Error>>| {
+            // Mark this response as cacheable.
+            response
+                .headers_mut()
+                .typed_insert(CacheControl::new().with_max_age(Duration::from_secs(604800)));
+            *response.body_mut() = make_body(MESSAGE.to_vec());
+        };
+    let (server, url) = make_server(handler);
+
+    let request = RequestBuilder::new(Some(TEST_WEBVIEW_ID), url.clone(), Referrer::NoReferrer)
+        .origin(url.origin())
+        .policy_container(Default::default())
+        .build();
+
+    // Use the same HttpCache for both fetches.
+    let mut context = new_fetch_context(None, None, None);
+
+    // Cold request - response should come from the server.
+    let initial_response = fetch_with_context(request.clone(), &mut context);
+    assert!(matches!(initial_response.cache_state, CacheState::None));
+
+    // Warm request - response should come from the cache.
+    let cached_response = fetch_with_context(request.clone(), &mut context);
+    assert!(matches!(cached_response.cache_state, CacheState::Local));
+
+    let _ = server.close();
+}
+
+#[test]
+fn test_response_cache_status_is_validated() {
+    static MESSAGE: &'static [u8] = b"cacheable content";
+    let handler =
+        move |request: HyperRequest<Incoming>,
+              response: &mut HyperResponse<BoxBody<Bytes, hyper::Error>>| {
+            // Check for the revalidation request.
+            if let Some(_) = request.headers().typed_get::<IfNoneMatch>() {
+                *response.status_mut() = StatusCode::NOT_MODIFIED;
+                return;
+            }
+            // Mark this cacheable reponse as requiring revalidation upon refetch.
+            response
+                .headers_mut()
+                .typed_insert(CacheControl::new().with_no_cache());
+            response
+                .headers_mut()
+                .typed_insert(ETag::from_str("\"1234abcd\"").unwrap());
+            *response.body_mut() = make_body(MESSAGE.to_vec());
+        };
+    let (server, url) = make_server(handler);
+
+    let request = RequestBuilder::new(Some(TEST_WEBVIEW_ID), url.clone(), Referrer::NoReferrer)
+        .origin(url.origin())
+        .policy_container(Default::default())
+        .build();
+
+    // Use the same HttpCache for both fetches.
+    let mut context = new_fetch_context(None, None, None);
+
+    // Cold request - response should come from the server.
+    let initial_response = fetch_with_context(request.clone(), &mut context);
+    assert!(matches!(initial_response.cache_state, CacheState::None));
+
+    // Warm request - response should come from the cache after revalidation with server.
+    let revalidated_response = fetch_with_context(request, &mut context);
+    assert!(matches!(
+        revalidated_response.cache_state,
+        CacheState::Validated
+    ));
+
+    let _ = server.close();
+}
+
 #[test]
 fn test_opaque_filtered_fetch_async_returns_complete_response() {
     static MESSAGE: &'static [u8] = b"";